/// <summary>
/// Make an Id for a boundary event
/// </summary>
/// <param name="ev"></param>
/// <param name="msId"></param>
/// <returns></returns>
public static string BoundaryMakeId(EventHolder ev, MicroserviceId msId)
{
var e = ev.Data as BoundaryEvent;
string id = $"{e.Payload?.Message?.ProcessCorrelationKey ?? "NoCorrId"}_{e.Id}";
return($"{string.Join("_", id.Split(Path.GetInvalidFileNameChars()))}.json");
}
/// <summary>
/// This is the default constructor.
/// </summary>
/// <param name="serviceHandlers">The service handler container.</param>
/// <param name="collector">The data collector.</param>
/// <param name="sharedServices">The shared service context.</param>
/// <param name="originatorId">This is the Microservice identifiers.</param>
/// <param name="outgoingRequest">This is the outgoing request initiator.</param>
public OnDataCollectionContext(
IServiceHandlers serviceHandlers
, IDataCollection collector
, ISharedService sharedServices
, MicroserviceId originatorId
, IMicroserviceDispatch outgoingRequest) : base(serviceHandlers, collector, sharedServices, originatorId, outgoingRequest)
{
}
/// <summary>
/// This is the default constructor.
/// </summary>
/// <param name="serializer">The serialization container.</param>
/// <param name="collector">The data collector.</param>
/// <param name="sharedServices">The shared service context.</param>
/// <param name="originatorId">This is the Microservice identifiers.</param>
/// <param name="outgoingRequest">This is the outgoing request initiator.</param>
public OnDataCollectionContext(
IPayloadSerializationContainer serializer
, IDataCollection collector
, ISharedService sharedServices
, MicroserviceId originatorId
, IMicroserviceDispatch outgoingRequest) : base(serializer, collector, sharedServices, originatorId, outgoingRequest)
{
}
/// <summary>
/// This is the default constructor.
/// </summary>
/// <param name="rq">The incoming request.</param>
/// <param name="rsCol">The outgoing response collection.</param>
/// <param name="serializer">The serialization container.</param>
/// <param name="collector">The data collector.</param>
/// <param name="sharedServices">The shared service context.</param>
/// <param name="originatorId">This is the Microservice identifiers.</param>
/// <param name="outgoingRequest">This is the outgoing request initiator.</param>
public CommandMethodRequestContext(TransmissionPayload rq, List <TransmissionPayload> rsCol
, IPayloadSerializationContainer serializer
, IDataCollection collector
, ISharedService sharedServices
, MicroserviceId originatorId
, ICommandOutgoing outgoingRequest) : base(rq, rsCol, serializer, collector, sharedServices, originatorId, outgoingRequest)
{
}
/// <summary>
/// This method serializes incoming objects in to standard JSON format encoded as UTF8.
/// </summary>
/// <param name="e">The incoming EventBase.</param>
/// <param name="id">The Microservice Id</param>
/// <returns>Returns the byte array.</returns>
public static AzureStorageBinary DefaultJsonBinarySerializer(EventHolder e, MicroserviceId id)
{
var jObj = JObject.FromObject(e.Data);
var body = jObj.ToString();
return(new AzureStorageBinary {
Blob = Encoding.UTF8.GetBytes(body)
});
}
/// <summary>
/// This is the default constructor.
/// </summary>
/// <param name="schedule">The incoming schedule.</param>
/// <param name="token">The cancellation token.</param>
/// <param name="serializer">The serialization container.</param>
/// <param name="collector">The data collector.</param>
/// <param name="sharedServices">The shared service context.</param>
/// <param name="originatorId">This is the Microservice identifiers.</param>
public CommandScheduleInlineContext(Schedule schedule, CancellationToken token
, IPayloadSerializationContainer serializer
, IDataCollection collector
, ISharedService sharedServices
, MicroserviceId originatorId) : base(serializer, collector, sharedServices, originatorId)
{
Schedule = schedule;
Token = token;
}
/// <summary>
/// This is the default constructor.
/// </summary>
/// <param name="rq">The incoming request.</param>
/// <param name="rsCol">The outgoing response collection.</param>
/// <param name="serializer">The serialization container.</param>
/// <param name="collector">The data collector.</param>
/// <param name="sharedServices">The shared service context.</param>
/// <param name="originatorId">This is the Microservice identifiers.</param>
public CommandMethodInlineContext(TransmissionPayload rq, List <TransmissionPayload> rsCol
, IPayloadSerializationContainer serializer
, IDataCollection collector
, ISharedService sharedServices
, MicroserviceId originatorId) : base(serializer, collector, sharedServices, originatorId)
{
Request = rq;
Responses = rsCol;
}
/// <summary>
/// This is the default constructor.
/// </summary>
/// <param name="rq">The incoming request.</param>
/// <param name="rsCol">The outgoing response collection.</param>
/// <param name="serviceHandlers">The service handlers container.</param>
/// <param name="collector">The data collector.</param>
/// <param name="sharedServices">The shared service context.</param>
/// <param name="originatorId">This is the Microservice identifiers.</param>
/// <param name="outgoingRequest">This is the outgoing request initiator.</param>
public CommandRequestContextBase(TransmissionPayload rq, List <TransmissionPayload> rsCol
, IServiceHandlers serviceHandlers
, IDataCollection collector
, ISharedService sharedServices
, MicroserviceId originatorId
, O outgoingRequest) : base(serviceHandlers, collector, sharedServices, originatorId, outgoingRequest)
{
Request = rq;
Responses = rsCol;
}
/// <summary>
/// This method writes the event holder to table storage.
/// </summary>
/// <param name="e">The event holder to write to table storage.</param>
/// <param name="id">The service id.</param>
/// <returns>This is an async process.</returns>
public override async Task Write(EventHolder e, MicroserviceId id)
{
//Create the output.
var output = Serializer(e, id);
// Create the TableOperation object that inserts the customer entity.
TableOperation insert = TableOperation.Insert(output);
// Execute the insert operation.
await Table.ExecuteAsync(insert);
}
public static ITableEntity ToTableTelemetryEvent(EventHolder e, MicroserviceId msId)
{
var ev = e.Data as TelemetryEvent;
var dict = new Dictionary <string, EntityProperty>();
dict.Add("Metric", new EntityProperty(ev.MetricName));
dict.Add("Value", new EntityProperty(ev.Value));
return(new DynamicTableEntity("Telemetry" + DatePartition(), ev.TraceId, "*", dict));
}
/// <summary>
/// This is the default constructor.
/// </summary>
/// <param name="schedule">The incoming schedule.</param>
/// <param name="token">The cancellation token.</param>
/// <param name="serviceHandlers">The service handler container.</param>
/// <param name="collector">The data collector.</param>
/// <param name="sharedServices">The shared service context.</param>
/// <param name="originatorId">This is the Microservice identifiers.</param>
/// <param name="outgoingRequest">This is the outgoing request initiator.</param>
public CommandScheduleInlineContext(Schedule schedule, CancellationToken token
, IServiceHandlers serviceHandlers
, IDataCollection collector
, ISharedService sharedServices
, MicroserviceId originatorId
, ICommandOutgoing outgoingRequest)
: base(serviceHandlers, collector, sharedServices, originatorId, outgoingRequest)
{
Schedule = schedule;
Token = token;
}
/// <summary>
/// This is the default constructor.
/// </summary>
/// <param name="serializer">The serialization container.</param>
/// <param name="collector">The data collector.</param>
/// <param name="sharedServices">The shared service context.</param>
/// <param name="originatorId">This is the Microservice identifiers.</param>
public CommandContextBase(
IPayloadSerializationContainer serializer
, IDataCollection collector
, ISharedService sharedServices
, MicroserviceId originatorId)
{
PayloadSerializer = serializer;
Collector = collector;
SharedServices = sharedServices;
OriginatorId = originatorId;
}
public static ITableEntity ToTableDispatcherEvent(EventHolder e, MicroserviceId msId)
{
var ev = e.Data as DispatcherEvent;
var dict = new Dictionary <string, EntityProperty>();
dict.Add("IsSuccess", new EntityProperty(ev.IsSuccess));
dict.Add("Type", GetEnum <PayloadEventType>(ev.Type));
dict.Add("Reason", GetEnum <DispatcherRequestUnresolvedReason>(ev.Reason));
dict.Add("Delta", new EntityProperty(ev.Delta));
dict.Add("Ex", new EntityProperty(ev.Ex?.Message));
dict.AddPayloadCommon(ev.Payload);
//ETag: Set this value to '*' to blindly overwrite an entity as part of an update operation.
return(new DynamicTableEntity("Dispatcher" + DatePartition(), ev.TraceId, "*", dict));
}
public static string LoggerMakeFolder(EventHolder ev, MicroserviceId msId)
{
var e = ev.Data as LogEvent;
string level = Enum.GetName(typeof(LoggingLevel), e.Level);
return(string.Format("{0}/{1}/{2:yyyy-MM-dd}/{2:HH}", msId.Name, level, DateTime.UtcNow));
//if (e is ILogStoreName)
// return ((ILogStoreName)logEvent).StorageId;
//// If there is a category specified and it contains valid digits or characters then make it part of the log name to make it easier to filter log events
//if (!string.IsNullOrEmpty(logEvent.Category) && logEvent.Category.Any(char.IsLetterOrDigit))
// return string.Format("{0}_{1}_{2}", logEvent.GetType().Name, new string(logEvent.Category.Where(char.IsLetterOrDigit).ToArray()), Guid.NewGuid().ToString("N"));
//return string.Format("{0}_{1}", logEvent.GetType().Name, Guid.NewGuid().ToString("N"));
}
/// <summary>
/// This method writes to the incoming event to the underlying storage technology.
/// </summary>
/// <param name="e">The event.</param>
/// <param name="id">The microservice metadata.</param>
/// <returns>
/// This is an async task.
/// </returns>
public override async Task Write(EventHolder e, MicroserviceId id)
{
var output = Serializer(e, id);
//Encrypt the payload when required.
if (EncryptionPolicy != AzureStorageEncryption.None && Encryptor != null)
{
//The checks for always encrypt are done externally.
output.Blob = Encryptor(output.Blob);
}
// Create a message and add it to the queue.
CloudQueueMessage message = new CloudQueueMessage(Convert.ToBase64String(output.Blob));
// Async enqueue the message
await Queue.AddMessageAsync(message);
}
/// <summary>
/// This is the Microservice constructor.
/// </summary>
/// <param name="name">The Microservice name.</param>
/// <param name="serviceId">The service id.</param>
/// <param name="description">An optional description for the Microservice.</param>
/// <param name="policySettings">The policy settings.</param>
/// <param name="properties">Any additional property key.</param>
/// <param name="serviceVersionId">This is the version id of the calling assembly as a string.</param>
public Microservice(
string name = null
, string serviceId = null
, string description = null
, IEnumerable <PolicyBase> policySettings = null
, IEnumerable <Tuple <string, string> > properties = null
, string serviceVersionId = null
)
: base(name)
{
Policy = new PolicyWrapper(policySettings, () => Status);
//Id
if (string.IsNullOrEmpty(name))
{
name = GetType().Name;
}
Id = new MicroserviceId(name
, serviceId: serviceId
, description: description
, serviceVersionId: serviceVersionId ?? Assembly.GetCallingAssembly().GetName().Version.ToString()
, serviceEngineVersionId: GetType().Assembly.GetName().Version.ToString()
, properties: properties);
//Security
mSecurity = InitialiseSecurityContainer();
Security = new SecurityWrapper(mSecurity, () => Status);
//Communication
mCommunication = InitialiseCommunicationContainer();
Communication = new CommunicationWrapper(mCommunication, () => Status);
//Commands
mCommands = InitialiseCommandContainer();
Commands = new CommandWrapper(mCommands, () => Status);
//Resources
mResourceMonitor = InitialiseResourceMonitor();
ResourceMonitor = new ResourceWrapper(mResourceMonitor, () => Status);
//Data Collection
mDataCollection = InitialiseDataCollectionContainer();
DataCollection = new DataCollectionWrapper(mDataCollection, () => Status);
//Events
mEventsWrapper = new EventsWrapper(this, mDataCollection, () => Status);
Events = mEventsWrapper;
//Serializer
mSerializer = InitialiseSerializationContainer();
Serialization = new SerializationWrapper(mSerializer, () => Status);
}
public static ITableEntity ToTableBoundaryEvent(EventHolder e, MicroserviceId msId)
{
var ev = e.Data as BoundaryEvent;
var dict = new Dictionary <string, EntityProperty>();
dict.Add("Type", GetEnum <BoundaryEventType>(ev.Type));
dict.Add("Direction", GetEnum <ChannelDirection>(ev.Direction));
dict.Add("ChannelId", new EntityProperty(ev.ChannelId));
dict.Add("ChannelPriority", new EntityProperty(ev.ChannelPriority));
dict.Add("Id", new EntityProperty(ev.Id));
dict.Add("BatchId", new EntityProperty(ev.BatchId));
dict.Add("Requested", new EntityProperty(ev.Requested));
dict.Add("Actual", new EntityProperty(ev.Actual));
dict.Add("Ex", new EntityProperty(ev.Ex?.Message));
dict.AddPayloadCommon(ev.Payload);
return(new DynamicTableEntity("Boundary" + DatePartition(), ev.TraceId, "*", dict));
}
public static ITableEntity ToTableLogEvent(EventHolder e, MicroserviceId id)
{
var ev = e.Data as LogEvent;
var dict = new Dictionary <string, EntityProperty>();
dict.Add("Machine", new EntityProperty(id.MachineName));
dict.Add("Name", new EntityProperty(id.Name));
dict.Add("ServiceId", new EntityProperty(id.ServiceId));
dict.Add("Level", GetEnum <LoggingLevel>(ev.Level));
dict.Add("Category", new EntityProperty(ev.Category));
dict.Add("Message", new EntityProperty(ev.Message));
dict.Add("Ex", new EntityProperty(ev.Ex?.Message));
//ETag: Set this value to '*' to blindly overwrite an entity as part of an update operation.
return(new DynamicTableEntity("Logger" + DatePartition(), ev.TraceId, "*", dict));
}
/// <summary>
/// This method writes the event holder to table storage.
/// </summary>
/// <param name="e">The event holder.</param>
/// <param name="id">The service identifier class.</param>
/// <returns>The is an async task.</returns>
public override async Task Write(EventHolder e, MicroserviceId id)
{
string storageId = MakeId(e, id);
string storageFolder = MakeFolder(e, id);
var output = Serializer(e, id);
//Encrypt the payload when required.
if (EncryptionPolicy != AzureStorageEncryption.None && Encryptor != null)
{
//The checks for always encrypt are done externally.
output.Blob = Encryptor(output.Blob);
}
var refEntityDirectory = Container.GetDirectoryReference(storageFolder);
var Blob = refEntityDirectory.GetBlockBlobReference(storageId);
Blob.Properties.ContentType = output.ContentType;
Blob.Properties.ContentEncoding = output.ContentEncoding;
await Blob.UploadFromByteArrayAsync(output.Blob, 0, output.Blob.Length);
}
public static ITableEntity ToTableGeneric(EventHolder e, MicroserviceId id)
{
var dict = new Dictionary <string, EntityProperty>();
return(new DynamicTableEntity(e.GetType().Name + DatePartition(), e.Data.TraceId, "*", dict));
}
/// <summary> /// This method writes to the incoming event to the underlying storage technology. /// </summary> /// <param name="e">The event.</param> /// <param name="id">The microservice metadata.</param> /// <returns>This is an async task.</returns> public abstract Task Write(EventHolder e, MicroserviceId id);
public override Task Write(EventHolder e, MicroserviceId id)
{
throw new NotImplementedException();
}
/// <summary>
/// Makes a folder for a boundary event
/// </summary>
/// <param name="ev"></param>
/// <param name="msId"></param>
/// <returns></returns>
public static string BoundaryMakeFolder(EventHolder ev, MicroserviceId msId)
{
var e = ev.Data as BoundaryEvent;
return(string.Format("{0}/{2:yyyy-MM-dd}/{2:HH}", msId.Name, DateTime.UtcNow));
}
public static string EventSourceMakeFolder(EventHolder ev, MicroserviceId msId)
{
var e = ev.Data as EventSourceEvent;
return($"{msId.Name}/{e.UtcTimeStamp:yyyy-MM-dd}/{e.Entry.EntityType}");
}
//Event Source
public static string EventSourceMakeId(EventHolder ev, MicroserviceId msId)
{
var e = ev.Data as EventSourceEvent;
return($"{string.Join("_", e.Entry.Key.Split(Path.GetInvalidFileNameChars()))}.json");
}
//Statistics
public static string StatisticsMakeId(EventHolder ev, MicroserviceId msId)
{
var e = ev.Data as MicroserviceStatistics;
return($"{e.StorageId}.json");
}
//Logger
public static string LoggerMakeId(EventHolder ev, MicroserviceId msId)
{
var e = ev.Data as LogEvent;
return($"{e.TraceId}.json");
}
public static string StatisticsMakeFolder(EventHolder ev, MicroserviceId msId)
{
var e = ev.Data as MicroserviceStatistics;
return(string.Format("{0}/{1:yyyy-MM-dd}/{1:HH}", msId.Name, DateTime.UtcNow));
}
