/// <summary> /// Executes the operation asynchronous with single result. /// </summary> /// <typeparam name="T">The type of of entity.</typeparam> /// <param name="entitySet">The entity set.</param> /// <param name="entitySetTypeName">Type name of the entity set.</param> /// <param name="operation">The operation name.</param> /// <param name="isAction">True, if the operation is an action; false, if the operation is a function.</param> /// <param name="expandProperties">The navigation property names to be expanded.</param> /// <param name="operationParameters">The operation parameters.</param> /// <returns>The object of type T.</returns> public async Task <T> ExecuteOperationSingleResultAsync <T>(string entitySet, string entitySetTypeName, string operation, bool isAction, ICollection <string> expandProperties, params OperationParameter[] operationParameters) { if (BatchHelper.IsInBatchMode(this.batchId)) { if (isAction) { throw new NotSupportedException("Action is not supported in batch mode, only Read, ReadAll, and Functions are supported."); } else { Guid localBatchId = this.batchId.Value; TaskCompletionSource <object> taskCompletionSource = this.parametersCache.PutParameters <T>(localBatchId, entitySet, entitySetTypeName, operation, null, null, operationParameters); return(await taskCompletionSource.Task.ContinueWith <T>(this.GetSingleEntity <T>)); } } else { string result = await Task.Run(async() => await AdaptorCaller.ExecuteAsync(GetRequestUri(entitySetTypeName, operation, operationParameters))); result = AdaptorCaller.RemoveCommerceRuntimePrefix(result); TryThrowAsCommerceException(result); return(result.DeserializeJsonObject <T>()); } }
private async Task <IEnumerable <WriteConcernResult> > InsertMultipleBatchesAsync(IChannelHandle channel, CancellationToken cancellationToken) { var helper = new BatchHelper(_documentSource, _writeConcern, _continueOnError); while (_documentSource.HasMore) { WriteConcernResult result; try { result = await ExecuteProtocolAsync(channel, helper.BatchWriteConcern, helper.ShouldSendGetLastError, cancellationToken).ConfigureAwait(false); } catch (MongoWriteConcernException ex) { result = helper.HandleException(ex); if (!_continueOnError) { return(null); } } helper.AddResult(result); _documentSource.ClearBatch(); } return(helper.CreateFinalResultOrThrow()); }
/// <summary> /// Sends the batch request to the server and clears the cache and the batchId. /// </summary> /// <param name="context">The context that sends the request.</param> /// <param name="cache">The cache containing the parameters of cached methods.</param> /// <param name="batchId">The batchId to retrieve the cached parameters.</param> /// <returns>A Task.</returns> internal static async Task ExecuteBatch(IContext context, ParametersCache cache, ThreadLocal <Guid> batchId) { if (!BatchHelper.IsInBatchMode(batchId)) { throw new InvalidOperationException("The calling thread was trying to do batch operation but it didn't begin the batch operations before."); } Guid localBatchId = batchId.Value; // Clears the batchId before executing the batch operation since after do "await" the original // thread will be used to do ExecuteBatchAsync and a new thread will be created to do the rest work. // So we will not be able to clear the original thread any more. batchId.Value = Guid.Empty; List <ParametersGroup> requests = cache.GetParameters(localBatchId); List <TaskCompletionSource <object> > tasks = cache.GetTasks(localBatchId); try { await context.ExecuteBatchAsync(requests, tasks); } catch { throw; } finally { // Clear the cache for this thread. cache.Clear(localBatchId); } }
public DataSet Calculate(AnalyzerTaskResult analyzerResult) { #region Argument exceptions if (analyzerResult == null) { throw new ArgumentNullException("analyzerResult"); } #endregion var store = new DataSet(); EventsNotifier.Instance.Notify(ProcedureEvents.ProcedureAnalyzeStepCalculateResult); store.Tables.Add(_procedureContext.ToExecutionInfoTable()); switch (_procedureContext.ExecutionMode) { case ProcedureExecutionMode.Live: var bag = new ConcurrentBag <DataTable>(); using (var task = Task.Factory.StartNew(() => { Task.Factory.StartNew(() => bag.Add(analyzerResult.Profiler.ToEnginePerformanceTable()), TaskCreationOptions.AttachedToParent); Task.Factory.StartNew(() => bag.Add(analyzerResult.Profiler.ToAggregationsReadTable()), TaskCreationOptions.AttachedToParent); Task.Factory.StartNew(() => bag.Add(analyzerResult.Profiler.ToPartitionsReadTable()), TaskCreationOptions.AttachedToParent); Task.Factory.StartNew(() => bag.Add(analyzerResult.Profiler.ToCachesReadTable()), TaskCreationOptions.AttachedToParent); store.Tables.Add(analyzerResult.QueryResult.ToQueryResultTable()); foreach (var table in analyzerResult.Performance.ToTables()) { store.Tables.Add(table); } foreach (var table in analyzerResult.Profiler.ToTables()) { store.Tables.Add(table); } })) { task.Wait(); } foreach (var table in bag) { store.Tables.Add(table); } break; case ProcedureExecutionMode.Batch: BatchHelper.Calculate(_procedureContext); break; } EventsNotifier.Instance.Notify(ProcedureEvents.ProcedureAnalyzeStepSendResult); store.Tables.Add(EventsNotifier.Instance.NotifiedEvents.ToProcedureEventTable()); return(store); }
public void GetSortModel(int value, int expectedSkip, int expectedTake) { var actual = BatchHelper.GetSortModel(value); Assert.Equal(expectedSkip, actual.Skip); Assert.Equal(expectedTake, actual.Take); Assert.Equal(expectedSkip + expectedTake, actual.RecordRequestNumber); }
/// <summary> /// Executes the authentication operation asynchronous with a single result. /// </summary> /// <typeparam name="T">The type of the result.</typeparam> /// <param name="operation">The operation name.</param> /// <param name="operationParameters">The operation parameters.</param> /// <returns>No return.</returns> public async Task <T> ExecuteAuthenticationOperationSingleResultAsync <T>(string operation, params OperationParameter[] operationParameters) { if (BatchHelper.IsInBatchMode(this.batchId)) { throw new NotSupportedException("Authentication operations are not supported in batch mode."); } return(await this.ExecuteAsync(null, operation, async (context) => await context.ExecuteAuthenticationOperationSingleResultAsync <T>(operation, operationParameters))); }
public void DbConnectionTest() { List <MSH> msh; using (ExportQueueTable exp = new ExportQueueTable(GeneralHelper.ConnectionString, 0, ProcessStageFilterEnum.Lookup, ProcessStateFilterEnum.Failed, "ResolveHealthConditions")) { msh = BatchHelper.LoadBatches(exp.Items_ExportQueue); } }
public override List <MSH> GetMSH() { const int NO_OF_RECORDS = 25; using (ExportQueueTable exp = new ExportQueueTable(GeneralHelper.ConnectionString, 0, ProcessStageFilterEnum.Lookup, ProcessStateFilterEnum.Failed, "ResolveHealthConditions")) { // Return 25 for now return(BatchHelper.LoadBatches(exp.Items_ExportQueue.Take(NO_OF_RECORDS).ToList())); } }
private async Task <BulkWriteOperationResult> ExecuteBatchesAsync(RetryableWriteContext context, CancellationToken cancellationToken) { var helper = new BatchHelper(_requests, _writeConcern, _isOrdered); foreach (var batch in helper.GetBatches()) { batch.Result = await ExecuteBatchAsync(context, batch, cancellationToken).ConfigureAwait(false); } return(helper.CreateFinalResultOrThrow(context.Channel)); }
public async Task <BulkWriteOperationResult> ExecuteAsync(RetryableWriteContext context, CancellationToken cancellationToken) { var helper = new BatchHelper(this, context.Channel); foreach (var batch in helper.GetBatches()) { batch.Result = await EmulateSingleRequestAsync(context.Channel, batch.Request, batch.OriginalIndex, cancellationToken).ConfigureAwait(false); } return(helper.GetFinalResultOrThrow()); }
private BulkWriteOperationResult ExecuteBatches(RetryableWriteContext context, CancellationToken cancellationToken) { var helper = new BatchHelper(_requests, _writeConcern, _isOrdered); foreach (var batch in helper.GetBatches()) { batch.Result = ExecuteBatch(context, batch, cancellationToken); } return(helper.CreateFinalResultOrThrow(context.Channel)); }
/// <summary> /// Updates the specified entity set. /// </summary> /// <typeparam name="T">The type of of entity.</typeparam> /// <param name="entitySet">The entity set.</param> /// <param name="entity">The entity.</param> /// <returns> /// The object of type T. /// </returns> public async Task <T> Update <T>(string entitySet, T entity) where T : CommerceEntity { if (BatchHelper.IsInBatchMode(this.batchId)) { throw new NotSupportedException("Update operation is not supported in batch mode, only Read, ReadAll, and Functions are supported."); } return(await this.ExecuteAsync(entitySet, ActionNames.Update, async (context) => await context.Update <T>(entitySet, entity))); }
// public methods public BulkWriteOperationResult Execute(RetryableWriteContext context, CancellationToken cancellationToken) { var helper = new BatchHelper(this, context.Channel); foreach (var batch in helper.GetBatches()) { batch.Result = EmulateSingleRequest(context.Channel, batch.Request, batch.OriginalIndex, cancellationToken); } return(helper.GetFinalResultOrThrow()); }
private async Task <BulkWriteOperationResult> ExecuteBatchesAsync(IChannelHandle channel, CancellationToken cancellationToken) { var decoratedRequests = DecorateRequests(_requests); var helper = new BatchHelper(decoratedRequests, _writeConcern, _isOrdered); foreach (var batch in helper.Batches) { batch.Result = await ExecuteBatchAsync(channel, batch.RequestSource, batch.OriginalIndex, cancellationToken).ConfigureAwait(false); } return(helper.CreateFinalResultOrThrow(channel)); }
private BulkWriteOperationResult ExecuteBatches(IChannelHandle channel, ICoreSessionHandle session, CancellationToken cancellationToken) { var decoratedRequests = DecorateRequests(_requests); var helper = new BatchHelper(decoratedRequests, _writeConcern, _isOrdered); foreach (var batch in helper.Batches) { batch.Result = ExecuteBatch(channel, session, batch.RequestSource, batch.OriginalIndex, cancellationToken); } return(helper.CreateFinalResultOrThrow(channel)); }
public async Task <List <ClientTradeEntity> > GetTradesByLimitOrderKeysAsync(IEnumerable <string> limitOrderIds) { var result = await BatchHelper.BatchGetDataAsync( null, _partitionKey, limitOrderIds, _storage, _log); return(result); }
private void BatchImportForm_Load(object sender, EventArgs e) { BatchHelper h = new BatchHelper(MainForm.CurrentProject, _records, "UDTService.DML.Command"); h.Size = 200; this.progressBar1.Maximum = h.BatchCount; this.progressBar1.Value = 0; h.CompleteOne += new EventHandler(h_CompleteOne); h.CompleteAll += new EventHandler(h_CompleteAll); h.OccuredError += new System.IO.ErrorEventHandler(h_OccuredError); h.Start(); }
/// <inheritdoc/> public async Task <BulkWriteOperationResult> ExecuteAsync(IWriteBinding binding, CancellationToken cancellationToken) { using (EventContext.BeginOperation()) using (var context = await RetryableWriteContext.CreateAsync(binding, _retryRequested, cancellationToken).ConfigureAwait(false)) { context.DisableRetriesIfAnyWriteRequestIsNotRetryable(_requests); var helper = new BatchHelper(_requests, _isOrdered, _writeConcern); foreach (var batch in helper.GetBatches()) { batch.Result = await ExecuteBatchAsync(context, batch, cancellationToken).ConfigureAwait(false); } return(helper.GetFinalResultOrThrow(context.Channel.ConnectionDescription.ConnectionId)); } }
protected virtual IEnumerable <SortModel> GetSortModels(DataLoading dataLoading, int recordRequestNumber) { if (dataLoading == DataLoading.BatchLoad) { foreach (var batch in BatchHelper.GetSortModels(recordRequestNumber)) { yield return(batch); } } else { yield return(new SortModel(recordRequestNumber, int.MaxValue)); } }
/// <summary> /// Executes the authentication operation asynchronous with no result. /// </summary> /// <param name="operation">The operation name.</param> /// <param name="operationParameters">The operation parameters.</param> /// <returns>No return.</returns> public async Task ExecuteAuthenticationOperationAsync(string operation, params OperationParameter[] operationParameters) { if (BatchHelper.IsInBatchMode(this.batchId)) { throw new NotSupportedException("Authentication operations are not supported in batch mode."); } if (this.authenticationProvider == null) { throw new NotSupportedException("Authentication provider is not set."); } await this.authenticationProvider.ExecuteAuthenticationSingleResultOperationAsync <object>(operation, operationParameters); }
/// <inheritdoc/> public async Task <BulkWriteOperationResult> ExecuteAsync(IWriteBinding binding, CancellationToken cancellationToken) { using (EventContext.BeginOperation()) using (var channelSource = await binding.GetWriteChannelSourceAsync(cancellationToken).ConfigureAwait(false)) using (var channel = await channelSource.GetChannelAsync(cancellationToken).ConfigureAwait(false)) { var helper = new BatchHelper(this, channel); foreach (var batch in helper.GetBatches()) { batch.Result = await ExecuteBatchAsync(channel, channelSource.Session, batch.Run, batch.IsLast, cancellationToken).ConfigureAwait(false); } return(helper.GetFinalResultOrThrow()); } }
// public methods /// <inheritdoc/> public BulkWriteOperationResult Execute(IWriteBinding binding, CancellationToken cancellationToken) { using (EventContext.BeginOperation()) using (var channelSource = binding.GetWriteChannelSource(cancellationToken)) using (var channel = channelSource.GetChannel(cancellationToken)) { var helper = new BatchHelper(this, channel); foreach (var batch in helper.GetBatches()) { batch.Result = ExecuteBatch(channel, channelSource.Session, batch.Run, batch.IsLast, cancellationToken); } return(helper.GetFinalResultOrThrow()); } }
public ActionResult Launch(string filePath) { try { CheckFilePath(filePath); var dataFile = new DataFile(filePath, (int)StatusHelper.Processing); Repositories.Files.Add(dataFile); Repositories.SaveChanges(); BatchHelper.StartProcessing(dataFile); AddMessage(SUCCESS, Batch.Success_Launch); } catch (FunctionalException e) { AddMessage(ERROR, e.Message); } return(RedirectToAction("Index")); }
// public methods /// <inheritdoc/> public BulkWriteOperationResult Execute(IWriteBinding binding, CancellationToken cancellationToken) { using (EventContext.BeginOperation()) using (var context = RetryableWriteContext.Create(binding, _retryRequested, cancellationToken)) { EnsureHintIsSupportedIfAnyRequestHasHint(); context.DisableRetriesIfAnyWriteRequestIsNotRetryable(_requests); var helper = new BatchHelper(_requests, _isOrdered, _writeConcern); foreach (var batch in helper.GetBatches()) { batch.Result = ExecuteBatch(context, batch, cancellationToken); } return(helper.GetFinalResultOrThrow(context.Channel.ConnectionDescription.ConnectionId)); } }
public ActionResult Continue(int idProcess) { try { CheckId(idProcess); DataFile dataFile = Repositories.Files.FindDistinctBy(x => x.Id == idProcess); if (dataFile != null) { BatchHelper.StartProcessing(dataFile); AddMessage(SUCCESS, Batch.Success_Continue); } } catch (FunctionalException e) { AddMessage(ERROR, e.Message); } return(RedirectToAction("Index")); }
/// <summary> /// Deletes the specified entity set. /// </summary> /// <typeparam name="T">The type of of entity.</typeparam> /// <param name="entitySet">The entity set.</param> /// <param name="entity">The entity.</param> /// <returns>No return.</returns> public async Task Delete <T>(string entitySet, T entity) where T : ICommerceEntity { if (BatchHelper.IsInBatchMode(this.batchId)) { throw new NotSupportedException("Delete operation is not supported in batch mode, only Read, ReadAll, and Functions are supported."); } string result = await Task.Run(async() => await AdaptorCaller.ExecuteAsync(GetRequestUri(typeof(T).Name, "Delete", new OperationParameter() { Name = "entity", Value = entity }))); result = AdaptorCaller.RemoveCommerceRuntimePrefix(result); TryThrowAsCommerceException(result); }
public void FirstSetupTest() { String dbConnection = ConfigurationManager.AppSettings["HL7ReportableDB"]; List <MSH> msh; using (ExportQueueTable exp = new ExportQueueTable(dbConnection, 0, ProcessStageFilterEnum.Lookup, ProcessStateFilterEnum.Failed, "ResolveHealthConditions")) { msh = BatchHelper.LoadBatches(exp.Items_ExportQueue); } var result = TreeViewHelper.Transform(msh); TreeViewData td = new TreeViewData() { MSHData = msh, TreeData = result }; }
public void GetSortModelsTest(int value, int expectedBatchSize, int expectedFirstStepSize, int expectedNextStepSize) { var actualList = BatchHelper.GetSortModels(value).ToList(); Assert.Equal(2, actualList.Count); var actualBatchSize = actualList.Max(x => x.RecordRequestNumber) - actualList.Min(x => x.Skip); Assert.Equal(expectedBatchSize, actualBatchSize); var actualFirstBatch = actualList.OrderBy(x => x.Skip).First(); Assert.Equal(value, actualFirstBatch.Skip); Assert.Equal(expectedFirstStepSize, actualFirstBatch.Take); var actualLastBatch = actualList.OrderByDescending(x => x.Skip).First(); Assert.Equal(value + actualFirstBatch.Take, actualLastBatch.Skip); Assert.Equal(expectedNextStepSize, actualLastBatch.Take); }
void h_OccuredError(object sender, System.IO.ErrorEventArgs e) { lblInfo.Text = "批次發生錯誤 !!"; Application.DoEvents(); MessageBox.Show("匯入時發生錯誤 : \n" + e.GetException().Message, "錯誤", MessageBoxButtons.OK, MessageBoxIcon.Error); lblInfo.Text = "取消作業中 ....."; Application.DoEvents(); BatchHelper h = sender as BatchHelper; h.Cancel(); lblInfo.Text = "取消完畢 !!"; Application.DoEvents(); this.Close(); }
/// <summary> /// Executes the authentication operation asynchronous with no result. /// </summary> /// <typeparam name="T">The type of the result.</typeparam> /// <param name="operation">The operation name.</param> /// <param name="operationParameters">The operation parameters.</param> /// <returns>No return.</returns> public async Task <T> ExecuteAuthenticationOperationSingleResultAsync <T>(string operation, params OperationParameter[] operationParameters) { if (BatchHelper.IsInBatchMode(this.batchId)) { throw new NotSupportedException("Authentication operations are not supported in batch mode."); } if (this.authenticationProvider == null) { throw new NotSupportedException("Authentication provider is not set."); } T result = await this.authenticationProvider.ExecuteAuthenticationSingleResultOperationAsync <T>(operation, operationParameters); if (string.Equals(operation, CommerceAuthenticationProvider.AcquireTokenActionName)) { this.SetUserToken(result as UserToken); } return(result); }
public async Task<BulkWriteOperationResult> ExecuteAsync(IChannelHandle channel, CancellationToken cancellationToken) { var helper = new BatchHelper(this, channel); foreach (var batch in helper.GetBatches()) { batch.Result = await EmulateSingleRequestAsync(channel, batch.Request, batch.OriginalIndex, cancellationToken).ConfigureAwait(false); } return helper.GetFinalResultOrThrow(); }
// public methods public BulkWriteOperationResult Execute(IChannelHandle channel, CancellationToken cancellationToken) { var helper = new BatchHelper(this, channel); foreach (var batch in helper.GetBatches()) { batch.Result = EmulateSingleRequest(channel, batch.Request, batch.OriginalIndex, cancellationToken); } return helper.GetFinalResultOrThrow(); }