public CopyBase()
: base()
{
Authentication = new Authentication();
ServerAddress = "[SshServerAddress]";
Port = "[SshServerPort]";
ExistsAction = STEM.Sys.IO.FileExistsAction.MakeUnique;
DestinationActionRule = DestinationRule.AllOrNone;
Retry = 1;
RetryDelaySeconds = 2;
ExpandSource = false;
SourcePath = "[TargetPath]";
FileFilter = "[TargetName]";
DirectoryFilter = "!TEMP";
RecurseSource = false;
RecreateTree = false;
ExpandDestination = false;
DestinationPath = "[DestinationPath]\\[SubDir]";
DestinationFilename = "*.*";
ExecutionMode = ExecuteOn.ForwardExecution;
ZeroFilesAction = FailureAction.SkipRemaining;
}
public async Task CloseAsync(
IEnumerable <Metadata> metadataEnumerator,
FailureAction failureAction)
{
// Note: Since we only support one action, we could have chosen not to pass in a failure action.
// I have it there to make it explicit and easily readable.
Utility.Assert(
failureAction == FailureAction.AbortStateProvider,
"{0}: ApiDispatcher::CloseAsync: Action only supports AbortStateProvider for CloseAsync. FailureAction: {1}",
this.traceType,
failureAction);
List <Task> taskList = new List <Task>();
foreach (Metadata metadata in metadataEnumerator)
{
// Since the failureAction must be AbortStateProvider, exceptions cannot happen here.
taskList.Add(CloseAsync(metadata, failureAction));
}
// The Task for waiting all CloseAsync finish is exception free, since for every CloseAsync
// failure, the state provider will call Abort which will never throw exception.
// We expect the c# scheduler to ensure the optimal number of awaitables execute asynchronously.
await Task.WhenAll(taskList).ConfigureAwait(false);
}
public GetDeliveryChannelConfigsResult DeepCloneWithFailureAction(FailureAction failureAction)
{
var result = new GetDeliveryChannelConfigsResult(
this.Configs?.DeepClone(),
this.Failures?.DeepClone(),
failureAction);
return(result);
}
public GetAudienceResult DeepCloneWithFailureAction(FailureAction failureAction)
{
var result = new GetAudienceResult(
this.Audience?.DeepClone(),
this.Failures?.DeepClone(),
failureAction);
return(result);
}
public TopicToFile()
{
Authentication = new Authentication();
DestinationFile = "[DestinationPath]\\[TargetName]";
FileExistsAction = STEM.Sys.IO.FileExistsAction.MakeUnique;
Retry = 1;
RetryDelaySeconds = 2;
ZeroItemsAction = FailureAction.SkipRemaining;
}
/// <summary>
/// Initializes a new instance of the <see cref="GetAudienceResult"/> class.
/// </summary>
/// <param name="audience">The resolved audience.</param>
/// <param name="failures">The failures that occurred when executing the operation.</param>
/// <param name="failureAction">The action to take when <paramref name="failures"/> contains one or more elements.</param>
public GetAudienceResult(
IAudience audience,
IReadOnlyCollection <IFailure> failures,
FailureAction failureAction)
{
new { failures }.AsArg().Must().NotContainAnyNullElementsWhenNotNull();
new { failureAction }.AsArg().Must().NotBeEqualTo(FailureAction.Unknown);
this.Audience = audience;
this.Failures = failures;
this.FailureAction = failureAction;
}
public TopicToContainer()
{
Authentication = new Authentication();
ContentType = DataType.String;
ContainerDataKey = "[TargetNameWithoutExt]";
TargetContainer = ContainerType.InstructionSetContainer;
Retry = 1;
RetryDelaySeconds = 2;
ZeroItemsAction = FailureAction.SkipRemaining;
}
public QueueToFile()
{
ServerAddress = "[QueueServerAddress]";
Port = "[QueueServerPort]";
QueueName = "[QueueName]";
DestinationFile = "[DestinationPath]\\[TargetName]";
FileExistsAction = STEM.Sys.IO.FileExistsAction.MakeUnique;
Retry = 1;
RetryDelaySeconds = 2;
ZeroItemsAction = FailureAction.SkipRemaining;
}
public QueueToContainer()
{
ServerAddress = "[QueueServerAddress]";
Port = "[QueueServerPort]";
QueueName = "[QueueName]";
ContentType = DataType.String;
ContainerDataKey = "[TargetNameWithoutExt]";
TargetContainer = ContainerType.InstructionSetContainer;
Retry = 1;
RetryDelaySeconds = 2;
ZeroItemsAction = FailureAction.SkipRemaining;
}
/// <summary>
/// Initializes a new instance of the <see cref="GetDeliveryChannelConfigsResult"/> class.
/// </summary>
/// <param name="configs">The delivery channel configs.</param>
/// <param name="failures">The failures that occurred when executing the operation.</param>
/// <param name="failureAction">The action to take when <paramref name="failures"/> contains one or more elements.</param>
public GetDeliveryChannelConfigsResult(
IReadOnlyCollection <DeliveryChannelConfig> configs,
IReadOnlyCollection <IFailure> failures,
FailureAction failureAction)
{
new { configs }.AsArg().Must().NotContainAnyNullElementsWhenNotNull();
var deliveryChannels = configs?.Select(_ => _.Channel).ToList();
new { deliveryChannels }.AsArg().Must().ContainOnlyDistinctElementsWhenNotNull();
new { failures }.AsArg().Must().NotContainAnyNullElementsWhenNotNull();
new { failureAction }.AsArg().Must().NotBeEqualTo(FailureAction.Unknown);
this.Configs = configs;
this.Failures = failures;
this.FailureAction = failureAction;
}
/// <summary>
/// Closes a given state provider
/// </summary>
public async Task CloseAsync(
Metadata metadata,
FailureAction failureAction)
{
Utility.Assert(
metadata != null,
"{0}: ApiDispatcher::CloseAsync: metadata passed to the function should not be null.",
this.traceType);
try
{
await metadata.StateProvider.CloseAsync().ConfigureAwait(false);
}
catch (Exception)
{
#if !DotNetCoreClr
// These are new events defined in System.Fabric, existing CoreCLR apps would break
// if these events are refernced as it wont be found. As CoreCLR apps carry System.Fabric
// along with application
// This is just a mitigation for now. Actual fix being tracked via bug# 11614507
FabricEvents.Events.ISP2_ApiError(
this.traceType,
metadata.StateProviderId,
"CloseAsync");
#endif
// In the native, this part is out of catch block, but if we do this in managed code, the
// stack trace will be lost, so keep it in the catch block.
if (failureAction == FailureAction.AbortStateProvider)
{
Abort(metadata);
}
else
{
throw;
}
}
}
//main method allows for form actions before and after conversation
public void Execute(object context)
{
PreExecuteAction?.Invoke(context);
if (InitiatorConv)
{
InitatorConversation(ref context);
}
else
{
ResponderConversation(ref context);
}
if (Error == null)
{
PostExecuteAction?.Invoke(context);
}
else
{
FailureAction?.Invoke(context);
}
Done = true;
ConversationDictionary.Instance.CloseQueue(MyQueue.QueueID);
}
public CopyBase()
: base()
{
ExistsAction = STEM.Sys.IO.FileExistsAction.MakeUnique;
Retry = 1;
RetryDelaySeconds = 2;
DestinationActionRule = DestinationRule.AllOrNone;
CB_ExpandSource = false;
CB_SourcePath = "[TargetPath]";
CB_FileFilter = "[TargetName]";
CB_DirectoryFilter = "!TEMP";
CB_RecurseSource = false;
RecreateTree = false;
ExpandDestination = false;
UseTempHop = true;
DestinationPath = "[DestinationPath]\\[SubDir]";
DestinationFilename = "*.*";
ExecutionMode = ExecuteOn.ForwardExecution;
ZeroFilesAction = FailureAction.SkipRemaining;
}
/// <summary>
/// Serialize to a JSON object
/// </summary>
public new void SerializeJson(Utf8JsonWriter writer, JsonSerializerOptions options, bool includeStartObject = true)
{
if (includeStartObject)
{
writer.WriteStartObject();
}
if (!string.IsNullOrEmpty(ResourceType))
{
writer.WriteString("resourceType", (string)ResourceType !);
}
((fhirCsR4.Models.DomainResource) this).SerializeJson(writer, options, false);
if ((Target != null) && (Target.Count != 0))
{
writer.WritePropertyName("target");
writer.WriteStartArray();
foreach (Reference valTarget in Target)
{
valTarget.SerializeJson(writer, options, true);
}
writer.WriteEndArray();
}
if ((TargetLocation != null) && (TargetLocation.Count != 0))
{
writer.WritePropertyName("targetLocation");
writer.WriteStartArray();
foreach (string valTargetLocation in TargetLocation)
{
writer.WriteStringValue(valTargetLocation);
}
writer.WriteEndArray();
}
if ((_TargetLocation != null) && (_TargetLocation.Count != 0))
{
writer.WritePropertyName("_targetLocation");
writer.WriteStartArray();
foreach (Element val_TargetLocation in _TargetLocation)
{
val_TargetLocation.SerializeJson(writer, options, true);
}
writer.WriteEndArray();
}
if (Need != null)
{
writer.WritePropertyName("need");
Need.SerializeJson(writer, options);
}
if (!string.IsNullOrEmpty(Status))
{
writer.WriteString("status", (string)Status !);
}
if (_Status != null)
{
writer.WritePropertyName("_status");
_Status.SerializeJson(writer, options);
}
if (!string.IsNullOrEmpty(StatusDate))
{
writer.WriteString("statusDate", (string)StatusDate !);
}
if (_StatusDate != null)
{
writer.WritePropertyName("_statusDate");
_StatusDate.SerializeJson(writer, options);
}
if (ValidationType != null)
{
writer.WritePropertyName("validationType");
ValidationType.SerializeJson(writer, options);
}
if ((ValidationProcess != null) && (ValidationProcess.Count != 0))
{
writer.WritePropertyName("validationProcess");
writer.WriteStartArray();
foreach (CodeableConcept valValidationProcess in ValidationProcess)
{
valValidationProcess.SerializeJson(writer, options, true);
}
writer.WriteEndArray();
}
if (Frequency != null)
{
writer.WritePropertyName("frequency");
Frequency.SerializeJson(writer, options);
}
if (!string.IsNullOrEmpty(LastPerformed))
{
writer.WriteString("lastPerformed", (string)LastPerformed !);
}
if (_LastPerformed != null)
{
writer.WritePropertyName("_lastPerformed");
_LastPerformed.SerializeJson(writer, options);
}
if (!string.IsNullOrEmpty(NextScheduled))
{
writer.WriteString("nextScheduled", (string)NextScheduled !);
}
if (_NextScheduled != null)
{
writer.WritePropertyName("_nextScheduled");
_NextScheduled.SerializeJson(writer, options);
}
if (FailureAction != null)
{
writer.WritePropertyName("failureAction");
FailureAction.SerializeJson(writer, options);
}
if ((PrimarySource != null) && (PrimarySource.Count != 0))
{
writer.WritePropertyName("primarySource");
writer.WriteStartArray();
foreach (VerificationResultPrimarySource valPrimarySource in PrimarySource)
{
valPrimarySource.SerializeJson(writer, options, true);
}
writer.WriteEndArray();
}
if (Attestation != null)
{
writer.WritePropertyName("attestation");
Attestation.SerializeJson(writer, options);
}
if ((Validator != null) && (Validator.Count != 0))
{
writer.WritePropertyName("validator");
writer.WriteStartArray();
foreach (VerificationResultValidator valValidator in Validator)
{
valValidator.SerializeJson(writer, options, true);
}
writer.WriteEndArray();
}
if (includeStartObject)
{
writer.WriteEndObject();
}
}
/// <summary>
/// Used to replace tokens in a string from the searchSpace of interest
///
/// e.g.
///
/// Session["[CompanyX DBAddress]"] = "192.168.100.100"
/// Session["[CompanyX DBUser]"] = "sa"
///
/// string sqlConn = Server=[CompanyX DBAddress];Database=myDataBase;User Id=[CompanyX DBUser];
/// sqlConn = ReplaceTokens(sqlConn, FailureAction.ThrowException, SearchSpace.Session)
///
/// </summary>
/// <param name="tokenizedString"></param>
/// <param name="failureAction"></param>
/// <param name="searchSpace"></param>
/// <returns>String with tokens replaced</returns>
protected string ReplaceTokens(string tokenizedString, FailureAction failureAction, SearchSpace searchSpace = SearchSpace.InstructionSetContainer | SearchSpace.Session | SearchSpace.Cache)
{
if (String.IsNullOrEmpty(tokenizedString))
{
throw new ArgumentNullException(nameof(tokenizedString));
}
string xform = tokenizedString;
List <string> tokens = new List <string>();
foreach (Match m in _Regex.Matches(tokenizedString))
{
tokens.Add(m.Value);
}
tokens = tokens.Distinct().ToList();
foreach (string t in tokens.ToList())
{
if ((searchSpace & SearchSpace.InstructionSetContainer) != 0)
{
if (InstructionSetContainer.ContainsKey(t))
{
xform = xform.Replace(t, (string)InstructionSetContainer[t]);
tokens.Remove(t);
continue;
}
string x = t.Replace("[", "");
x = x.Replace("]", "");
if (InstructionSetContainer.ContainsKey(x))
{
xform = xform.Replace(t, (string)InstructionSetContainer[x]);
tokens.Remove(t);
continue;
}
}
if ((searchSpace & SearchSpace.Session) != 0)
{
if (STEM.Sys.Global.Session.ContainsKey(t))
{
xform = xform.Replace(t, (string)STEM.Sys.Global.Session[t]);
tokens.Remove(t);
continue;
}
string x = t.Replace("[", "");
x = x.Replace("]", "");
if (STEM.Sys.Global.Session.ContainsKey(x))
{
xform = xform.Replace(t, (string)STEM.Sys.Global.Session[x]);
tokens.Remove(t);
continue;
}
}
if ((searchSpace & SearchSpace.Cache) != 0)
{
if (STEM.Sys.Global.Cache.ContainsKey(t))
{
xform = xform.Replace(t, (string)STEM.Sys.Global.Cache[t]);
tokens.Remove(t);
continue;
}
string x = t.Replace("[", "");
x = x.Replace("]", "");
if (STEM.Sys.Global.Cache.ContainsKey(x))
{
xform = xform.Replace(t, (string)STEM.Sys.Global.Cache[x]);
tokens.Remove(t);
continue;
}
}
}
if (tokens.Count > 0)
{
switch (failureAction)
{
case FailureAction.ReturnInput:
return(tokenizedString);
case FailureAction.ReturnNull:
return(null);
case FailureAction.ThrowException:
Exception e = new Exception("Tokens not found: " + String.Join(",", tokens));
STEM.Sys.EventLog.WriteEntry("InstructionSet.ReplaceTokens", e.ToString(), STEM.Sys.EventLog.EventLogEntryType.Error);
throw e;
}
}
return(xform);
}
private ApplicationUpgradePolicy SetUpgradePolicy(ApplicationUpgradePolicy currentPolicy)
{
if (currentPolicy == null)
{
currentPolicy = new ApplicationUpgradePolicy();
}
if (ForceRestart.IsPresent)
{
currentPolicy.ForceRestart = true;
}
if (this.IsParameterBound(c => c.UpgradeReplicaSetCheckTimeoutSec))
{
currentPolicy.UpgradeReplicaSetCheckTimeout = TimeSpan.FromSeconds(UpgradeReplicaSetCheckTimeoutSec).ToString("");
}
//RollingUpgradeMonitoringPolicy
if (currentPolicy.RollingUpgradeMonitoringPolicy == null)
{
//initialize with defaults
currentPolicy.RollingUpgradeMonitoringPolicy = new ArmRollingUpgradeMonitoringPolicy(
failureAction: "Manual",
healthCheckStableDuration: TimeSpan.FromSeconds(120).ToString("c"),
healthCheckRetryTimeout: TimeSpan.FromSeconds(600).ToString("c"),
healthCheckWaitDuration: TimeSpan.FromSeconds(0).ToString("c"),
upgradeTimeout: TimeSpan.MaxValue.ToString("c"),
upgradeDomainTimeout: TimeSpan.MaxValue.ToString("c"));
}
if (this.IsParameterBound(c => c.FailureAction))
{
currentPolicy.RollingUpgradeMonitoringPolicy.FailureAction = FailureAction.ToString();
}
if (this.IsParameterBound(c => c.HealthCheckRetryTimeoutSec))
{
currentPolicy.RollingUpgradeMonitoringPolicy.HealthCheckRetryTimeout = TimeSpan.FromSeconds(HealthCheckRetryTimeoutSec).ToString("c");
}
if (this.IsParameterBound(c => c.HealthCheckWaitDurationSec))
{
currentPolicy.RollingUpgradeMonitoringPolicy.HealthCheckWaitDuration = TimeSpan.FromSeconds(HealthCheckWaitDurationSec).ToString("c");
}
if (this.IsParameterBound(c => c.HealthCheckStableDurationSec))
{
currentPolicy.RollingUpgradeMonitoringPolicy.HealthCheckStableDuration = TimeSpan.FromSeconds(HealthCheckStableDurationSec).ToString("c");
}
if (this.IsParameterBound(c => c.UpgradeDomainTimeoutSec))
{
currentPolicy.RollingUpgradeMonitoringPolicy.UpgradeDomainTimeout = TimeSpan.FromSeconds(UpgradeDomainTimeoutSec).ToString("c");
}
if (this.IsParameterBound(c => c.UpgradeTimeoutSec))
{
currentPolicy.RollingUpgradeMonitoringPolicy.UpgradeTimeout = TimeSpan.FromSeconds(UpgradeTimeoutSec).ToString("c");
}
//ApplicationHealthPolicy
if (currentPolicy.ApplicationHealthPolicy == null)
{
currentPolicy.ApplicationHealthPolicy = new ArmApplicationHealthPolicy();
}
if (ConsiderWarningAsError.IsPresent)
{
currentPolicy.ApplicationHealthPolicy.ConsiderWarningAsError = true;
}
if (currentPolicy.ApplicationHealthPolicy.DefaultServiceTypeHealthPolicy == null)
{
currentPolicy.ApplicationHealthPolicy.DefaultServiceTypeHealthPolicy = new ArmServiceTypeHealthPolicy(
maxPercentUnhealthyPartitionsPerService: DefaultServiceTypeMaxPercentUnhealthyPartitionsPerService,
maxPercentUnhealthyReplicasPerPartition: DefaultServiceTypeMaxPercentUnhealthyReplicasPerPartition,
maxPercentUnhealthyServices: DefaultServiceTypeUnhealthyServicesMaxPercent);
}
else
{
if (this.IsParameterBound(c => c.DefaultServiceTypeMaxPercentUnhealthyPartitionsPerService))
{
currentPolicy.ApplicationHealthPolicy.DefaultServiceTypeHealthPolicy.MaxPercentUnhealthyPartitionsPerService = DefaultServiceTypeMaxPercentUnhealthyPartitionsPerService;
}
if (this.IsParameterBound(c => c.DefaultServiceTypeMaxPercentUnhealthyReplicasPerPartition))
{
currentPolicy.ApplicationHealthPolicy.DefaultServiceTypeHealthPolicy.MaxPercentUnhealthyReplicasPerPartition = DefaultServiceTypeMaxPercentUnhealthyReplicasPerPartition;
}
if (this.IsParameterBound(c => c.DefaultServiceTypeUnhealthyServicesMaxPercent))
{
currentPolicy.ApplicationHealthPolicy.DefaultServiceTypeHealthPolicy.MaxPercentUnhealthyServices = DefaultServiceTypeUnhealthyServicesMaxPercent;
}
if (this.IsParameterBound(c => c.UnhealthyDeployedApplicationsMaxPercent))
{
currentPolicy.ApplicationHealthPolicy.MaxPercentUnhealthyDeployedApplications = UnhealthyDeployedApplicationsMaxPercent;
}
}
if (ServiceTypeHealthPolicyMap != null)
{
foreach (DictionaryEntry entry in this.ServiceTypeHealthPolicyMap)
{
currentPolicy.ApplicationHealthPolicy.ServiceTypeHealthPolicyMap.Add(entry.Key as string, this.ParseServiceTypeHealthPolicy(entry.Value as string));
}
}
return(currentPolicy);
}
