internal Fault(ActorSystem system, ActorPath receiver, IActorReference faulted_actor, Exception exception)
{
System = system;
Receiver = receiver;
FaultedActor = faulted_actor;
Exception = exception;
}
public ActorQueueToken(ActorSystem system, ActorPath receiver, Type data_type, object data, IActorReference sender)
{
System = system;
Receiver = receiver;
DataType = data_type;
Data = data;
Sender = sender;
}
internal void Populate(ActorSystem system, IActorReference parent, ActorPath path)
{
Path = path;
ActorLog = new ActorLogger(this);
System = system;
Self = new LocalActorReference(system, path);
Stash = new MessageStash(system, this);
Handlers = new HandlerService(system, this);
InternalParent = parent;
InternalChildren = new List <IActorReference>();
InternalLog = ActorLog;
}
// NOTICE: we just aren't doing an Ask method
public Task <Context <R> > Ask <T, R>(T data, IActorReference sender, TimeSpan timeout)
{
var token = new CancellationTokenSource();
// Tell<T>(data, sender);
// TODO: we need to put the scheduler's container for the sender
// in some sort of state where it will only accept a message of type
// R from this actor.
// No, actually just return R. The problem is how to get it out of this actor reference.
// TODO: we'll have tell the scheduler this is an Ask message and intercept it when it runs,
// then instead of Telling the sender normally, the scheduler will just return the message
// from here as a Task<R>
// TODO: maybe instead, we'll put the state machine for Ask'ing inside the sender actor itself
var task = Task <R> .Run <R>(() =>
{
// TODO: tell the sender?
// we might need to run some of the scheduler manually in here
return(null !);
}
, token.Token)
.ContinueWith(t =>
{
if (t.IsFaulted)
{
// TODO: escelate errors
}
});
token.CancelAfter(timeout);
// return task;
throw new NotImplementedException();
}
public void DestroyActor(IActorReference reference)
{
DestroyActor(reference.Path);
}
public void InformError(IActorReference sender, Exception e)
{
// Do nothing.
}
public void Tell <T>(T data, IActorReference sender)
{
// Do nothing.
}
static ActorReferences()
{
Nobody = new NoActorReference("nobody");
NoSender = new NoActorReference("no-sender");
LostActor = new NoActorReference("lost-actor");
}
internal Context(IActorReference sender)
{
Sender = sender;
}
public Task <Context <T> > Ask <T>(T data, IActorReference sender)
{
return(Ask <T, T>(data, sender, TimeSpan.FromSeconds(5)));
}
public LostLetter(IActorReference sender, ActorPath receiver, object data)
{
Sender = sender;
Receiver = receiver;
Data = data;
}
public void InformError(IActorReference sender, Exception e)
{
throw new NotImplementedException();
}
public void Tell <T>(T data, IActorReference sender)
{
throw new NotImplementedException();
}
public void InformError(IActorReference sender, Exception e)
{
System.InformUnhandledError(Path, sender, e);
}
internal Context()
{
Sender = ActorReferences.NoSender;
}
public StashAtom(IActorReference sender, object message)
{
Sender = sender;
Message = message;
}
public void Tell <T>(T data, IActorReference sender)
{
System.EnqueueForMessageProcessing <T>(Path, data, sender);
}
