public XTMFRunRemoteClient(Configuration configuration, string runName, string runDirectory, string modelSystemString) : base(runName, runDirectory, configuration) { using (var memStream = new MemoryStream()) { try { Project temp = new Project(Path.GetFileName(runDirectory), configuration, true); ((ProjectRepository)(configuration.ProjectRepository)).SetActiveProject(temp); temp.ExternallySaved += (o, e) => { SendProjectSaved(null); }; var msAsBytes = Encoding.Unicode.GetBytes(modelSystemString); memStream.Write(msAsBytes, 0, msAsBytes.Length); memStream.Position = 0; var mss = ModelSystemStructure.Load(memStream, configuration); memStream.Position = 0; _Root = (ModelSystemStructure)mss; temp.AddModelSystem(_Root, LoadLinkedParameters(_Root, memStream), String.Empty); } catch (Exception e) { Console.WriteLine(e.Message); } } }
private void LoadAndSignalModelSystem(BinaryReader reader) { try { var length = (int)reader.ReadInt64(); byte[] msText = new byte[length]; var soFar = 0; while (soFar < length) { soFar += reader.Read(msText, soFar, length - soFar); } using (var stream = new MemoryStream(msText)) { var mss = ModelSystemStructure.Load(stream, Configuration); SendProjectSaved(mss as ModelSystemStructure); } } catch (Exception e) { SendRunMessage(e.Message + "\r\n" + e.StackTrace); } }
public void SetActive(object data) { var result = data as QuestionResult; if (result == null && data is string) { this.RunDirectory = System.IO.Path.GetDirectoryName((string)data); this.ModelInterface.LoadRoot(ModelSystemStructure.Load((string)data, this.XTMF.XTMF.Configuration)); this.ModelInterface.EditMode = false; } else if (result != null && result.Data is IModelSystem) { // save here IModelSystem ms = result.Data as IModelSystem; ms.ModelSystemStructure = this.ModelInterface.Root.Clone(); string error = null; if (!ms.Save(ref error)) { MessageBox.Show("Unable to save Model System!\r\n" + error, "Unable to save!", MessageBoxButton.OK, MessageBoxImage.Error); } this.XTMF.XTMF.Configuration.ModelSystemRepository.Add(ms); } }
private bool ProcessMessage(BinaryWriter writer, BinaryFormatter outputFormat, Message message) { switch (message.Type) { case MessageType.PostComplete: { writer.Write((Int32)MessageType.PostComplete); } break; case MessageType.PostResource: { var data = message.Data as Result; writer.Write(data.Name); outputFormat.Serialize(writer.BaseStream, data.Data); } break; case MessageType.PostProgess: { writer.Write((Int32)MessageType.PostProgess); writer.Write(_Progress); writer.Flush(); } break; case MessageType.RequestResource: { var dr = message.Data as DelayedResult; ResourceRequests.AddLast(dr); writer.Write((Int32)MessageType.RequestResource); writer.Write(dr.Name); writer.Flush(); } break; case MessageType.ReturningResource: { var result = message.Data as Result; DelayedResult toRemove = null; foreach (var delayed in ResourceRequests) { if (delayed.Name == result.Name) { toRemove = delayed; delayed.Data = result.Data; delayed.Lock.Release(); break; } } if (toRemove != null) { ResourceRequests.Remove(toRemove); } } break; case MessageType.PostCancel: { var ms = _CurrentRunningModelSystem; // if we don't have a model system then we are done if (ms == null) { break; } try { // try to cancel the model system ms.ExitRequest(); } catch { } } break; case MessageType.SendModelSystem: try { var mssBuff = message.Data as byte[]; IModelSystemStructure mss = null; using (MemoryStream memory = new MemoryStream()) { memory.Write(mssBuff, 0, mssBuff.Length); memory.Position = 0; mss = ModelSystemStructure.Load(memory, _Configuration); } if (_ModelSystemThread != null && _ModelSystemThread.IsAlive) { try { _ModelSystemThread.Abort(); } catch { } } // now that the other thread is going to end // we can now go and start generating ourselves // in another run thread (_ModelSystemThread = new Thread(ModelSystemStartup)).Start(mss); } catch (Exception e) { Console.WriteLine(e.ToString()); return(true); } break; case MessageType.WriteToHostConsole: writer.Write((int)MessageType.WriteToHostConsole); writer.Write(message.Data as string); break; case MessageType.SendCustomMessage: { var msg = message.Data as SendCustomMessageMessage; int msgNumber = msg.CustomMessageNumber; int length = 0; var failed = false; byte[] buffer = null; Action <object, Stream> customConverter; bool getConverter = false; lock (this) { getConverter = _CustomSenders.TryGetValue(msgNumber, out customConverter); } if (getConverter) { using (MemoryStream mem = new MemoryStream(0x100)) { try { customConverter(msg.Data, mem); mem.Position = 0; buffer = mem.ToArray(); length = buffer.Length; } catch { failed = true; } } } writer.Write((Int32)MessageType.SendCustomMessage); writer.Write((Int32)msg.CustomMessageNumber); writer.Write((Int32)length); if (!failed) { writer.Write(buffer, 0, length); buffer = null; } } break; case MessageType.ReceiveCustomMessage: { var msg = message.Data as ReceiveCustomMessageMessage; var customNumber = msg.CustomMessageNumber; Func <Stream, object> customConverter; bool getConverted = false; lock (this) { getConverted = _CustomReceivers.TryGetValue(customNumber, out customConverter); } if (getConverted) { using (var stream = msg.Stream) { try { object output = customConverter(stream); if (_CustomHandlers.TryGetValue(msg.CustomMessageNumber, out List <Action <object> > handlers)) { foreach (var handler in handlers) { try { handler(output); } catch (Exception e) { Console.WriteLine(e.Message + "\r\n" + e.StackTrace); } } } } catch { } } } } break; default: // FAIL! Console.WriteLine("Processing a message of type " + message.Type + " and we didn't know what to do with it."); return(true); } return(false); }