public void Resume()
{
if (this.State == RunState.Paused)
{
this.State = RunState.Starting;
this.logger.WriteEntry("Resume: Called", EventLogEntryType.Information);
this.running = false; //tells the monitor to stop
while (this.monitoring)
{
Thread.Sleep(1); //wait for the monitor to stop
}
HostCommunication comm = this.comms;
HostMessage response = this.SendMessage(this.procs, comm, HostCommand.Resume, null);
if (response != null && response.Command == HostCommand.Resume)
{
if (response.Message.StartsWith("success"))
{
this.logger.WriteEntry("Resume: started", EventLogEntryType.Information);
}
else
{
this.logger.WriteEntry("Resume: failed resuming", EventLogEntryType.Information);
}
}
this.State = RunState.Running;
}
}
public async Task <FunctionResult> ExecuteAsync(IStorageQueueMessage value, CancellationToken cancellationToken)
{
HostMessage model = JsonConvert.DeserializeObject <HostMessage>(value.AsString, JsonSerialization.Settings);
if (model == null)
{
throw new InvalidOperationException("Invalid invocation message.");
}
CallAndOverrideMessage callAndOverrideModel = model as CallAndOverrideMessage;
if (callAndOverrideModel != null)
{
await ProcessCallAndOverrideMessage(callAndOverrideModel, cancellationToken);
return(new FunctionResult(true));
}
AbortHostInstanceMessage abortModel = model as AbortHostInstanceMessage;
if (abortModel != null)
{
ProcessAbortHostInstanceMessage();
return(new FunctionResult(true));
}
string error = String.Format(CultureInfo.InvariantCulture, "Unsupported invocation type '{0}'.", model.Type);
throw new NotSupportedException(error);
}
public void Shutdown()
{
if (this.State == RunState.Running || this.State == RunState.Stopped)
{
this.logger.WriteEntry("Shutdown: Called");
this.running = false; //tells the monitor to stop
while (this.monitoring)
{
Thread.Sleep(1); //wait for the monitor to stop
}
HostCommunication comm = comms;
HostMessage response = this.SendMessage(this.procs, comm, HostCommand.Shutdown, null);
if (response != null && response.Command == HostCommand.Shutdown)
{
if (response.Message.StartsWith("success"))
{
this.logger.WriteEntry("Shutdown: started", EventLogEntryType.Information);
}
else
{
this.logger.WriteEntry("Shutdown: failed shutting down", EventLogEntryType.Warning);
}
}
this.State = RunState.Shutdown;
}
}
private bool RestartProcess(string fileName)
{
try
{
Process p = this.procs;
if (p != null && !p.HasExited)
{
p.Kill();
}
p = CreateProcess(fileName);
if (p.Start())
{
HostCommunication comm = new HostCommunication(p.StandardOutput, p.StandardInput);
//we need to also init this thing
HostMessage response = this.SendMessage(p, comm, HostCommand.Init, null);
if (response != null && response.Command == HostCommand.Init)
{
if (response.Message.StartsWith("success"))
{
response = this.SendMessage(p, comm, HostCommand.Start, null);
if (response != null && response.Command == HostCommand.Start)
{
if (response.Message.StartsWith("success"))
{
this.comms = comm;
this.procs = p;
return(true);
}
else
{
p.Kill();
}
}
else
{
p.Kill();
}
}
else
{
p.Kill();
}
}
else
{
p.Kill();
}
}
}
catch
{ }
return(false);
}
private void MonitorServices()
{
this.monitoring = true;
this.running = true;
string success = Osrs.Runtime.RunState.Running.ToString();
string failed = Osrs.Runtime.RunState.FailedRunning.ToString();
string starting = Osrs.Runtime.RunState.Starting.ToString();
string stopping = Osrs.Runtime.RunState.Stopping.ToString();
while (this.running)
{
//make a copy of the list so we're sure we can mutate the lists for restart
HostCommunication comm = this.comms;
HostMessage response = this.SendMessage(this.procs, comm, HostCommand.HeartBeat, null);
if (response != null && response.Command == HostCommand.HeartBeat)
{
if (!response.Message.StartsWith(Osrs.Runtime.RunState.Running.ToString()))
{
if (response.Message.StartsWith(starting) || response.Message.StartsWith(stopping))
{
continue; //may need to deal with hangs later
}
if (response.Message.StartsWith(failed))
{
this.logger.WriteEntry("Monitor: problem " + response.Message, EventLogEntryType.Warning);
if (this.RestartProcess(this.fileName))
{
this.logger.WriteEntry("Monitor: successfully restarted", EventLogEntryType.Information);
}
else
{
this.logger.WriteEntry("Monitor: failed to restart", EventLogEntryType.Warning);
}
}
else
{
this.logger.WriteEntry("Monitor: problem (ignored)" + response.Message, EventLogEntryType.Warning);
}
}
}
if (!this.running) //get us out ASAP
{
break;
}
for (int i = 0; i < 10; i++)
{
if (this.running) //get us out ASAP
{
Thread.Sleep(500); //5 seconds in total
}
}
}
this.monitoring = false;
}
private async void SendScoreboard(Object state)
{
var message = new HostMessage
{
Type = HostMessageType.Scoreboard,
PlayerScores = Scorecards,
TimeSent = DateTime.Now
};
await DispatcherHelper.ExecuteOnUIThreadAsync(async() =>
await App.SessionManager.SendMessageToParticipantsAsync(message));
}
public void JsonConvert_Roundtrips()
{
// Arrange
HostMessage roundtrip = new HostMessage();
// Act
HostMessage message = JsonConvert.DeserializeObject <HostMessage>(
JsonConvert.SerializeObject(roundtrip));
// Assert
Assert.NotNull(message);
Assert.Equal(typeof(HostMessage).Name, message.Type);
}
public void JsonConvert_Roundtrips()
{
// Arrange
HostMessage roundtrip = new HostMessage();
// Act
HostMessage message = JsonConvert.DeserializeObject<HostMessage>(
JsonConvert.SerializeObject(roundtrip));
// Assert
Assert.NotNull(message);
Assert.Equal(typeof(HostMessage).Name, message.Type);
}
static void Shutdown()
{
lock (syncRoot)
{
HostMessage m = new HostMessage();
m.Command = HostCommand.Shutdown;
state = RunState.Stopping;
HostingManager.Instance.Shutdown();
state = RunState.Shutdown;
m.Message = "success";
comms.Send(m);
}
}
/// <inheritdoc />
public void Enqueue(string queueName, HostMessage message)
{
if (message == null)
{
throw new ArgumentNullException("message");
}
CloudQueue queue = _client.GetQueueReference(queueName);
Debug.Assert(queue != null);
queue.CreateIfNotExists();
string content = JsonConvert.SerializeObject(message, JsonSerialization.Settings);
Debug.Assert(content != null);
CloudQueueMessage queueMessage = new CloudQueueMessage(content);
queue.AddMessage(queueMessage);
}
/// <inheritdoc />
public async Task EnqueueAsync(string queueName, HostMessage message)
{
if (message == null)
{
throw new ArgumentNullException("message");
}
CloudQueue queue = _client.GetQueueReference(queueName);
Debug.Assert(queue != null);
await queue.CreateIfNotExistsAsync();
string content = JsonConvert.SerializeObject(message, JsonSerialization.Settings);
Debug.Assert(content != null);
CloudQueueMessage queueMessage = new CloudQueueMessage(content);
await queue.AddMessageAsync(queueMessage);
}
public void JsonConvertDerivedType_Roundtrips()
{
// Arrange
CallAndOverrideMessage expectedMessage = new CallAndOverrideMessage
{
Id = Guid.NewGuid()
};
// Act
HostMessage message = JsonConvert.DeserializeObject <HostMessage>(
JsonConvert.SerializeObject(expectedMessage));
// Assert
Assert.NotNull(message);
Assert.IsType <CallAndOverrideMessage>(message);
CallAndOverrideMessage typedMessage = (CallAndOverrideMessage)message;
Assert.Equal(expectedMessage.Id, typedMessage.Id);
}
private HostMessage SendMessage(Process p, HostCommunication comm, HostCommand cmd, string msg)
{
try
{
if (!p.HasExited)
{
HostMessage mess = new HostMessage();
mess.Command = cmd;
if (msg != null)
{
mess.Message = msg;
}
return(comm.SendReceive(mess));
}
}
catch
{ }
return(new HostMessage());
}
static void Main(string[] args)
{
Environment.CurrentDirectory = System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetEntryAssembly().Location);
comms = new HostCommunication(Console.In, Console.Out);
//basic REPL loop logic on main thread
while (true)
{
HostMessage message = comms.Receive();
if (message.Command == HostCommand.HeartBeat)
{
message.Message = HostingManager.Instance.RealtimeState().ToString();
comms.Send(message); //just an echo back
}
else if (message.Command == HostCommand.Pause)
{
Pause();
}
else if (message.Command == HostCommand.Resume)
{
Resume();
}
else if (message.Command == HostCommand.Stop)
{
Stop();
}
else if (message.Command == HostCommand.Start)
{
Start();
}
else if (message.Command == HostCommand.Init)
{
Init();
}
else if (message.Command == HostCommand.Shutdown)
{
Shutdown();
Environment.Exit(0); //exits the app
}
}
}
static void Resume()
{
lock (syncRoot)
{
HostMessage m = new HostMessage();
m.Command = HostCommand.Start;
if (state == RunState.Paused)
{
state = RunState.Starting;
HostingManager.Instance.Resume();
state = RunState.Running;
m.Message = "success";
}
else
{
m.Message = "ignored";
}
comms.Send(m);
}
}
public void Pause()
{
if (this.State == RunState.Running)
{
this.State = RunState.Stopping;
this.logger.WriteEntry("Pause: Called");
HostCommunication comm = this.comms;
HostMessage response = this.SendMessage(this.procs, comm, HostCommand.Pause, null);
if (response != null && response.Command == HostCommand.Pause)
{
if (response.Message.StartsWith("success"))
{
this.logger.WriteEntry("Pause: started", EventLogEntryType.Information);
}
else
{
this.logger.WriteEntry("Pause: failed pausing", EventLogEntryType.Warning);
}
}
this.State = RunState.Paused;
}
}
public async Task <MessageWithReply> GetChanelMessages(string messageId)
{
Models.Message data = await _data.GetChannelMessages(messageId);
ReplyMessage replyData = await _data.GetReplyMessages(messageId);
var hostData = new HostMessage {
CreatedDateTime = data.CreatedDateTime, HostUserId = data.From.User.Id
};
IEnumerable <ReplyMessageData> reply = replyData.Value.Select(s =>
{
return(new ReplyMessageData
{
CreatedDateTime = s.CreatedDateTime,
Content = s.Body.Content,
UserId = s.From.User.Id
});
}).OrderBy(o => o.CreatedDateTime);
return(new MessageWithReply {
Message = hostData, ReplyMessage = reply
});
}
public void Start(EventLog logger)
{
this.logger = logger;
if (this.State == RunState.Created || this.State == RunState.FailedInitializing)
{
this.Init();
}
if (this.State == RunState.Initialized || this.State == RunState.Stopped)
{
this.State = RunState.Starting;
this.logger.WriteEntry("Start: Called");
if (File.Exists(this.fileName))
{
if (this.procs == null) //new for this startup
{
try
{
Process p = this.CreateProcess(this.fileName);
if (p.Start())
{
HostCommunication comm = new HostCommunication(p.StandardOutput, p.StandardInput);
//we need to also init this thing
HostMessage response = this.SendMessage(p, comm, HostCommand.Init, null);
if (response != null && response.Command == HostCommand.Init)
{
if (response.Message.StartsWith("success"))
{
this.logger.WriteEntry("Start: initialized");
this.comms = comm;
this.procs = p;
}
}
else
{
p.Kill();
}
}
else
{
p.Kill();
}
}
catch
{ }
}
if (this.procs != null)
{
HostCommunication comm = this.comms;
HostMessage response = this.SendMessage(this.procs, comm, HostCommand.Start, null);
if (response != null && response.Command == HostCommand.Start)
{
if (response.Message.StartsWith("success"))
{
this.logger.WriteEntry("Start: started");
}
else
{
this.logger.WriteEntry("Start: failed starting", EventLogEntryType.Warning);
}
}
}
else
{
this.logger.WriteEntry("Start: no process", EventLogEntryType.Warning);
this.State = RunState.FailedStarting;
return;
}
}
else
{
this.logger.WriteEntry("Start: failed to find", EventLogEntryType.Warning);
this.State = RunState.FailedStarting;
return;
}
//we've started
this.logger.WriteEntry("Start: Succeeded, starting monitoring");
Task t = new Task(this.MonitorServices);
t.Start();
this.State = RunState.Running;
}
}
private void __OnRegistered(Network.Node player)
{
if (player == null)
{
return;
}
short index = player.index;
player.RegisterHandler((short)HostMessageHandle.Ready, delegate(NetworkReader reader)
{
Ready(index);
});
player.RegisterHandler((short)HostMessageHandle.NotReady, delegate(NetworkReader reader)
{
NotReady(index);
});
Node node;
if (GetNode(player.index, out node))
{
IEnumerable <KeyValuePair <int, Network.Node> > room = GetRoom(node.roomIndex);
if (room != null)
{
NetworkWriter writer = new NetworkWriter();
writer.Write((short)HostMessageHandle.Ready);
writer.Write(new ReadyMessage());
HostMessage hostMessage = new HostMessage(-1, writer.Position, writer.AsArray());
Lobby.Node instance;
int i;
foreach (KeyValuePair <int, Network.Node> pair in room)
{
instance = pair.Value as Lobby.Node;
if (instance != null)
{
hostMessage.index = instance.index;
for (i = 0; i < instance._count; ++i)
{
Send(node.connectionId, (short)Network.HostMessageType.Rpc, hostMessage);
}
}
}
IEnumerable <int> neighborRoomIndices = GetNeighborRoomIndices(node.roomIndex);
if (neighborRoomIndices != null)
{
foreach (int neighborRoomIndex in neighborRoomIndices)
{
room = GetRoom(neighborRoomIndex);
if (room == null)
{
continue;
}
foreach (KeyValuePair <int, Network.Node> pair in room)
{
instance = pair.Value as Lobby.Node;
if (instance != null)
{
hostMessage.index = instance.index;
for (i = 0; i < instance._count; ++i)
{
Send(node.connectionId, (short)Network.HostMessageType.Rpc, hostMessage);
}
}
}
}
}
}
}
}
protected override bool _Unregister(NetworkReader reader, int connectionId, short index)
{
int count = 0;
while (__NotReady(index, connectionId >= 0))
{
++count;
}
if (connectionId >= 0 && count > 0)
{
Node node;
if (GetNode(index, out node))
{
IEnumerable <KeyValuePair <int, Network.Node> > room = GetRoom(node.roomIndex);
if (room != null)
{
NetworkWriter writer = new NetworkWriter();
writer.Write((short)HostMessageHandle.NotReady);
writer.Write(new NotReadyMessage());
HostMessage hostMessage = new HostMessage(-1, writer.Position, writer.AsArray());
Lobby.Node instance;
int i;
foreach (KeyValuePair <int, Network.Node> pair in room)
{
instance = pair.Value as Lobby.Node;
if (instance != null)
{
hostMessage.index = instance.index;
for (i = 0; i < instance._count; ++i)
{
Send(connectionId, (short)Network.HostMessageType.Rpc, hostMessage);
}
}
}
IEnumerable <int> neighborRoomIndices = GetNeighborRoomIndices(node.roomIndex);
if (neighborRoomIndices != null)
{
foreach (int neighborRoomIndex in neighborRoomIndices)
{
room = GetRoom(neighborRoomIndex);
if (room == null)
{
continue;
}
foreach (KeyValuePair <int, Network.Node> pair in room)
{
instance = pair.Value as Lobby.Node;
if (instance != null)
{
hostMessage.index = instance.index;
for (i = 0; i < instance._count; ++i)
{
Send(connectionId, (short)Network.HostMessageType.Rpc, hostMessage);
}
}
}
}
}
}
}
}
return(true);
}
static void Init()
{
lock (syncRoot)
{
HostMessage m = new HostMessage();
m.Command = HostCommand.Init;
if (state == RunState.Created)
{
IEnumerable <TypeNameReference> names = null;
m.Message = "";
LogProviderBase log = null;
try
{
ConfigurationManager.Instance.Bootstrap();
ConfigurationManager.Instance.Initialize();
ConfigurationManager.Instance.Start();
if (ConfigurationManager.Instance.State == RunState.Running)
{
LogManager.Instance.Bootstrap();
LogManager.Instance.Initialize();
LogManager.Instance.Start();
if (LogManager.Instance.State == RunState.Running)
{
log = LogManager.Instance.GetProvider(typeof(Program));
}
if (log == null)
{
log = new NullLogger(typeof(Program));
}
ConfigurationProviderBase prov = ConfigurationManager.Instance.GetProvider();
if (prov != null)
{
ConfigurationParameter param = prov.Get(typeof(Program), "hostList");
if (param != null)
{
string[] values = param.Value as string[];
if (values != null && values.Length > 0)
{
HashSet <TypeNameReference> tps = new HashSet <TypeNameReference>();
foreach (string s in values)
{
TypeNameReference cur = TypeNameReference.Parse(s);
if (cur != null)
{
tps.Add(cur);
}
else
{
log.Log(5, "Failed to parse TypeName for: " + s);
}
}
if (tps.Count > 0)
{
names = tps;
}
}
else
{
m.Message = "Failed to get configuration value";
log.Log(1000, m.Message);
}
}
else
{
m.Message = "Failed to get configuration parameter: hostList";
log.Log(1000, m.Message);
}
}
else
{
m.Message = "Failed to get configuration provider";
log.Log(1000, m.Message);
}
}
else
{
m.Message = "Failed to initialize using local file, quitting (" + AppContext.BaseDirectory + ")";
if (log != null)
{
log.Log(1000, m.Message);
}
}
}
catch
{
m.Message = "Failed to initialize using config, falling back to local file";
if (log != null)
{
log.Log(1000, m.Message);
}
}
if (names != null)
{
HostingManager.Instance.Initialize(names);
state = HostingManager.Instance.State;
if (state == RunState.Initialized)
{
m.Message = "success " + m.Message;
if (log != null)
{
log.Log(0, m.Message);
}
}
else
{
m.Message = "failed " + m.Message;
if (log != null)
{
log.Log(1000, m.Message);
}
}
}
else
{
state = HostingManager.Instance.State;
m.Message = "failed " + m.Message;
if (log != null)
{
log.Log(1000, m.Message);
}
}
}
else
{
state = HostingManager.Instance.State;
m.Message = "ignored";
}
comms.Send(m);
}
}
