/// <summary>
/// <para>Initializes a new instance of the <see cref="System.Fabric.Chaos.DataStructures.ChaosDescription" /> class.</para>
/// </summary>
/// <param name="chaosStatus">The status of Chaos. Can be Stopped, Running or Invalid</param>
/// <param name="chaosParameters">The parameters that Chaos runs with if Chaos is currently running or the parameters if Chaos was running with if Chaos was running. If Chaos has never ran before, then the value here does not have a meaning.</param>
/// <param name="chaosScheduleStatus">The state of the schedule.</param>
public ChaosDescription(
ChaosStatus chaosStatus,
ChaosParameters chaosParameters,
ChaosScheduleStatus chaosScheduleStatus)
{
this.Status = chaosStatus;
this.ChaosParameters = chaosParameters;
this.ScheduleStatus = chaosScheduleStatus;
}
private static async Task RegisterChaosEventAndUpdateChaosStatusPrivateAsync(
this IReliableStateManager stateManager,
ChaosEvent chaosEvent,
ChaosStatus currentStatus,
Action postAction,
CancellationToken cancellationToken)
{
var eventsDictionary = await stateManager.GetOrAddAsync <IReliableDictionary <long, byte[]> >(FASConstants.ChaosEventsDictionaryName).ConfigureAwait(false);
var lastEventKeyDictionary = await stateManager.GetOrAddAsync <IReliableDictionary <string, byte[]> >(FASConstants.ChaosLastEventKeyDictionaryName).ConfigureAwait(false);
var statusDictionary = await stateManager.GetOrAddAsync <IReliableDictionary <string, byte[]> >(FASConstants.ChaosStatusDictionaryName).ConfigureAwait(false);
using (ITransaction tx = stateManager.CreateTransaction())
{
long eventKey = chaosEvent.TimeStampUtc.Ticks;
if (await eventsDictionary.ContainsKeyAsync(tx, eventKey, FASConstants.ReliableDictionaryTimeout, cancellationToken).ConfigureAwait(false))
{
++eventKey;
chaosEvent.TimeStampUtc = chaosEvent.TimeStampUtc.AddTicks(1);
}
byte[] chaosEventInBytes = chaosEvent.ToBytes();
TestabilityTrace.TraceSource.WriteInfo(TraceType, "RegisterChaosEventAndUpdateChaosStatusPrivateAsync attempting to add event == {0} with key {1}.", chaosEvent, eventKey);
await eventsDictionary.AddOrUpdateAsync(tx, eventKey, chaosEventInBytes, (k, v) => chaosEventInBytes, FASConstants.ReliableDictionaryTimeout, cancellationToken).ConfigureAwait(false);
await lastEventKeyDictionary.UpdateLastEventKeyAsync(tx, chaosEvent.TimeStampUtc.Ticks, cancellationToken).ConfigureAwait(false);
// Update status
byte[] statusInBytes = BitConverter.GetBytes((int)currentStatus);
if (await statusDictionary.ContainsKeyAsync(tx, FASConstants.ChaosStatusKeyName, FASConstants.ReliableDictionaryTimeout, cancellationToken).ConfigureAwait(false))
{
TestabilityTrace.TraceSource.WriteInfo(TraceType, "RegisterChaosEventAndUpdateChaosStatusPrivateAsync attempting to update status == {0} with key {1}.", currentStatus, FASConstants.ChaosStatusKeyName);
await statusDictionary.SetAsync(tx, FASConstants.ChaosStatusKeyName, statusInBytes, FASConstants.ReliableDictionaryTimeout, cancellationToken).ConfigureAwait(false);
}
else
{
TestabilityTrace.TraceSource.WriteInfo(TraceType, "RegisterChaosEventAndUpdateChaosStatusPrivateAsync attempting to add status == {0} with key {1}.", currentStatus, FASConstants.ChaosStatusKeyName);
await statusDictionary.AddAsync(tx, FASConstants.ChaosStatusKeyName, statusInBytes, FASConstants.ReliableDictionaryTimeout, cancellationToken).ConfigureAwait(false);
}
if (postAction != null)
{
postAction();
}
TestabilityTrace.TraceSource.WriteInfo(TraceType, "RegisterChaosEventAndUpdateChaosStatusPrivateAsync stored event == {0} and status {1}.", chaosEvent, currentStatus);
await tx.CommitAsync().ConfigureAwait(false);
}
}
/// <summary>
/// <para>Initializes a new instance of the <see cref="System.Fabric.Chaos.DataStructures.ChaosReport" /> class.</para>
/// </summary>
/// <param name="chaosParameters">Parameters with which Chaos was started</param>
/// <param name="status">If Chaos is currently running or stopped.</param>
/// <param name="history">The list of ChaosEvent's that match the ChaosReportFilter in ChaosParameters</param>
/// <param name="continuationToken">If too many events match the ChaosReportFilter, those will be returned in multiple batches, the batches are linked by this token.</param>
public ChaosReport(
ChaosParameters chaosParameters,
ChaosStatus status,
List <ChaosEvent> history,
string continuationToken)
{
this.ChaosParameters = chaosParameters;
this.Status = status;
this.History = history;
this.ContinuationToken = continuationToken;
}
// Start is called before the first frame update
void Start()
{
PfScript = GetComponent <PathFinding>();
demon_m = GetComponent <ChaosMotion>();
demon_s = GetComponent <ChaosStatus>();
GetComponent <CapsuleCollider2D>().isTrigger = false;
a = gameObject.GetComponent <SpriteRenderer>().color;
HPbar.gameObject.SetActive(false);
Name.gameObject.SetActive(false);
HPbar.maxValue = demon_s.hp;
}
public static async Task RegisterCurrentStatusAsync(
this IReliableStateManager stateManager,
ChaosStatus currentStatus,
IStatefulServicePartition partition,
CancellationToken cancellationToken)
{
await FaultAnalysisServiceUtility.RunAndReportFaultOnRepeatedFailure(
ChaosOperationID,
() => RegisterCurrentStatusPrivateAsync(stateManager, currentStatus, cancellationToken),
partition,
"RegisterCurrentStatusPrivateAsync",
FASConstants.MaxRetriesForReliableDictionary,
cancellationToken).ConfigureAwait(false);
}
private static async Task <ChaosStatus> GetCurrentStatusPrivateAsync(
IReliableDictionary <string, byte[]> statusDictionary,
ITransaction tx,
CancellationToken cancellationToken)
{
ChaosStatus status = ChaosStatus.Stopped;
if (await statusDictionary.ContainsKeyAsync(tx, FASConstants.ChaosStatusKeyName, FASConstants.ReliableDictionaryTimeout, cancellationToken).ConfigureAwait(false))
{
var conditionalStatus = await statusDictionary.TryGetValueAsync(tx, FASConstants.ChaosStatusKeyName, FASConstants.ReliableDictionaryTimeout, cancellationToken).ConfigureAwait(false);
if (conditionalStatus.HasValue)
{
status = (ChaosStatus)BitConverter.ToInt32(conditionalStatus.Value, 0);
}
}
else
{
TestabilityTrace.TraceSource.WriteError(TraceType, "GetCurrentStatus was called, but there was no entry with key == {0}.", FASConstants.ChaosStatusKeyName);
}
return(status);
}
private static async Task RegisterCurrentStatusPrivateAsync(
IReliableStateManager stateManager,
ChaosStatus currentStatus,
CancellationToken cancellationToken)
{
var statusDictionary = await stateManager.GetOrAddAsync <IReliableDictionary <string, byte[]> >(FASConstants.ChaosStatusDictionaryName).ConfigureAwait(false);
using (ITransaction tx = stateManager.CreateTransaction())
{
byte[] statusInBytes = BitConverter.GetBytes((int)currentStatus);
if (await statusDictionary.ContainsKeyAsync(tx, FASConstants.ChaosStatusKeyName, FASConstants.ReliableDictionaryTimeout, cancellationToken).ConfigureAwait(false))
{
await statusDictionary.SetAsync(tx, FASConstants.ChaosStatusKeyName, statusInBytes, FASConstants.ReliableDictionaryTimeout, cancellationToken).ConfigureAwait(false);
}
else
{
await statusDictionary.AddAsync(tx, FASConstants.ChaosStatusKeyName, statusInBytes, FASConstants.ReliableDictionaryTimeout, cancellationToken).ConfigureAwait(false);
}
await tx.CommitAsync().ConfigureAwait(false);
}
}
public override void Read(BinaryReader br)
{
this.ScheduleStatus = (ChaosScheduleStatus)br.ReadInt32();
this.ChaosStatus = (ChaosStatus)br.ReadInt32();
}
public SchedulerState(ChaosScheduleStatus scheduleStatus, ChaosStatus chaosStatus)
{
this.ScheduleStatus = scheduleStatus;
this.ChaosStatus = chaosStatus;
}
public StateTransition(ChaosScheduleStatus scheduleStatus, ChaosStatus chaosStatus, Command command)
{
this.state = new SchedulerState(scheduleStatus, chaosStatus);
this.command = command;
}
