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();
}
