public void ToStream(DataFrames.DataWriter writer, StateDictionary state, Utils.Logger logger) { if (Bytes != null) { writer.Write(Bytes); } }
public void FromReader(DataReader reader, DataFrames.DataKey root, Utils.Logger logger) { IStreamTypeParser parser = new T(); StateDictionary state = new StateDictionary(); try { // Reset byte count reader.ByteCount = 0; parser.FromStream(reader, state, logger); ObjectConverter.ToNode(root, parser, _derivedTypes); } catch (ThreadAbortException) { throw; } catch (Exception ex) { if (!(ex is EndOfStreamException) || (reader.ByteCount != 0)) { logger.LogError(CANAPE.Parser.Properties.Resources.GenericStreamParser_ReadException, ex.Message, typeof(T).Name); } throw; } }
public void ToWriter(DataFrames.DataWriter writer, DataFrames.DataKey root, Utils.Logger logger) { foreach (DataNode node in root.SubNodes) { writer.Write(node.ToArray()); } }
void IPersistNode.SetState(object state, Utils.Logger logger) { if (state is DynamicConfigObject) { _config = (DynamicConfigObject)state; } }
public TaskManager(Runner.SubtaskRunner runner, ITask[] tasks, Utils.Logger logger = null, Profiler.Timeline profiler = null) { this.runner = runner; //Create executors for all the tasks ITaskExecutor[] executors = new ITaskExecutor[tasks.Length]; for (int i = 0; i < tasks.Length; i++) { executors[i] = tasks[i].CreateExecutor(runner, logger, profiler); } //Create a querier for querying all the executors for work querier = new TaskQuerier(runner, executors, logger, profiler); //Setup a chain between the executors, starting from the querier for (int i = 0; i < executors.Length; i++) { switch (i) { case 0: querier.Completed += executors[i].RunSubtasks; break; default: executors[i - 1].Completed += executors[i].RunSubtasks; break; } } if (executors.Length > 0) { executors[executors.Length - 1].Completed += LastTaskCompleted; } else { querier.Completed += LastTaskCompleted; } }
public override void Run(DataAdapters.IDataAdapter adapter, Utils.Logger logger) { while (adapter.Read() != null) { // Do not alot } }
public TaskQuerier(Runner.SubtaskRunner runner, ITaskExecutor[] tasks, Utils.Logger logger, Profiler.Timeline profiler = null) { this.runner = runner; this.tasks = tasks; this.logger = logger; this.profilerTrack = profiler?.CreateTrack <Profiler.TimelineTrack>(GetType().Name); }
public static DoorstopManager Create(string expectedTargetAssemblyPath, Logger logger) { DoorstopManager manager = null; RuntimePlatform platform = Application.platform; if (platform == RuntimePlatform.WindowsPlayer || platform == RuntimePlatform.WindowsEditor) { manager = new WindowsDoorstopManager(expectedTargetAssemblyPath, logger); } if (platform == RuntimePlatform.OSXPlayer || platform == RuntimePlatform.OSXEditor) { manager = new MacOSDoorstopManager(expectedTargetAssemblyPath, logger); } if (platform == RuntimePlatform.LinuxPlayer) { manager = new LinuxDoorstopManager(expectedTargetAssemblyPath, logger); } if (manager == null) { throw new PlatformNotSupportedException($"Platform {platform} is not supported!"); } if (manager.IsInstalled()) { manager.LoadConfig(); manager.RestoreTargetAssemblyPathIfNecessary(); } return(manager); }
public byte[] ToArray(DataFrames.DataKey root, Utils.Logger logger) { DataValue value = root.SelectSingleNode("xml") as DataValue; byte[] ret = new byte[0]; if (value != null) { if (!Config.NoEncode) { XmlDocument doc = new XmlDocument(); doc.LoadXml(value.Value.ToString()); MemoryStream stm = new MemoryStream(); XmlDictionaryWriter writer = XmlDictionaryWriter.CreateBinaryWriter(stm, wcfDictionary); doc.Save(writer); writer.Flush(); ret = stm.ToArray(); } else { ret = new BinaryEncoding().GetBytes(value.Value.ToString()); } } return(ret); }
/// <summary> /// Create the layer /// </summary> /// <param name="logger"></param> /// <returns></returns> public override INetworkLayer CreateLayer(Utils.Logger logger) { HttpNetworkLayer layer = new HttpNetworkLayer(_config); layer.Binding = Binding; return(layer); }
public void ToStream(DataWriter writer, StateDictionary state, Utils.Logger logger) { _writer = writer; _state = state; _logger = logger; ToStream(); }
public void FromString(string data, DataFrames.DataKey root, Utils.Logger logger) { string[] cookies = data.Split(';'); foreach (string cookie in cookies) { AddCookie(cookie, root, logger); } }
public string ToDisplayString(DataFrames.DataKey root, Utils.Logger logger) { DataValue value = root.SelectSingleNode("xml") as DataValue; if (value != null) { return(value.ToString()); } return(String.Empty); }
public GroupExecutor( ITask[] tasks, Runner.SubtaskRunner runner, Utils.Logger logger = null, Profiler.Timeline profiler = null) { executors = new ITaskExecutor[tasks.Length]; for (int i = 0; i < tasks.Length; i++) { executors[i] = tasks[i].CreateExecutor(runner, logger, profiler); } }
/// <summary> /// Creates new instance of game server /// </summary> /// <param name="boundAddress">Server bound address</param> /// <param name="port">Server bound port</param> public GameServer(string boundAddress, int port) { Logger = new Utils.Logger(Path.Combine(Environment.CurrentDirectory, "logs"), "serverLog"); server = new WebSocketServer(IPAddress.Parse(boundAddress), port); server.Log.Output = new Action <LogData, string>((LogData logData, string input) => { switch (logData.Level) { case LogLevel.Info: foreach (var ln in logData.Message.Split(new string[] { "\r", "\r\n", "\n" }, StringSplitOptions.None)) { Logger.Log(Utils.LogEntryType.Info, ln); } break; case LogLevel.Error: foreach (var ln in logData.Message.Split(new string[] { "\r", "\r\n", "\n" }, StringSplitOptions.None)) { Logger.Log(Utils.LogEntryType.Error, ln); } break; case LogLevel.Warn: foreach (var ln in logData.Message.Split(new string[] { "\r", "\r\n", "\n" }, StringSplitOptions.None)) { Logger.Log(Utils.LogEntryType.Warning, ln); } break; case LogLevel.Fatal: foreach (var ln in logData.Message.Split(new string[] { "\r", "\r\n", "\n" }, StringSplitOptions.None)) { Logger.Log(Utils.LogEntryType.Critical, ln); } break; case LogLevel.Debug: foreach (var ln in logData.Message.Split(new string[] { "\r", "\r\n", "\n" }, StringSplitOptions.None)) { Logger.Log(Utils.LogEntryType.Debug, ln); } break; case LogLevel.Trace: foreach (var ln in logData.Message.Split(new string[] { "\r", "\r\n", "\n" }, StringSplitOptions.None)) { Logger.Log(Utils.LogEntryType.Stacktrace, ln); } break; } }); server.AddWebSocketService <GameServerBehaviour>("/"); }
public SubtaskExecutor( IProvider provider, Runner.SubtaskRunner runner, int batchSize, Utils.Logger logger = null, Profiler.Timeline profiler = null) { this.provider = provider; this.runner = runner; this.batchSize = batchSize; this.logger = logger; this.profilerTrack = profiler?.CreateTrack <Profiler.TimelineTrack>(provider.GetType().Name); }
public string ToDisplayString(DataFrames.DataKey root, Utils.Logger logger) { DataNode node = root.SelectSingleNode("Data"); if (node != null) { return(node.ToString()); } else { return(String.Format("Type: {0} Little Endian: {1} Exclusive: {2}", Config.LengthType, Config.LittleEndian, Config.Inclusive)); } }
public void FromStream(DataReader reader, StateDictionary state, Utils.Logger logger) { _reader = reader; _state = state; _logger = logger; if (_state.ContainsKey("parent")) { _parent = _state["parent"]; } FromStream(); }
//Load IO settings public void InitSettings() { this._ioManager = new IOManager(); //this._ioManager.ReInitSettings(); this._log = new Utils.Logger(); //Load sim settings this.simulationSettings = new SimulationSettings(); _log.PrintInit(simulationSettings.ToString()); Console.WriteLine("Loading settings"); this.simulationSettings = new SimulationSettings(this._ioManager.GetSettings()); //Load of python files _interfacePython = this._ioManager.LoadPythonModules(); }
/// <summary> /// Set the node state /// </summary> /// <param name="state"></param> /// <param name="logger"></param> public void SetState(object state, Utils.Logger logger) { T config = state as T; if (state == null) { logger.LogError(Properties.Resources.PersistNodeImpl_InvalidConfig, GetType().Name); } else { ValidateConfig(config); _config = config; } }
/// <summary> /// Method to create the client /// </summary> /// <param name="logger">The logger to use</param> /// <returns>The proxy client</returns> /// <exception cref="ArgumentException">Throw if configuration invalid</exception> public override ProxyClient Create(Utils.Logger logger) { if (String.IsNullOrWhiteSpace(_hostname)) { throw new ArgumentException("Must specify a hostname"); } if ((_port <= 0) || (_port > 65535)) { throw new ArgumentException("Must specify a valid port number"); } return(new HttpProxyClient(_hostname, _port, _ipv6)); }
public string ToDisplayString(DataKey root, Utils.Logger logger) { // Need to implement some mechanism of handling this if (String.IsNullOrWhiteSpace(_formatString)) { return(typeof(T).ToString()); } else { // Do format return(GeneralUtils.FormatKeyString(_formatString, root)); } }
/// <summary> /// Method to create the client /// </summary> /// <param name="logger">The logger to use</param> /// <returns>The proxy client</returns> public override CANAPE.Net.Clients.ProxyClient Create(Utils.Logger logger) { if (String.IsNullOrWhiteSpace(_hostname)) { throw new ArgumentException("Must specify a hostname"); } if ((_port <= 0) || (_port > 65535)) { throw new ArgumentException("Must specify a valid port number"); } return(new FixedIpProxyClient(_hostname, _port, _udp ? IpProxyToken.IpClientType.Udp : IpProxyToken.IpClientType.Tcp, _ipv6)); }
/// <summary> /// Create client /// </summary> /// <param name="logger">The logger to use</param> /// <returns>The new proxy client</returns> public override ProxyClient Create(Utils.Logger logger) { IWebProxyScript proxyScript = GetProxyInstance(); if (proxyScript == null) { logger.LogError(Properties.Resources.ScriptProxyFactory_CannotCreateScript); return(new IpProxyClient()); } else { return(new ScriptProxyClient(proxyScript)); } }
/// <summary> /// Create the proxy client /// </summary> /// <param name="logger">The service logger</param> /// <returns>The proxy client</returns> public override ProxyClient Create(Utils.Logger logger) { if (String.IsNullOrWhiteSpace(_hostname)) { throw new ArgumentException("Must specify a hostname"); } if ((_port <= 0) || (_port > 65535)) { throw new ArgumentException("Must specify a valid port number"); } return(new SocksProxyClient(_hostname, _port, _ipv6, _v4 ? SocksProxyClient.SupportedVersion.Version4 : SocksProxyClient.SupportedVersion.Version5, _sendHostname)); }
public override void Run(IDataAdapter adapter, Utils.Logger logger) { DataFrame frame = adapter.Read(); while (frame != null) { if (Config.ConvertToBasic) { frame.ConvertToBasic(); } adapter.Write(frame); frame = adapter.Read(); } }
public void FromReader(DataReader reader, DataFrames.DataKey root, Utils.Logger logger) { if (Config.PrefixLen > 0) { root.AddValue("Prefix", reader.ReadBytes(Config.PrefixLen, true)); } ulong length = ReadLength(reader, logger); logger.LogVerbose("Read length field of {0} bytes", length); byte[] data = reader.ReadBytes((int)(length * Config.Stride) + Config.Adjustment, true); root.AddValue("Data", data); }
public void FromReader(DataReader reader, DataFrames.DataKey root, Utils.Logger logger) { Asn1InputStream input = new Asn1InputStream(reader.GetStream()); Asn1Object obj = input.ReadObject(); if (obj == null) { throw new EndOfStreamException(); } while (obj != null) { AddAsn1Object(obj.GetType().Name, root, obj, 0, logger); obj = input.ReadObject(); } }
public void ProcessGlobalProfit(List <Federation> federationsList) { Utils.Logger tempLog = new Utils.Logger(); tempLog.PrintConsoleMessage("Recalculate Gloabl MarketShare", ""); if (!this.GlobalProfitHistory.ContainsKey(this.CurrentStateModel.CurrentTurn)) { this.GlobalProfitHistory.Add(this.CurrentStateModel.CurrentTurn, 1); } double sumCollabTraining = federationsList.Sum(f => f.CollabTrainingQuality); foreach (Federation f in federationsList) { f.MarketShare = this.GetSharePct(f.CollabTrainingQuality, sumCollabTraining); Console.WriteLine("DEBUG :: New Market Share :" + f.MarketShare); } }
/// <summary> /// Create client /// </summary> /// <param name="logger">The logger to use</param> /// <returns>The new proxy client</returns> public override ProxyClient Create(Utils.Logger logger) { logger.LogError(Properties.Resources.ScriptProxyFactory_CannotCreateScript); return(new IpProxyClient()); // TODO: Implement a better way of using this // IWebProxyScript proxyScript = GetProxyInstance(); //if (proxyScript == null) //{ // logger.LogError(Properties.Resources.ScriptProxyFactory_CannotCreateScript); // return new IpProxyClient(); //} //else //{ // return new ScriptProxyClient(proxyScript); //} }
public void BasicTest() { var path = @"C:\CodeGarten\loggerTest.txt"; var writer = File.CreateText(path); var logger = new Utils.Logger(writer); var list = new LinkedList<Thread>(); var numbers = new bool[1000]; logger.Start(); Thread thread; for (var i = 0; i < numbers.Length; i++) { var iContext = i; thread = new Thread(() => logger.Log(iContext.ToString())); thread.Start(); list.AddLast(thread); } foreach (var threadList in list) threadList.Join(); writer.Close(); var reader = File.ReadAllLines(path); foreach (var s in reader) { int i; var split = s.Split(new[] {':', ' '}, StringSplitOptions.RemoveEmptyEntries); Int32.TryParse(split[4], out i); numbers[i] = true; } foreach (var number in numbers) if(!number) throw new Exception(); logger.Stop(); }