private async Task <Tuple <int, int> > CommitAndCount(ITransactionManagerService tms, List <TransactionInfo> newTransactions, HashSet <long> transactionsInFlight)
        {
            int success = 0;
            int failed  = 0;
            CommitTransactionsResponse commitResponse = await tms.CommitTransactions(newTransactions, transactionsInFlight);

            if (commitResponse.CommitResult.Count != 0)
            {
                Console.WriteLine($"Commited {commitResponse.CommitResult.Count} Transactions.");
            }
            else
            {
                await Task.Delay(10);
            }
            foreach (KeyValuePair <long, CommitResult> kvp in commitResponse.CommitResult)
            {
                bool removed = transactionsInFlight.Remove(kvp.Key);
                if (!removed)
                {
                    Console.WriteLine($"Unrequested result: {kvp.Key}.");
                    continue;
                }
                if (kvp.Value.Success)
                {
                    success++;
                }
                else
                {
                    failed++;
                }
            }
            return(Tuple.Create(success, failed));
        }
Esempio n. 2
0
        public StatementController(
            [NotNull] IUiContext uiContext,
            [NotNull] StatementControllerFileOperations fileOperations,
            [NotNull] ITransactionManagerService transactionService)
        {
            if (uiContext == null)
            {
                throw new ArgumentNullException(nameof(uiContext));
            }

            if (fileOperations == null)
            {
                throw new ArgumentNullException(nameof(fileOperations));
            }

            if (transactionService == null)
            {
                throw new ArgumentNullException(nameof(transactionService));
            }

            FileOperations          = fileOperations;
            this.uiContext          = uiContext;
            this.transactionService = transactionService;

            MessengerInstance = uiContext.Messenger;
            MessengerInstance.Register <FilterAppliedMessage>(this, OnGlobalDateFilterApplied);
            MessengerInstance.Register <ApplicationStateRequestedMessage>(this, OnApplicationStateRequested);
            MessengerInstance.Register <ApplicationStateLoadedMessage>(this, OnApplicationStateLoaded);
            MessengerInstance.Register <BudgetReadyMessage>(this, OnBudgetReadyMessageReceived);
            MessengerInstance.Register <ShellDialogResponseMessage>(this, OnShellDialogResponseMessageReceived);

            this.transactionService.Closed += OnClosedNotificationReceived;
            this.transactionService.NewDataSourceAvailable += OnNewDataSourceAvailableNotificationReceived;
            this.transactionService.Saved += OnSavedNotificationReceived;
        }
        public void Initialize_test_objects()
        {
            switch (TestContext.TestName)
            {
            case nameof(AddTransactionAsync_adds_transaction_then_saves):
            case nameof(RemoveTransactionAsync_removes_transaction_then_saves):
            case nameof(UpdateTransactionAsync_edits_transaction_then_saves):
                _mockRepo = new Mock <IBudgetRepo>(MockBehavior.Strict);
                break;

            default:
                _mockRepo = new Mock <IBudgetRepo>();
                break;
            }
            _testService = new TransactionManagerService(_mockRepo.Object);
        }
Esempio n. 4
0
        public TransactionAgent(ILocalSiloDetails siloDetails, ITransactionManagerService tmService, ILoggerFactory loggerFactory)
            : base(Constants.TransactionAgentSystemTargetId, siloDetails.SiloAddress, loggerFactory)
        {
            logger                = new LoggerWrapper <TransactionAgent>(loggerFactory);
            this.tmService        = tmService;
            ReadOnlyTransactionId = 0;
            //abortSequenceNumber = 0;
            abortLowerBound    = 0;
            this.loggerFactory = loggerFactory;

            abortedTransactions    = new ConcurrentDictionary <long, long>();
            transactionStartQueue  = new ConcurrentQueue <Tuple <TimeSpan, TaskCompletionSource <long> > >();
            transactionCommitQueue = new ConcurrentQueue <TransactionInfo>();
            commitCompletions      = new ConcurrentDictionary <long, TaskCompletionSource <bool> >();
            outstandingCommits     = new HashSet <long>();
        }
Esempio n. 5
0
        public TransactionAgent(ILocalSiloDetails siloDetails, ITransactionManagerService tmService, ILoggerFactory loggerFactory, ITelemetryProducer telemetryProducer, Factory <NodeConfiguration> getNodeConfig)
            : base(Constants.TransactionAgentSystemTargetId, siloDetails.SiloAddress, loggerFactory)
        {
            logger                = loggerFactory.CreateLogger <TransactionAgent>();
            this.tmService        = tmService;
            ReadOnlyTransactionId = 0;
            //abortSequenceNumber = 0;
            abortLowerBound    = 0;
            this.loggerFactory = loggerFactory;

            abortedTransactions    = new ConcurrentDictionary <long, long>();
            transactionStartQueue  = new ConcurrentQueue <Tuple <TimeSpan, TaskCompletionSource <long> > >();
            transactionCommitQueue = new ConcurrentQueue <TransactionInfo>();
            commitCompletions      = new ConcurrentDictionary <long, TaskCompletionSource <bool> >();
            outstandingCommits     = new HashSet <long>();
            this.metrics           = new TransactionAgentMetrics(telemetryProducer, getNodeConfig().StatisticsMetricsTableWriteInterval);
        }
Esempio n. 6
0
 public TransactionManagerGrain(ITransactionManager transactionManager)
 {
     this.transactionManager        = transactionManager;
     this.transactionManagerService = new TransactionManagerService(transactionManager);
 }
 public StatementViewModel Initialise(ITransactionManagerService transactionManagerService)
 {
     this.transactionService = transactionManagerService;
     return(this);
 }
 public TransactionController(ITransactionManagerService service) => _serviceRO = service;
 public StatementViewModel Initialise(ITransactionManagerService transactionManagerService)
 {
     this.transactionService = transactionManagerService;
     return this;
 }
 internal void Initialise(ITransactionManagerService transactionManagerService)
 {
     this.transactionService = transactionManagerService;
     ViewModel.Initialise(this.transactionService);
 }
 internal void Initialise(ITransactionManagerService transactionManagerService)
 {
     this.transactionService = transactionManagerService;
     ViewModel.Initialise(this.transactionService);
 }