// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
var log = ConfigureLogger();
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
// app.UseOwin(x => x.UseNancy());
app.UseOwin(buildFunc =>
{
/*
* buildFunc(next => GlobalErrorLogging.Middleware(next, log));
* buildFunc(next => CorrelationToken.Middleware(next));
* buildFunc(next => RequestLogging.Middleware(next, log));
* buildFunc(next => PerformanceLogging.Middleware(next, log));
* buildFunc(next => new MonitoringMiddleware(next, HealthCheck).Invoke);
* buildFunc.UseNancy(opt => opt.Bootstrapper = new Bootstrapper(log));
*/
buildFunc(next => CorrelationToken.Middleware(next));
buildFunc(next => RequestLogging.Middleware(next, log));
buildFunc.UseNancy();
});
}
private static void SubscribeForCorrelationTokenInvalidation(Activity activity, Type interfaceType, string followermethodName, IActivityEventListener <QueueEventArgs> eventListener, Guid instanceId)
{
CorrelationToken reference = GetCorrelationToken(activity);
CorrelationTokenInvalidatedHandler dataChangeEventListener = new CorrelationTokenInvalidatedHandler(interfaceType, followermethodName, eventListener, instanceId);
reference.SubscribeForCorrelationTokenInitializedEvent(activity, dataChangeEventListener);
}
internal static IComparable ResolveQueueName(Activity activity, Type interfaceType, string methodName)
{
if (activity == null)
{
throw new ArgumentNullException("activity");
}
if (interfaceType == null)
{
throw new ArgumentNullException("interfaceType");
}
if (methodName == null)
{
throw new ArgumentNullException("methodName");
}
if (CorrelationResolver.IsInitializingMember(interfaceType, methodName, null))
{
return(new EventQueueName(interfaceType, methodName, CorrelationResolver.ResolveCorrelationValues(interfaceType, methodName, null, true)));
}
CorrelationToken correlationToken = GetCorrelationToken(activity);
if (!correlationToken.Initialized)
{
return(null);
}
return(new EventQueueName(interfaceType, methodName, correlationToken.Properties));
}
internal static void InvalidateCorrelationToken(Activity activity, Type interfaceType, string methodName, object[] messageArgs)
{
object correlationProvider = CorrelationResolver.GetCorrelationProvider(interfaceType);
if (correlationProvider is NonCorrelatedProvider)
{
return;
}
CorrelationToken reference = GetCorrelationToken(activity);
ICollection <CorrelationProperty> correlationvalues = CorrelationResolver.ResolveCorrelationValues(interfaceType, methodName, messageArgs, false);
if (!CorrelationResolver.IsInitializingMember(interfaceType, methodName, messageArgs))
{
if (!reference.Initialized)
{
throw new InvalidOperationException(SR.GetString(SR.Error_CorrelationNotInitialized, reference.Name, activity.QualifiedName));
}
ValidateCorrelation(reference.Properties, correlationvalues, reference.Name, activity);
return;
}
// invalidate correlation token if methodName is an initializer
reference.Initialize(activity, correlationvalues);
}
public void Add_correlation_token_to_log_context_and_Owin_context(string requestPath)
{
using (TestCorrelator.CreateContext())
{
AppFunc pipelineFunc(AppFunc next) => CorrelationToken.Middleware(next);
var ctx = SetupOwinTestEnvironment(requestPath);
var pipeline = pipelineFunc(m_TestModule(m_NoOp, m_Logger));
var env = ctx.Environment;
pipeline(env);
// m_Logger was enriched from the log context so it's properties should include CorrelationToken
var tokenProp = TestCorrelator.GetLogEventsFromCurrentContext().Should().ContainSingle()
.Which.Properties.Should().ContainSingle();
tokenProp.Which.Key.Should().Be("CorrelationToken");
// the token was also saved in OwinContext with the same value
tokenProp.Which.Value.ToString().Should().Equals(ctx.Get <string>("correlationToken"));
// the token should be from request header if it is available there
var tokenFromRequestHeader = ctx.Request.Headers["Correlation-Token"];
if (!string.IsNullOrEmpty(tokenFromRequestHeader))
{
tokenProp.Which.Value.ToString().Should().Equals(tokenFromRequestHeader);
}
}
}
internal static IComparable ResolveQueueName(Activity activity, Type interfaceType, string methodName)
{
if (activity == null)
{
throw new ArgumentNullException("activity");
}
if (interfaceType == null)
{
throw new ArgumentNullException("interfaceType");
}
if (methodName == null)
{
throw new ArgumentNullException("methodName");
}
// resolver will check for an explicit correlation provider,
// if none present this will return an uncorrelated provider.
// note, an uncorrelated methodName will always be an initializer
if (CorrelationResolver.IsInitializingMember(interfaceType, methodName, null))
{
ICollection <CorrelationProperty> corrvalues = CorrelationResolver.ResolveCorrelationValues(interfaceType, methodName, null, true);
return(new EventQueueName(interfaceType, methodName, corrvalues));
}
CorrelationToken reference = GetCorrelationToken(activity);
if (!reference.Initialized)
{
return(null);
}
return(new EventQueueName(interfaceType, methodName, reference.Properties));
}
public CorrelationToken Subscribe(IQueueSubscriber <M> Subscriber)
{
var ct = CorrelationToken.Create();
Subscribers.TryAdd(ct, Subscriber);
return(ct);
}
public override object ConvertFrom(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value)
{
object convertedValue = null;
string correlatorName = value as String;
if (!String.IsNullOrEmpty(correlatorName))
{
foreach (object obj in GetStandardValues(context))
{
CorrelationToken correlator = obj as CorrelationToken;
if (correlator != null && correlator.Name == correlatorName)
{
convertedValue = correlator;
break;
}
}
if (convertedValue == null)
{
convertedValue = new CorrelationToken(correlatorName);
}
}
return(convertedValue);
}
internal static void InitializeCorrelationTokenCollection(Activity activity, CorrelationToken correlator)
{
if ((correlator != null) && !string.IsNullOrEmpty(correlator.OwnerActivityName))
{
string ownerActivityName = correlator.OwnerActivityName;
Activity activityByName = activity.GetActivityByName(ownerActivityName);
if (activityByName == null)
{
activityByName = Helpers.ParseActivityForBind(activity, ownerActivityName);
}
if (activityByName == null)
{
throw new ArgumentException("ownerActivity");
}
CorrelationTokenCollection tokens = activityByName.GetValue(CorrelationTokenCollection.CorrelationTokenCollectionProperty) as CorrelationTokenCollection;
if (tokens == null)
{
tokens = new CorrelationTokenCollection();
activityByName.SetValue(CorrelationTokenCollection.CorrelationTokenCollectionProperty, tokens);
}
if (!tokens.Contains(correlator.Name))
{
tokens.Add(correlator);
}
}
}
CorrelationToken IQueueReceiver.Subscribe(IQueueSubscriber Subscriber)
{
var ct = CorrelationToken.Create();
Subscribers.TryAdd(ct, Subscriber);
return(ct);
}
public CorrelationToken Transmit(IMessage command)
{
var token = CorrelationToken.Create();
messages.Enqueue(stream(command, new Message("", $"echo command {token} completed")));
return(token);
}
IEnumerable <FileChangeDescription> MergeChanges(CorrelationToken token)
{
var indexedFiles = FileIndex[token];
var currentFiles = FolderIndex[token].ListFiles(null, true);
foreach (var file in currentFiles)
{
if (!indexedFiles.ContainsKey(file))
{
indexedFiles.Add(file, new FileDescription(file));
yield return(new FileChangeDescription(file, token, FileChangeKind.Added));
}
else
{
if (indexedFiles[file].HasChanged() == true)
{
yield return(new FileChangeDescription(file, token, FileChangeKind.Modifed));
}
}
}
foreach (var file in rolist(indexedFiles.Keys.Except(currentFiles)))
{
indexedFiles.Remove(file);
yield return(new FileChangeDescription(file, token, FileChangeKind.Removed));
}
}
internal static void InitializeCorrelationTokenCollection(Activity activity, CorrelationToken correlator)
{
if (correlator != null && !String.IsNullOrEmpty(correlator.OwnerActivityName))
{
string ownerActivityId = correlator.OwnerActivityName;
Activity owner = activity.GetActivityByName(ownerActivityId);
if (owner == null)
{
owner = System.Workflow.Activities.Common.Helpers.ParseActivityForBind(activity, ownerActivityId);
}
if (owner == null)
{
throw new ArgumentException("ownerActivity");
}
CorrelationTokenCollection collection = owner.GetValue(CorrelationTokenCollection.CorrelationTokenCollectionProperty) as CorrelationTokenCollection;
if (collection == null)
{
collection = new CorrelationTokenCollection();
owner.SetValue(CorrelationTokenCollection.CorrelationTokenCollectionProperty, collection);
}
if (!collection.Contains(correlator.Name))
{
collection.Add(correlator);
}
}
}
public void Cancel(CorrelationToken Subscription)
{
if (Subscriptions.TryRemove(Subscription, out IQueueReceiver receiver))
{
receiver?.Cancel(Subscription);
receiver?.Dispose();
}
}
public Option <CorrelationToken> Listen(CorrelationToken MonitorToken, Action <FileChangeDescription> Listener)
{
if (Listeners.TryAdd(MonitorToken, Listener))
{
C.Notify(inform($"{AgentRuntimeId} registered correlated listener {MonitorToken}"));
}
return(MonitorToken);
}
public void GetSetValues()
{
CorrelationToken ct = new CorrelationToken();
Assert.AreEqual(false, ct.Initialized, "C2#1");
Assert.AreEqual(null, ct.Name, "C2#2");
Assert.AreEqual(null, ct.OwnerActivityName, "C2#3");
}
public void InitTwice()
{
DelayActivity da = new DelayActivity();
CorrelationToken ct = new CorrelationToken();
List <CorrelationProperty> properties = new List <CorrelationProperty> ();
ct.Initialize(da, properties);
ct.Initialize(da, properties);
}
public void Initialize()
{
DelayActivity da = new DelayActivity();
CorrelationToken ct = new CorrelationToken();
List <CorrelationProperty> properties = new List <CorrelationProperty> ();
ct.Initialize(da, properties);
Assert.AreEqual(true, ct.Initialized, "C3#1");
}
public static IAppMessage Babble(CorrelationToken CT, string text, [CallerFilePath] string callerFile = null,
[CallerMemberName] string callerName = null, [CallerLineNumber] int?callerLineNumber = null)
=> new AppMessage(new AppMessgaeState
(
CorrelationToken: CT,
Level: EventLevel.Verbose,
Template: text,
MessageType: DeriveMessageType(callerFile, callerName),
SourceComponent: Assembly.GetEntryAssembly().GetSimpleName()
));
public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType)
{
object convertedValue = null;
CorrelationToken correlator = value as CorrelationToken;
if (destinationType == typeof(string) && correlator != null)
{
convertedValue = correlator.Name;
}
return(convertedValue);
}
public static IAppMessage Warn(CorrelationToken CT, string message,
[CallerFilePath] string callerFile = null, [CallerMemberName] string callerName = null)
=> new AppMessage(new AppMessgaeState
(
CorrelationToken: CT,
Level: EventLevel.Warning,
Template: message,
Content: new object { },
MessageType: DeriveMessageType(callerFile, callerName),
SourceComponent: Assembly.GetEntryAssembly().GetSimpleName()
));
public static IAppMessage Error(CorrelationToken CT, Exception e,
[CallerFilePath] string callerFile = null, [CallerMemberName] string callerName = null)
=> new AppMessage(new AppMessgaeState
(
CorrelationToken: CT,
Level: EventLevel.Error,
Template: e.ToString(),
Content: e,
MessageType: DeriveMessageType(callerFile, callerName),
SourceComponent: Assembly.GetEntryAssembly().GetSimpleName()
));
public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
{
object name = null;
CorrelationToken token = value as CorrelationToken;
if ((destinationType == typeof(string)) && (token != null))
{
name = token.Name;
}
return(name);
}
public static IAppMessage <C> BabbleFrom <C>(CorrelationToken CT, string template, C content,
string source, [CallerFilePath] string callerFile = null, [CallerMemberName] string callerName = null)
=> new ApplicationMessage <C>(new AppMessgaeState
(
CorrelationToken: CT,
Level: EventLevel.Verbose,
Template: template,
Content: content,
MessageType: DeriveMessageType(callerFile, callerName),
SourceComponent: source
));
public Option <FolderPath> EndPathMonitor(CorrelationToken MonitorToken)
{
if (FolderIndex.TryRemove(MonitorToken, out FolderTree tree))
{
FileIndex.TryRemove(MonitorToken, out Dictionary <FilePath, FileDescription> content);
Listeners.TryRemove(MonitorToken, out Action <FileChangeDescription> listener);
return(tree.Root);
}
return(none <FolderPath>());
}
public static IAppMessage <C> Error <C>(CorrelationToken CT, string template, C content,
[CallerFilePath] string callerFile = null, [CallerMemberName] string callerName = null)
=> new ApplicationMessage <C>(new AppMessgaeState
(
CorrelationToken: CT,
Level: EventLevel.Error,
Template: template,
Content: content,
MessageType: DeriveMessageType(callerFile, callerName),
SourceComponent: Assembly.GetEntryAssembly().GetSimpleName()
));
public static IAppMessage Inform(CorrelationToken ct, string text,
[CallerFilePath] string callerFile = null,
[CallerMemberName] string callerName = null,
[CallerLineNumber] int?callerLineNumber = null
)
=> new AppMessage(new AppMessgaeState
(
Level: EventLevel.Informational,
Template: text,
MessageType: DeriveMessageType(callerFile, callerName),
SourceComponent: Assembly.GetEntryAssembly().GetSimpleName(),
CorrelationToken: ct
));
public void Configure(IApplicationBuilder app)
{
var log = ConfigureLogger();
app.UseOwin(buildFunc =>
{
buildFunc(next => GlobalErrorLogging.Middleware(next, log));
buildFunc(next => CorrelationToken.Middleware(next));
buildFunc(next => RequestLogging.Middleware(next, log));
buildFunc(next => PerformanceLogging.Middleware(next, log));
buildFunc(next => new MonitoringMiddleware(next, HealthCheck).Invoke);
buildFunc.UseNancy(opt => opt.Bootstrapper = new Bootstrapper(log));
});
}
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
app.UseCors("Cors");
Logger log = ConfigurationLogger();
app.UseOwin(buildFunc =>
{
buildFunc(next => GlobalErrorLogging.Middleware(next, log));
buildFunc(next => CorrelationToken.Middleware(next));
buildFunc(next => RequestLogging.Middleware(next, log));
buildFunc(next => PerformanceLogging.Middleware(next, log));
buildFunc(next => new MonitoringMiddleware(next, HealthCheck).Invoke);
buildFunc.UseNancy(opt => opt.Bootstrapper = new CustomBootstrapper());
});
}
public WorkFlowCallExternal()
{
CreateDocument createDocument1 = new CreateDocument();
CorrelationToken correlator1 = new CorrelationToken();
CanModifyActivities = true;
Name = "WorkFlowCallExternal";
correlator1.Name = "c1";
correlator1.OwnerActivityName = "WorkFlowCallExternal";
createDocument1.CorrelationToken = correlator1;
createDocument1.Name = "createDocument1";
createDocument1.DocumentId = "First";
createDocument1.Text = "Joan Martinez";
Activities.Add(createDocument1);
CanModifyActivities = false;
}
/// <summary>
/// Initializes a new instance of the <see cref="AsyncEvent" /> class.
/// </summary>
/// <param name="queueManager">The queue manager.</param>
/// <param name="primaryEntityId">The primary entity unique identifier.</param>
/// <param name="id">The unique identifier.</param>
/// <param name="operationType">Type of the operation.</param>
/// <param name="data">The data.</param>
/// <param name="dependencyToken">The dependency token.</param>
/// <param name="regardingObject">The regarding object.</param>
/// <param name="retryCount">The retry count.</param>
/// <param name="messageName">Name of the message.</param>
/// <param name="recurrencePattern">The recurrence pattern.</param>
/// <param name="recurrenceStartTime">The recurrence start time.</param>
/// <param name="recurrenceEndTime">The recurrence end time.</param>
/// <param name="createdOn">The created configuration.</param>
/// <param name="correlationToken">The correlation token.</param>
/// <param name="requestId">The request unique identifier.</param>
/// <param name="previousExecutionTime">The previous execution time.</param>
/// <param name="lastPostponeUntil">The last postpone until.</param>
/// <param name="startedOn">The started configuration.</param>
public AsyncEvent(IQueueManager queueManager, Guid primaryEntityId, Guid id, Guid operationType, string data, string dependencyToken, Guid regardingObject,
int retryCount, string messageName, string recurrencePattern, DateTime recurrenceStartTime, DateTime? recurrenceEndTime, DateTime createdOn, CorrelationToken correlationToken,
Guid? requestId, double previousExecutionTime, DateTime? lastPostponeUntil, DateTime startedOn)
{
this._queueManager = queueManager;
this.PrimaryEntityId = primaryEntityId;
this.EventId = id;
this.OperationType = operationType;
this.Data = data;
this.DependencyToken = dependencyToken;
this.RegardingObject = regardingObject;
this.RetryCount = retryCount;
this.MessageName = messageName;
this._recurrencePattern = recurrencePattern;
this._recurrenceStartTime = recurrenceStartTime;
this._recurrenceEndTime = recurrenceEndTime;
this.CorrelationToken = correlationToken;
this.RequestId = requestId;
this.CreatedOn = createdOn;
this._previousExecutionTime = TimeSpan.MaxValue.TotalSeconds < previousExecutionTime ? TimeSpan.MaxValue : TimeSpan.FromSeconds(previousExecutionTime);
this._lastPostponeUntil = lastPostponeUntil;
this.StartedOn = startedOn;
}
