private BSONDocument toBSON(ProcessFrame frame)
{
var result = new BSONDocument();
var t = frame.GetType();
var descriptor = frame.Descriptor;
var pid = descriptor.PID;
result.Set(new BSONStringElement(Query._ID, pid.ID));
result.Set(new BSONStringElement(FLD_PROCESS_ZONE, pid.Zone));
result.Set(new BSONInt32Element(FLD_PROCESS_PROCESSOR_ID, pid.ProcessorID));
result.Set(new BSONBooleanElement(FLD_PROCESS_UNIQUE, pid.IsUnique));
result.Set(new BSONStringElement(FLD_PROCESS_TYPE, frame.Type.ToString()));
result.Set(elmStr(FLD_PROCESS_DESCRIPTION, descriptor.Description));
result.Set(new BSONDateTimeElement(FLD_PROCESS_TIMESTAMP, descriptor.Timestamp));
result.Set(elmStr(FLD_PROCESS_ABOUT, descriptor.About));
result.Set(new BSONInt32Element(FLD_PROCESS_STATUS, (int)descriptor.Status));
result.Set(elmStr(FLD_PROCESS_STATUS_DESCRIPTION, descriptor.StatusDescription));
result.Set(new BSONDateTimeElement(FLD_PROCESS_STATUS_TIMESTAMP, descriptor.StatusTimestamp));
result.Set(elmStr(FLD_PROCESS_STATUS_ABOUT, descriptor.StatusAbout));
result.Set(new BSONInt32Element(FLD_PROCESS_SERIALIZER, frame.Serializer));
result.Set(elmBin(FLD_PROCESS_CONTENT, frame.Content));
return(result);
}
public override void Delete(ProcessFrame frame, object transaction)
{
if (Disposed)
{
return;
}
var pid = frame.Descriptor.PID;
m_Database["P" + pid.ProcessorID].DeleteOne(Query.ID_EQ_String(pid.ID));
}
public override void Update(ProcessFrame frame, bool sysOnly, object transaction)
{
if (Disposed)
{
return;
}
var pid = frame.Descriptor.PID;
var doc = toBSONUpdate(frame, sysOnly);
m_Database["P" + pid.ProcessorID].Update(new UpdateEntry(Query.ID_EQ_String(pid.ID), doc, false, false));
}
public override void Put(ProcessFrame frame, object transaction)
{
if (Disposed)
{
return;
}
var pid = frame.Descriptor.PID;
var doc = toBSON(frame);
m_Database["P" + pid.ProcessorID].Insert(doc);
}
private void delete(ProcessFrame frame, object transaction = null)
{
try
{
m_ProcessStore.Delete(frame, transaction);
}
catch (Exception e)
{
Log(MessageType.Critical, "delete", "{0} Leaked: {1}".Args(frame, e.ToMessageWithType()), e);
throw;
}
}
private void put(ProcessFrame frame, object transaction = null)
{
try
{
frame.Descriptor = new ProcessDescriptor(frame.Descriptor, ProcessStatus.Started, "Started", App.TimeSource.UTCNow, "@{0}@{1}".Args(App.Name, App.AsSky().HostName));
m_ProcessStore.Put(frame, transaction);
}
catch (Exception e)
{
Log(MessageType.Critical, "put", "{0} Leaked: {1}".Args(frame, e.ToMessageWithType()), e);
throw;
}
}
public override bool TryGetByPID(PID pid, out ProcessFrame frame)
{
var query = new Query(@"{ '$query': { _id: '$$id' } }", true, new TemplateArg(new BSONStringElement("id", pid.ID)));
frame = new ProcessFrame();
var doc = m_Database["P" + pid.ProcessorID].FindOne(query);
if (doc == null)
{
return(false);
}
frame = toFrame(doc);
return(true);
}
private void spawnCore(ProcessFrame frame, object tx)
{
var pid = frame.Descriptor.PID;
if (pid.IsUnique)
{
put(frame, tx);
return;
}
lockProcess(pid.ID);
try
{
var utcNow = App.TimeSource.UTCNow;
ProcessFrame existing;
if (!m_ProcessStore.TryGetByPID(pid, out existing))
{
put(frame, tx);
return;
}
var app = App.AsSky();
var processExisting = existing.Materialize(app.ProcessManager.ProcessTypeResolver);
var processAnother = frame.Materialize(app.ProcessManager.ProcessTypeResolver);
if (processExisting == null || processAnother == null)//safeguard
{
put(frame, tx);
return;
}
try
{
processExisting.Merge(this, utcNow, processAnother);
}
catch (Exception error)
{
// TODO : fix exception
throw new WorkersException(StringConsts.TODO_CORRELATED_MERGE_ERROR.Args(processExisting, processAnother, error.ToMessageWithType()), error);
}
}
finally
{
releaseProcess(pid.ID);
}
}
private ResultSignal dispatch(SignalFrame signalFrame)
{
lockProcess(signalFrame.PID.ID);
try
{
ProcessFrame processFrame = m_ProcessStore.GetByPID(signalFrame.PID);
var process = processFrame.Materialize(AgniSystem.ProcessManager.ProcessTypeResolver);
var signal = signalFrame.Materialize(AgniSystem.ProcessManager.SignalTypeResolver);
if (process == null || signal == null)//safeguard
{
throw new WorkersException("TODO");
}
return(process.Accept(this, signal));
}
finally
{
releaseProcess(signalFrame.PID.ID);
}
}
private ProcessFrame toFrame(BSONDocument doc)
{
try
{
var descriptor = toDescriptor(doc);
var result = new ProcessFrame();
result.Type = Guid.Parse(((BSONStringElement)doc[FLD_PROCESS_TYPE]).Value);
result.Descriptor = descriptor;
result.Serializer = ((BSONInt32Element)doc[FLD_PROCESS_SERIALIZER]).Value;
result.Content = elmBin(doc[FLD_PROCESS_CONTENT]);
return(result);
}
catch (Exception error)
{
throw new MongoWorkersException(StringConsts.PROCESS_BSON_READ_ERROR.Args(error.ToMessageWithType()), error);
}
}
public void Finalize(ProcessFrame frame)
{
CheckDaemonActive();
var tx = m_ProcessStore.BeginTransaction();
try
{
delete(frame, tx);
m_ProcessStore.CommitTransaction(tx);
}
catch (Exception error)
{
m_ProcessStore.RollbackTransaction(tx);
Log(MessageType.CatastrophicError, "Finalize", error.ToMessageWithType(), error);
// TODO fix exception
throw new WorkersException(StringConsts.TODO_ENQUEUE_TX_BODY_ERROR.Args(error.ToMessageWithType()), error);
}
}
public void Update(ProcessFrame frame, bool sysOnly)
{
CheckServiceActive();
var tx = m_ProcessStore.BeginTransaction();
try
{
update(frame, sysOnly, tx);
m_ProcessStore.CommitTransaction(tx);
}
catch (Exception error)
{
m_ProcessStore.RollbackTransaction(tx);
Log(MessageType.CatastrophicError, "Update", error.ToMessageWithType(), error);
// TODO fix exception
throw new WorkersException(StringConsts.TODO_ENQUEUE_TX_BODY_ERROR.Args(error.ToMessageWithType()), error);
}
}
private BSONDocument toBSONUpdate(ProcessFrame frame, bool sysOnly)
{
var setDoc = new BSONDocument();
var descriptor = frame.Descriptor;
setDoc.Set(new BSONInt32Element(FLD_PROCESS_STATUS, (int)descriptor.Status));
setDoc.Set(elmStr(FLD_PROCESS_STATUS_DESCRIPTION, descriptor.StatusDescription));
setDoc.Set(new BSONDateTimeElement(FLD_PROCESS_STATUS_TIMESTAMP, descriptor.StatusTimestamp));
setDoc.Set(elmStr(FLD_PROCESS_STATUS_ABOUT, descriptor.StatusAbout));
if (!sysOnly)
{
setDoc.Set(new BSONInt32Element(FLD_PROCESS_SERIALIZER, frame.Serializer));
setDoc.Set(elmBin(FLD_PROCESS_CONTENT, frame.Content));
}
var result = new BSONDocument();
result.Set(new BSONDocumentElement("$set", setDoc));
return(result);
}
public abstract void Delete(ProcessFrame frame, object transaction);
public abstract bool TryGetByPID(PID pid, out ProcessFrame frame);
public ProcessDescriptor GetDescriptor(PID pid)
{
ProcessFrame processFrame = m_ProcessStore.GetByPID(pid);
return(processFrame.Descriptor);
}
public abstract void Put(ProcessFrame frame, object transaction);
public abstract void Update(ProcessFrame frame, bool sysOnly, object transaction);
public void Spawn(ProcessFrame frame) => Service.Spawn(frame);
public void Spawn(ProcessFrame frame)
{
ProcessControllerService.Instance.Spawn(frame);
}
