static void ReportFailure(int result)
{
if (!GGPO.SUCCEEDED(result))
{
OnLog?.Invoke(GGPO.GetErrorCodeMessage(result));
}
}
string[] ReadCode(String strName)
{
try
{
List <String> lstSource = new List <String>();
if (OnLog != null)
{
OnLog.Invoke(String.Format("Reading {0}...", strName));
}
foreach (String strFile in Directory.GetFiles(String.Format(@"Source\{0}", strName), "*.cs", SearchOption.AllDirectories))
{
if (OnLog != null)
{
OnLog.Invoke(String.Format("Reading: {0}", strFile));
}
String strContent = File.ReadAllText(strFile);
if (!String.IsNullOrEmpty(strContent))
{
lstSource.Add(strContent);
}
}
if (OnLog != null)
{
OnLog.Invoke(String.Format("{0} reading finished.", strName));
}
return(lstSource.ToArray());
}
catch { }
return(null);
}
private void Node_OnStop(Guid g)
{
if (Peers.TryRemove(g, out T peer))
{
OnLog?.Invoke($"Peer disconnected: {peer.RemoteEndpoint}");
}
}
public int Login()
{
MakeLoginPacket(salt, out buffer, out int len);
SendPacket(buffer, len);
int recv_len = ReceivePacket();
if (recv_len == -5)
{
return(-5);
}
if (recv_len <= 0)
{
OnLog.Invoke("login", "Login timeout.", false);
return(-1);
}
if (buffer[0] != 0x04)
{
if (buffer[0] == 0x05)
{
OnLog.Invoke("login", "Login fail, wrong password or username!", false);
}
else
{
OnLog.Invoke("login", string.Format("Login fail, unrecognized responese: {0:x}", buffer[0]), false);
}
CloseSocket();
return(-1);
}
Buffer.BlockCopy(buffer, 0x17, tail, 0, 16);
OnLog.Invoke("login", "Login success!", false);
return(0);
}
void Log(LogLevel level, Action <TraceRecord> traceAction, [CallerMemberName] string member = "", [CallerLineNumber] int line = 0)
{
// Check if this log level is enabled and client is subscribed to the OnLog event
if (OnLog == null || this.LogLevel >= level)
{
return;
}
TraceRecord tr = new TraceRecord()
{
Level = level
};
traceAction(tr);
string message = $"{member}() line {line}: {tr.Message}";
if (UseSynchronizationContextForEvents && syncContext != null && syncContext != SynchronizationContext.Current)
{
syncContext?.Post(o => OnLog?.Invoke(this, new LogEventArgs()
{
LogLevel = level, Message = message, Exception = tr.Exception
}), null);
}
else
{
OnLog?.Invoke(this, new LogEventArgs()
{
LogLevel = level, Message = message, Exception = tr.Exception
});
}
}
public void Log(LogVerbosity verbosity, string sender, string message, object payload = null)
{
var log = new Log()
{
Sender = sender, Message = message, Payload = payload
};
OnLog?.Invoke(this, log);
_logs.Add(log);
if (_logs.Count > 250)
{
_logs.RemoveAt(0);
}
//if (Debugger.IsAttached) return;
try
{
using (var eventLog = new EventLog("Application")
{
Source = _name
})
{
eventLog.WriteEntry($"{sender} {message}", ToEventLog(verbosity), 0);
}
}
catch { }
}
public SerializingProducer(Producer producer, ISerializer <TKey> keySerializer, ISerializer <TValue> valueSerializer)
{
this.producer = producer;
KeySerializer = keySerializer;
ValueSerializer = valueSerializer;
// TODO: allow serializers to be set in the producer config IEnumerable<KeyValuePair<string, object>>.
if (KeySerializer == null)
{
if (typeof(TKey) != typeof(Null))
{
throw new ArgumentNullException("Key serializer must be specified.");
}
}
if (ValueSerializer == null)
{
if (typeof(TValue) != typeof(Null))
{
throw new ArgumentNullException("Value serializer must be specified.");
}
}
producer.OnLog += (sender, e) => OnLog?.Invoke(sender, e);
producer.OnError += (sender, e) => OnError?.Invoke(sender, e);
producer.OnStatistics += (sender, e) => OnStatistics?.Invoke(sender, e);
}
private async Task print(IPAddress ip, BmpInfo bmpInfo)
{
TcpClientInfo client = IPClientBmpMap[ip].TcpClientInfo;
try {
OnLog?.Invoke(ip, bmpInfo.bmp, $"正在尝试打印", LogLevel.Info);
NetworkStream stream = client.Client.GetStream();
// 写入打印数据流
await stream.WriteAsync(bmpInfo.printingBytes, 0, bmpInfo.printingBytes.Length);
lock (IPClientBmpMap) {
client.IdleTime = 0;
IPClientBmpMap[ip].Queue.Dequeue();
}
OnLog?.Invoke(ip, bmpInfo?.bmp, "打印成功", LogLevel.Success);
await prePrint(ip);
}
catch (Exception e) {
OnLog?.Invoke(ip, null, $"写入数据发生错误 {e.Message}", LogLevel.Error);
lock (IPClientBmpMap) {
closeIP(ip);
}
OnLog?.Invoke(ip, null, "重新尝试连接", LogLevel.Info);
await Connect(ip);
}
}
public async Task Connect(IPAddress ip)
{
ClientBmpInfo clientBmpInfo;
lock (IPClientBmpMap) {
addIP(ip);
clientBmpInfo = IPClientBmpMap[ip];
OnLog?.Invoke(ip, null, null, LogLevel.Info);
if (clientBmpInfo.TcpClientInfo != null)
{
OnLog?.Invoke(ip, null, "已连接", LogLevel.Success);
return;
}
if (clientBmpInfo.IsConnecting)
{
OnLog?.Invoke(ip, null, "正在连接中", LogLevel.Info);
return;
}
clientBmpInfo.IsConnecting = true;
}
await connect(ip, clientBmpInfo);
}
private static void ParsePicture(Stream fs, ref FlacInfo info)
{
var pictureType = fs.BEInt32();
var mimeStringLength = (int)fs.BEInt32();
var mimeType = Encoding.ASCII.GetString(fs.ReadBytes(mimeStringLength), 0, mimeStringLength);
var descriptionLength = (int)fs.BEInt32();
var description = Encoding.UTF8.GetString(fs.ReadBytes(descriptionLength), 0, descriptionLength);
var pictureWidth = fs.BEInt32();
var pictureHeight = fs.BEInt32();
var colorDepth = fs.BEInt32();
var indexedColorCount = fs.BEInt32();
var pictureDataLength = fs.BEInt32();
fs.Seek(pictureDataLength, SeekOrigin.Current);
info.TrueLength -= pictureDataLength;
info.HasCover = true;
if (pictureType > 20)
{
pictureType = 21;
}
OnLog?.Invoke($" | picture type: {PictureTypeName[pictureType]}");
OnLog?.Invoke($" | picture format type: {mimeType}");
if (descriptionLength > 0)
{
OnLog?.Invoke($" | description: {description}");
}
OnLog?.Invoke($" | attribute: {pictureWidth}px*{pictureHeight}px@{colorDepth}-bit");
if (indexedColorCount != 0)
{
OnLog?.Invoke($" | indexed-color color: {indexedColorCount}");
}
}
public async Task Print(IPAddress ip, Bitmap bmp, int colorDepth)
{
await Task.Run(async() => {
BmpInfo bmpInfo = null;
// 获得需要打印的图片数据
bmpInfo = new BmpInfo {
bmp = bmp,
printingBytes = await getPrintingBytes(bmp, colorDepth)
};
lock (IPClientBmpMap) {
addIP(ip);
IPClientBmpMap[ip].Queue.Enqueue(bmpInfo);
OnLog?.Invoke(ip, bmpInfo?.bmp, "已进入打印队列", LogLevel.Success);
// 如果正在打印则不做任何操作, 队列中的数据会自动打印
if (IPClientBmpMap[ip].IsPrinting)
{
return;
}
IPClientBmpMap[ip].IsPrinting = true;
}
await prePrint(ip);
});
}
public void Log(string s, Verbosity v = Verbosity.Info, string prefix = "")
{
if (v < Verbosity && v < FileWriteVerbosity)
{
return;
}
if (v >= Verbosity)
{
ix++;
var item = new Item(v, ix, DateTime.Now, prefix, s);
//lock (itemsLocker) {
// if (cnt < bufferSize) cnt++;
// else items.Dequeue();
// items.Enqueue(item);
//}
OnLog?.Invoke(this, item);
}
#if WRITE_LOG_TO_FILE
if (v >= FileWriteVerbosity)
{
var pfx = $"{Prefix}.{prefix}".Trim('.');
writeLineToCurLogFile($"{DateTime.Now:T} [{VerbosityDescriptions[v]}] {pfx} : {s}");
}
#endif
}
private void ListeningMq(RedisReliableQueue <string> redisReliableQueue)
{
while (true)
{
try
{
var queue = redisReliableQueue;
var msg = queue.TakeOne(1);
if (msg != null)
{
var message = JsonConvert.DeserializeObject <TransportMessage>(msg);
message.Headers.Add(Headers.Group, _queueName);
OnMessageReceived?.Invoke(message.GetId(), message);
// 确认消息
queue.Acknowledge(new[] { msg });
}
else
{
// 没事干，歇一会
System.Threading.Tasks.Task.Delay(1000);
}
}
catch (Exception ex)
{
OnLog?.Invoke(this, new LogMessageEventArgs()
{
LogType = MqLogType.ExceptionReceived, Reason = $"{_queueName}-{redisReliableQueue.Key}-{ex.Message}"
});
//throw;
}
}
}
internal void Log(LogLevels level, string message)
{
if (LogLevel.HasFlag(level))
{
OnLog?.Invoke(this, new LogEventArgs(level, message));
}
}
public void Log(string message, LoggerSeverity severity, object reference = null)
{
LoggerSeverity getMostSevere(int s)
{
int i = 0;
while (s != 0)
{
s /= 2;
i++;
}
return((LoggerSeverity)(1 << (i - 1)));
}
int sev = ((int)severity & (int)Take);
if (sev == 0)
{
return;
}
Console.ForegroundColor = _colorTable[getMostSevere(sev)];
Console.WriteLine($"[{severity.ToString()}][{message}]");
Console.ResetColor();
OnLog?.Invoke(message, severity, reference);
}
public void ShutDown()
{
IsRunning = false;
SaveData();
DeactivateModules();
OnLog?.Invoke(this, new OnLogHandlerArgs("Service Shut down", LogReason.STATUSCHANGE));
}
public MatroskaData()
{
var mkvToolnixPath = RegistryStorage.Load(@"Software\ChapterTool", "mkvToolnixPath");
// saved path not found.
if (string.IsNullOrEmpty(mkvToolnixPath))
{
try
{
mkvToolnixPath = GetMkvToolnixPathViaRegistry();
RegistryStorage.Save(mkvToolnixPath, @"Software\ChapterTool", "mkvToolnixPath");
}
catch (Exception exception)
{
// no valid path found in Registry
OnLog?.Invoke($"Warning: {exception.Message}");
}
// Installed path not found.
if (string.IsNullOrEmpty(mkvToolnixPath))
{
mkvToolnixPath = Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location);
}
}
if (mkvToolnixPath != null)
{
_mkvextractPath = Path.Combine(mkvToolnixPath, "mkvextract.exe");
}
if (!File.Exists(_mkvextractPath))
{
OnLog?.Invoke($"Mkvextract Path: {_mkvextractPath}");
throw new Exception("无可用 MkvExtract, 安装个呗~");
}
}
private void SetUpHeartbeatModule()
{
var heartbeatModule = new HeartbeatModule(GetKnownChanges);
this.heartbeatModule = heartbeatModule;
heartbeatModule.OnHeartbeatAnswerReceived += (sender, args) =>
{
var receiverId = args.HeartbeatReq.SenderUID;
OnLog?.Invoke(this, new OnLogHandlerArgs(
"Heartbeat answer received from " + receiverId + " with " + args.HeartbeatReq.KnownChanges.Count + " known changes",
LogReason.RABBITMQ_COMMUNICATION
));
metaDataModule.SendMetaDataShareRequest(receiverId, CreateMetaDataRequest(receiverId));
};
heartbeatModule.OnOutdatedLocalChanges += (sender, args) =>
{
OnLog?.Invoke(this, new OnLogHandlerArgs(
$"Found {args.OutdatedLocalChanges.Count} outdated local changes from: " +
string.Join(", ", args.OutdatedLocalChanges),
LogReason.RABBITMQ_COMMUNICATION));
updaterModule.NotifyAboutOutdatedAlienChanges(args.OutdatedLocalChanges);
};
}
public void Log(LogLevel logLevel, object message,
[CallerFilePath] string callingFilePath = default,
[CallerMemberName] string callingMethod = default,
[CallerLineNumber] int callingFileLineNumber = 0)
{
OnLog?.Invoke(this, logLevel, message, callingFilePath, callingMethod, callingFileLineNumber);
}
private void OnMetaDataExchangeReceived(IMetaDataShareModule sender, MetaDataAnswerReceivedArgs args)
{
OnLog?.Invoke(this, new OnLogHandlerArgs(
$"Received MetaDataExchange with {args.MetaDataAnswer?.DomesticChanges.Changes.Count} domestic changes" +
$" and changes from {args.MetaDataAnswer.AlienChanges.Count} other services",
LogReason.RABBITMQ_COMMUNICATION));
var changes = new List <ChangeSet>();
if (args.MetaDataAnswer.AlienChanges != null)
{
changes.AddRange(args.MetaDataAnswer.AlienChanges);
}
if (args.MetaDataAnswer.DomesticChanges != null)
{
changes.Add(args.MetaDataAnswer.DomesticChanges);
}
foreach (var changeSet in changes)
{
var changeData = changeSet.Changes.OrderBy(c => c.TimeStamp).ToList();
lock (data)
{
fileManagerModule.ApplyChanges(changeData);
data.AddSortedAlienChanges(changeSet.ServiceUID, changeData);
SaveData();
}
}
}
public int Alive()
{
randtimes = rand.Next(0, 32767) % 0xFFFF;
for (int i = 0; i < 3; i++)
{
MakeKeepAlivePacket(out buffer, i, randtimes);
SendPacket(buffer, i == 0 ? 38 : 40);
int r = ReceivePacket();
if (r == -5)
{
return(-5);
}
if (r < 0)
{
OnLog.Invoke("alive", "Alive(" + i + ") timeout.", false);
return(-1);
}
if (buffer[0] != 0x07)
{
OnLog.Invoke("alive", string.Format("Alive fail, unrecognized responese: {0:x}", buffer[0]), false);
return(-1);
}
if (i > 0)
{
Buffer.BlockCopy(buffer, 16, flux, 0, 4);
}
}
return(0);
}
public static void WriteLine(string text, LogType messageType = LogType.Message)
{
DateTime timestamp = DateTime.Now;
text = $"[{timestamp.Hour.ToString().PadLeft(2, '0')}:{timestamp.Minute.ToString().PadLeft(2, '0')}:{timestamp.Second.ToString().PadLeft(2, '0')}]: {text}";
OnLog?.Invoke(text, LogTypeToColor(messageType));
}
public virtual O Execute <T, I, O>(I args) where T : AbstractCallable, ICallable
{
StackTraceCollector stackTraceCollector = new StackTraceCollector(this);
var op = Get <ICallable, T>();
try
{
var result = op.Apply <O>(args);
this.CallStack = null;
return(result);
}
catch (Exception e) // Dumps q# call-stack in case of exception if CallStack tracking was enabled
{
this.CallStack = stackTraceCollector.CallStack;
OnLog?.Invoke($"Unhandled exception. {e.GetType().FullName}: {e.Message}");
bool first = true;
foreach (StackFrame sf in this.CallStack)
{
var msg = (first ? " ---> " : " at ") + sf.ToStringWithBestSourceLocation();
OnLog?.Invoke(msg);
first = false;
}
OnLog?.Invoke("");
throw;
}
finally
{
stackTraceCollector.Dispose();
}
}
private void Log(string level, string who, string message)
{
var logLine = $"{DateTime.Now} [{level}] {who}: {message}";
_logWriter.WriteLine(logLine);
OnLog?.Invoke(logLine);
}
private void log(string message, bool includeDate = false, bool includeTime = false)
{
if (Logging)
{
string dateTimeStr = "";
if (includeDate && includeTime)
{
dateTimeStr = $"{DateTime.UtcNow}";
}
else if (includeDate)
{
dateTimeStr = $"{DateTime.UtcNow.ToShortDateString()}";
}
else
{
dateTimeStr = $"{DateTime.UtcNow.ToShortTimeString()}";
}
if (includeDate || includeTime)
{
Console.WriteLine($"[TwitchLib, {Assembly.GetExecutingAssembly().GetName().Version.ToString()} - {dateTimeStr}] {message}");
}
else
{
Console.WriteLine($"[TwitchLib, {Assembly.GetExecutingAssembly().GetName().Version.ToString()}] {message}");
}
OnLog?.Invoke(this, new OnLogArgs()
{
BotUsername = ConnectionCredentials.TwitchUsername, Data = message, DateTime = DateTime.UtcNow
});
}
}
public virtual TResponse Run <TResponse>
(
ITasq <TResponse> tasq
)
{
TResponse retVal;
OnLog?.Invoke(this, TasqProcess.Start, new LogEventHandlerEventArgs(tasq));
var resolvedHandler = GetHandlerDetail(tasq);
OnLog?.Invoke(this, TasqProcess.Start, new LogEventHandlerEventArgs(resolvedHandler.Handler));
if (resolvedHandler.Handler is TasqHandlerAsync)
{
retVal = RunAsync(tasq).Result;
}
else
{
TasqHandler tasqHandlerInstance = (TasqHandler)resolvedHandler.Handler;
tasqHandlerInstance.Initialize(tasq);
tasqHandlerInstance.BeforeRun(tasq);
retVal = (TResponse)tasqHandlerInstance.XRun(null, tasq);
tasqHandlerInstance.AfterRun(tasq);
}
return(retVal);
}
private void Log(string str)
{
if (OnLog != null)
{
OnLog.Invoke(str);
}
}
void Log(LogLevel level, Action <TraceRecord> traceAction, [CallerMemberName] string member = "", [CallerLineNumber] int line = 0)
{
// Check if this log level is enabled and client is subscribed to the OnLog event
if (OnLog == null || (int)LogLevel >= (int)level)
{
return;
}
TraceRecord tr = new TraceRecord()
{
Level = level
};
traceAction(tr);
// StringBuild is faster than $"{member}() line {line}: {tr.Message}"
var sb = new StringBuilder(member.Length + tr.Message.Length + 100);
sb.Append(member);
sb.Append("() line ");
sb.Append(line);
sb.Append(": ");
sb.Append(tr.Message);
OnLog?.Invoke(this, new LogEventArgs()
{
LogLevel = level, Message = sb.ToString(), Exception = tr.Exception
});
}
private Logger Log(Level level, object format, params object[] Params)
{
if (Enabled || OnGlobalLog != null)
{
var stackTrace = new StackTrace();
StackFrame stackFrame = null;
var stackFrames = stackTrace.GetFrames();
if (stackFrames != null)
{
foreach (var frame in stackFrames)
{
if (frame.GetMethod().DeclaringType != typeof(Logger))
{
stackFrame = frame;
break;
}
}
}
if (Enabled)
{
OnLog?.Invoke(level, Format(format.ToString(), Params), stackFrame);
}
OnGlobalLog?.Invoke(Name, level, Format(format.ToString(), Params), stackFrame);
}
return(this);
}
/*
* vw_log_game_state --
*
* Log the gamestate. Used by the synctest debugging tool.
*/
static unsafe bool Vw_log_game_state(string filename, void *buffer, int length)
{
OnLog?.Invoke($"vw_log_game_state {filename}");
var gamestate = new GameState();
GameState.FromBytes(gamestate, Helper.ToArray(buffer, length));
string fp = "";
fp += "GameState object.\n";
fp += string.Format(" bounds: {0},{1} x {2},{3}.\n", gamestate._bounds.xMin, gamestate._bounds.yMin,
gamestate._bounds.xMax, gamestate._bounds.yMax);
fp += string.Format(" num_ships: {0}.\n", gamestate._ships.Length);
for (int i = 0; i < gamestate._ships.Length; i++)
{
var ship = gamestate._ships[i];
fp += string.Format(" ship {0} position: %.4f, %.4f\n", i, ship.position.x, ship.position.y);
fp += string.Format(" ship {0} velocity: %.4f, %.4f\n", i, ship.velocity.x, ship.velocity.y);
fp += string.Format(" ship {0} radius: %d.\n", i, ship.radius);
fp += string.Format(" ship {0} heading: %d.\n", i, ship.heading);
fp += string.Format(" ship {0} health: %d.\n", i, ship.health);
fp += string.Format(" ship {0} cooldown: %d.\n", i, ship.cooldown);
fp += string.Format(" ship {0} score: {1}.\n", i, ship.score);
for (int j = 0; j < ship.bullets.Length; j++)
{
fp += string.Format(" ship {0} bullet {1}: {2} {3} -> {4} {5}.\n", i, j,
ship.bullets[j].position.x, ship.bullets[j].position.y,
ship.bullets[j].velocity.x, ship.bullets[j].velocity.y);
}
}
File.WriteAllText(filename, fp);
return(true);
}
