public ErrorViewModel(ErrorContext errorContext, IDictionary<string, object> routeValues, WikiDownConfig config) { if (config == null) { throw new ArgumentNullException("config"); } this.ClientMessage = (errorContext != null) ? errorContext.ClientData : null; var exception = (errorContext != null) ? errorContext.Exception : null; if (exception != null) { this.ExceptionContent = exception.ToString(); this.ExceptionMessage = exception.Message; this.ExceptionTypeName = exception.GetType().Name; } if (routeValues != null) { this.ActionName = routeValues.TryGet("action") as string; this.ControllerName = routeValues.TryGet("controller") as string; } this.config = config; }
internal GroupKeyAggregateInfo( GroupAggregateKind aggregateKind, ErrorContext errCtx, GroupAggregateInfo containingAggregate, ScopeRegion definingScopeRegion) : base( aggregateKind, null /* there is no AST.GroupAggregateExpression corresponding to the group key */, errCtx, containingAggregate, definingScopeRegion) { }
public void NotifyError(ErrorContext context) { Console.WriteLine(); Console.WriteLine("Exception is received."); try { RenderException(context.Exception); } catch { Console.WriteLine("During exception rendering was obtained unhandled exception. For more information, check the log."); } }
//通过menu层传来的消息初始化 public static void InitItemInfo(string frameName, object sender) { if (sender == null) return; selectItem = sender as ITEM_TYPE_C; DATA_ITEM_C getSetting = DseFunctions.GetSetting(globalDefine.STA_NAME, globalDefine.EQU_NAME, selectItem.MenuPath); if (getSetting != null) initSetting = getSetting; else initSetting = new ErrorContext("获取定制失败!!!!"); initInfoTitle = selectItem.Name; }
public static ActionResult Resolve(ErrorContext errorContext, HttpContextBase httpContext) { if (errorContext == null) { throw new ArgumentNullException("errorContext"); } if (httpContext == null) { throw new ArgumentNullException("httpContext"); } return ResolveInternal(errorContext, httpContext) ?? GetDefaultErrorResult(errorContext, httpContext); }
async Task<ErrorHandleResult> MoveToError(ErrorContext errorContext, string errorQueue) { var message = errorContext.Message; Logger.Error($"Moving message '{message.MessageId}' to the error queue '{ errorQueue }' because processing failed due to an exception:", errorContext.Exception); await moveToErrorsExecutor.MoveToErrorQueue(errorQueue, message, errorContext.Exception, errorContext.TransportTransaction).ConfigureAwait(false); if (raiseNotifications) { await eventAggregator.Raise(new MessageFaulted(errorContext, errorQueue)).ConfigureAwait(false); } return ErrorHandleResult.Handled; }
private static ActionResult GetDefaultErrorResult(ErrorContext errorContext, HttpContextBase httpContext) { var model = new ErrorViewModel(errorContext, httpContext.Request.RequestContext.RouteData.Values); var tempData = (httpContext.Session != null) ? httpContext.Session[TempDataSessionStateKey] as TempDataDictionary : null; return new ViewResult { ViewName = "~/Views/Shared/Error.cshtml", MasterName = string.Empty, ViewData = new ViewDataDictionary<ErrorViewModel>(model), TempData = tempData ?? new TempDataDictionary() }; }
async Task<ErrorHandleResult> RaiseImmediateRetryNotifications(ErrorContext errorContext) { Logger.Info($"Immediate Retry is going to retry message '{errorContext.Message.MessageId}' because of an exception:", errorContext.Exception); if (raiseNotifications) { await eventAggregator.Raise( new MessageToBeRetried( attempt: errorContext.ImmediateProcessingFailures - 1, delay: TimeSpan.Zero, immediateRetry: true, errorContext: errorContext)) .ConfigureAwait(false); } return ErrorHandleResult.RetryRequired; }
private static ActionResult ResolveInternal(ErrorContext errorContext, HttpContextBase httpContext) { if (!errorContext.IsHandled) { return null; } var urlHelper = new UrlHelper(httpContext.Request.RequestContext); if (errorContext.IsExceptionOfType<ArticleAccessException>() && !httpContext.User.Identity.IsAuthenticated) { var returnUrl = httpContext.Request.Url.ToRelativePathAndQuery(); string loginUrl = urlHelper.AccountsLogin(returnUrl); return new RedirectResult(loginUrl); } return null; }
/// <summary> /// Invokes the default recovery policy. /// </summary> /// <param name="config">The recoverability configuration.</param> /// <param name="errorContext">The error context.</param> /// <returns>The recoverability action.</returns> public static RecoverabilityAction Invoke(RecoverabilityConfig config, ErrorContext errorContext) { if (errorContext.Exception is MessageDeserializationException) { return RecoverabilityAction.MoveToError(config.Failed.ErrorQueue); } if (errorContext.ImmediateProcessingFailures <= config.Immediate.MaxNumberOfRetries) { return RecoverabilityAction.ImmediateRetry(); } TimeSpan delay; if (TryGetDelay(errorContext.Message, errorContext.DelayedDeliveriesPerformed, config.Delayed, out delay)) { return RecoverabilityAction.DelayedRetry(delay); } return RecoverabilityAction.MoveToError(config.Failed.ErrorQueue); }
public Task<ErrorHandleResult> Invoke(ErrorContext errorContext) { var recoveryAction = recoverabilityPolicy(configuration, errorContext); // When we can't do immediate retries and policy did not honor MaxNumberOfRetries for ImmediateRetries if (recoveryAction is ImmediateRetry && !immediateRetriesAvailable) { Logger.Warn("Recoverability policy requested ImmediateRetry however immediate retries are not available with the current endpoint configuration. Moving message to error queue instead."); return MoveToError(errorContext, configuration.Failed.ErrorQueue); } if (recoveryAction is ImmediateRetry) { return RaiseImmediateRetryNotifications(errorContext); } // When we can't do delayed retries, a policy customization probably didn't honor MaxNumberOfRetries for DelayedRetries if (recoveryAction is DelayedRetry && !delayedRetriesAvailable) { Logger.Warn("Recoverability policy requested DelayedRetry however delayed delivery capability is not available with the current endpoint configuration. Moving message to error queue instead."); return MoveToError(errorContext, configuration.Failed.ErrorQueue); } var delayedRetryAction = recoveryAction as DelayedRetry; if (delayedRetryAction != null) { return DeferMessage(delayedRetryAction, errorContext); } var moveToError = recoveryAction as MoveToError; if (moveToError != null) { return MoveToError(errorContext, moveToError.ErrorQueue); } Logger.Warn("Recoverability policy returned an unsupported recoverability action. Moving message to error queue instead."); return MoveToError(errorContext, configuration.Failed.ErrorQueue); }
static RecoverabilityAction RecoverabilityPolicy(RecoverabilityConfig config, ErrorContext errorContext) { if (errorContext.ImmediateProcessingFailures <= MaxNumberOfImmediateRetries) { return RecoverabilityAction.ImmediateRetry(); } return RecoverabilityAction.MoveToError(config.Failed.ErrorQueue); }
public override bool Validate(Severity severity, string propertyName, ObjectType objectType, string objectName, string propertyNameValue, ErrorContext errorContext) { bool result = true; if (propertyNameValue == null || !base.IsUnique(propertyNameValue)) { errorContext.Register(ProcessingErrorCode.rsInvalidCustomPropertyName, severity, objectType, objectName, propertyNameValue); result = false; } return(result); }
public override void CheckContainerJoinForNaturalJoin(IRIFDataScope startScope, ErrorContext errorContext, IRIFDataScope scope) { DataSet dataSet = scope.DataScopeInfo.DataSet; base.CheckContainerRelationshipForNaturalJoin(startScope, errorContext, scope, this.GetActiveRowRelationship(dataSet)); base.CheckContainerRelationshipForNaturalJoin(startScope, errorContext, scope, this.GetActiveColumnRelationship(dataSet)); }
public LoopsAndConditions(ErrorContext error)//DecompilerContext context) { this.error = error; }
/// <summary> /// Converts boolean literal value. /// </summary> private static bool ConvertBooleanLiteralValue(ErrorContext errCtx, string booleanLiteralValue) { bool result = false; if (!Boolean.TryParse(booleanLiteralValue, out result)) { throw EntityUtil.EntitySqlError(errCtx, System.Data.Entity.Strings.InvalidLiteralFormat("Boolean", booleanLiteralValue)); } return result; }
/// <summary> /// Converts time literal value. /// </summary> private static TimeSpan ConvertTimeLiteralValue(ErrorContext errCtx, string datetimeLiteralValue) { string[] datetimeParts = datetimeLiteralValue.Split(_datetimeSeparators, StringSplitOptions.RemoveEmptyEntries); Debug.Assert(datetimeParts.Length >= 2, "time literal value must have at least 2 parts"); int hour; int minute; int second; int ticks; GetTimeParts(datetimeLiteralValue, datetimeParts, 0, out hour, out minute, out second, out ticks); Debug.Assert(hour >= 0 && hour <= 24); Debug.Assert(minute >= 0 && minute <= 59); Debug.Assert(second >= 0 && second <= 59); Debug.Assert(ticks >= 0 && ticks <= 9999999); TimeSpan ts = new TimeSpan(hour, minute, second); ts = ts.Add(new TimeSpan(ticks)); return ts; }
bool IParameterDef.ValidateValueForBlank(object newValue, ErrorContext errorContext, string parameterValueProperty) { return(ValidateValueForBlank(newValue, errorContext, parameterValueProperty)); }
/// <summary> /// Performs conversion of numeric strings that have no type suffix hint. /// </summary> private static object DefaultNumericConversion(string numericString, ErrorContext errCtx) { if (-1 != numericString.IndexOfAny(_floatTokens)) { Double value; if (!Double.TryParse(numericString, NumberStyles.Float, CultureInfo.InvariantCulture, out value)) { var message = Strings.CannotConvertNumericLiteral(numericString, "double"); throw EntitySqlException.Create(errCtx, message, null); } return value; } else { Int32 int32Value; if (Int32.TryParse(numericString, NumberStyles.Integer, CultureInfo.InvariantCulture, out int32Value)) { return int32Value; } Int64 int64Value; if (!Int64.TryParse(numericString, NumberStyles.Integer, CultureInfo.InvariantCulture, out int64Value)) { var message = Strings.CannotConvertNumericLiteral(numericString, "long"); throw EntitySqlException.Create(errCtx, message, null); } return int64Value; } }
/// <nodoc /> public UndefinedMapKeyException(ErrorContext errorContext) : base("Undefined map key", errorContext) { }
bool IParameterDef.ValidateValueForNull(object newValue, ErrorContext errorContext, string parameterValueProperty) { return(ParameterBase.ValidateValueForNull(newValue, base.Nullable, errorContext, Microsoft.ReportingServices.ReportProcessing.ObjectType.ReportParameter, base.Name, parameterValueProperty)); }
public void Handle(ErrorContext errorContext) { action(errorContext); }
private static RecoverabilityAction SubscriberServiceRetryPolicy(RecoverabilityConfig config, ErrorContext context) { var action = DefaultRecoverabilityPolicy.Invoke(config, context); if (!(action is DelayedRetry delayedRetryAction)) { return(action); } if (context.Exception is UserNotFoundException) { return(RecoverabilityAction.MoveToError(config.Failed.ErrorQueue)); } // Override default delivery delay. /* var recoverability = endpointConfiguration.Recoverability(); * recoverability.Delayed( * customizations: delayed => * { * delayed.NumberOfRetries(3); * delayed.TimeIncrease(TimeSpan.FromMinutes(3)); * });*/ return(RecoverabilityAction.DelayedRetry(TimeSpan.FromMinutes(3))); }
/// <nodoc /> public UndefinedSetItemException(ErrorContext errorContext) : base("Undefined set item", errorContext) { }
public bool LogValue(DateTime timestamp, long value, List<string> measureMetric, ErrorContext errorContext) { if (measureMetric.Count != this.dimensionNames.Length) { errorContext.ErrorMessage = $"{measureMetric.Count} dimension values were passed while the metric has {this.dimensionNames.Length} dimensions"; return false; } try { return this.wrappedMeasureMetric.LogValue(timestamp, value, ref errorContext, measureMetric.ToArray()); } catch (Exception e) { errorContext.ErrorMessage = e.Message; return false; } }
internal void Parse(string name, List <string> defaultValues, string type, string nullable, ExpressionInfo prompt, string promptUser, string allowBlank, string multiValue, string usedInQuery, bool hidden, ErrorContext errorContext, CultureInfo language) { base.Parse(name, defaultValues, type, nullable, prompt, promptUser, allowBlank, multiValue, usedInQuery, hidden, errorContext, language); if (hidden) { m_prompt = ExpressionInfo.CreateConstExpression(""); } else if (prompt == null) { m_prompt = ExpressionInfo.CreateConstExpression(name + ":"); } else { m_prompt = prompt; } ValidateExpressionDataTypes(m_validValuesValueExpressions, errorContext, name, "ValidValue", fromValidValues: true, language); ValidateExpressionDataTypes(m_defaultExpressions, errorContext, name, "DefaultValue", fromValidValues: false, language); }
async Task Process(BasicDeliverEventArgs message) { Dictionary <string, string> headers; try { headers = messageConverter.RetrieveHeaders(message); } catch (Exception ex) { Logger.Error($"Failed to retrieve headers from poison message. Moving message to queue '{settings.ErrorQueue}'...", ex); await MovePoisonMessage(message, settings.ErrorQueue).ConfigureAwait(false); return; } string messageId; try { messageId = messageConverter.RetrieveMessageId(message, headers); } catch (Exception ex) { Logger.Error($"Failed to retrieve ID from poison message. Moving message to queue '{settings.ErrorQueue}'...", ex); await MovePoisonMessage(message, settings.ErrorQueue).ConfigureAwait(false); return; } using (var tokenSource = new CancellationTokenSource()) { var processed = false; var errorHandled = false; var numberOfDeliveryAttempts = 0; var messageBody = message.Body.ToArray(); while (!processed && !errorHandled) { try { var contextBag = new ContextBag(); contextBag.Set(message); var messageContext = new MessageContext(messageId, headers, messageBody ?? Array.Empty <byte>(), transportTransaction, tokenSource, contextBag); await onMessage(messageContext).ConfigureAwait(false); processed = true; } catch (Exception exception) { ++numberOfDeliveryAttempts; headers = messageConverter.RetrieveHeaders(message); var contextBag = new ContextBag(); contextBag.Set(message); var errorContext = new ErrorContext(exception, headers, messageId, messageBody ?? Array.Empty <byte>(), transportTransaction, numberOfDeliveryAttempts, contextBag); try { errorHandled = await onError(errorContext).ConfigureAwait(false) == ErrorHandleResult.Handled; if (!errorHandled) { headers = messageConverter.RetrieveHeaders(message); } } catch (Exception ex) { criticalError.Raise($"Failed to execute recoverability policy for message with native ID: `{messageId}`", ex); await consumer.Model.BasicRejectAndRequeueIfOpen(message.DeliveryTag).ConfigureAwait(false); return; } } } if (processed && tokenSource.IsCancellationRequested) { await consumer.Model.BasicRejectAndRequeueIfOpen(message.DeliveryTag).ConfigureAwait(false); } else { try { await consumer.Model.BasicAckSingle(message.DeliveryTag).ConfigureAwait(false); } catch (AlreadyClosedException ex) { Logger.Warn($"Failed to acknowledge message '{messageId}' because the channel was closed. The message was returned to the queue.", ex); } } } }
private void ValidateExpressionDataTypes(List <ExpressionInfo> expressions, ErrorContext errorContext, string paramName, string memberName, bool fromValidValues, CultureInfo language) { if (expressions == null) { return; } int num = expressions.Count - 1; while (true) { if (num < 0) { return; } ExpressionInfo expressionInfo = expressions[num]; if (fromValidValues && expressionInfo == null && base.MultiValue) { m_validValuesValueExpressions.RemoveAt(num); } else if (expressionInfo != null && ExpressionInfo.Types.Constant == expressionInfo.Type) { if (!ParameterBase.CastFromString(expressionInfo.StringValue, out object newValue, base.DataType, language)) { if (errorContext == null) { break; } errorContext.Register(ProcessingErrorCode.rsParameterPropertyTypeMismatch, Severity.Error, Microsoft.ReportingServices.ReportProcessing.ObjectType.ReportParameter, paramName, memberName); } else { ValidateValue(newValue, errorContext, Microsoft.ReportingServices.ReportProcessing.ObjectType.ReportParameter, memberName); if (newValue != null && base.DataType != DataType.String) { ExpressionInfo expressionInfo2 = new ExpressionInfo(); expressionInfo2.Type = ExpressionInfo.Types.Constant; expressionInfo2.OriginalText = expressionInfo.OriginalText; expressionInfo2.ConstantType = base.DataType; expressions[num] = expressionInfo2; switch (base.DataType) { case DataType.Boolean: expressionInfo2.BoolValue = (bool)newValue; break; case DataType.DateTime: if (newValue is DateTimeOffset) { expressionInfo2.SetDateTimeValue((DateTimeOffset)newValue); } else { expressionInfo2.SetDateTimeValue((DateTime)newValue); } break; case DataType.Float: expressionInfo2.FloatValue = (double)newValue; break; case DataType.Integer: expressionInfo2.IntValue = (int)newValue; break; } } } } num--; }
private static object ConvertNumericLiteral(ErrorContext errCtx, string numericString) { int k = numericString.IndexOfAny(numberSuffixes); if (-1 != k) { string suffix = numericString.Substring(k).ToUpperInvariant(); string numberPart = numericString.Substring(0, numericString.Length - suffix.Length); switch (suffix) { case "U": { UInt32 value; if (!UInt32.TryParse(numberPart, NumberStyles.Integer, CultureInfo.InvariantCulture, out value)) { throw EntityUtil.EntitySqlError(errCtx, System.Data.Entity.Strings.CannotConvertNumericLiteral(numericString, "unsigned int")); } return value; } ; case "L": { long value; if (!Int64.TryParse(numberPart, NumberStyles.Integer, CultureInfo.InvariantCulture, out value)) { throw EntityUtil.EntitySqlError(errCtx, System.Data.Entity.Strings.CannotConvertNumericLiteral(numericString, "long")); } return value; } ; case "UL": case "LU": { UInt64 value; if (!UInt64.TryParse(numberPart, NumberStyles.Integer, CultureInfo.InvariantCulture, out value)) { throw EntityUtil.EntitySqlError(errCtx, System.Data.Entity.Strings.CannotConvertNumericLiteral(numericString, "unsigned long")); } return value; } ; case "F": { Single value; if (!Single.TryParse(numberPart, NumberStyles.Float, CultureInfo.InvariantCulture, out value)) { throw EntityUtil.EntitySqlError(errCtx, System.Data.Entity.Strings.CannotConvertNumericLiteral(numericString, "float")); } return value; } ; case "M": { Decimal value; if (!Decimal.TryParse(numberPart, NumberStyles.AllowLeadingSign | NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out value)) { throw EntityUtil.EntitySqlError(errCtx, System.Data.Entity.Strings.CannotConvertNumericLiteral(numericString, "decimal")); } return value; } ; case "D": { Double value; if (!Double.TryParse(numberPart, NumberStyles.Float, CultureInfo.InvariantCulture, out value)) { throw EntityUtil.EntitySqlError(errCtx, System.Data.Entity.Strings.CannotConvertNumericLiteral(numericString, "double")); } return value; } ; } } // // If hit this point, try default conversion // return DefaultNumericConversion(numericString, errCtx); }
internal override void CheckContainerJoinForNaturalJoin(IRIFDataScope startScope, ErrorContext errorContext, IRIFDataScope scope) { CheckContainerRelationshipForNaturalJoin(startScope, errorContext, scope, GetActiveRelationship(scope.DataScopeInfo.DataSet)); }
/// <summary> /// Converts datetime literal value. /// </summary> private static DateTime ConvertDateTimeLiteralValue(ErrorContext errCtx, string datetimeLiteralValue) { string[] datetimeParts = datetimeLiteralValue.Split(_datetimeSeparators, StringSplitOptions.RemoveEmptyEntries); Debug.Assert(datetimeParts.Length >= 5, "datetime literal value must have at least 5 parts"); int year; int month; int day; GetDateParts(datetimeLiteralValue, datetimeParts, out year, out month, out day); int hour; int minute; int second; int ticks; GetTimeParts(datetimeLiteralValue, datetimeParts, 3, out hour, out minute, out second, out ticks); Debug.Assert(year >= 1 && year <= 9999); Debug.Assert(month >= 1 && month <= 12); Debug.Assert(day >= 1 && day <= 31); Debug.Assert(hour >= 0 && hour <= 24); Debug.Assert(minute >= 0 && minute <= 59); Debug.Assert(second >= 0 && second <= 59); Debug.Assert(ticks >= 0 && ticks <= 9999999); DateTime dateTime = new DateTime(year, month, day, hour, minute, second, 0); dateTime = dateTime.AddTicks(ticks); return dateTime; }
async Task ProcessFile(ILearningTransportTransaction transaction, string messageId, CancellationToken messageProcessingCancellationToken) { var message = await AsyncFile.ReadText(transaction.FileToProcess, messageProcessingCancellationToken) .ConfigureAwait(false); var bodyPath = Path.Combine(bodyDir, $"{messageId}{BodyFileSuffix}"); var headers = HeaderSerializer.Deserialize(message); if (headers.TryGetValue(LearningTransportHeaders.TimeToBeReceived, out var ttbrString)) { headers.Remove(LearningTransportHeaders.TimeToBeReceived); var ttbr = TimeSpan.Parse(ttbrString); //file.move preserves create time var sentTime = File.GetCreationTimeUtc(transaction.FileToProcess); var utcNow = DateTime.UtcNow; if (sentTime + ttbr < utcNow) { await transaction.Commit(messageProcessingCancellationToken) .ConfigureAwait(false); log.InfoFormat("Dropping message '{0}' as the specified TimeToBeReceived of '{1}' expired since sending the message at '{2:O}'. Current UTC time is '{3:O}'", messageId, ttbrString, sentTime, utcNow); return; } } var body = await AsyncFile.ReadBytes(bodyPath, messageProcessingCancellationToken) .ConfigureAwait(false); var transportTransaction = new TransportTransaction(); if (transactionMode == TransportTransactionMode.SendsAtomicWithReceive) { transportTransaction.Set(transaction); } var processingContext = new ContextBag(); var messageContext = new MessageContext(messageId, headers, body, transportTransaction, processingContext); try { await onMessage(messageContext, messageProcessingCancellationToken) .ConfigureAwait(false); } catch (OperationCanceledException ex) when(messageProcessingCancellationToken.IsCancellationRequested) { log.Info("Message processing cancelled. Rolling back transaction.", ex); transaction.Rollback(); return; } catch (Exception exception) { transaction.ClearPendingOutgoingOperations(); var processingFailures = retryCounts.AddOrUpdate(messageId, id => 1, (id, currentCount) => currentCount + 1); headers = HeaderSerializer.Deserialize(message); headers.Remove(LearningTransportHeaders.TimeToBeReceived); var errorContext = new ErrorContext(exception, headers, messageId, body, transportTransaction, processingFailures, processingContext); ErrorHandleResult result; try { result = await onError(errorContext, messageProcessingCancellationToken).ConfigureAwait(false); } catch (OperationCanceledException ex) when(messageProcessingCancellationToken.IsCancellationRequested) { log.Info("Message processing cancelled. Rolling back transaction.", ex); transaction.Rollback(); return; } catch (Exception ex) { criticalErrorAction($"Failed to execute recoverability policy for message with native ID: `{messageContext.NativeMessageId}`", ex, CancellationToken.None); result = ErrorHandleResult.RetryRequired; } if (result == ErrorHandleResult.RetryRequired) { transaction.Rollback(); return; } } await transaction.Commit(messageProcessingCancellationToken).ConfigureAwait(false); }
public void OnError(ErrorContext context) { _writer.NotifyError(context); }
protected async Task<ErrorHandleResult> HandleError(Message message, Dictionary<string, string> headers, Exception exception, TransportTransaction transportTransaction, int processingAttempts) { try { var body = await ReadStream(message.BodyStream).ConfigureAwait(false); var errorContext = new ErrorContext(exception, headers, message.Id, body, transportTransaction, processingAttempts); return await onError(errorContext).ConfigureAwait(false); } catch (Exception ex) { criticalError.Raise($"Failed to execute recoverability actions for message `{message.Id}`", ex); //best thing we can do is roll the message back if possible return ErrorHandleResult.RetryRequired; } }
public RecoverabilityAction Invoke(RecoverabilityConfig config, ErrorContext errorContext) { return(actions.Dequeue()); }
internal void OnDerivedErrorMethod(StreamingContext context, ErrorContext errorContext) { }
protected MessageProcessingFailed(ErrorContext errorContext) { Message = errorContext.Message; Exception = errorContext.Exception; ErrorContext = errorContext; }
/// <summary> /// Initializes a new instance EntityException with an ErrorContext instance and a given error message. /// </summary> internal static EntitySqlException Create(ErrorContext errCtx, string errorMessage, Exception innerException) { return(Create( errCtx.CommandText, errorMessage, errCtx.InputPosition, errCtx.ErrorContextInfo, errCtx.UseContextInfoAsResourceIdentifier, innerException)); }
async Task ProcessMessage(IMessageReceiverInternal internalReceiver, BrokeredMessage message, int slotNumber) { if (stopping) { logger.Info($"Received message with ID {message.MessageId} while shutting down. Message will not be processed and will be retried after {message.LockedUntilUtc}."); return; } try { IncomingMessageDetailsInternal incomingMessage; try { incomingMessage = brokeredMessageConverter.Convert(message); } catch (UnsupportedBrokeredMessageBodyTypeException exception) { await message.DeadLetterAsync("BrokeredMessage to IncomingMessageDetails conversion failure", exception.ToString()).ConfigureAwait(false); return; } var context = new BrokeredMessageReceiveContextInternal(message, entity, internalReceiver.Mode); var scope = wrapInScope ? new TransactionScope(TransactionScopeOption.RequiresNew, new TransactionOptions { IsolationLevel = IsolationLevel.Serializable }, TransactionScopeAsyncFlowOption.Enabled) : null; { using (scope) { var wasCompleted = false; try { await incomingCallback(incomingMessage, context).ConfigureAwait(false); if (context.CancellationToken.IsCancellationRequested) { await AbandonOnCancellation(message).ConfigureAwait(false); } else { wasCompleted = await HandleCompletion(message, context, completionCanBeBatched, slotNumber).ConfigureAwait(false); } } catch (Exception exception) when(!stopping) { // and go into recovery mode so that no new messages are added to the transfer queue context.Recovering = true; // pass the context into the error pipeline var transportTransaction = new TransportTransaction(); transportTransaction.Set(context); var errorContext = new ErrorContext(exception, brokeredMessageConverter.GetHeaders(message), incomingMessage.MessageId, incomingMessage.Body, transportTransaction, message.DeliveryCount); var result = await processingFailureCallback(errorContext).ConfigureAwait(false); if (result == ErrorHandleResult.RetryRequired) { await Abandon(message, exception).ConfigureAwait(false); } else { wasCompleted = await HandleCompletion(message, context, completionCanBeBatched, slotNumber).ConfigureAwait(false); } } finally { if (wasCompleted) { scope?.Complete(); } } } } } catch (Exception onErrorException) { await Abandon(message, onErrorException).ConfigureAwait(false); await errorCallback(onErrorException).ConfigureAwait(false); } }
public void MergeCollationSettings(ErrorContext errorContext, string dataSourceType, string cultureName, bool caseSensitive, bool accentSensitive, bool kanatypeSensitive, bool widthSensitive) { this.m_dataSetCore.MergeCollationSettings(errorContext, dataSourceType, cultureName, caseSensitive, accentSensitive, kanatypeSensitive, widthSensitive); }
public override bool Validate(Severity severity, ObjectType objectType, string objectName, string propertyNameValue, ErrorContext errorContext) { Global.Tracer.Assert(false); return(this.Validate(severity, "", objectType, objectName, propertyNameValue, errorContext)); }
internal void OnErrorMethod(StreamingContext context, ErrorContext errorContext) { Messages.Add(errorContext.Path + " - Error message for member " + errorContext.Member + " = " + errorContext.Error.Message); errorContext.Handled = true; }
static void Main(string[] args) { // Context.doThreads = false; // Context.doXML = true; // Context.doAssigmentOffsets = true; // ugh have to do it here? string dataWinFileName = args.ElementAtOrDefault(0); if (string.IsNullOrWhiteSpace(dataWinFileName)) { InstructionError("Missing data.win file"); } try { File.LoadDataWin(dataWinFileName); } catch (Exception e) { Context.Error(e); InstructionError("Could not open data.win file {0}\n Exception:", dataWinFileName, e.Message); } List<string> chunks = new List<string>(); byte[] changedData = null; for(int i=1; i < args.Length; i++) { string a = args[i]; if (string.IsNullOrWhiteSpace(a)) continue; // does this ever happen? switch (a) { case "-printOffset": { Context.saveChangedDataWin = true; string offset_name = args.ElementAtOrDefault(i + 1); i += 1; uint offset_int; if (!TryParseOffset(offset_name, out offset_int)) Context.FatalError("Cannot parse {0} value in -printOffset", offset_name); Context.Message(Context.FormatDebugOffset(changedData ?? File.DataWinRaw, (int)offset_int)); } break; case "-changeInt": case "-changeShort": { Context.saveChangedDataWin = true; string offset_name = args.ElementAtOrDefault(i + 1); string to_value = args.ElementAtOrDefault(i + 2); i += 2; uint offset_int; int to_int; if (!TryParseOffset(offset_name, out offset_int)) Context.FatalError("Cannot parse {0} value in -changeShort", offset_name); if (!TryParseHex(to_value, out to_int)) Context.FatalError("Cannot parse {0} value in -changeShort", to_value); if (changedData == null) { changedData = File.CopyData(); File.LoadEveything(); } if(a == "-changeShort") File.ChangeOffset(changedData, offset_int, (short)to_int); else File.ChangeOffset(changedData, offset_int, to_int); } break; case "-changeVar": { Context.saveChangedDataWin = true; string code_name = args.ElementAtOrDefault(i + 1); string var_name = args.ElementAtOrDefault(i + 2) ?? ""; string from_value = args.ElementAtOrDefault(i + 3) ?? ""; string to_value = args.ElementAtOrDefault(i + 4) ?? ""; int from_int; int to_int; if (!TryParseHex(from_value, out from_int)) Context.FatalError("Cannot parse {0} value in -change",from_value); if (!TryParseHex(to_value, out to_int)) Context.FatalError("Cannot parse {0} value in -change", to_value); i += 4; if (changedData == null) { changedData = File.CopyData(); File.LoadEveything(); } File.Code code=null; File.Script script=null; if (File.TryLookup(code_name, out code) || File.TryLookup(code_name, out script)) { if (script != null) code = script.Code; File.ChangeVarValue(changedData, code, var_name, from_int, to_int); } else Context.Error("'{0}' code/script not found", code_name); } break; case "-output": { i++; string dir = args.ElementAtOrDefault(i); if(string.IsNullOrWhiteSpace(dir)) InstructionError("Missing otuput directory"); Context.CheckAndSetOutputDirectory(dir); } break; case "-delete": Context.deleteDirectorys = true; break; case "-lua": Context.doLua = true; Context.doXML = false; break; case "-oneFile": Context.oneFile = true; break; case "-constOffsets": Context.doAssigmentOffsets = true; break; case "-mask": Context.saveAllMasks = true; break; case "-png": Context.saveAllPngs = true; break; case "-xml": Context.doXML = true; break; case "-search": Context.doSearch = true; break; case "-json": Context.doXML = false; break; case "-old": Context.Version = UndertaleVersion.V10000; break; case "-debug": Context.Debug = true; break; case "-nothread": Context.doThreads = false; break; case "-watch": Context.debugSearch = true; break; default: if (a[0] == '-') InstructionError("bad flag '{0}'", a); if (char.IsLetter(a[0])) chunks.Add(a); break; } } Context.CheckAndSetOutputDirectory(); ErrorContext.StartErrorSystem(); if (Context.saveChangedDataWin) { if (changedData != null) { using (var file = Context.CreateFileStream("changed_data.win", FileMode.Create, true)) { file.Write(changedData, 0, changedData.Length); file.Flush(); } } } else { File.LoadEveything(); var w = new Writers.AllWriter(); if (Context.doSearch) { var results = File.Search(chunks); if (results.Count == 0) Context.Error("No data found in search"); string path = "."; if (Context.doThreads) { Parallel.ForEach(results, result => AllWriter.DoSingleItem(path, result)); } else { foreach (var result in results) AllWriter.DoSingleItem(path, result); } } else if (Context.debugSearch) { Context.doThreads = false; Context.Debug = true; var results = File.Search(chunks); if (results.Count == 0) Context.FatalError("No data found in search"); foreach (var f in new DirectoryInfo(".").GetFiles("*.txt")) { if (System.IO.Path.GetFileName(f.Name) != "errors.txt") f.Delete(); // clear out eveything } foreach (var a in results) { File.Code c = a as File.Code; if (c != null) { var error = new ErrorContext(c.Name); error.Message("Decompiling"); Context.Debug = true; var block = c.Block; if (block != null) { using (Writers.BlockToCode to = new Writers.BlockToCode(c.Name + "_watch.js")) to.Write(block); error.Message("Finished Decompiling"); } else error.Message("Block is null"); } else Context.Error("Code '{0} not found", a); } //Context.HackyDebugWatch = new HashSet<string>(chunks); // w.AddAction("code"); } else { if (chunks.Count == 0) chunks.Add("everything"); foreach (var a in chunks) w.AddAction(a); } w.FinishProcessing(); } GoodExit(); }
internal void RetrieveSubreport() { if (!m_isNewContext) { return; } if (m_isOldSnapshot) { Microsoft.ReportingServices.ReportRendering.SubReport subReport = (Microsoft.ReportingServices.ReportRendering.SubReport)m_renderReportItem; if (subReport.Report != null) { if (m_report == null) { m_report = new Report(this, m_inSubtotal, subReport, m_renderingContext); } else { m_report.UpdateSubReportContents(this, subReport); } } m_noRows = subReport.NoRows; m_processedWithError = subReport.ProcessedWithError; } else { Microsoft.ReportingServices.ReportIntermediateFormat.SubReport subReport2 = (Microsoft.ReportingServices.ReportIntermediateFormat.SubReport)m_reportItemDef; RenderingContext renderingContext = null; try { if (subReport2.ExceededMaxLevel) { m_errorCode = SubReportErrorCodes.ExceededMaxRecursionLevel; m_errorMessage = RPRes.rsExceededMaxRecursionLevel(subReport2.Name); FinalizeErrorMessageAndThrow(); } else { CheckRetrievalStatus(subReport2.RetrievalStatus); } if (m_renderingContext.InstanceAccessDisallowed) { renderingContext = GetOrCreateRenderingContext(subReport2, null); renderingContext.SubReportHasNoInstance = true; } else { m_renderingContext.OdpContext.SetupContext(subReport2, base.Instance.ReportScopeInstance); if (subReport2.CurrentSubReportInstance == null) { renderingContext = GetOrCreateRenderingContext(subReport2, null); renderingContext.SubReportHasNoInstance = true; } else { Microsoft.ReportingServices.ReportIntermediateFormat.SubReportInstance subReportInstance = subReport2.CurrentSubReportInstance.Value(); m_noRows = subReportInstance.NoRows; m_processedWithError = subReportInstance.ProcessedWithError; if (m_processedWithError) { CheckRetrievalStatus(subReportInstance.RetrievalStatus); } Microsoft.ReportingServices.ReportIntermediateFormat.ReportInstance reportInstance = subReportInstance.ReportInstance.Value(); renderingContext = GetOrCreateRenderingContext(subReport2, reportInstance); renderingContext.OdpContext.LoadExistingSubReportDataChunkNameModifier(subReportInstance); renderingContext.OdpContext.SetSubReportContext(subReportInstance, setupReportOM: true); reportInstance.SetupEnvironment(renderingContext.OdpContext); } } } catch (Exception e) { m_processedWithError = true; ErrorContext subReportErrorContext = null; if (subReport2.OdpContext != null) { subReportErrorContext = subReport2.OdpContext.ErrorContext; } if (renderingContext == null && m_report != null) { renderingContext = m_report.RenderingContext; } Microsoft.ReportingServices.ReportProcessing.ReportProcessing.HandleSubReportProcessingError(m_renderingContext.OdpContext.TopLevelContext.ErrorContext, subReport2, subReport2.UniqueName, subReportErrorContext, e); } if (renderingContext != null) { renderingContext.SubReportProcessedWithError = m_processedWithError; } } if (m_processedWithError) { m_noRows = false; if (m_errorCode == SubReportErrorCodes.Success) { m_errorCode = SubReportErrorCodes.ProcessingError; m_errorMessage = RPRes.rsRenderSubreportError; } } m_isNewContext = false; }
public MessageFaulted(ErrorContext errorContext, string errorQueue) : base(errorContext) { ErrorQueue = errorQueue; }
public MessageToBeRetried(int attempt, TimeSpan delay, bool immediateRetry, ErrorContext errorContext) : base(errorContext) { Attempt = attempt; Delay = delay; IsImmediateRetry = immediateRetry; }
/// <summary> /// Converts boolean literal value. /// </summary> private static bool ConvertBooleanLiteralValue(ErrorContext errCtx, string booleanLiteralValue) { var result = false; if (!Boolean.TryParse(booleanLiteralValue, out result)) { var message = Strings.InvalidLiteralFormat("Boolean", booleanLiteralValue); throw EntitySqlException.Create(errCtx, message, null); } return result; }
async Task ProcessFile(ILearningTransportTransaction transaction, string messageId) { string message; try { message = await AsyncFile.ReadText(transaction.FileToProcess) .ConfigureAwait(false); } catch (Exception e) { Console.WriteLine(e); throw; } var bodyPath = Path.Combine(bodyDir, $"{messageId}{BodyFileSuffix}"); var headers = HeaderSerializer.Deserialize(message); if (headers.TryGetValue(Headers.TimeToBeReceived, out var ttbrString)) { var ttbr = TimeSpan.Parse(ttbrString); //file.move preserves create time var sentTime = File.GetCreationTimeUtc(transaction.FileToProcess); if (sentTime + ttbr < DateTime.UtcNow) { await transaction.Commit() .ConfigureAwait(false); return; } } var tokenSource = new CancellationTokenSource(); var body = await AsyncFile.ReadBytes(bodyPath, cancellationToken) .ConfigureAwait(false); var transportTransaction = new TransportTransaction(); if (transactionMode == TransportTransactionMode.SendsAtomicWithReceive) { transportTransaction.Set(transaction); } var messageContext = new MessageContext(messageId, headers, body, transportTransaction, tokenSource, new ContextBag()); try { await onMessage(messageContext) .ConfigureAwait(false); } catch (Exception exception) { transaction.ClearPendingOutgoingOperations(); var processingFailures = retryCounts.AddOrUpdate(messageId, id => 1, (id, currentCount) => currentCount + 1); var errorContext = new ErrorContext(exception, headers, messageId, body, transportTransaction, processingFailures); // the transport tests assume that all transports use a circuit breaker to be resillient against exceptions // in onError. Since we don't need that robustness we just retry onError once should it fail. ErrorHandleResult actionToTake; try { actionToTake = await onError(errorContext) .ConfigureAwait(false); } catch (Exception) { actionToTake = await onError(errorContext) .ConfigureAwait(false); } if (actionToTake == ErrorHandleResult.RetryRequired) { transaction.Rollback(); return; } } if (tokenSource.IsCancellationRequested) { transaction.Rollback(); return; } await transaction.Commit() .ConfigureAwait(false); }
/// <summary> /// Performs conversion of numeric strings that have no type suffix hint. /// </summary> private static object DefaultNumericConversion(string numericString, ErrorContext errCtx) { if (-1 != numericString.IndexOfAny(floatTokens)) { Double value; if (!Double.TryParse(numericString, NumberStyles.Float, CultureInfo.InvariantCulture, out value)) { throw EntityUtil.EntitySqlError(errCtx, System.Data.Entity.Strings.CannotConvertNumericLiteral(numericString, "double")); } return value; } else { Int32 int32Value; if (Int32.TryParse(numericString, NumberStyles.Integer, CultureInfo.InvariantCulture, out int32Value)) { return int32Value; } Int64 int64Value; if (!Int64.TryParse(numericString, NumberStyles.Integer, CultureInfo.InvariantCulture, out int64Value)) { throw EntityUtil.EntitySqlError(errCtx, System.Data.Entity.Strings.CannotConvertNumericLiteral(numericString, "long")); } return int64Value; } }
internal void OnError(StreamingContext context, ErrorContext errorContext) { errorContext.Handled = true; }
/// <summary> /// Converts hex string to byte array. /// </summary> private static byte[] ConvertBinaryLiteralValue(ErrorContext errCtx, string binaryLiteralValue) { Debug.Assert(null != binaryLiteralValue, "binaryStringLiteral must not be null"); if (String.IsNullOrEmpty(binaryLiteralValue)) { return _emptyByteArray; } int startIndex = 0; int endIndex = binaryLiteralValue.Length - 1; Debug.Assert(startIndex <= endIndex, "startIndex <= endIndex"); int binaryStringLen = endIndex - startIndex + 1; int byteArrayLen = binaryStringLen / 2; bool hasOddBytes = 0 != (binaryStringLen % 2); if (hasOddBytes) { byteArrayLen++; } byte[] binaryValue = new byte[byteArrayLen]; int arrayIndex = 0; if (hasOddBytes) { binaryValue[arrayIndex++] = (byte)HexDigitToBinaryValue(binaryLiteralValue[startIndex++]); } while (startIndex < endIndex) { binaryValue[arrayIndex++] = (byte)((HexDigitToBinaryValue(binaryLiteralValue[startIndex++]) << 4) | HexDigitToBinaryValue(binaryLiteralValue[startIndex++])); } return binaryValue; }
internal void OnError(StreamingContext context, ErrorContext errorContext) { UnityEngine.Debug.LogError("Serialization Error: " + errorContext.Error.Message); errorContext.Handled = true; }
private static DateTimeOffset ConvertDateTimeOffsetLiteralValue(ErrorContext errCtx, string datetimeLiteralValue) { string[] datetimeParts = datetimeLiteralValue.Split(_datetimeOffsetSeparators, StringSplitOptions.RemoveEmptyEntries); Debug.Assert(datetimeParts.Length >= 7, "datetime literal value must have at least 7 parts"); int year; int month; int day; GetDateParts(datetimeLiteralValue, datetimeParts, out year, out month, out day); int hour; int minute; int second; int ticks; //Copy the time parts into a different array since the last two parts will be handled in this method. string[] timeParts = new String[datetimeParts.Length - 2]; Array.Copy(datetimeParts, timeParts, datetimeParts.Length - 2); GetTimeParts(datetimeLiteralValue, timeParts, 3, out hour, out minute, out second, out ticks); Debug.Assert(year >= 1 && year <= 9999); Debug.Assert(month >= 1 && month <= 12); Debug.Assert(day >= 1 && day <= 31); Debug.Assert(hour >= 0 && hour <= 24); Debug.Assert(minute >= 0 && minute <= 59); Debug.Assert(second >= 0 && second <= 59); Debug.Assert(ticks >= 0 && ticks <= 9999999); int offsetHours = Int32.Parse(datetimeParts[datetimeParts.Length - 2], NumberStyles.Integer, CultureInfo.InvariantCulture); int offsetMinutes = Int32.Parse(datetimeParts[datetimeParts.Length - 1], NumberStyles.Integer, CultureInfo.InvariantCulture); TimeSpan offsetTimeSpan = new TimeSpan(offsetHours, offsetMinutes, 0); //If DateTimeOffset had a negative offset, we should negate the timespan if (datetimeLiteralValue.IndexOf('+') == -1) { offsetTimeSpan = offsetTimeSpan.Negate(); } DateTime dateTime = new DateTime(year, month, day, hour, minute, second, 0); dateTime = dateTime.AddTicks(ticks); try { return new DateTimeOffset(dateTime, offsetTimeSpan); } catch (ArgumentOutOfRangeException e) { throw EntityUtil.EntitySqlError(errCtx, System.Data.Entity.Strings.InvalidDateTimeOffsetLiteral(datetimeLiteralValue), e); } }
internal void OnError(StreamingContext context, ErrorContext errorContext) { }
/// <summary> /// Converts guid literal value. /// </summary> private static Guid ConvertGuidLiteralValue(ErrorContext errCtx, string guidLiteralValue) { return new Guid(guidLiteralValue); }
public ProcessReportOdpSnapshot(IConfiguration configuration, ProcessingContext pc, AspNetCore.ReportingServices.ReportIntermediateFormat.Report report, ErrorContext errorContext, ReportProcessing.StoreServerParameters storeServerParameters, GlobalIDOwnerCollection globalIDOwnerCollection, ExecutionLogContext executionLogContext, OnDemandMetadata odpMetadataFromSnapshot) : base(configuration, pc, report, errorContext, storeServerParameters, globalIDOwnerCollection, executionLogContext) { Global.Tracer.Assert(odpMetadataFromSnapshot != null, "Must provide existing metadata when processing an existing snapshot"); Global.Tracer.Assert(odpMetadataFromSnapshot.OdpChunkManager != null && null != odpMetadataFromSnapshot.ReportSnapshot, "Must provide chunk manager and ReportSnapshot when processing an existing snapshot"); this.m_odpMetadataFromSnapshot = odpMetadataFromSnapshot; }
private static void RegisterInvalidCellDataSetNameError(ScopeTree scopeTree, ErrorContext errorContext, IRIFReportDataScope currentScope, DataSet ourDataSet, DataSet parentDataSet) { DataRegion parentDataRegion = scopeTree.GetParentDataRegion(currentScope); errorContext.Register(ProcessingErrorCode.rsInvalidCellDataSetName, Severity.Error, currentScope.DataScopeObjectType, parentDataRegion.Name, "DataSetName", parentDataSet.Name.MarkAsPrivate(), ourDataSet.Name.MarkAsPrivate(), parentDataRegion.ObjectType.ToString()); }
public List<ILNode> Build(File.Code code, ErrorContext error=null) { if (code == null) throw new ArgumentNullException("code"); Stream stream = code.Data; if (stream == null) throw new ArgumentNullException("code.Data"); if (!stream.CanRead) throw new ArgumentException("Must be readable", "code_stream"); if (!stream.CanSeek) throw new ArgumentException("Must be seekable", "code_stream"); if (stream.Length == 0) return new List<ILNode>(); // empty stream StartingOffset = code.CodePosition; Error = error ?? new ErrorContext(code.Name); labels = new Dictionary<int, ILLabel>(); // cause they are all the same stream.Position = 0; r = new BinaryReader(stream); CurrentPC = 0; List<ILNode> list = new List<ILNode>(); Dictionary<int, int> pcToExpressoin = new Dictionary<int, int>(); Start(list); while (stream.Position < stream.Length) { CurrentPC = (int)stream.Position / 4; CurrentRaw = r.ReadUInt32(); ILExpression e = CreateExpression(list); if (e != null) { /* // hack here cause of issues if (e.Code == GMCode.Conv) { var prev = list.Last.Value as ILExpression; Debug.Assert(prev.Code != GMCode.Pop); prev.ILRanges.Add(new ILRange(CurrentPC, CurrentPC)); prev.Types = e.Types; // don't add it } else */ pcToExpressoin.Add(CurrentPC, list.Count); list.Add(e); } } CurrentPC = (int) stream.Position / 4; CurrentRaw = 0; if(labelExists(CurrentPC)) // this is in case we do have a jump but we need to exit clean { pcToExpressoin.Add(CurrentPC, list.Count); list.Add(CreateExpression(GMCode.Exit, null)); // make sure we got an exit as the last code // we HAVE to have an exit } else { ILExpression last = list.Last() as ILExpression; if(last.Code != GMCode.Ret && last.Code != GMCode.Exit) { pcToExpressoin.Add(CurrentPC, list.Count); list.Add(CreateExpression(GMCode.Exit, null)); // make sure we got an exit as the last code } } foreach (var l in labels) { int n; if (pcToExpressoin.TryGetValue(l.Key, out n)) list[n].UserData = l.Value; } var rlist = new List<ILNode>(); for(int i=0; i < list.Count; i++) { ILExpression e = list[i] as ILExpression; if (e != null) { if (e.UserData != null) { rlist.Add(e.UserData as ILLabel); e.UserData = null; } if (e.Code == GMCode.Conv) { ILExpression ne = list[i+1] as ILExpression; ne.ILRanges.AddRange(e.ILRanges); ne.Types = e.Types; continue; // skip } } rlist.Add(list[i]); } Finish(rlist); return rlist; }
public abstract bool Validate(Severity severity, string propertyName, ObjectType objectType, string objectName, string propertyNameValue, ErrorContext errorContext);