public SavePostureConstraintResponse SavePostureConstraint(SavePostureConstraintRequest request)
{
try
{
var postureConstraint = request.MapTo <PostureConstraint>();
if (request.Id == 0)
{
var posture = new Posture {
Id = request.PostureId
};
DataContext.Postures.Attach(posture);
postureConstraint.Posture = posture;
foreach (var id in request.RelationIds)
{
var desiredState = new DesiredState {
Id = id
};
DataContext.DesiredStates.Attach(desiredState);
postureConstraint.DesiredStates.Add(desiredState);
}
DataContext.PostureConstraints.Add(postureConstraint);
}
else
{
postureConstraint = DataContext.PostureConstraints.Include(x => x.DesiredStates).First(x => x.Id == request.Id);
request.MapPropertiesToInstance <PostureConstraint>(postureConstraint);
postureConstraint.DesiredStates = new List <DesiredState>();
foreach (var id in request.RelationIds)
{
var desiredState = DataContext.DesiredStates.Local.FirstOrDefault(x => x.Id == id);
if (desiredState == null)
{
desiredState = new DesiredState {
Id = id
};
DataContext.DesiredStates.Attach(desiredState);
}
postureConstraint.DesiredStates.Add(desiredState);
}
}
DataContext.SaveChanges();
return(new SavePostureConstraintResponse
{
IsSuccess = true,
Message = "The item has been saved successfully",
Id = postureConstraint.Id,
Definition = postureConstraint.Definition,
RelationIds = postureConstraint.DesiredStates.Select(x => x.Id).ToArray()
});
}
catch
{
return(new SavePostureConstraintResponse
{
IsSuccess = false,
Message = "An error occured, please contact the administrator for further information"
});
}
}
public async Task <ResourceRoot> AddResourceAsync(DesiredState desiredState, CancellationToken cancellationToken = default)
{
var resource = _resourceRepository.Add(new ResourceRoot(desiredState));
await _resourceRepository.UnitOfWork.SaveChangesAsync(cancellationToken);
return(resource);
}
public async Task <EnvironmentRoot> AddEnvironmentAsync(DesiredState desiredState, CancellationToken cancellationToken = default)
{
var environment = _environmentRepository.Add(new EnvironmentRoot(desiredState));
await _environmentRepository.UnitOfWork.SaveChangesAsync(cancellationToken);
return(environment);
}
private void WaitForInstances(AwsClientDetails clientDetails)
{
using (var helper = new EC2Helper(clientDetails))
{
helper.WaitForInstances(InstanceIds, DesiredState.ToLower(), TimeOutSeconds, PollIntervalSeconds);
Log.LogMessage(MessageImportance.Normal, "All Instances {0} in the state {1}", Join(InstanceIds), DesiredState);
}
}
public async Task <IEnumerable <IAggregateRoot> > GetAggregatesByState(DesiredState desiredState)
{
var resources = await _resourceRepository.GetAsync(o => o.DesiredState.Equals(desiredState));
var environments = await _resourceRepository.GetAsync(o => o.DesiredState.Equals(desiredState));
return(resources.Cast <IAggregateRoot>().Concat(environments));
}
public async Task ApplyDesiredStateAsync(
Guid environmentId,
DesiredState desiredState,
CancellationToken cancellationToken = default)
{
var request = new ApplyDesiredStateRequest(environmentId, desiredState);
var response = await SendAsync(request, cancellationToken);
response.EnsureSuccessStatusCode();
}
public async Task <ResourceRoot> UpdateResourceAsync(Guid resourceId, DesiredState desiredState, CancellationToken cancellationToken = default)
{
var resource = await GetResourceByIdAsync(resourceId);
resource.SetDesiredState(desiredState);
_resourceRepository.Update(resource);
await _resourceRepository.UnitOfWork.SaveChangesAsync(cancellationToken);
return(resource);
}
public AppDesiredState(string packageFamilyName, DesiredState state, string version, StartupState startUp, string appxSource, string dep0Source, string dep1Source, string certificateSource, string certificateTarget)
{
PackageFamilyName = packageFamilyName;
State = state;
Version = version;
StartUp = startUp;
AppxSource = appxSource;
Dep0Source = dep0Source;
Dep1Source = dep1Source;
CertificateSource = certificateSource;
CertificateTarget = certificateTarget;
}
public Factorial(int i)
//throws Exception
{
trace = new Trace("fact_trace");
_fact = new FactorialType(i);
EqualsOneRange defaultRange = new EqualsOneRange();
GreaterThanOneRange multRange = new GreaterThanOneRange();
LessThanOneRange fRange = new LessThanOneRange();
EqualsTwoRange desiredRange = new EqualsTwoRange();
_multiply = new MultiplyAction(_fact);
_initialize = new InitializeAction(_fact);
_multiply.SetTrace(trace);
_initialize.SetTrace(trace);
_multiply.SetId("multiply");
_initialize.SetId("initialize");
_mult = new State(_multiply, true);
_def = new State(_initialize);
_mult.SetId("mult");
_def.SetId("default");
_forbidden = new ForbiddenState();
_desired = new DesiredState();
_forbidden.SetId("f1");
_desired.SetId("d1");
_mult.SetTrace(trace);
_def.SetTrace(trace);
_forbidden.SetTrace(trace);
_desired.SetTrace(trace);
_fact.AddRange(_mult, multRange);
_fact.AddRange(_def, defaultRange);
_fact.AddRange(_forbidden, fRange);
_fact.AddRange(_desired, desiredRange);
_behavior = new FactorialBehavior(_fact);
_behavior.Add(_mult);
_behavior.Add(_def);
this.Add(_behavior);
Element.SetWarnOnErrroneousAction(true);
State s = _fact.CurrentState();
if (HasTrace())
{
_trace.AddTrace(s);
}
}
private async Task When_a_environment_is_requested()
{
var provider = _services.BuildServiceProvider();
var provisioningBroker = provider.GetRequiredService <IProvisioningBroker>();
var environmentDesiredState = new DesiredState(
name: "environment",
apiVersion: "1",
labels: null,
properties: new[]
{
new Property("name", "production"), new Property("capability.RootId", "operateports-zekzl"),
}
);
var createEnvironmentCommand = new CreateEnvironmentCommand(environmentDesiredState);
var result = await provisioningBroker.Handle(createEnvironmentCommand);
}
public DeleteDesiredStateResponse DeleteDesiredState(DeleteDesiredStateRequest request)
{
try
{
var desiredStae = new DesiredState {
Id = request.Id
};
DataContext.DesiredStates.Attach(desiredStae);
DataContext.DesiredStates.Remove(desiredStae);
DataContext.SaveChanges();
return(new DeleteDesiredStateResponse
{
IsSuccess = true,
Message = "The item has been deleted successfully",
});
}
catch {
return(new DeleteDesiredStateResponse
{
IsSuccess = false,
Message = "An error occured, please contact the administrator for further information"
});
}
}
public ResourceRoot(DesiredState desiredState) : base()
{
DesiredState = desiredState;
}
private async Task Given_a_json_payload()
{
var jsonPayload = "{\"Name\":null,\"ApiVersion\":null,\"Labels\":null,\"Properties\":null}";
_payload = JsonSerializer.Deserialize <DesiredState>(jsonPayload);
}
public ResourceRoot(DesiredState desiredState) : base()
{
DesiredState = desiredState;
AddDomainEvent(new ResourceInitializingEvent(this));
}
public void SetDesiredState(DesiredState desiredState)
{
DesiredState = desiredState;
}
public CreateEnvironmentCommand(DesiredState desiredState)
{
DesiredState = desiredState;
}
public CreateEnvironmentCommand(DesiredState desiredState)
{
DesiredState = desiredState ?? throw new ArgumentNullException(nameof(desiredState));
}
public EnvironmentRoot(DesiredState desiredState) : this()
{
SetDesiredState(desiredState);
}
public void ClearDesiredState()
{
DesiredState.ClearState();
}
public void ApplyDesiredState(DeviceContext dc, ParameterManager paramManager)
{
OnApplyDesiredState(dc, paramManager);
DesiredState.ResetTracking();
CurrentState.Clone(DesiredState);
}
public void SetDesiredState(DesiredState desiredState)
{
DesiredState = desiredState;
Initialize();
}
public void SetState(DesiredState state, long timestamp)
{
currentStates[state.laneID] = new Tuple <DesiredState, long>(state, timestamp);
}
public async Task <EnvironmentRoot> UpdateEnvironmentAsync(Guid environmentId, DesiredState desiredState, CancellationToken cancellationToken = default)
{
var environment = await GetEnvironmentByIdAsync(environmentId);
environment.SetDesiredState(desiredState);
_environmentRepository.Update(environment);
await _environmentRepository.UnitOfWork.SaveChangesAsync(cancellationToken);
return(environment);
}
internal PnpReported(object value, DesiredState desiredState)
{
Value = value;
DesiredState = desiredState;
}
public EnvironmentRoot(DesiredState desiredState) : this()
{
DesiredState = desiredState;
AddDomainEvent(new EnvironmentCreatedEvent(this));
}
public DieHard(int big, int small)
{
trace = new Trace("fact_trace");
_jugs = new JugType(big, small);
EmptyBigEmptySmallRange emptyBigEmptySmallRange = new EmptyBigEmptySmallRange();
FullBigFullSmallRange fullBigFullSmallRange = new FullBigFullSmallRange();
FullBigEmptySmallRange fullBigEmptySmallRange = new FullBigEmptySmallRange();
EmptyBigFullSmallRange emptyBigFullSmallRange = new EmptyBigFullSmallRange();
PartialBigEmptySmallRange partialBigEmptySmallRange = new PartialBigEmptySmallRange();
PartialBigFullSmallRange partialBigFullSmallRange = new PartialBigFullSmallRange();
FullBigPartialSmallRange fullBigPartialSmallRange = new FullBigPartialSmallRange();
EmptyBigPartialSmallRange emptyBigPartialSmallRange = new EmptyBigPartialSmallRange();
PartialBigPartialSmallRange partialBigPartialSmallRange = new PartialBigPartialSmallRange();
_fillBig = new FillBigAction(_jugs);
_fillSmall = new FillSmallAction(_jugs);
_emptyBig = new EmptyBigAction(_jugs);
_emptySmall = new EmptySmallAction(_jugs);
_big2Small = new Big2SmallAction(_jugs);
_small2Big = new Small2BigAction(_jugs);
_fillBig.SetTrace(trace);
_fillSmall.SetTrace(trace);
_emptyBig.SetTrace(trace);
_emptySmall.SetTrace(trace);
_big2Small.SetTrace(trace);
_small2Big.SetTrace(trace);
_fillBig.SetId("fillBig");
_fillSmall.SetId("fillSmall");
_emptyBig.SetId("emptyBig");
_emptySmall.SetId("emptySmall");
_big2Small.SetId("big2Small");
_small2Big.SetId("small2Big");
_emptyBigEmptySmall = new State(_fillBig);
_fullBigFullSmall = new State(_emptyBig);
_fullBigEmptySmall = new State(_big2Small);
_emptyBigFullSmall = new State(_small2Big);
_partialBigEmptySmall = new State(_big2Small);
_partialBigFullSmall = new State(_emptySmall);
_fullBigPartialSmall = new State(_big2Small);
_emptyBigPartialSmall = new State(_small2Big);
_partialBigPartialSmall = new State(_big2Small);
_forbidden = new ForbiddenState();
_desired = new DesiredState();
_forbidden.SetId("f1");
_desired.SetId("d1");
_emptyBigEmptySmall.SetTrace(trace).SetId("emptyBigEmptySmall");
_emptyBigEmptySmall.Add(_fillSmall);
_fullBigFullSmall.SetTrace(trace).SetId("fullBigFullSmall");
_fullBigEmptySmall.SetTrace(trace).SetId("fullBigEmptySmall");
_fullBigEmptySmall.Add(_fillSmall);
_emptyBigFullSmall.SetTrace(trace).SetId("emptyBigFullSmall");
_emptyBigFullSmall.Add(_emptySmall);
_partialBigEmptySmall.SetTrace(trace).SetId("partialBigEmptySmall");
_partialBigEmptySmall.Add(_emptyBig);
_partialBigFullSmall.SetTrace(trace).SetId("partialBigFullSmall");
_partialBigFullSmall.Add(_emptyBig);
_fullBigPartialSmall.SetTrace(trace).SetId("fullBigPartialSmall");
_emptyBigPartialSmall.SetTrace(trace).SetId("emptyBigPartialSmall");
_emptyBigPartialSmall.Add(_fillBig);
_partialBigPartialSmall.SetTrace(trace).SetId("partialBigPartialSmall");
_forbidden.SetTrace(trace);
_desired.SetTrace(trace);
_jugs.AddRange(_emptyBigEmptySmall, emptyBigEmptySmallRange);
_jugs.AddRange(_fullBigFullSmall, fullBigFullSmallRange);
_jugs.AddRange(_fullBigEmptySmall, fullBigEmptySmallRange);
_jugs.AddRange(_emptyBigFullSmall, emptyBigFullSmallRange);
_jugs.AddRange(_partialBigEmptySmall, partialBigEmptySmallRange);
_jugs.AddRange(_partialBigFullSmall, partialBigFullSmallRange);
_jugs.AddRange(_fullBigPartialSmall, fullBigPartialSmallRange);
_jugs.AddRange(_emptyBigPartialSmall, emptyBigPartialSmallRange);
_jugs.AddRange(_partialBigPartialSmall, partialBigPartialSmallRange);
DesiredRange desiredRange = new DesiredRange();
_jugs.AddRange(_desired, desiredRange);
_behavior = new JugBehavior(_jugs);
_behavior.Add(_emptyBigEmptySmall);
_behavior.Add(_fullBigFullSmall);
_behavior.Add(_partialBigEmptySmall);
_behavior.Add(_partialBigFullSmall);
_behavior.Add(_fullBigPartialSmall);
_behavior.Add(_emptyBigPartialSmall);
_behavior.Add(_partialBigPartialSmall);
}
