public Task WriteAndReadManyEventsAcrossCheckpoints(FailureMode persistentStorageFailure, FailureMode volatileStorageFailure)
{
var testSize = 5;
return(RunTest(async(context, stream, _, _) =>
{
var requests = Enumerable.Range(0, testSize).Select(idx => new RegisterContentLocationsRequest()
{
MachineId = new MachineId(idx),
}).ToArray();
var cursors = new CheckpointLogId[testSize];
foreach (var indexed in requests.AsIndexed())
{
await stream.WriteEventAsync(context, indexed.Item).SelectResult(r => r.Should().BeTrue());
cursors[indexed.Index] = await stream.BeforeCheckpointAsync(context).ThrowIfFailureAsync();
// By not calling AfterCheckpointAsync, we stop GC from happening. This should let us read
// all events we have posted
}
if (volatileStorageFailure == FailureMode.All)
{
await CollectStream(context, stream, cursors[0]).ShouldBeError();
}
else
{
var events = await CollectStream(context, stream, cursors[0]).ThrowIfFailureAsync();
events.Count.Should().Be(testSize);
}
},
persistentStorageFailure: persistentStorageFailure,
volatileStorageFailure: volatileStorageFailure));
}
public TaskConfiguration(ISchedule schedule, FailureMode failureMode, ExecutionMode executionMode, TimeSpan leaseDuration, IReadOnlyDictionary <string, object?> data)
{
Schedule = schedule ?? throw new ArgumentNullException(nameof(schedule));
Data = data ?? throw new ArgumentNullException(nameof(data));
FailureMode = failureMode;
ExecutionMode = executionMode;
LeaseDuration = leaseDuration;
}
public Task <Result <Optional <ReadOnlyMemory <byte> > > > ReadAsync(OperationContext context, BlockReference cursor)
{
if (FailureMode.HasFlag(FailureMode.Read))
{
return(Task.FromResult(Result.FromErrorMessage <Optional <ReadOnlyMemory <byte> > >("Volatile event storage failure")));
}
return(InnerStorage.ReadAsync(context, cursor));
}
public Task <Result <bool> > IsSealedAsync(OperationContext context, CheckpointLogId logId)
{
if (FailureMode.HasFlag(FailureMode.Read))
{
return(Task.FromResult(Result.FromErrorMessage <bool>("Persistent event storage failure")));
}
return(InnerStorage.IsSealedAsync(context, logId));
}
/// <summary>
/// Converts the supplied <see cref="FaultData"/> into a <see cref="DbFaultData"/>.
/// </summary>
/// <param name="">The <see cref="FaultData"/> to be converted.</param>
/// <returns></returns>
public static DbFaultData GetDbFaultData(FaultData faultData)
{
Controller faultDataController = faultData.Controller;
Device faultDataDevice = faultData.Device;
Diagnostic faultDataDiagnostic = null;
if (faultData.Diagnostic != null)
{
faultDataDiagnostic = faultData.Diagnostic;
}
User faultDataDismissUser = faultData.DismissUser;
FailureMode faultDataFailureMode = faultData.FailureMode;
var faultDataFaultState = faultData.FaultState;
DbFaultData dbFaultData = new DbFaultData
{
GeotabId = faultData.Id.ToString(),
AmberWarningLamp = faultData.AmberWarningLamp,
ControllerId = faultDataController.Id.ToString(),
ControllerName = faultDataController.Name,
Count = faultData.Count,
DateTime = faultData.DateTime,
DeviceId = faultDataDevice.Id.ToString(),
DiagnosticId = "",
DismissDateTime = faultData.DismissDateTime,
DismissUserId = faultDataDismissUser.Id.ToString(),
FailureModeId = faultDataFailureMode.Id.ToString(),
FailureModeName = faultDataFailureMode.Name,
FaultLampState = faultData.FaultLampState.HasValue ? faultData.FaultLampState.ToString() : null,
MalfunctionLamp = faultData.MalfunctionLamp,
ProtectWarningLamp = faultData.ProtectWarningLamp,
RedStopLamp = faultData.RedStopLamp,
Severity = faultData.Severity.HasValue ? faultData.Severity.ToString() : null,
SourceAddress = faultData.SourceAddress
};
if (faultDataDiagnostic != null)
{
dbFaultData.DiagnosticId = faultDataDiagnostic.Id.ToString();
}
if (faultData.ClassCode != null)
{
dbFaultData.ClassCode = faultData.ClassCode.ToString();
}
if (faultDataFailureMode.Code != null)
{
dbFaultData.FailureModeCode = faultDataFailureMode.Code;
}
if (faultDataFaultState != null)
{
dbFaultData.FaultState = faultDataFaultState.ToString();
}
return(dbFaultData);
}
public Task <BoolResult> GarbageCollectAsync(OperationContext context, BlockReference cursor)
{
if (FailureMode.HasFlag(FailureMode.SilentWrite))
{
return(BoolResult.SuccessTask);
}
else if (FailureMode.HasFlag(FailureMode.Write))
{
return(Task.FromResult(new BoolResult("Volatile event storage failure")));
}
return(InnerStorage.GarbageCollectAsync(context, cursor));
}
public Task <BoolResult> AppendAsync(OperationContext context, BlockReference cursor, Stream stream)
{
if (FailureMode.HasFlag(FailureMode.SilentWrite))
{
return(BoolResult.SuccessTask);
}
else if (FailureMode.HasFlag(FailureMode.Write))
{
return(Task.FromResult(new BoolResult("Persistent event storage failure")));
}
return(InnerStorage.AppendAsync(context, cursor, stream));
}
public Task <BoolResult> AppendAsync(OperationContext context, BlockReference cursor, ReadOnlyMemory <byte> piece)
{
if (FailureMode.HasFlag(FailureMode.SilentWrite))
{
return(BoolResult.SuccessTask);
}
else if (FailureMode.HasFlag(FailureMode.Write))
{
return(Task.FromResult(new BoolResult("Volatile event storage failure")));
}
return(InnerStorage.AppendAsync(context, cursor, piece));
}
public Task <BoolResult> GarbageCollectAsync(OperationContext context, CheckpointLogId logId)
{
if (FailureMode.HasFlag(FailureMode.SilentWrite))
{
return(BoolResult.SuccessTask);
}
else if (FailureMode.HasFlag(FailureMode.Write))
{
return(Task.FromResult(new BoolResult(errorMessage: "Persistent event storage failure")));
}
return(InnerStorage.GarbageCollectAsync(context, logId));
}
public Task PublishAsync(
FailureMode failureMode,
ProcessingContext context,
byte[] payload,
IDictionary<string, string> properties,
Exception ex = null)
{
_messages.Add(new PoisonMessage()
{
Mode = failureMode,
Payload = payload,
Properties = properties,
ExceptionObject = ex
});
Console.WriteLine("Writing message to mock poison queue.. count = {0}",
_messages.Count);
Thread.Sleep(1);
return _onPublishAsync(failureMode, payload, properties, ex);
}
public Task PublishAsync(
FailureMode failureMode,
ProcessingContext context,
byte[] payload,
IDictionary <string, string> properties,
Exception ex = null)
{
_messages.Add(new PoisonMessage()
{
Mode = failureMode,
Payload = payload,
Properties = properties,
ExceptionObject = ex
});
Console.WriteLine("Writing message to mock poison queue.. count = {0}",
_messages.Count);
Thread.Sleep(1);
return(_onPublishAsync(failureMode, payload, properties, ex));
}
void Write(FaultData faultData)
{
StringBuilder sb = new StringBuilder();
AppendDeviceValues(sb, faultData.Device.Id);
AppendValues(sb, faultData.DateTime);
AppendName(sb, faultData.Diagnostic);
FailureMode failureMode = faultData.FailureMode;
AppendName(sb, failureMode);
if (failureMode is NoFailureMode)
{
AppendValues(sb, "None");
}
else
{
AppendName(sb, failureMode.Source);
}
AppendName(sb, faultData.Controller);
Console.WriteLine(sb.ToString().TrimEnd(trimChars));
}
private async Task RunTest(
Func <OperationContext, ContentMetadataEventStream, IFailureController, IFailureController, Task> runTestAsync,
ContentMetadataEventStreamConfiguration contentMetadataEventStreamConfiguration = null,
RedisVolatileEventStorageConfiguration redisVolatileEventLogConfiguration = null,
FailureMode persistentStorageFailure = FailureMode.None,
FailureMode volatileStorageFailure = FailureMode.None)
{
var tracingContext = new Context(Logger);
var operationContext = new OperationContext(tracingContext);
redisVolatileEventLogConfiguration ??= new RedisVolatileEventStorageConfiguration();
using var database = LocalRedisProcessDatabase.CreateAndStartEmpty(_redisFixture, TestGlobal.Logger, SystemClock.Instance);
var primaryFactory = await RedisDatabaseFactory.CreateAsync(
operationContext,
new LiteralConnectionStringProvider(database.ConnectionString),
new RedisConnectionMultiplexerConfiguration()
{
LoggingSeverity = Severity.Error
});
var primaryDatabaseAdapter = new RedisDatabaseAdapter(primaryFactory, "keyspace");
var redisVolatileEventStorage = new RedisWriteAheadEventStorage(redisVolatileEventLogConfiguration, primaryDatabaseAdapter);
var mockPersistentEventStorage = new MockPersistentEventStorage();
var volatileEventStorage = new FailingVolatileEventStorage(volatileStorageFailure, redisVolatileEventStorage);
var persistentEventStorage = new FailingPersistentEventStorage(persistentStorageFailure, mockPersistentEventStorage);
contentMetadataEventStreamConfiguration ??= new ContentMetadataEventStreamConfiguration();
var contentMetadataEventStream = new ContentMetadataEventStream(contentMetadataEventStreamConfiguration, volatileEventStorage, persistentEventStorage);
await contentMetadataEventStream.StartupAsync(operationContext).ThrowIfFailure();
await contentMetadataEventStream.CompleteOrChangeLogAsync(operationContext, CheckpointLogId.InitialLogId);
contentMetadataEventStream.SetIsLogging(true);
await runTestAsync(operationContext, contentMetadataEventStream, volatileEventStorage, persistentEventStorage);
await contentMetadataEventStream.ShutdownAsync(operationContext).ThrowIfFailure();
}
/// <summary>
/// Returns a fully populated <see cref="FailureMode"/> from the cache if it exists, otherwise gets it from the server and adds it to the cache before returning it.
/// </summary>
/// <param name="failureMode">The <see cref="FailureMode"/> to populate.</param>
/// <returns>A fully-populated <see cref="FailureMode"/>.</returns>
async Task <FailureMode> GetFailureModeAsync(FailureMode failureMode)
{
if (failureMode == null || failureMode is NoFailureMode)
{
return(NoFailureMode.Value);
}
Id id = failureMode.Id;
if (failureModeCache.TryGetValue(id, out failureMode))
{
return(failureMode);
}
IList <FailureMode> returnedFailureModes = await api.GetFailureModesAsync(id.ToString());
if (!returnedFailureModes.Any())
{
return(null);
}
failureMode = returnedFailureModes.First();
failureModeCache.Add(id, failureMode);
return(failureMode);
}
/// <summary>
/// Returns a fully populated <see cref="FailureMode"/> from the cache if it exists, otherwise gets it from the server and adds it to the cache before returning it.
/// </summary>
/// <param name="failureMode">The <see cref="FailureMode"/> to populate.</param>
/// <returns>populated failure mode</returns>
async Task <FailureMode> GetFailureModeAsync(FailureMode failureMode)
{
if (failureMode == null || failureMode is NoFailureMode)
{
return(NoFailureMode.Value);
}
Id id = failureMode.Id;
if (failureModeCache.TryGetValue(id, out failureMode))
{
return(failureMode);
}
IList <FailureMode> returnedFailureMode = await api.CallAsync <IList <FailureMode> >("Get", typeof(FailureMode), new { search = new FailureModeSearch(id) });
if (returnedFailureMode.Count == 0)
{
return(null);
}
failureMode = returnedFailureMode[0];
failureModeCache.Add(id, failureMode);
return(failureMode);
}
public Task WriteAndReadManyEventsSingleBlock(FailureMode persistentStorageFailure, FailureMode volatileStorageFailure)
{
var testSize = 100;
return(RunTest(async(context, stream, _, _) =>
{
var requests = Enumerable.Range(0, testSize).Select(idx => new RegisterContentLocationsRequest()
{
MachineId = new MachineId(idx),
}).ToArray();
// Wait one after the other to ensure the sequencing is exactly what we expect
foreach (var request in requests)
{
await stream.WriteEventAsync(context, request).SelectResult(r => r.Should().BeTrue());
}
var cursor = await stream.BeforeCheckpointAsync(context).ThrowIfFailureAsync();
if (volatileStorageFailure == FailureMode.All)
{
await CollectStream(context, stream, cursor).ShouldBeError();
}
else
{
var events = await CollectStream(context, stream, cursor).ThrowIfFailureAsync();
events.Count.Should().Be(testSize);
for (var i = 0; i < requests.Length; i++)
{
(events[i] as RegisterContentLocationsRequest).MachineId.Should().BeEquivalentTo(requests[i].MachineId);
}
}
},
persistentStorageFailure: persistentStorageFailure,
volatileStorageFailure: volatileStorageFailure));
}
public Task WriteAndReadManyEventsAcrossBlocks(FailureMode persistentStorageFailure, FailureMode volatileStorageFailure)
{
var testSize = 5;
var logRefreshFrequency = TimeSpan.FromMinutes(5);
return(RunTest(async(context, stream, _, _) =>
{
var requests = Enumerable.Range(0, testSize).Select(idx => new RegisterContentLocationsRequest()
{
MachineId = new MachineId(idx),
}).ToArray();
// Wait one after the other to ensure the sequencing is exactly what we expect
foreach (var request in requests)
{
await stream.WriteEventAsync(context, request).SelectResult(r => r.Should().BeTrue());
await stream.WriteBehindCommitLoopIterationAsync(context);
}
var cursor = await stream.BeforeCheckpointAsync(context).ThrowIfFailureAsync();
if (volatileStorageFailure == FailureMode.All)
{
await CollectStream(context, stream, cursor).ShouldBeError();
}
else
{
var events = await CollectStream(context, stream, cursor).ThrowIfFailureAsync();
events.Count.Should().Be(testSize);
}
}, contentMetadataEventStreamConfiguration: new ContentMetadataEventStreamConfiguration()
{
LogBlockRefreshInterval = logRefreshFrequency,
},
persistentStorageFailure: persistentStorageFailure,
volatileStorageFailure: volatileStorageFailure));
}
public async Task PublishAsync(
FailureMode failureMode,
ProcessingContext context,
byte[] payload,
IDictionary<string, string> properties,
Exception ex = null)
{
var blobMetaData = new Dictionary<string, string>();
// Construct a name for the blob that helps communicate
// the nature of the failure. We append a Guid in order
// to avoid any naming collisions.
var blobName = string.Concat(
failureMode,
"/",
context.EventHubName,
"/",
context.PartitionId,
"/",
context.EventDataOffset,
"_",
Guid.NewGuid().ToString("N"));
try
{
var blob = _blobContainer.GetBlockBlobReference(blobName);
// Add the property dictionary as a JSON object
var messageProperties = JsonConvert.SerializeObject(properties);
blobMetaData.Add("messageProperties", messageProperties);
// Upload the blob and properties
await blob.UploadFromByteArrayAsync(payload, 0, payload.Length);
foreach (var p in blobMetaData)
{
blob.Metadata.Add(p.Key, p.Value);
}
await blob.SetMetadataAsync();
// If the message has an attached exception publish as an associated blob
if (ex != null)
{
var blobEx = _blobContainer.GetBlockBlobReference(blobName + "_exception");
await blobEx.UploadTextAsync(ex.ToString());
}
}
catch (Exception ex0)
{
var sb = new StringBuilder();
foreach (var pair in blobMetaData)
{
sb.AppendFormat("{0}:{1}", pair.Key, pair.Value);
sb.AppendLine();
}
Logger.Error(ex0,
"Could not publish poison message to blob container. Properties from message:" + sb
);
}
}
/// <summary>
/// Writes the <see cref="ReceivedFaultData"/> or <see cref="ReceivedStatusData"/> of this <see cref="TrackedDiagnostic"/> (depending on its <see cref="DiagnosticCategory"/>) to file and then clears the subject data from memory.
/// </summary>
/// <returns></returns>
public async Task WriteDataToFileAsync()
{
try
{
switch (DiagnosticCategoryType)
{
case DiagnosticCategory.FaultData:
if (receivedFaultData.Count > 0)
{
// Ensure FaultData records are sorted chronologiocally.
List <FaultData> sortedFaultData = receivedFaultData.OrderBy(faultData => faultData.DateTime).ToList();
// Write FaultData records to file.
using (TextWriter fileWriter = new StreamWriter(OutputFilePath, true))
{
foreach (FaultData faultData in sortedFaultData)
{
string failureModeCode = "";
string failureModeName = "";
string failureModeSourceName = "";
FailureMode failureMode = faultData.FailureMode;
if (failureMode != null)
{
failureModeCode = failureMode.Code.ToString();
failureModeName = failureMode.Name;
Source failureModeSource = failureMode.Source;
if (failureModeSource != null)
{
failureModeSourceName = failureModeSource.Name;
}
}
string dismissUserName = "";
string dismissDateTime = "";
User dismissUser = faultData.DismissUser;
if (dismissUser != null)
{
dismissUserName = dismissUser.Name;
dismissDateTime = faultData.DismissDateTime.ToString();
}
await fileWriter.WriteLineAsync($"{DeviceId.ToString()}|{DeviceSerialNumber}|{DeviceName}|{faultData.DateTime.ToString()}|{faultData.Diagnostic.Id.ToString()}|{faultData.Diagnostic.Name}|{failureModeCode}|{failureModeName}|{failureModeSourceName}|{faultData.Controller.Name}|{faultData.Count.ToString()}|{faultData.FaultState.ToString()}|{faultData.MalfunctionLamp.ToString()}|{faultData.RedStopLamp.ToString()}|{faultData.AmberWarningLamp.ToString()}|{faultData.ProtectWarningLamp.ToString()}|{dismissDateTime}|{dismissUserName}");
}
}
receivedFaultData.Clear();
}
break;
case DiagnosticCategory.StatusData:
if (receivedStatusData.Count > 0)
{
// Ensure StatusData records are sorted chronologiocally.
List <StatusData> sortedStatusData = receivedStatusData.OrderBy(statusData => statusData.DateTime).ToList();
// Write StatusData records to file.
using (TextWriter fileWriter = new StreamWriter(OutputFilePath, true))
{
foreach (StatusData statusData in sortedStatusData)
{
await fileWriter.WriteLineAsync($"{DeviceId.ToString()}|{DeviceSerialNumber}|{DeviceName}|{statusData.DateTime.ToString()}|{statusData.Diagnostic.Id.ToString()}|{statusData.Diagnostic.Name}|{statusData.Diagnostic.Source.Name}|{statusData.Data.ToString()}|{statusData.Diagnostic.UnitOfMeasure.Name}");
}
}
receivedStatusData.Clear();
}
break;
default:
break;
}
}
catch (Exception ex)
{
ConsoleUtility.LogError(ex);
if (ex is IOException)
{
// Possiable system out of memory exception or file lock. Sleep for a minute and continue.
await Task.Delay(TimeSpan.FromMinutes(1));
}
}
}
public List <FailureMode> GetFailureModeList(DataTable dataTable, int DataStartColumn, AnalysisType failureAnalysisType)
{
#region *** Variable define ***
//m_FailureArray = new string[dataTable.Rows.Count - 3];
m_FailureArray = new string[100000];
string[] deviceNoArray;
Dictionary <string, string> myDic = new Dictionary <string, string>();
List <FailureMode> failureModeList = new List <FailureMode>();
#endregion *** Variable define ***
#region *** Generate failure parameter list for each device ***
m_FailureArray[0] = "This array contain failure parameter list for each device";
foreach (DataRow dr in dataTable.Rows) // for datatable rows
{
if (dataTable.Rows.IndexOf(dr) > 3 && Convert.ToString(dr[dataTable.Columns.Count - 1]).ToUpper() == "FAIL") //if Datarow
{
for (int j = DataStartColumn; j < dataTable.Columns.Count - 1; j++) //for Column loop
{
//if (dr[j] != DBNull.Value) //if DBNull
if (util.IsNumeral(dr[j]))
{
double Value = Convert.ToDouble(dr[j]);
double LowLimit = Convert.ToDouble(dataTable.Rows[2][j]);
double HighLimit = Convert.ToDouble(dataTable.Rows[3][j]);
int DeviceNo = Convert.ToInt32(dr[0]);
if (Value < LowLimit || Value > HighLimit)
{
m_FailureArray[DeviceNo] += dataTable.Rows[0][j].ToString() + " " + '"' + " ";
}
} //end of if DBNull
} //end of for Column loop
} // end of if Datarow
} // end of for datatable rows
#endregion *** Generate failure parameter list for each device ***
if (failureAnalysisType == AnalysisType.FailureMode) //if Analysis type = failure mode
{
#region *** Caculate failure mode ***
for (int i = 1; i < m_FailureArray.Length; i++) // for failureArray length
{
string FaulireModeTemp = m_FailureArray[i];
if (FaulireModeTemp != null)
{
if (myDic.ContainsKey(FaulireModeTemp))
{//if Contain key, append device no
string DeviceNo = myDic[FaulireModeTemp] + "," + i.ToString();
myDic[FaulireModeTemp] = DeviceNo;
}
else
{ //if not, add the failure mode and device no
string DeviceNo = i.ToString();
myDic.Add(FaulireModeTemp, DeviceNo);
}
}
}// end of for failureArray length
#endregion *** Caculate failure mode ***
} //end of if Analysis type = failure mode
else //if Analysis type = failure rate
{
#region *** Caculate failure rate ***
for (int i = 1; i < m_FailureArray.Length; i++) // for failureArray length
{
if (m_FailureArray[i] != null) //if (m_FailureArray[i] != null)
{
int stringLength = m_FailureArray[i].Length - 2;
string[] failureRateTemp = m_FailureArray[i].Substring(0, stringLength).Split('"');
for (int j = 0; j < failureRateTemp.Length; j++) //for failureRateTemp.Length
{
string failureParameter = failureRateTemp[j].Trim();
if (myDic.ContainsKey(failureParameter))
{//if Contain key, append device no
string DeviceNo = myDic[failureParameter] + "," + i.ToString();
myDic[failureParameter] = DeviceNo;
}
else
{ //if not, add the failure mode and device no
string DeviceNo = i.ToString();
myDic.Add(failureParameter, DeviceNo);
}
} //end of for failureRateTemp.Length
} //end of if (m_FailureArray[i] != null)
} // end of for failureArray length
#endregion *** Caculate failure rate ***
}//end of if Analysis type = failure rate
#region *** Sorting failure mode ***
foreach (string key in myDic.Keys)
{
deviceNoArray = myDic[key].Split(',');
FailureMode FMTemp = new FailureMode();
FMTemp.Count = deviceNoArray.Length;
FMTemp.Parameter = key;
FMTemp.Device = deviceNoArray;
failureModeList.Add(FMTemp);
}
Comparison <FailureMode> cmp = (x, y) =>
{
if (x.Count > y.Count)
{
return(-1);
}
else if (x.Count < y.Count)
{
return(1);
}
else
{
return(0);
}
};
failureModeList.Sort(cmp);
#endregion *** Sorting failure mode ***
return(failureModeList);
} //end of GetFailureModeList
/// <summary>
/// Default constructor
/// </summary>
/// <param name="request">The request that was executed and failed</param>
/// <param name="exception">The exception that was raised</param>
internal FailedCopyRequest(CopyObjectRequest request, Exception exception, FailureMode mode)
{
this.Request = request ?? throw new ArgumentNullException("request");
this.FailureReason = exception ?? throw new ArgumentNullException("exception");
this.FailureMode = mode;
}
static public void SetFailureMode(FailureMode inMode)
{
#if DEVELOPMENT
s_FailureMode = inMode;
#endif // DEVELOPMENT
}
public TaskConfiguration WithFailureModeM(FailureMode failureMode) => new TaskConfiguration(Schedule, failureMode, ExecutionMode, LeaseDuration, Data);
public async Task PublishAsync(
FailureMode failureMode,
ProcessingContext context,
byte[] payload,
IDictionary <string, string> properties,
Exception ex = null)
{
var blobMetaData = new Dictionary <string, string>();
// Construct a name for the blob that helps communicate
// the nature of the failure. We append a Guid in order
// to avoid any naming collisions.
var blobName = string.Concat(
failureMode,
"/",
context.EventHubName,
"/",
context.PartitionId,
"/",
context.EventDataOffset,
"_",
Guid.NewGuid().ToString("N"));
try
{
var blob = _blobContainer.GetBlockBlobReference(blobName);
// Add the property dictionary as a JSON object
var messageProperties = JsonConvert.SerializeObject(properties);
blobMetaData.Add("messageProperties", messageProperties);
// Upload the blob and properties
await blob.UploadFromByteArrayAsync(payload, 0, payload.Length);
foreach (var p in blobMetaData)
{
blob.Metadata.Add(p.Key, p.Value);
}
await blob.SetMetadataAsync();
// If the message has an attached exception publish as an associated blob
if (ex != null)
{
var blobEx = _blobContainer.GetBlockBlobReference(blobName + "_exception");
await blobEx.UploadTextAsync(ex.ToString());
}
}
catch (Exception ex0)
{
var sb = new StringBuilder();
foreach (var pair in blobMetaData)
{
sb.AppendFormat("{0}:{1}", pair.Key, pair.Value);
sb.AppendLine();
}
Logger.Error(ex0,
"Could not publish poison message to blob container. Properties from message:" + sb
);
}
}
public void Write(TProtocol oprot)
{
oprot.IncrementRecursionDepth();
try
{
TStruct struc = new TStruct("TDDIOutputFailure");
oprot.WriteStructBegin(struc);
TField field = new TField();
if (__isset.Id)
{
field.Name = "Id";
field.Type = TType.I64;
field.ID = 1;
oprot.WriteFieldBegin(field);
oprot.WriteI64(Id);
oprot.WriteFieldEnd();
}
if (Name != null && __isset.Name)
{
field.Name = "Name";
field.Type = TType.String;
field.ID = 2;
oprot.WriteFieldBegin(field);
oprot.WriteString(Name);
oprot.WriteFieldEnd();
}
if (Description != null && __isset.Description)
{
field.Name = "Description";
field.Type = TType.String;
field.ID = 3;
oprot.WriteFieldBegin(field);
oprot.WriteString(Description);
oprot.WriteFieldEnd();
}
if (__isset.IsCitation)
{
field.Name = "IsCitation";
field.Type = TType.Bool;
field.ID = 4;
oprot.WriteFieldBegin(field);
oprot.WriteBool(IsCitation);
oprot.WriteFieldEnd();
}
if (__isset.IsAbstract)
{
field.Name = "IsAbstract";
field.Type = TType.Bool;
field.ID = 5;
oprot.WriteFieldBegin(field);
oprot.WriteBool(IsAbstract);
oprot.WriteFieldEnd();
}
if (KeyValueMaps != null && __isset.KeyValueMaps)
{
field.Name = "KeyValueMaps";
field.Type = TType.List;
field.ID = 6;
oprot.WriteFieldBegin(field);
{
oprot.WriteListBegin(new TList(TType.Struct, KeyValueMaps.Count));
foreach (TDDIKeyValueMapRef _iter454 in KeyValueMaps)
{
_iter454.Write(oprot);
}
oprot.WriteListEnd();
}
oprot.WriteFieldEnd();
}
if (CitedElement != null && __isset.CitedElement)
{
field.Name = "CitedElement";
field.Type = TType.Struct;
field.ID = 7;
oprot.WriteFieldBegin(field);
CitedElement.Write(oprot);
oprot.WriteFieldEnd();
}
if (__isset.FailureRate)
{
field.Name = "FailureRate";
field.Type = TType.Double;
field.ID = 8;
oprot.WriteFieldBegin(field);
oprot.WriteDouble(FailureRate);
oprot.WriteFieldEnd();
}
if (FailureMode != null && __isset.FailureMode)
{
field.Name = "FailureMode";
field.Type = TType.Struct;
field.ID = 9;
oprot.WriteFieldBegin(field);
FailureMode.Write(oprot);
oprot.WriteFieldEnd();
}
if (ProbabilityDistribution != null && __isset.ProbabilityDistribution)
{
field.Name = "ProbabilityDistribution";
field.Type = TType.Struct;
field.ID = 10;
oprot.WriteFieldBegin(field);
ProbabilityDistribution.Write(oprot);
oprot.WriteFieldEnd();
}
if (MinimalCutsets != null && __isset.MinimalCutsets)
{
field.Name = "MinimalCutsets";
field.Type = TType.List;
field.ID = 11;
oprot.WriteFieldBegin(field);
{
oprot.WriteListBegin(new TList(TType.Struct, MinimalCutsets.Count));
foreach (TDDIMinimalCutset _iter455 in MinimalCutsets)
{
_iter455.Write(oprot);
}
oprot.WriteListEnd();
}
oprot.WriteFieldEnd();
}
oprot.WriteFieldStop();
oprot.WriteStructEnd();
}
finally
{
oprot.DecrementRecursionDepth();
}
}
private int WriteFailures(MailboxDatabase mdb, int?errorcode, FailureMode failureMode, ExDateTime?startDate, ExDateTime?endDate)
{
int num = 0;
StoreSession storeSession = null;
ADUser aduser = null;
Guid? mailboxGuid = null;
if (this.Identity != null)
{
mailboxGuid = new Guid?(this.Archive ? this.mailbox.ArchiveGuid : this.mailbox.ExchangeGuid);
aduser = this.mailbox;
}
MdbInfo mdbInfo = new MdbInfo(mdb);
mdbInfo.EnableOwningServerUpdate = true;
mdbInfo.UpdateDatabaseLocationInfo();
Guid?guid = null;
try
{
using (IFailedItemStorage failedItemStorage = Factory.Current.CreateFailedItemStorage(Factory.Current.CreateSearchServiceConfig(mdbInfo.Guid), mdbInfo.IndexSystemName, mdbInfo.OwningServer))
{
FailedItemParameters parameters = new FailedItemParameters(failureMode, FieldSet.Default)
{
MailboxGuid = mailboxGuid,
ErrorCode = errorcode,
StartDate = startDate,
EndDate = endDate
};
foreach (IFailureEntry failureEntry in failedItemStorage.GetFailedItems(parameters))
{
if (failureEntry.MailboxGuid != guid)
{
guid = new Guid?(failureEntry.MailboxGuid);
if (storeSession != null)
{
storeSession.Dispose();
storeSession = null;
}
if (mailboxGuid == null)
{
aduser = this.GetADUser(guid.Value);
}
if (aduser != null && aduser.RecipientTypeDetails == RecipientTypeDetails.PublicFolderMailbox)
{
storeSession = this.OpenPublicFolderMailboxSession(mdbInfo.Guid, aduser);
}
else
{
storeSession = this.OpenMailboxSession(mdbInfo.Guid, guid.Value);
}
}
if (storeSession != null)
{
int num2 = (int)storeSession.Mailbox.TryGetProperty(MailboxSchema.MailboxNumber);
if (num2 != ((MdbItemIdentity)failureEntry.ItemId).MailboxNumber)
{
continue;
}
}
string subject = this.GetSubject(failureEntry, storeSession);
this.WriteResult(new FailedDocument(failureEntry, subject, mdbInfo.Name, aduser));
num++;
}
}
}
catch (ComponentException exception)
{
base.WriteError(exception, ErrorCategory.ReadError, null);
}
finally
{
if (storeSession != null)
{
storeSession.Dispose();
}
}
return(num);
}
public FailingVolatileEventStorage(FailureMode failureMode = FailureMode.All, IWriteAheadEventStorage innerStorage = null)
{
FailureMode = failureMode;
InnerStorage = innerStorage;
}
/// <summary>
/// Initializes a new instance of the <see cref="AzureBlobOverflownMessageHandler"/> class.
/// </summary>
/// <param name="container">The BLOB container that will hold the overflown messages.</param>
public ChaosMonkeyOverflownMessageHandler(IBlobContainer container, FailureMode failureMode)
{
this.OverflowContainer = container;
this._failureMode = failureMode;
}
private void UpdateCounts(FailureMode mode)
{
switch (mode)
{
case FailureMode.None:
m_iSuccesses++;
break;
case FailureMode.ConversionFailed:
m_iConvFails++;
break;
case FailureMode.DiscoveryFailed:
m_iDiscoFails++;
break;
case FailureMode.CleaningFailed:
m_iCleanFails++;
break;
case FailureMode.DocumentCorruption:
m_iCorrupted++;
break;
case FailureMode.DiscoveryMismatch:
m_iMismatches++;
break;
case FailureMode.ThingsNotCleaned:
m_iNotCleaned++;
break;
}
UpdateCountTextBoxes();
}
void WriteDataToCsv <T>()
where T : class
{
try
{
Type type = typeof(T);
if (type == typeof(LogRecord))
{
using (TextWriter writer = new StreamWriter(Path.Combine(path, MakeFileName(GpsPrefix)), true))
{
writer.WriteLine(GpsDataHeader);
foreach (LogRecord gpsRecord in gpsRecords)
{
Write(writer, gpsRecord, (StringBuilder sb, LogRecord logRecord) =>
{
AppendDeviceValues(sb, logRecord.Device);
AppendValues(sb, logRecord.DateTime);
AppendValues(sb, logRecord.Longitude);
AppendValues(sb, logRecord.Latitude);
AppendValues(sb, logRecord.Speed);
});
}
}
}
else if (type == typeof(StatusData))
{
using (TextWriter writer = new StreamWriter(Path.Combine(path, MakeFileName(StatusPrefix)), true))
{
writer.WriteLine(StatusDataHeader);
foreach (StatusData statusRecord in statusRecords)
{
Write(writer, statusRecord, (StringBuilder sb, StatusData statusData) =>
{
AppendDeviceValues(sb, statusData.Device);
AppendValues(sb, statusData.DateTime);
Diagnostic diagnostic = statusData.Diagnostic;
AppendDiagnosticValues(sb, diagnostic);
AppendValues(sb, statusData.Data);
if (diagnostic is DataDiagnostic dataDiagnostic)
{
AppendName(sb, dataDiagnostic.UnitOfMeasure);
}
});
}
}
}
else if (type == typeof(FaultData))
{
using (TextWriter writer = new StreamWriter(Path.Combine(path, MakeFileName(FaultPrefix)), true))
{
writer.WriteLine(FaultDataHeader);
foreach (FaultData faultRecord in faultRecords)
{
Write(writer, faultRecord, (StringBuilder sb, FaultData faultData) =>
{
AppendDeviceValues(sb, faultData.Device);
AppendValues(sb, faultData.DateTime);
AppendName(sb, faultData.Diagnostic);
FailureMode failureMode = faultData.FailureMode;
AppendName(sb, failureMode);
AppendValues(sb, failureMode.Code);
if (failureMode is NoFailureMode)
{
AppendValues(sb, "None");
}
else
{
AppendName(sb, failureMode.Source);
}
AppendName(sb, faultData.Controller);
AppendValues(sb, faultData.Count);
AppendValues(sb, faultData.FaultState);
AppendValues(sb, faultData.MalfunctionLamp);
AppendValues(sb, faultData.RedStopLamp);
AppendValues(sb, faultData.AmberWarningLamp);
AppendValues(sb, faultData.ProtectWarningLamp);
AppendValues(sb, faultData.DismissDateTime);
User dismissUser = faultData.DismissUser;
if (dismissUser != null)
{
AppendValues(sb, faultData.DismissUser.Name.Replace(",", " "));
}
});
}
}
}
else if (type == typeof(Trip))
{
using (TextWriter writer = new StreamWriter(Path.Combine(path, MakeFileName(TripPrefix)), true))
{
writer.WriteLine(TripHeader);
foreach (Trip tripToWrite in trips)
{
Write(writer, tripToWrite, (StringBuilder sb, Trip trip) =>
{
AppendDeviceValues(sb, trip.Device);
AppendDriverValues(sb, trip.Driver);
AppendValues(sb, trip.Start);
AppendValues(sb, trip.Stop);
AppendValues(sb, trip.Distance);
});
}
}
}
else if (type == typeof(ExceptionEvent))
{
using (TextWriter writer = new StreamWriter(Path.Combine(path, MakeFileName(ExceptionEventPrefix)), true))
{
writer.WriteLine(ExceptionEventHeader);
foreach (ExceptionEvent exceptionEventToWrite in exceptionEvents)
{
Write(writer, exceptionEventToWrite, (StringBuilder sb, ExceptionEvent exceptionEvent) =>
{
AppendValues(sb, exceptionEvent.Id);
AppendDeviceValues(sb, exceptionEvent.Device);
AppendDiagnosticValues(sb, exceptionEvent.Diagnostic);
AppendDriverValues(sb, exceptionEvent.Driver);
AppendName(sb, exceptionEvent.Rule);
AppendValues(sb, exceptionEvent.ActiveFrom);
AppendValues(sb, exceptionEvent.ActiveTo);
});
}
}
}
else
{
throw new NotSupportedException(type.ToString());
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
if (e is IOException)
{
// Possiable system out of memory exception or file lock. Log then sleep for a minute and continue.
Thread.Sleep(TimeSpan.FromMinutes(1));
}
}
}
public FailingPersistentEventStorage(FailureMode failureMode = FailureMode.All, IWriteBehindEventStorage innerStorage = null)
{
FailureMode = failureMode;
InnerStorage = innerStorage;
}
public override string ToString()
{
StringBuilder __sb = new StringBuilder("TDDIOutputFailure(");
bool __first = true;
if (__isset.Id)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("Id: ");
__sb.Append(Id);
}
if (Name != null && __isset.Name)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("Name: ");
__sb.Append(Name);
}
if (Description != null && __isset.Description)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("Description: ");
__sb.Append(Description);
}
if (__isset.IsCitation)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("IsCitation: ");
__sb.Append(IsCitation);
}
if (__isset.IsAbstract)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("IsAbstract: ");
__sb.Append(IsAbstract);
}
if (KeyValueMaps != null && __isset.KeyValueMaps)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("KeyValueMaps: ");
__sb.Append(KeyValueMaps);
}
if (CitedElement != null && __isset.CitedElement)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("CitedElement: ");
__sb.Append(CitedElement == null ? "<null>" : CitedElement.ToString());
}
if (__isset.FailureRate)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("FailureRate: ");
__sb.Append(FailureRate);
}
if (FailureMode != null && __isset.FailureMode)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("FailureMode: ");
__sb.Append(FailureMode == null ? "<null>" : FailureMode.ToString());
}
if (ProbabilityDistribution != null && __isset.ProbabilityDistribution)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("ProbabilityDistribution: ");
__sb.Append(ProbabilityDistribution == null ? "<null>" : ProbabilityDistribution.ToString());
}
if (MinimalCutsets != null && __isset.MinimalCutsets)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("MinimalCutsets: ");
__sb.Append(MinimalCutsets);
}
__sb.Append(")");
return(__sb.ToString());
}
public override string ToString()
{
StringBuilder __sb = new StringBuilder("TDDIFailureAnalysisArtifactUnion(");
bool __first = true;
if (FailureLogicPackage != null && __isset.FailureLogicPackage)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("FailureLogicPackage: ");
__sb.Append(FailureLogicPackage);
}
if (MinimalCutset != null && __isset.MinimalCutset)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("MinimalCutset: ");
__sb.Append(MinimalCutset == null ? "<null>" : MinimalCutset.ToString());
}
if (InterfaceFailurePropagation != null && __isset.InterfaceFailurePropagation)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("InterfaceFailurePropagation: ");
__sb.Append(InterfaceFailurePropagation == null ? "<null>" : InterfaceFailurePropagation.ToString());
}
if (Failure != null && __isset.Failure)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("Failure: ");
__sb.Append(Failure == null ? "<null>" : Failure.ToString());
}
if (FailureMode != null && __isset.FailureMode)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("FailureMode: ");
__sb.Append(FailureMode == null ? "<null>" : FailureMode.ToString());
}
if (ProbabilityDistribution != null && __isset.ProbabilityDistribution)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("ProbabilityDistribution: ");
__sb.Append(ProbabilityDistribution == null ? "<null>" : ProbabilityDistribution.ToString());
}
if (ProbDistParam != null && __isset.ProbDistParam)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("ProbDistParam: ");
__sb.Append(ProbDistParam == null ? "<null>" : ProbDistParam.ToString());
}
if (FTAArtifact != null && __isset.FTAArtifact)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("FTAArtifact: ");
__sb.Append(FTAArtifact);
}
if (FMEAArtifact != null && __isset.FMEAArtifact)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("FMEAArtifact: ");
__sb.Append(FMEAArtifact);
}
if (MarkovArtifact != null && __isset.MarkovArtifact)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("MarkovArtifact: ");
__sb.Append(MarkovArtifact);
}
__sb.Append(")");
return(__sb.ToString());
}
