private void ActivateSnapshot(ListBox lb)
{
int index = lb.SelectedIndex;
if (index > 0)
{
EnvironmentVariableTarget target = (EnvironmentVariableTarget)lb.Tag;
EnvironmentSnapshot snapshot = snapshotManager.GetSnapshot(index, target);
EnvironmentSnapshot current = snapshotManager.GetSnapshot(0, target);
if (snapshot != null)
{
EnvironmentVariableManager.Begin(snapshot.Target);
foreach (var variable in current.Variables)
{
EnvironmentVariableManager.DeleteEnvironmentVariable(variable.Name, target);
}
current.Variables.Clear();
foreach (var variable in snapshot.Variables)
{
EnvironmentVariableManager.SetEnvironmentVariable(variable.Name, variable.Value, target);
current.Variables.Add(variable.Clone() as EnvironmentVariable);
}
EnvironmentVariableManager.End(snapshot.Target);
lb.SelectedIndex = 0;
}
}
}
private void CreateSnapshot(ListBox lb, string name)
{
try
{
if (name.Length > 0)
{
EnvironmentSnapshot snapshot = new EnvironmentSnapshot(name, (EnvironmentVariableTarget)lb.Tag);
foreach (DictionaryEntry entry in EnvironmentVariableManager.GetEnvironmentVariables((EnvironmentVariableTarget)lb.Tag))
{
EnvironmentVariable variable = new EnvironmentVariable();
variable.Name = entry.Key.ToString();
variable.Value = entry.Value.ToString();
snapshot.Variables.Add(variable);
}
if (snapshotManager.AppendSnapshot(snapshot))
{
lb.Items.Add(snapshot.Name);
}
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Error!");
}
}
public void RecordEnvironmentalSnapshot(EnvironmentSnapshot snapshot)
{
if (!Temperature.ContainsKey(snapshot.StorageSiteId))
{
Temperature.Add(snapshot.StorageSiteId, new List <DataPoint>());
}
if (!Humidity.ContainsKey(snapshot.StorageSiteId))
{
Humidity.Add(snapshot.StorageSiteId, new List <DataPoint>());
}
if (snapshot.Temperature.HasValue)
{
Temperature[snapshot.StorageSiteId].Add(new DataPoint()
{
Timestamp = snapshot.Timestamp,
Value = snapshot.Temperature.Value
});
}
if (snapshot.Humidity.HasValue)
{
Humidity[snapshot.StorageSiteId].Add(new DataPoint()
{
Timestamp = snapshot.Timestamp,
Value = snapshot.Humidity.Value
});
}
}
/// <summary>
/// Records an environmental snapshot.
/// </summary>
/// <param name="snapshot">The snapshot to record.</param>
public void RecordEnvironmentalSnapshot(EnvironmentSnapshot snapshot)
{
using (IDbConnection connection = GetNewConnection())
{
connection.Execute("INSERT INTO environment (timestamp, site, temperature, humidity) VALUES (@Timestamp, @StorageSiteId, @Temperature, @Humidity)", snapshot);
}
}
static Printf()
{
_arguments = new EnvironmentSnapshot();
_arguments.SymbolTable.Push("s",
new VarSymbol("s", new SymbolType(false, false, SymbolTypeKind.STRING), new Position(0, 0)));
_arguments.SymbolTable.Push("o",
new VarSymbol("o", new SymbolType(false, false, SymbolTypeKind.INT), new Position(0, 0)));
}
public FrmEditEnvVar(ref EnvironmentSnapshot snapshot, EnvironmentVariable variable)
{
InitializeComponent();
this.snapshot = snapshot;
this.variable = variable;
this.MinimumSize = new Size(327, 439);
dgvValuesList.TabIndex = 0;
LoadSettings();
txtVariableName.CausesValidation = false;
dgvHandler = new DgvHandler(ref dgvValuesList);
// set default icon
dgvValuesList_UserAddedRow(null, null);
this.txtVariableName.Text = variable.Name;
this.validator = new EnvironmentValueValidator();
if (txtVariableName.Text.Length != 0)
{
// Check if we are editing variable
LoadEnvironmentVariableValues();
}
// Set form title
this.Text = (txtVariableName.Text.Length != 0
? "Edit" : "New") + " "
+ (this.snapshot.Target == EnvironmentVariableTarget.Machine
? "System" : "User") + " Variable";
#region Create DgvHandler Commands
commandsList = new CommandStack();
dgvHandler.SetCurrentCell(0);
editVarNameCommand = new EditVarNameCommand(txtVariableName);
#endregion DgvHandler Commands
// disable buttons
SetBtnState();
txtVariableName.CausesValidation = true;
isVarNameChanged = false;
// Open/Save File dialogs
openFileDialog.Filter = FILE_FILTER;
openFileDialog.DefaultExt = DEFAULT_FILTER_EXTENSION;
saveFileDialog.Filter = FILE_FILTER;
saveFileDialog.DefaultExt = DEFAULT_FILTER_EXTENSION;
if (EnvironmentVariableManager.IsElevated)
{
btnSave.Image = Resources.Save;
}
else
{
btnSave.Image = Resources.shield_uac;
}
}
static Offset <FEnvironmentDescription> Serialise(FlatBufferBuilder b, EnvironmentSnapshot snapshot)
{
var actors_offsets = new Offset <FActor> [snapshot.Description.Actors.Values.Count];
var j = 0;
foreach (var actor in snapshot.Description.Actors)
{
var actuators_offsets = new Offset <FActuator> [actor.Value.Actuators.Values.Count];
var i = 0;
foreach (var actuator in actor.Value.Actuators)
{
actuators_offsets[i++] = Serialise(b, actuator.Value, actuator.Key);
}
actors_offsets[j++] = Serialise(b,
actuators_offsets,
actor.Value,
actor.Key);
}
var actors_vector_offset = FEnvironmentDescription.CreateActorsVector(b, actors_offsets);
var configurables_offsets = new Offset <FConfigurable> [snapshot.Description.Configurables.Values.Count];
var k = 0;
foreach (var configurable in snapshot.Description.Configurables)
{
configurables_offsets[k++] = Serialise(b, configurable.Value, configurable.Key);
}
var configurables_vector_offset =
FEnvironmentDescription.CreateConfigurablesVector(b, configurables_offsets);
var objective_offset = Serialise(b, snapshot.Description);
var sensors = new Offset <FSensor> [snapshot.Description.Sensors.Values.Count];
var js = 0;
foreach (var sensor in snapshot.Description.Sensors)
{
sensors[js++] = Serialise(b, sensor.Key, sensor.Value);
}
var sensors_vector = FEnvironmentDescription.CreateSensorsVector(b, sensors);
FEnvironmentDescription.StartFEnvironmentDescription(b);
FEnvironmentDescription.AddObjective(b, objective_offset);
FEnvironmentDescription.AddActors(b, actors_vector_offset);
FEnvironmentDescription.AddConfigurables(b, configurables_vector_offset);
FEnvironmentDescription.AddSensors(b, sensors_vector);
return(FEnvironmentDescription.EndFEnvironmentDescription(b));
}
/// <summary>
/// </summary>
/// <returns></returns>
public EnvironmentSnapshot[] CollectStates()
{
var environments = this._Environments.Values;
var states = new EnvironmentSnapshot[environments.Count];
var i = 0;
foreach (var environment in environments)
{
states[i++] = environment.Snapshot();
}
return(states);
}
private void dgvSysVariables_RowsRemoved(object sender, DataGridViewRowsRemovedEventArgs e)
{
if (snapshot != null)
{
if (snapshot.Name == "[Current]")
{
EnvironmentVariableManager.End(snapshot.Target);
}
snapshotManager.SaveSnapshot(ref snapshot);
FillEnvironmentVariables(dgvSysVariables, snapshot);
snapshot = null;
}
}
private void DeleteSnapshot(ListBox lb)
{
int index = lb.SelectedIndex;
if (index > 0)
{
EnvironmentSnapshot snapshot = snapshotManager.GetSnapshot(index, (EnvironmentVariableTarget)lb.Tag, false);
if (snapshotManager.RemoveSnapshot(snapshot))
{
lb.Items.RemoveAt(index);
lb.SelectedIndex = 0;
}
}
}
private void dgvSysVariables_UserDeletingRow(object sender, DataGridViewRowCancelEventArgs e)
{
if (snapshot == null)
{
snapshot = DgvSnapshot(lbSysVariables, dgvSysVariables);
if (snapshot.Name == "[Current]")
{
EnvironmentVariableManager.Begin(snapshot.Target);
}
}
var variable = snapshot.Variables[e.Row.Index];
if (snapshot.Name == "[Current]")
{
EnvironmentVariableManager.DeleteEnvironmentVariable(variable.Name, snapshot.Target);
}
snapshot.Variables.Remove(variable);
}
private void FillEnvironmentVariables(DataGridView dgv, EnvironmentSnapshot snapshot)
{
int currentRowIndex = (dgv.CurrentRow != null ? dgv.CurrentRow.Index : 0);
dgv.Rows.Clear();
if (snapshot.Variables.Count == 0)
{
return;
}
EnvironmentValueValidator validator = new EnvironmentValueValidator();
int rowIndex = 0;
foreach (var variable in snapshot.Variables)
{
string key = variable.Name;
string value = variable.Value;
string[] row = { key, value };
rowIndex = dgv.Rows.Add(row);
if (!validator.Validate(value))
{
dgv.Rows[rowIndex].Cells[0].Style.ForeColor = Color.Red;
dgv.Rows[rowIndex].Cells[1].Style.ForeColor = Color.Red;
}
}
dgv.Sort(dgv.Columns[0], ListSortDirection.Ascending);
try
{
dgv.CurrentCell = dgv[0, currentRowIndex];
dgv.FirstDisplayedScrollingRowIndex = currentRowIndex;
}
catch
{ // if row was deleted this will set it to first one
// TODO: Implement this by searching for var name in the grid.
// Catching Exceptions makes program slow
dgv.CurrentCell = dgv[0, 0];
dgv.FirstDisplayedScrollingRowIndex = 0;
}
int widthCol0 = dgv.Columns[0].Width;
dgv.Columns[0].AutoSizeMode = DataGridViewAutoSizeColumnMode.None;
dgv.Columns[0].Width = widthCol0;
}
/// <summary>
/// Starts and returns a task that reads environmental data from Kafka.
/// </summary>
/// <returns>Returns the new task.</returns>
private Task StartConsuming()
{
return(new TaskFactory().StartNew(() =>
{
using (IConsumer <Ignore, string> consumer = new ConsumerBuilder <Ignore, string>(ConsumerConfig).Build())
{
Logger.LogInformation($" + Starting to read environment data from topic `{Topic}`.");
consumer.Subscribe(Topic);
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
Console.CancelKeyPress += (_, @event) => {
@event.Cancel = true;
cancellationTokenSource.Cancel();
};
try
{
while (true)
{
try
{
ConsumeResult <Ignore, string> result = consumer.Consume(cancellationTokenSource.Token);
EnvironmentSnapshot snapshot = JsonConvert.DeserializeObject <EnvironmentSnapshot>(result.Message.Value);
snapshot.StorageSiteId = StorageSiteId;
SnapshotQueue.Enqueue(snapshot);
Logger.LogDebug($"Consumed message '{result.Message.Value}' at: '{result.TopicPartitionOffset}'.");
}
catch (ConsumeException exception)
{
Logger.LogError($"Error occured: {exception.Error.Reason}");
}
}
}
catch (OperationCanceledException)
{
consumer.Close();
}
finally
{
Logger.LogInformation($"Kafka consumer for topic `{Topic}` shut down.");
}
}
}, TaskCreationOptions.LongRunning));
}
/// <summary>
/// </summary>
/// <param name="b"></param>
/// <param name="snapshot"></param>
/// <param name="serialise_individual_observables"></param>
/// <param name="do_serialise_unobservables"></param>
/// <param name="do_serialise_aggregated_float_array"></param>
/// <returns></returns>
static Offset <FState> SerialiseState(FlatBufferBuilder b,
EnvironmentSnapshot snapshot,
bool do_serialise_unobservables = false,
bool do_serialise_aggregated_float_array = false,
bool serialise_individual_observables = false)
{
var n = b.CreateString(snapshot.EnvironmentName);
var observables_vector = _null_vector_offset;
if (do_serialise_aggregated_float_array)
{
observables_vector = FState.CreateObservablesVector(b, snapshot.Observables);
}
var unobservables = _null_unobservables_offset;
if (do_serialise_unobservables)
{
var state_unobservables = snapshot.Unobservables;
if (state_unobservables != null)
{
var bodies = state_unobservables.Bodies;
FUnobservables.StartBodiesVector(b, bodies.Length);
foreach (var rig in bodies)
{
var vel = rig.Velocity;
var ang = rig.AngularVelocity;
FBody.CreateFBody(b,
vel.x,
vel.y,
vel.z,
ang.x,
ang.y,
ang.z);
}
var bodies_vector = b.EndVector();
var poses = state_unobservables.Poses;
FUnobservables.StartPosesVector(b, poses.Length);
foreach (var tra in poses)
{
var pos = tra.position;
var rot = tra.rotation;
FQuaternionTransform.CreateFQuaternionTransform(b,
pos.x,
pos.y,
pos.z,
rot.x,
rot.y,
rot.z,
rot.w);
}
var poses_vector = b.EndVector();
FUnobservables.StartFUnobservables(b);
FUnobservables.AddPoses(b, poses_vector);
FUnobservables.AddBodies(b, bodies_vector);
unobservables = FUnobservables.EndFUnobservables(b);
}
}
var description_offset = new Offset <FEnvironmentDescription>();
if (snapshot.Description != null)
{
description_offset = Serialise(b, snapshot);
}
var d = new StringOffset();
if (snapshot.DebugMessage != "")
{
d = b.CreateString(snapshot.DebugMessage);
}
var t = b.CreateString(snapshot.TerminationReason);
FState.StartFState(b);
FState.AddEnvironmentName(b, n);
FState.AddFrameNumber(b, snapshot.FrameNumber);
if (do_serialise_aggregated_float_array)
{
FState.AddObservables(b, observables_vector);
}
if (do_serialise_unobservables)
{
FState.AddUnobservables(b, unobservables);
}
FState.AddSignal(b, snapshot.Signal);
FState.AddTerminated(b, snapshot.Terminated);
FState.AddTerminationReason(b, t);
if (snapshot.Description != null)
{
FState.AddEnvironmentDescription(b, description_offset);
}
if (snapshot.DebugMessage != "")
{
FState.AddExtraSerialisedMessage(b, d);
}
return(FState.EndFState(b));
}
/// <inheritdoc />
/// <summary>
/// </summary>
/// <returns></returns>
public override EnvironmentSnapshot Snapshot()
{
lock (this._Reaction_Lock) {
var signal = 0f;
if (this.ObjectiveFunction != null)
{
signal = this.ObjectiveFunction.Evaluate();
}
EnvironmentDescription description = null;
if (this.ReplyWithDescriptionThisStep ||
this.SimulationManager.SimulatorConfiguration.AlwaysSerialiseIndividualObservables)
{
#if NEODROID_DEBUG
if (this.Debugging)
{
Debug.Log("Describing Environment");
}
#endif
var virtual_actors =
new SortedDictionary <String, IActor> {
{ "All", new VirtualActor(this.Actuators) }
};
description = new EnvironmentDescription(this.ObjectiveFunction,
virtual_actors,
this.Configurables,
this.Sensors,
this.Displayers);
}
this._Observables.Clear();
foreach (var item in this.Sensors)
{
if (item.Value != null)
{
if (item.Value.FloatEnumerable != null)
{
this._Observables.AddRange(item.Value.FloatEnumerable);
}
else
{
#if NEODROID_DEBUG
if (this.Debugging)
{
Debug.Log($"Sensor with key {item.Key} has a null FloatEnumerable value");
}
#endif
}
}
else
{
#if NEODROID_DEBUG
if (this.Debugging)
{
Debug.Log($"Sensor with key {item.Key} has a null value");
}
#endif
}
}
var obs = this._Observables.ToArray();
var time = Time.realtimeSinceStartup - this.LastResetTime;
var state = new EnvironmentSnapshot(this.Identifier,
this.StepI,
time,
signal,
this.Terminated,
ref obs,
this.LastTerminationReason,
description);
if (this.SimulationManager.SimulatorConfiguration.AlwaysSerialiseUnobservables ||
this.ReplyWithDescriptionThisStep)
{
state.Unobservables = new Unobservables(ref this._Tracked_Rigid_Bodies, ref this._Poses);
}
return(state);
}
}