public LogicalBinaryStateActuator WithActuator(IStateMachine actuator)
{
if (actuator == null)
{
throw new ArgumentNullException(nameof(actuator));
}
actuator.StateChanged += (s, e) =>
{
var oldState = _state;
_state = GetStateInternal();
if (oldState.Equals(_state))
{
return;
}
OnActiveStateChanged(oldState, _state);
};
Actuators.Add(actuator);
_state = GetStateInternal();
return(this);
}
protected void OnActiveStateChanged(IComponentState oldState, IComponentState newState)
{
_stateLastChanged = DateTime.Now;
Log.Info($"Component '{Id}' updated state from '{oldState}' to '{newState}'");
StateChanged?.Invoke(this, new ComponentStateChangedEventArgs(oldState, newState));
}
private void ThrowIfStateNotSupported(IComponentState stateId)
{
if (!GetSupportsState(stateId))
{
throw new NotSupportedException($"State '{stateId}' is not supported.");
}
}
public override void SetState(IComponentState state, params IHardwareParameter[] parameters)
{
if (state == null)
{
throw new ArgumentNullException(nameof(state));
}
if (state.Equals(_state))
{
return;
}
if (state.Equals(RollerShutterStateId.Off))
{
_endpoint.Stop(parameters);
}
else if (state.Equals(RollerShutterStateId.MovingUp))
{
_endpoint.StartMoveUp(parameters);
RestartTracking();
}
else if (state.Equals(RollerShutterStateId.MovingDown))
{
_endpoint.StartMoveDown(parameters);
RestartTracking();
}
var oldState = _state;
_state = state;
OnActiveStateChanged(oldState, _state);
}
public void Add(IComponentState <TJob> state)
{
if (list.Count == capcity)
{
list.Dequeue();
}
list.Enqueue(state);
}
public void SaveState <T> (IComponentState <T> state)
{
using (var textWriter = new StreamWriter(path, true))
{
var csv = new CsvWriter(textWriter);
csv.WriteRecord(state);
}
}
public StateMachineState(IComponentState id)
{
if (id == null)
{
throw new ArgumentNullException(nameof(id));
}
Id = id;
}
public bool Equals(IComponentState otherState)
{
if (ReferenceEquals(otherState, this))
{
return(true);
}
return(Equals(otherState as StatefulComponentState));
}
public StateNotSupportedException(IComponentState state)
: base($"State '{state}' is not supported.")
{
if (state == null)
{
throw new ArgumentNullException(nameof(state));
}
State = state;
}
public Frame WithTargetState(IActuator actuator, IComponentState state)
{
if (actuator == null)
{
throw new ArgumentNullException(nameof(actuator));
}
_states.Add(new PendingActuatorState().WithActuator(actuator).WithState(state));
return(this);
}
public void SetState(IComponentState state, object obj)
{
foreach (var propertyInfo in GetStatePropertyInfo(obj))
{
if (!state.ContainsKey(propertyInfo.Name))
{
continue;
}
var propertyType = Nullable.GetUnderlyingType(propertyInfo.PropertyType) ?? propertyInfo.PropertyType;
propertyInfo.SetValue(this, Convert.ChangeType(state[propertyInfo.Name], propertyType), null);
}
}
public static bool GetSupportsState(this IComponent component, IComponentState componentState)
{
if (componentState == null)
{
throw new ArgumentNullException(nameof(componentState));
}
if (component == null)
{
throw new ArgumentNullException(nameof(component));
}
return(component.GetSupportedStates().Any(s => s.Equals(componentState)));
}
protected void SetState(IComponentState newState)
{
if (newState.Equals(_state))
{
return;
}
var oldValue = _state;
_state = newState;
OnActiveStateChanged(oldValue, newState);
}
public ComponentIsInStateCondition(IComponent component, IComponentState state)
{
if (component == null)
{
throw new ArgumentNullException(nameof(component));
}
if (state == null)
{
throw new ArgumentNullException(nameof(state));
}
WithExpression(() => component.GetState().Equals(state));
}
public void AddSynonymsForComponentState(IComponentState componentState, params string[] synonyms)
{
if (componentState == null)
{
throw new ArgumentNullException(nameof(componentState));
}
if (synonyms == null)
{
throw new ArgumentNullException(nameof(synonyms));
}
AddSynonyms(_componentStateSynonyms, componentState, synonyms);
_storage.PersistComponentStateSynonyms(_componentStateSynonyms);
}
public void GetState(object obj, IComponentState state)
{
foreach (var propertyInfo in GetStatePropertyInfo(obj))
{
if (state.ContainsKey(propertyInfo.Name))
{
state[propertyInfo.Name] = propertyInfo.GetValue(obj);
}
else
{
state.Add(propertyInfo.Name, propertyInfo.GetValue(obj));
}
}
}
public IComponentState GetNextState(IComponentState baseStateId)
{
if (baseStateId.Equals(BinaryStateId.Off))
{
return(BinaryStateId.On);
}
if (baseStateId.Equals(BinaryStateId.On))
{
return(BinaryStateId.Off);
}
throw new StateNotSupportedException(baseStateId);
}
private IStateMachineState GetState(IComponentState id)
{
IStateMachineState state = _states.FirstOrDefault(s => s.Id.Equals(id));
if (state == null && _stateAlias.TryGetValue(id, out id))
{
state = _states.FirstOrDefault(s => s.Id.Equals(id));
}
if (state == null)
{
throw new InvalidOperationException("State machine state is unknown.");
}
return(state);
}
public bool Equals(IComponentState otherState)
{
var other = otherState as NumericSensorValue;
if (other == null)
{
return(false);
}
if (ReferenceEquals(other, this))
{
return(true);
}
return(other.Value.Equals(Value));
}
public bool GetSupportsState(IComponentState stateId)
{
if (stateId == null)
{
throw new ArgumentNullException(nameof(stateId));
}
if (_states.Any(s => s.Id.Equals(stateId)))
{
return(true);
}
if (!_stateAlias.TryGetValue(stateId, out stateId))
{
return(false);
}
return(_states.Any(s => s.Id.Equals(stateId)));
}
public IComponentState GetNextState(IComponentState stateId)
{
if (stateId == null)
{
throw new ArgumentNullException(nameof(stateId));
}
ThrowIfStateNotSupported(stateId);
IStateMachineState startState = GetState(stateId);
int indexOfStartState = _states.IndexOf(startState);
if (indexOfStartState == _states.Count - 1)
{
return(_states.First().Id);
}
return(_states[indexOfStartState + 1].Id);
}
public void SaveState <T> (IComponentState <T> state)
{
var cmd = connection.CreateCommand();
cmd.CommandText =
"insert into {0} (lbs_statusdate,loadballancer_machines_lbm_id," +
"lbs_cpuussage,lbs_freememory,lbs_freediskspace) " +
"values ($1,$2,$3,$4,$5)";
IDbDataParameter param = cmd.CreateParameter();
param.DbType = DbType.DateTime;
param.ParameterName = "1";
param.Value = DateTime.UtcNow;
cmd.Parameters.Add(param);
param = cmd.CreateParameter();
param.DbType = DbType.UInt64;
param.ParameterName = "2";
param.Value = state.MachineNumber;
cmd.Parameters.Add(param);
param = cmd.CreateParameter();
param.DbType = DbType.Double;
param.ParameterName = "3";
param.Value = state.CpuUsages.Average(x => (double)x.Value);
cmd.Parameters.Add(param);
param = cmd.CreateParameter();
param.DbType = DbType.UInt64;
param.ParameterName = "4";
param.Value = state.AviableMemory;
cmd.Parameters.Add(param);
param = cmd.CreateParameter();
param.DbType = DbType.UInt64;
param.ParameterName = "5";
param.Value = state.FreeDiskSpace;
cmd.Parameters.Add(param);
cmd.ExecuteNonQuery();
}
public override void SetState(IComponentState id, params IHardwareParameter[] parameters)
{
if (id == null)
{
throw new ArgumentNullException(nameof(id));
}
ThrowIfNoStatesAvailable();
IStateMachineState oldState = _activeState;
IStateMachineState newState = GetState(id);
if (newState.Id.Equals(_activeState?.Id))
{
if (_turnOffIfStateIsAppliedTwice && GetSupportsState(BinaryStateId.Off) && !GetState().Equals(BinaryStateId.Off))
{
SetState(BinaryStateId.Off, parameters);
return;
}
if (!parameters.Any(p => p is ForceUpdateStateParameter))
{
return;
}
}
oldState?.Deactivate(parameters);
newState.Activate(parameters);
if (parameters.Any(p => p is IsPartOfPartialUpdateParameter))
{
return;
}
_activeState = newState;
OnActiveStateChanged(oldState, newState);
}
public override void SetState(IComponentState state, params IHardwareParameter[] parameters)
{
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
////var animationParameter = parameters.SingleOrDefault(p => p is AnimateParameter) as AnimateParameter;
////if (animationParameter != null)
////{
//// Animate(animationParameter, state);
//// return;
////}
foreach (var actuator in Actuators)
{
actuator.SetState(state, parameters);
}
////foreach (var actuator in Actuators)
////{
//// actuator.SetState(state, HardwareParameter.IsPartOfPartialUpdate);
////}
////bool commit = !parameters.Any(p => p is IsPartOfPartialUpdateParameter);
////bool forceUpdate = parameters.Any(p => p is ForceUpdateStateParameter);
////if (!commit && !forceUpdate)
////{
//// return;
////}
////foreach (var actuator in Actuators)
////{
//// actuator.SetState(state, parameters);
////}
}
public DirectionAnimation WithTargetOffState()
{
_targetState = BinaryStateId.Off;
return(this);
}
public DirectionAnimation WithTargetState(IComponentState state)
{
_targetState = state;
return(this);
}
public ComponentStateChangedEventArgs(IComponentState oldState, IComponentState newState)
{
OldState = oldState;
NewState = newState;
}
public abstract void SetState(IComponentState state, params IHardwareParameter[] parameters);
public void SetStateIdAlias(IComponentState id, IComponentState alias)
{
throw new NotSupportedException();
}
public void SetStateIdAlias(IComponentState stateId, IComponentState alias)
{
_stateAlias[alias] = stateId;
}
