/// <summary> /// Parses unsigned constant values. Parses hex, oct, bin and exponent values as well. /// </summary> /// <param name="val">The string value to convert from. It can be hex, oct, bin, or nnnExx</param> /// <param name="maxBitSize"></param> /// <param name="paramNo">The parameter place for logging errors. </param> /// <param name="log"></param> /// <returns></returns> internal static uint parseUnSignedNumber(string val, int maxBitSize, int paramNo, Log log) { Match m = Regex.Match(val, RegexRecognizers.UnSignedNumber); if (!m.Groups[2].Success) { log.Error("param {0}: unable to recognize constant '{1}'", paramNo, val); return 0; } char opType = m.Groups[1].Value[0]; string opVal = m.Groups[2].Value; if (opVal == "") log.Error("param {0}: compiler error 4360 '{1}'", paramNo, val); uint num; if (opType > '0' && opType <= '9') num = UInt32.Parse(opVal, NumberStyles.AllowLeadingSign | NumberStyles.AllowExponent); else // if (opType == 'x' || opType == 'o' || opType == 'b') num = Convert.ToUInt32(opVal, (opType == 'x') ? 16 : (opType == 'o') ? 8 : 2); if (num > ((1 << maxBitSize) - 1)) { log.Error("param {0}: The value '{1}' will not fit in {2} bits", paramNo, val, maxBitSize); num &= (uint)((1 << maxBitSize) - 1); } return num; }
/// <inheritdoc /> /// <summary> /// Checks if we can handle/store the given asset pair. Also, writes an error to log according to timeout from settings. /// </summary> /// <param name="assetPairId">Asset pair ID.</param> /// <returns>True if repository is able to store such a pair, and false otherwise.</returns> public override bool CanHandleAssetPair(string assetPairId) { if (base.CanHandleAssetPair(assetPairId)) { return(true); // It's Ok, we can store this asset pair } // If we can't store and need to notify others... var needToLog = false; if (!_knownUnsupportedAssetPairs.TryGetValue(assetPairId, out var lastLogMoment)) { _knownUnsupportedAssetPairs.Add(assetPairId, _clock.UtcNow); needToLog = true; } else { if (_clock.UtcNow.Subtract(lastLogMoment) > _notificationTimeout) { needToLog = true; _knownUnsupportedAssetPairs[assetPairId] = _clock.UtcNow; } } if (needToLog) { Log?.Error(nameof(CanHandleAssetPair), new ArgumentOutOfRangeException("Incomptible candle batch recieved: connection string for asset pair not configured. Skipping..."), context: assetPairId); } return(false); // Finally }
/// <summary> /// Create a table /// e.g. DDL.CreateTable( "Sample", "col1,int,col2,int,col3,varchar(10),col4,int,col5,int"); /// </summary> /// <param name="sTableName"></param> - Name of the new table /// <param name="sColumns_i"></param> - A string containing list of colums in the format Column1,datatype, /// Column2,datatype...etc public static void CreateTable(string sTableName, string sColumns_i) { using (Log log = new Log(".::()")) { try { string sQuerry = "CREATE TABLE " + sTableName + "("; string[] sColums = Strings.Split(sColumns_i, ",", -1, CompareMethod.Text); sQuerry = sQuerry + sColums[0] + " " + sColums[1]; for (int nIndex = 2; nIndex < sColums.Length; nIndex += 2) sQuerry = sQuerry + "," + sColums[nIndex] + " " + sColums[nIndex + 1]; sQuerry += ")"; DBWrapper.ExecuteNonQueryEx(sQuerry); } catch (Exception ex) { log.Error(ex); } } }
public override bool Validate(IISWebArguments current, MainArguments main) { if (!base.Validate(current, main)) { return(false); } if (!string.IsNullOrEmpty(current.SSLPort)) { if (int.TryParse(current.SSLPort, out var port)) { if (port < 1 || port > 65535) { Log?.Error("Invalid --{param}, value should be between 1 and 65535", SslPortParameterName); return(false); } } else { Log?.Error("Invalid --{param}, value should be a number", SslPortParameterName); return(false); } } if (!string.IsNullOrEmpty(current.SSLIPAddress)) { if (!IPAddress.TryParse(current.SSLIPAddress, out _)) { Log?.Error("Invalid --{sslipaddress}", SslIpParameterName); return(false); } } return(true); }
public bool Initialize() { string methoName = MethodBase.GetCurrentMethod().Name; try { smtp = new SmtpClient(); smtp.Host = settings.Host; smtp.Port = settings.Port; smtp.EnableSsl = settings.Ssl; smtp.Timeout = 20 * 1000; smtp.DeliveryMethod = SmtpDeliveryMethod.Network; smtp.UseDefaultCredentials = false; if (settings.UseCredential) { smtp.Credentials = new System.Net.NetworkCredential(settings.EmailAddress, settings.Password); } IsInitialized = true; } catch (Exception ex) { Log?.Error(className, methoName, ex.ToString()); IsInitialized = false; } return(IsInitialized); }
public static void Main(string[] args) { Configuration config = Configuration.LoadConfiguration("settings.json"); Log mainLog = new Log (config.MainLog, null); //byte counter = 0; foreach (Configuration.BotInfo info in config.Bots) { //Console.WriteLine("--Launching bot " + info.DisplayName +"--"); mainLog.Info ("Launching Bot " + info.DisplayName + "..."); new Thread(() => { int crashes = 0; while (crashes < 1000) { try { new Bot(info, config.ApiKey); } catch (Exception e) { mainLog.Error ("Error With Bot: "+e); crashes++; } } }).Start(); Thread.Sleep(5000); } }
private void DisconnectAllClientChannels() { try { Log?.Information(className, "DisconnectAllClientChannels", "Disconnecting clients"); //var channels = ClientChannelManager?.Channels.Keys.ToArray(); //foreach (var channel in channels) //{ // try // { // channel.CloseAsync(); // } // catch (Exception ex) // { // Logging.ServerChannelLogger.Instance.Log.Error(className, "DisconnectAllClientChannels", // string.Format("Message: {0}, Details: {1}", ex.Message, ex.ToString())); // } //} } catch (Exception ex) { Log?.Error(className, "DisconnectAllClientChannels", string.Format("Message: {0}, Details: {1}", ex.Message, ex.ToString())); } }
public static Window AboutWindow(Application application, Log log) { const string prefix = "Dialogs - AboutWindow"; if ((application == null) || application.HasExited) { throw new RegressionTestFailedException(prefix + ": Application does not exist or has already exited."); } // Note that the windows can't be found through an Automation ID for some reason, hence // using the title of the window. var mainWindow = MainWindow(application, log); if (mainWindow == null) { return null; } return Retry.Times( () => { log.Debug(prefix, "Trying to get the about window."); var window = mainWindow.ModalWindow("About"); if (window == null) { log.Error(prefix, "Failed to get the about window."); } return window; }); }
public bool SendMessage(string msg) { if (string.IsNullOrEmpty(msg)) { return(false); } if (!_tcpClient.Connected) { return(false); } var strm = _tcpClient.GetStream(); var writer = new StreamWriter(strm) { AutoFlush = true }; try { if (_tcpClient.Connected) { writer.WriteLine(msg); } return(true); } catch (Exception ex) { SendFailed?.Invoke(this, ex); Log?.Error("SendMessage failed", ex); return(false); } }
static void Main(string[] args) { log4net.Config.XmlConfigurator.Configure(); var log = new Log(); log.Info("Startup"); var servers = new List<ServerInfo>(); using (var dc = new Arma3BeClientContext()) { servers = dc.ServerInfo.Where(x => x.Active).ToList(); } var models = servers.Select(x=>OpenServerInfo(x, log)).ToList(); while (true) { try { var t = Task.Run(() => run(models)); t.Wait(); } catch (Exception ex) { log.Error(ex); } } }
public async Task HandleLines() { try { var strm = _tcpClient.GetStream(); using (StreamReader reader = new StreamReader(strm, Encoding.UTF8)) { string line; while ((line = reader.ReadLine()) != null) { LineReceived?.Invoke(this, line); } } } catch (IOException ex) { Log?.Error("HandleLines::IOException", ex); } catch (InvalidOperationException ex) { Log?.Error("HandleLines::InvalidOperationException", ex); } await Task.Delay(1000); }
private async Task SetTabAsync( Type selectedTabType) { if (!IsTab(selectedTabType)) { return; } var tabbedPage = RootPage as TabbedPage; await Device.InvokeOnMainThreadAsync(() => { var tab = tabbedPage .Children .FirstOrDefault(tab => IsPageOfType( tab, selectedTabType)); if (tab == null) { Log?.Error( $"{tabbedPage.GetType().Name} does not contain requested view {selectedTabType.Name}!"); return; } tabbedPage.CurrentPage = tab; }); }
private void DpOnModified(object sender) { var dp = sender as DataProvider; if (dp == null) { return; } if (Router == null) { Log?.Error("Error: router is not set"); return; } var obj = dp.ToJson(); if (obj == null) { Log?.Error("Error: data object is null"); return; } Router.SendBroadcast(obj, dp.Mode); }
// TODO - Define a margin to move time and review possible tamper scenarios private DateTime GetUtc() { DateTime? antiBack = null; DateTime? reliable = null; Exception exception = null; try { reliable = ReliableTimeProvider.UtcNow(); Log?.Info("Reliable provider get time successfully"); AntiBackTimeProvider.SetValue(reliable.Value); } catch (Exception ex) { exception = ex; Log?.Error($"Error '{ex.GetType().Name}' in ReliableTimeProvider: {ex.Message}", ex); } try { antiBack = AntiBackTimeProvider.UtcNow(); Log?.Info("Anti-back provider get time successfully"); } //catch (NoStoredTimeValueException nstvex) { exception = nstvex; } //catch (BackTimeException btex) { exception = btex; } catch (Exception ex) { exception = ex; Log?.Error($"Error '{ex.GetType().Name}' in AntiBackProvider: {ex.Message}", ex); } if (reliable != null || antiBack != null) { return((reliable ?? antiBack).Value); } throw new TamperedTimeException(exception); }
/// <summary>开始工作</summary> /// <param name="reason"></param> protected virtual void StartWork(String reason) { // 依赖服务检测 this.PreStartWork(); var tcount = ThreadCount; var sch = Schedule; var count = tcount + sch.Count; WriteLog("服务启动 共[{0:n0}]个工作线程 {1}", count, reason); try { var ss = Items = new ServiceItem[count]; // 可以通过设置任务的时间间隔小于0来关闭指定任务 var vs = Intervals; for (var i = 0; i < count; i++) { var time = vs[0]; // 使用专用的时间间隔 if (i < vs.Length) { time = vs[i]; } var si = ss[i] = new ServiceItem(i, null, time); if (i < tcount) { si.Callback = Work; } else { var job = sch.Jobs[i - tcount]; if (job is JobBase jb) { jb.Log = Log; } si.Job = job; } //StartWork(i); ss[i].Start(reason); } // 启动服务管理线程 StartManagerThread(); //// 显示用户界面交互窗体 //Interactive.ShowForm(); } catch (Exception ex) { //WriteLog(ex.ToString()); Log?.Error(ex.GetTrue()?.ToString()); } }
private static void LogMessagesTo(TraceSource traceSource) { var log = new Log(traceSource); log.Verbose(_verboseMessage); log.Information(_infoMessage); log.Warning(_warningMessage); log.Error(_errorMessage); traceSource.Flush(); }
private IChannelHandler CreateChannelHandler() { IChannelHandler channelHandler = null; try { channelHandler = new ActionChannelInitializer <ISocketChannel>(channel => { IChannelPipeline pipeline = channel.Pipeline; if (configuration.EnableTls) { X509Certificate2 cert = GetCertificate(); if (cert != null) { targetHost = cert.GetNameInfo(X509NameType.DnsName, false); if (string.IsNullOrEmpty(targetHost)) { RaiseError(null, ErrorMessages.Message(ErrorType.TargetHostDnsNameNotFound), ErrorType.TargetHostDnsNameNotFound); throw new NullReferenceException(ErrorMessages.Message(ErrorType.TargetHostDnsNameNotFound)); } TlsHandlerFactory tlsFactory = new TlsHandlerFactory(); TlsHandler tlsHandler = tlsFactory.CreateStandardTlsHandler(targetHost); pipeline.AddLast("tls", tlsHandler); //pipeline.AddLast("tls", new TlsHandler(stream => new SslStream(stream, true, (sender, certificate, chain, errors) => true), new ClientTlsSettings(targetHost))); //} } else { RaiseError(null, ErrorMessages.Message(ErrorType.NoCertificateFoundWhenTlsEnabled), ErrorType.NoCertificateFoundWhenTlsEnabled); throw new NullReferenceException(ErrorMessages.Message(ErrorType.NoCertificateFoundWhenTlsEnabled)); // add intialization error here } } pipeline.AddLast("encoder", encoder); pipeline.AddLast("decoder", decoder); handler = new ChannelHandler(); handler.ChannelKey = configuration.ChannelKey; handler.ClientChannelHandler = ClientChannelHandler; pipeline.AddLast("echo", handler); }); } catch (Exception ex) { channelHandler = null; Log?.Error(className, "CreateChannelHandler", ex.ToString()); } return(channelHandler); }
private async Task ProcessMessage(FtpCommand command) { FtpResponse response; Log?.Trace(command); var result = FindCommandHandler(command); if (result != null) { var handler = result.Item2; var handlerCommand = result.Item1; var isLoginRequired = result.Item3; if (isLoginRequired && !Data.IsLoggedIn) { response = new FtpResponse(530, "Not logged in."); } else { try { var cmdHandler = handler as FtpCommandHandler; var isAbortable = cmdHandler?.IsAbortable ?? false; if (isAbortable) { var newBackgroundTask = Data.BackgroundCommandHandler.Execute(handler, handlerCommand); if (newBackgroundTask != null) { _activeBackgroundTask = newBackgroundTask; response = null; } else { response = new FtpResponse(503, "Parallel commands aren't allowed."); } } else { response = await handler.Process(handlerCommand, _cancellationTokenSource.Token); } } catch (Exception ex) { Log?.Error(ex, "Failed to process message ({0})", command); response = new FtpResponse(501, "Syntax error in parameters or arguments."); } } } else { response = new FtpResponse(500, "Syntax error, command unrecognized."); } if (response != null) { await WriteAsync(response, _cancellationTokenSource.Token); } }
private static void ThrowNotRegisteredException <TViewModel>() { // todo: which exception type fits best? var notRegisteredException = new InvalidOperationException( $"There is no reference from viewmodel type {typeof(TViewModel).Name} to a page."); Log?.Error(notRegisteredException); throw notRegisteredException; }
public void SetValue(DateTime value) { foreach (var s in providers) { try { s.SaveUtcTime(value); } catch (Exception ex) { Log?.Error($"Error '{ex.GetType().Name}' saving storage: {ex.Message}", ex); } } }
protected void Application_Error(object sender,EventArgs e) { ILog _log = new Log(); StringBuilder content = new StringBuilder(); HttpRequest request = HttpContext.Current.Request; content.AppendFormat("\r\nNavigator:{0}", request.UserAgent); content.AppendFormat("\r\nIp:{0}", request.UserHostAddress); content.AppendFormat("\r\nUrlReferrer:{0}", request.UrlReferrer != null ? request.UrlReferrer.AbsoluteUri : ""); content.AppendFormat("\r\nRequest:{0}", Utils.GetRequestValues(request)); content.AppendFormat("\r\nUrl:{0}", request.Url.AbsoluteUri); _log.Error(content.ToString(), Server.GetLastError().GetBaseException());//记录日志 }
public async Task StartAsync() { string methodName = MethodBase.GetCurrentMethod().Name; bossGroup = new MultithreadEventLoopGroup(1); workerGroup = new MultithreadEventLoopGroup(); var encoder = new StringEncoder(); var decoder = new StringDecoder(); try { bootstrap = new ServerBootstrap(); bootstrap.Group(bossGroup, workerGroup); bootstrap.Channel <TcpServerSocketChannel>(); bootstrap .Option(ChannelOption.SoBacklog, 100) .Handler(new LoggingHandler("SRV-LSTN")) .ChildHandler(new ActionChannelInitializer <IChannel>(channel => { IChannelPipeline pipeline = channel.Pipeline; if (configuration.EnableTls) { X509Certificate2 tlsCertificate = GetCertificate(); if (tlsCertificate != null) { pipeline.AddLast("tls", TlsHandler.Server(tlsCertificate)); } else { Log?.Error(className, methodName, "Certificate not found"); } } pipeline.AddLast("encoder", encoder); pipeline.AddLast("decoder", decoder); handler = new ServerChannelHandler(); //handler.ClientChannelManager = ClientChannelManager; handler.ChannelHandler = ServerChannelHandler; handler.Log = Log; pipeline.AddLast("handler", handler); })); boundChannel = await bootstrap.BindAsync(configuration.Port); } catch (Exception ex) { Log?.Error(className, methodName, ex.ToString()); } }
public async Task InitializeSchedule() { if (!Enabled) { return; } var type = GetJobObjectType(); if (type == null) { Log?.Error($"Job \"{Name}\" cannot be instantiated."); return; } if (_jobInstance == null) { _jobInstance = Activator.CreateInstance(type) as IJob; } while (Repeatable) { var timeSchedule = GetTimeSchedule(); if (timeSchedule == null) { if (!await ExecuteJobAndContinue()) { return; } } else { var difference = timeSchedule.TimeNow.TimeOfDay - timeSchedule.Value.TimeOfDay; if (0 <= difference.TotalSeconds && difference.TotalSeconds < RepetitionIntervalTime) { if (!await ExecuteJobAndContinue()) { return; } } } if (RepetitionIntervalTime > 0) { //Thread.Sleep(RepetitionIntervalTime * 1000); await Task.Delay(RepetitionIntervalTime * 1000); } } // else !Repeatable await ExecuteJobAndContinue(); }
/// <inheritdoc cref="INavigationService.CloseModalAsync" /> public virtual async Task CloseModalAsync <TViewModel>() { if (Navigation == null) { Log?.Error( $"'{nameof(Navigation)}' is null!"); return; } await Navigation.PopModalAsync( animated : Configuration.UseAnimations); }
//----------------------------------------------------------------------------------------- /// <summary> /// 处理错误 /// </summary> /// <param name="e"></param> protected void DealError(Exception e) { Log log = new Log(typeof(BllBase)); log.Error(e); //DateTime dt = DateTime.Now; //string errorLogName = String.Format("{0}{1}_Error.txt", APPLICATION_ERROR_PATH, dt.ToString("yyyyMMdd")); //using (StreamWriter sw = new StreamWriter(errorLogName, true, Encoding.GetEncoding("gb2312"))) //{ // sw.WriteLine(String.Format("[{0}]{1}\r\n" // , dt.ToString("HH:mm:hh") // , e.ToString())); //} }
static void Main(string[] args) { Log log = new Log(); Migrator migrator = null; AbstractParser parser = null; try { parser = Factory.Create(args); } catch (Exception ex) { Console.Write(GetHelp(parser)); log.Error("Could not continue: " + ex.Message); Exit(1); } try { migrator = parser.Parse(args, new Migrator()); } catch (Exception ex) { Console.Write(GetHelp(parser)); log.Error("Error: " + ex.Message); Exit(1); } if (migrator != null) { migrator.Run(); } Exit(Environment.ExitCode); }
private async Task StopApplication() { try { // NOTE: Service still can recieve and process requests here, so take care about it if you add logic here. await ApplicationContainer.Resolve <IShutdownManager>().StopAsync(); } catch (Exception ex) { Log?.Error(nameof(StopApplication), ex); throw; } }
public void Connect(string hostname, int port) { Port = port; Host = hostname; try { _tcpClient = new System.Net.Sockets.TcpClient(Host, Port); } catch (SocketException ex) { Log?.Error("Connect failed", ex); throw new Exception(ex.Message); } }
internal static bool CopyFile(string file, string destinationFolder, Log log) { try { var sourceFileName = Path.GetFileName(file); if (sourceFileName == null || !File.Exists(file)) { log.Error("File not found {0}", file); return false; } var destinationFilePath = Path.Combine(destinationFolder, sourceFileName); if (File.Exists(destinationFilePath)) { File.Delete(destinationFilePath); } File.Copy(file, destinationFilePath); } catch (Exception e) { log.Error(e.Message); return false; } return true; }
public Login() { using (Log log = new Log("Glx.App.Login::Login()")) { try { DBWrapper.InitializeDB("\\database\\GlxDB.mdf", true); InitializeComponent(); } catch (Exception ex) { log.Error(ex); } } }
/// <summary> /// Constructor : creates string array from entered string /// Working: Converts "Column1,Column2,Column3" to string[3] /// </summary> /// <param name="Columns_i"></param> public Table( string Columns_i ) { using (Log log = new Log("Glx.DB.Table::Table()")) { try { sColumns = Columns_i; Columns = Strings.Split(Columns_i, ",", -1, CompareMethod.Text); nColumnCount = Columns.Length; } catch (Exception ex) { log.Error(ex); } } }
private async Task StartApplication() { try { // NOTE: Service not yet recieve and process requests here await ApplicationContainer.Resolve <IStartupManager>().StartAsync(); HealthNotifier.Notify($"Env: {Program.EnvInfo} started"); } catch (Exception ex) { Log?.Error(nameof(StartApplication), ex); throw; } }
public ServerChannel(ServerChannelConfiguration configuration) { Log?.Verbose(className, className, "Constructor fired"); timer = new Timer(); timer.Interval = timerIntervalInSeconds * 1000; timer.Elapsed += Timer_Elapsed; timer.Start(); //ClientChannelManager = new ClientChannelManager(); if (configuration == null) { Log?.Error(className, className, "No configuration found"); Log?.Error(className, className, "Unable to to create proper Router Channel"); return; } this.configuration = configuration; }
public T GetProperty <T>(string name, Log log, T def, Func <string, T> convert) { var str = GetString(name, log); try { if (!string.IsNullOrEmpty(str)) { return(convert(GetString(name, log))); } } catch (Exception e) { log?.Error(GetSource(name), null, "Failed to parse $(" + name + "): " + e.Message); } return(def); }
/// <summary>服务管理线程封装</summary> /// <param name="data"></param> protected virtual void ManagerThreadWaper(Object data) { // 暂停一会,等待各个任务线程完全启动 Thread.Sleep(2 * 1000); while (true) { try { CheckActive(); // 如果某一项检查需要重启服务,则返回true,这里跳出循环,等待服务重启 if (CheckMemory()) { break; } if (CheckThread()) { break; } if (CheckHandle()) { break; } if (CheckAutoRestart()) { break; } // 检查看门狗 CheckWatchDog(); Thread.Sleep(10 * 1000); } catch (ThreadAbortException) { break; } catch (Exception ex) { //WriteLine(ex.ToString()); Log?.Error(ex.GetTrue()?.ToString()); } } }
/// <summary> /// Returns the index of a column by the statement: TableObject/"column_name" /// </summary> /// <param name="t"></param> /// <param name="sColumn"></param> /// <returns></returns> public static int operator /( Table t, string sColumn ) { using (Log log = new Log("Glx.DB.Table::/()")) { try { for (int nIndex = 0; nIndex < t.nColumnCount; nIndex++) if (String.Compare(sColumn, t.Columns[nIndex], true) == 0) return nIndex; } catch (Exception ex) { log.Error(ex); return -1; } } return -1; }
private async Task <bool> ExecuteJobAndContinue() { Log?.Info($"Start job \"{Name}\"."); try { await _jobInstance.Execute(); } catch (Exception ex) { if (StopOnError) { Log?.Error($"Job \"{Name}\" could not be executed, throwing an exception and stopped.", ex); return(false); } Log?.Error($"Job \"{Name}\" could not be executed, throwing an exception.", ex); } return(true); }
/// <summary>停止服务管理线程</summary> public void StopManagerThread() { var mt = ManagerThread; if (mt == null) { return; } if (mt.IsAlive) { try { mt.Abort(); } catch (Exception ex) { //WriteLine(ex.ToString()); Log?.Error(ex.GetTrue()?.ToString()); } } }
/// <summary> /// Load a dll file( AddIn file ) and get a user control named 'Icon' for Executing the AddIn /// </summary> /// <param name="sDllFileName"></param> /// <param name="sUserControlName"></param> /// <returns></returns> public static UserControl GetAddInIconFromDll(string sDllFileName) { using (Log log = new Log("Glx.Common.::GetAddInIconFromDll()")) { try { Assembly assembly = Assembly.LoadFile(@sDllFileName); object obj; Type myType = assembly.GetType("Glx.AddIn.Icon"); obj = Activator.CreateInstance(myType); UserControl userControl = (UserControl)obj; return userControl; } catch (Exception ex) { log.Error(ex); return null; } } }
public bool SendEmail(Email email) { string methoName = MethodBase.GetCurrentMethod().Name; bool isSent = false; try { using (MailMessage mail = new MailMessage()) { mail.Subject = email.Subject; mail.Body = email.Body; mail.From = new MailAddress(email.FromEmail, email.FromName); mail.IsBodyHtml = email.IsHtml; if (email.To == null) { email.To = new List <string> { email.FromEmail }; } if (email.To.Count == 0) { email.To.Add(email.FromEmail); } AddToEmailTo(mail, email.To); AddToEmailCC(mail, email.CC); AddToEmailBcc(mail, email.BCC); smtp.Send(mail); isSent = true; } } catch (Exception ex) { Log?.Error(className, methoName, ex.ToString()); isSent = false; } return(isSent); }
public async Task StopAsync() { string methodName = MethodBase.GetCurrentMethod().Name; try { DisconnectAllClientChannels(); if (boundChannel != null) { await boundChannel.CloseAsync(); await boundChannel.DisconnectAsync(); await boundChannel.DeregisterAsync(); if (!boundChannel.Open) { if (!boundChannel.Registered) { boundChannel = null; } } } if (bossGroup != null) { await Task.WhenAll(bossGroup.ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(1))); } if (workerGroup != null) { await Task.WhenAll(workerGroup.ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(1))); } } catch (Exception ex) { Log?.Error(className, methodName, ex.ToString()); } }
internal static uint parseSignedNumber(string val, int maxBitSize, int paramNo, Log log) { Match m = Regex.Match(val, @"^(?i:" + @"(?:0(?<1>x)(?<2>[0-9a-f]+))|" + // hex values 0x12AB @"(?:0(?<1>o)(?<2>[0-7]+))|" + // oct values 0o7564 @"(?:0(?<1>b)(?<2>[01]+))|" + // bin values 0b1101010 @"(?<2>-?(?<1>\d)\d*(?:E[+-]?\d+)?)" +//simple number with optional exponent(nnnExx, nnnE+xx, and nnnE-xx) //@"|(?:(?<1>@)(?<2>[a-z_][0-9a-z_]+))" + //labels @myLabel (removed: labels processed before parsing) @")$"); if (!m.Groups[2].Success) { log.Error("param {0}: unable to recognize constant '{1}'", paramNo, val); return 0; } char opType = m.Groups[1].Value[0]; string opVal = m.Groups[2].Value; if (opVal == "") log.Error("param {0}: compiler error 4360 '{1}'", paramNo, val); int num; if (opType > '0' && opType <= '9') num = Int32.Parse(opVal, NumberStyles.AllowLeadingSign | NumberStyles.AllowExponent); else // if (opType == 'x' || opType == 'o' || opType == 'b') num = Convert.ToInt32(opVal, (opType == 'x') ? 16 : (opType == 'o') ? 8 : 2); if (num > ((1 << maxBitSize - 1) - 1)) log.Error("param {0}: The value '{1}' will not fit in {2} bits", paramNo, val, maxBitSize); if (num < -(1 << maxBitSize)) log.Error("param {0}: The value '{1}' will not fit in {2} bits", paramNo, val, maxBitSize); int mask = ((1 << maxBitSize) - 1); return (uint)(num & mask); //returned as uint for b32 }
public static void Main(string[] args) { if (System.IO.File.Exists(AppDomain.CurrentDomain.BaseDirectory + "/settings.json")) { Configuration config = Configuration.LoadConfiguration(AppDomain.CurrentDomain.BaseDirectory + "/settings.json"); Log mainLog = new Log(config.MainLog, null); foreach (Configuration.BotInfo info in config.Bots) { mainLog.Info("Launching Bot " + info.DisplayName + "..."); new Thread(() => { int crashes = 0; while (crashes < 1000) { try { new Bot(info, config.ApiKey, (Bot bot, SteamID sid) => { return (SteamBot.UserHandler)System.Activator.CreateInstance(Type.GetType(info.BotControlClass), new object[] { bot, sid }); }); } catch (Exception e) { mainLog.Error("Error With Bot: " + e); crashes++; } } }).Start(); Thread.Sleep(5000); } MySQL.start(); } else { Console.WriteLine(AppDomain.CurrentDomain.BaseDirectory); Console.WriteLine("Configuration File Does not exist. Please rename 'settings-template.json' to 'settings.json' and modify the settings to match your environment"); } }
public static void Main(string[] args) { if (System.IO.File.Exists("settings.json")) { Configuration config = Configuration.LoadConfiguration("settings.json"); Log mainLog = new Log(config.MainLog, null); foreach (Configuration.BotInfo info in config.Bots) { mainLog.Info("Launching Bot " + info.DisplayName + "..."); new Thread(() => { int crashes = 0; while (crashes < 1000) { try { new Bot(info, config.ApiKey, (Bot bot, SteamID sid) => { return new SimpleUserHandler(bot, sid); }, true); } catch (Exception e) { mainLog.Error("Error With Bot: " + e); crashes++; } } }).Start(); Thread.Sleep(5000); } } else { Console.WriteLine("Configuration File Does not exist. Please rename 'settings-template.json' to 'settings.json' and modify the settings to match your environment"); } }
public static void ExitApplication(Application application, Log log) { const string prefix = "Application - Exit"; if (application != null) { log.Info(prefix, "Closing application."); try { application.Close(); if (application.Process.HasExited) { return; } application.Process.WaitForExit(Constants.ShutdownWaitTimeInMilliSeconds()); if (!application.Process.HasExited) { application.Kill(); } } catch (InvalidOperationException) { // Do nothing because the cause for this exception is when there is no process // associated with the application.Process object. } catch (Exception e) { log.Error( prefix, string.Format( CultureInfo.InvariantCulture, "Error trying to terminate application. Error was: {0}", e)); } } }
/// <summary> /// Insert data into table /// e.g. DDL.InsertInto("Sample", "col1,col2", "10,20"); /// </summary> /// <param name="sTableName"></param> /// <param name="sColumns_i"></param> /// <param name="sValues_i"></param> public static void InsertInto(string sTableName, string sColumns_i, string sValues_i ) { using( Log log = new Log( "Glx.DB.DDL.InsertInto()" ) ) { try { string sQuerry = "INSERT INTO " + sTableName + "("; string[] sColums = Strings.Split(sColumns_i, ",", -1, CompareMethod.Text); sQuerry = sQuerry + sColums[0]; for (int nIndex = 1; nIndex < sColums.Length; nIndex++) sQuerry = sQuerry + "," + sColums[nIndex]; sQuerry += ") VALUES("; string[] sValues = Strings.Split(sValues_i, ",", -1, CompareMethod.Text); sQuerry = sQuerry + sValues[0]; for (int nIndex = 1; nIndex < sValues.Length; nIndex++) sQuerry = sQuerry + "," + sValues[nIndex]; sQuerry += ")"; log.PutQuerry( sQuerry); DBWrapper.ExecuteNonQueryEx(sQuerry); } catch (Exception ex) { log.Error(ex); } } }
/// <summary> /// SOPK encoding format /// |ENCODING(4)-28|OP(5)-23|SDST(7)-16|SIMM16(int,16)-0| /// </summary> private static OpCode encodeSOPK(InstInfo instr, string options, Log log) { // Field beg end dataType size notes (from AMD ISA Manual) // SIMM16 0 15 int 16 // SDST 16 22 enum 7 Scalar destination for instruction. Same codes as for SIMM16, above, except that this can use only codes 0 to 127. 16-bit integer input for opcode. Signedness is determined by opcode. // OP 23 27 enum 5 Opcode. // ENCODING 28 31 enum 4 Must be 1 0 1 1. OpCode op_code = new OpCode { code = instr.opCode }; string[] args = Regex.Split(options, @"\s*[,\s]\s*"); if (args.Length < instr.opCtMin) { log.Error("{0} should have at least {1} argument(s).", instr.name, instr.opCtMin); return op_code; } else if (args.Length > instr.opCtMax) { log.Error("{0} should have no more then {1} argument(s).", instr.name, instr.opCtMax); return op_code; } uint immd = ParseOperand.parseSignedNumber(args[0], 16, 2, log); uint sdst = ParseOperand.parseOperand(args[1], OpType.SCALAR_DST, 1, log).reg; op_code.code |= (sdst << 16) | immd; return op_code; }
/// <summary> /// Primary entry point to setup a new algorithm /// </summary> /// <param name="algorithm">Algorithm instance</param> /// <param name="brokerage">New brokerage output instance</param> /// <param name="job">Algorithm job task</param> /// <param name="resultHandler">The configured result handler</param> /// <param name="transactionHandler">The configurated transaction handler</param> /// <param name="realTimeHandler">The configured real time handler</param> /// <returns>True on successfully setting up the algorithm state, or false on error.</returns> public bool Setup(IAlgorithm algorithm, IBrokerage brokerage, AlgorithmNodePacket job, IResultHandler resultHandler, ITransactionHandler transactionHandler, IRealTimeHandler realTimeHandler) { _algorithm = algorithm; // verify we were given the correct job packet type var liveJob = job as LiveNodePacket; if (liveJob == null) { AddInitializationError("BrokerageSetupHandler requires a LiveNodePacket"); return(false); } // verify the brokerage was specified if (string.IsNullOrWhiteSpace(liveJob.Brokerage)) { AddInitializationError("A brokerage must be specified"); return(false); } // attach to the message event to relay brokerage specific initialization messages EventHandler <BrokerageMessageEvent> brokerageOnMessage = (sender, args) => { if (args.Type == BrokerageMessageType.Error) { AddInitializationError(string.Format("Brokerage Error Code: {0} - {1}", args.Code, args.Message)); } }; try { Log.Trace("BrokerageSetupHandler.Setup(): Initializing algorithm..."); resultHandler.SendStatusUpdate(AlgorithmStatus.Initializing, "Initializing algorithm..."); //Execute the initialize code: var controls = job.Controls; var isolator = new Isolator(); var initializeComplete = isolator.ExecuteWithTimeLimit(TimeSpan.FromSeconds(300), () => { try { //Set the default brokerage model before initialize algorithm.SetBrokerageModel(_factory.BrokerageModel); //Set our parameters algorithm.SetParameters(job.Parameters); //Algorithm is live, not backtesting: algorithm.SetLiveMode(true); //Initialize the algorithm's starting date algorithm.SetDateTime(DateTime.UtcNow); //Set the source impl for the event scheduling algorithm.Schedule.SetEventSchedule(realTimeHandler); //Initialise the algorithm, get the required data: algorithm.Initialize(); if (liveJob.Brokerage != "PaperBrokerage") { //Zero the CashBook - we'll populate directly from brokerage foreach (var kvp in algorithm.Portfolio.CashBook) { kvp.Value.SetAmount(0); } } } catch (Exception err) { AddInitializationError(err.Message); } }); if (!initializeComplete) { AddInitializationError("Initialization timed out."); return(false); } // let the world know what we're doing since logging in can take a minute resultHandler.SendStatusUpdate(AlgorithmStatus.LoggingIn, "Logging into brokerage..."); brokerage.Message += brokerageOnMessage; algorithm.Transactions.SetOrderProcessor(transactionHandler); algorithm.PostInitialize(); Log.Trace("BrokerageSetupHandler.Setup(): Connecting to brokerage..."); try { // this can fail for various reasons, such as already being logged in somewhere else brokerage.Connect(); } catch (Exception err) { Log.Error(err); AddInitializationError(string.Format("Error connecting to brokerage: {0}. " + "This may be caused by incorrect login credentials or an unsupported account type.", err.Message)); return(false); } if (!brokerage.IsConnected) { // if we're reporting that we're not connected, bail AddInitializationError("Unable to connect to brokerage."); return(false); } Log.Trace("BrokerageSetupHandler.Setup(): Fetching cash balance from brokerage..."); try { // set the algorithm's cash balance for each currency var cashBalance = brokerage.GetCashBalance(); foreach (var cash in cashBalance) { Log.Trace("BrokerageSetupHandler.Setup(): Setting " + cash.Symbol + " cash to " + cash.Amount); algorithm.Portfolio.SetCash(cash.Symbol, cash.Amount, cash.ConversionRate); } } catch (Exception err) { Log.Error(err); AddInitializationError("Error getting cash balance from brokerage: " + err.Message); return(false); } Log.Trace("BrokerageSetupHandler.Setup(): Fetching open orders from brokerage..."); try { // populate the algorithm with the account's outstanding orders var openOrders = brokerage.GetOpenOrders(); foreach (var order in openOrders) { // be sure to assign order IDs such that we increment from the SecurityTransactionManager to avoid ID collisions Log.Trace("BrokerageSetupHandler.Setup(): Has open order: " + order.Symbol.ToString() + " - " + order.Quantity); order.Id = algorithm.Transactions.GetIncrementOrderId(); transactionHandler.Orders.AddOrUpdate(order.Id, order, (i, o) => order); } } catch (Exception err) { Log.Error(err); AddInitializationError("Error getting open orders from brokerage: " + err.Message); return(false); } Log.Trace("BrokerageSetupHandler.Setup(): Fetching holdings from brokerage..."); try { // populate the algorithm with the account's current holdings var holdings = brokerage.GetAccountHoldings(); var supportedSecurityTypes = new HashSet <SecurityType> { SecurityType.Equity, SecurityType.Forex, SecurityType.Cfd }; var minResolution = new Lazy <Resolution>(() => algorithm.Securities.Select(x => x.Value.Resolution).DefaultIfEmpty(Resolution.Second).Min()); foreach (var holding in holdings) { Log.Trace("BrokerageSetupHandler.Setup(): Has existing holding: " + holding); // verify existing holding security type if (!supportedSecurityTypes.Contains(holding.Type)) { Log.Error("BrokerageSetupHandler.Setup(): Unsupported security type: " + holding.Type + "-" + holding.Symbol.Value); AddInitializationError("Found unsupported security type in existing brokerage holdings: " + holding.Type + ". " + "QuantConnect currently supports the following security types: " + string.Join(",", supportedSecurityTypes)); // keep aggregating these errors continue; } if (!algorithm.Portfolio.ContainsKey(holding.Symbol)) { Log.Trace("BrokerageSetupHandler.Setup(): Adding unrequested security: " + holding.Symbol.ToString()); // for items not directly requested set leverage to 1 and at the min resolution algorithm.AddSecurity(holding.Type, holding.Symbol.Value, minResolution.Value, null, true, 1.0m, false); } algorithm.Portfolio[holding.Symbol].SetHoldings(holding.AveragePrice, (int)holding.Quantity); algorithm.Securities[holding.Symbol].SetMarketPrice(new TradeBar { Time = DateTime.Now, Open = holding.MarketPrice, High = holding.MarketPrice, Low = holding.MarketPrice, Close = holding.MarketPrice, Volume = 0, Symbol = holding.Symbol, DataType = MarketDataType.TradeBar }); } } catch (Exception err) { Log.Error(err); AddInitializationError("Error getting account holdings from brokerage: " + err.Message); return(false); } //Set the starting portfolio value for the strategy to calculate performance: StartingPortfolioValue = algorithm.Portfolio.TotalPortfolioValue; StartingDate = DateTime.Now; } catch (Exception err) { AddInitializationError(err.Message); } finally { if (brokerage != null) { brokerage.Message -= brokerageOnMessage; } } return(Errors.Count == 0); }
/// <summary> /// Retrieves the templates /// </summary> public async Task <List <TemplateViewModel> > GetTemplates() { try { using (var context = new WebAppContext()) { var email = ClaimsPrincipal.Current.FindFirst("http://schemas.xmlsoap.org/ws/2005/05/identity/claims/name").Value; var userGroups = ClaimsPrincipal.Current.FindAll("groups").Select(g => g.Value).ToList(); var adminUser = UserRoleHelper.AdminUserName; var graphGroups = await new GraphGroupController().GetGraphGroups(); var graphUsers = await new GraphUserController().GetGetGraphUsers(); graphGroups.AddRange(graphUsers.Select(user => new GraphGroupsViewModel() { ObjectId = user.UserPrincipalName, DisplayName = user.DisplayName })); var intersectGroups = (from gGroup in graphGroups from uGroup in userGroups where gGroup.ObjectId == uGroup select gGroup).ToList(); intersectGroups.Add(new GraphGroupsViewModel() { ObjectId = email, DisplayName = email }); intersectGroups.Add(new GraphGroupsViewModel() { ObjectId = "*", DisplayName = "Available to All" }); graphGroups.Add(new GraphGroupsViewModel() { ObjectId = email, DisplayName = email }); graphGroups.Add(new GraphGroupsViewModel() { ObjectId = "*", DisplayName = "Available to All" }); var templates = await context.TemplateJsons.ToListAsync(); var result = new List <TemplateViewModel>(); if (email == adminUser) { foreach (var template in templates) { var uGroups = template.TemplateUsersGroup.Split(','); template.TemplateUsersGroup = GetInlineGroups(uGroups, graphGroups); result.Add(template); } } else { foreach (var template in templates) { var uGroups = template.TemplateUsersGroup.Split(','); var intersectResult = GetInlineGroups(uGroups, intersectGroups); if (intersectResult.Length > 0) { var groups = GetInlineGroups(uGroups, graphGroups); template.TemplateUsersGroup = groups; result.Add(template); } } } return(result); } } catch (Exception exception) { Log.Error(exception); return(new List <TemplateViewModel>()); } }
/// <summary> /// DS encoding format /// |ENCODE(6)-26|--OP(8)-18--|GDS(1)-17|reserved(1)-16|OFFSET1(8)-8|OFFSET0(8)-0| /// |VDST(8)-56|DATA1(8)-48|DATA0(8)-40|ADDR(8)-32| /// </summary> private static OpCode encodeDS(InstInfo instr, string options, Log log) { string[] args = Regex.Split(options, @"\s*[,\s]\s*"); OpCode op_code = new OpCode{code = instr.opCode}; if (instr.name == "ds_nop") { if (args.Length > 1 || args[0] != "") log.Warning("ds_nop does not support any options"); op_code.code = instr.opCode; op_code.literal = 0; return op_code; } if (args.Length < 4) { log.Error("number of passed operands is too low"); return op_code; } // Setup arguments string vdst_str = args[0]; string addr_str = args[1]; string data0_str= args[2]; string data1_str= args[3]; // Parse optional parameters for (int i = 4; i < args.Length; i++) { if (args[i]== "gds") op_code.code |= (1 << 17); else if (args[i].StartsWith("offset")) { Match m = Regex.Match(args[i], @"offset(0|1):([0-9a-fxo]+)$"); uint val = 0; if (m.Success) val = ParseOperand.parseUnSignedNumber(m.Groups[2].Value, 16, i, log); //hack: sometimes this is 8 bits(not 16) else log.Error("incorrect offset format - example OFFSET0:123"); op_code.code |= val << (m.Groups[1].Value == "0" ? 0 : 8); } } uint vdst_val = ParseOperand.parseOnlyVGPR(vdst_str, 1, log); uint addr_op = ParseOperand.parseOnlyVGPR(addr_str, 2, log); uint data0_op = ParseOperand.parseOnlyVGPR(data0_str, 3, log); uint data1_op = ParseOperand.parseOnlyVGPR(data1_str, 4, log); op_code.literal = addr_op | data0_op << 8 | data1_op << 16 | vdst_val << 24; return op_code; }
private static uint processOModFromRegEx(Match m, Log log) { uint val = 0; if (m.Groups["omod"].Success) { if (!m.Groups["omod"].Value.Contains(".")) log.Warning("omod or mul arguments should use a period(.) in the number to show it is float"); if (Regex.Match(m.Groups["omod"].Value, "^4.?0*$").Success) val |= 1 << 58; else if (Regex.Match(m.Groups["omod"].Value, "^2.?0*$").Success) val |= 2 << 58; else if (Regex.Match(m.Groups["omod"].Value, "^0?.50*$").Success) val |= 3 << 58; else log.Error("unknown omod format, valid examples: omod:2.0, omod:4.0, omod:0.5 " +"mul(2.0) mul(4.0) mul(0.5) or mul=2.0 mul=4.0 mul=0.5"); } return val; }
/// <summary> /// VOP1 encoding format /// |ENCODE(7)-25|VDST(8)-17|OP(8)-9|SRC0(9)-0| /// </summary> private static OpCode encodeVOP1(InstInfo instr, string options, Log log) { OpCode op_code = new OpCode { code = instr.opCode }; string[] args = Regex.Split(options, @"\s*[,\s]\s*"); if (args.Length < instr.opCtMin) { log.Error("{0} should have at least {1} argument(s).", instr.name, instr.opCtMin); return op_code; } if (args.Length > instr.opCtMax) { log.Error("{0} should have no more then {1} argument(s).", instr.name, instr.opCtMax); return op_code; } uint vdst; OpInfo vsrc0; if (instr.name == "v_readfirstlane_b32") { vdst = ParseOperand.parseOnlySGPR(args[0], 1, log); vsrc0 = ParseOperand.parseOperand(args[1], OpType.VGPR | OpType.LDS_DIRECT, 2, log); } else { vdst = ParseOperand.parseOnlyVGPR(args[0], 1, log); vsrc0 = ParseOperand.parseOperand(args[1], OpType.ALL, 2, log); if (vsrc0.flags.HasFlag(OpType.LITERAL)) op_code.literal = vsrc0.value; } op_code.code |= (vdst << 17) | vsrc0.reg; return op_code; }
/// <summary> /// VOP2 encoding format /// |Encode(1)-31|OP(6)-25|VDST(8)-17|VSRC1(8)-9|SRC0(9)-0| /// </summary> private static OpCode encodeVOP2(InstInfo instr, string options, Log log) { OpCode op_code = new OpCode { code = instr.opCode }; string[] args = Regex.Split(options, @"\s*[,\s]\s*"); int argCt = args.Length; if (argCt < 3) { log.Error("{0} should have at least {1} argument(s).", instr.name, instr.opCtMin); return op_code; } // handle "vcc" destination in VOP2. example: v_add_a32 v0, vcc, v1, v2 if (instr.OpNum.IsBetween<uint>(36, 43)) if (args[1] == "vcc") { for (int i = 2; i < args.Length; i++) args[i - 1] = args[i]; argCt--; } else log.Warning("{0} should specify VCC as output param for clarity.", instr.name); if (argCt > instr.opCtMax) { log.Error("{0} should have no more then {1} argument(s).", instr.name, instr.opCtMax); return op_code; } uint vdst, vsrc1; OpInfo vsrc0; if (instr.name == "v_readlane_b32") { vdst = ParseOperand.parseOnlySGPR(args[0], 1, log, OpType.SCALAR_DST); vsrc0 = ParseOperand.parseOperand(args[1], OpType.VGPR | OpType.LDS_DIRECT | OpType.M0, 2, log); vsrc1 = ParseOperand.parseOperand(args[2], OpType.SGPR | OpType.LDS_DIRECT | OpType.M0 | OpType.INLINE, 3, log).reg; } else if (instr.name == "v_writelane_b32") { vdst = ParseOperand.parseOnlyVGPR(args[0], 1, log); vsrc0 = ParseOperand.parseOperand(args[1], OpType.SGPR | OpType.M0 | OpType.EXEC | OpType.CONST, 2, log); vsrc1 = ParseOperand.parseOperand(args[2], OpType.SGPR | OpType.M0 | OpType.INLINE, 3, log).reg; } else { vdst = ParseOperand.parseOnlyVGPR(args[0], 1, log); vsrc0 = ParseOperand.parseOperand(args[1], OpType.ALL, 2, log); if (vsrc0.flags.HasFlag(OpType.LITERAL)) op_code.literal = vsrc0.value; vsrc1 = ParseOperand.parseOnlyVGPR(args[2], 2, log); } op_code.code |= (vdst << 17) | (vsrc1 << 9) | vsrc0.reg; return op_code; }
/// <summary> /// SOPP encoding format /// |ENCODING(9)-23|OP(7)-16|SIMM16(int,16)-0| /// </summary> private static OpCode encodeSOPP(InstInfo instr, string options, Log log) { if (instr.name == "s_waitcnt") { uint VMCt= 0x0F/*0-15*/, LGKMCt= 0x0F/*0-15*/, EXPCt= 0x07/*0-7*/; //string regex = @"(?:(?:"+ //@"vm_?(?:ct|cnt|count)=?\(?(?<vm>\d+)\)?|"+ //vmcnt(#),vm_ct(#), vm_count(#) vmcount(#)... //@"lgkm_?(?:ct|cnt|count)=?\((?<lgkm>\d+)\)|" + //vmcnt=#,vm_ct=#, vm_count=# vmcount=#... //@"exp_?(?:ct|cnt|count)=?\((?<exp>\d+)\)|" + //@")\s*,?\s*)+"; MatchCollection matches = Regex.Matches(options, @"(vm|lgkm|exp)_?(?:ct|cnt|count)=?\(?(\d+)\)?"); foreach (Match m in matches) { string type = m.Groups[1].Value; uint val = uint.Parse(m.Groups[2].Value); switch (type) { case "lgkm": LGKMCt = val; if (LGKMCt > 31) log.Warning("LGKM_CNT must be between 0 and 15."); break; case "vm": VMCt = val; if (VMCt > 15) log.Warning("VM_CNT must be between 0 and 15."); break; case "exp": EXPCt = val; if (EXPCt > 7) log.Warning("EXPCt must be between 0 and 7."); break; } } return new OpCode { code = instr.opCode | VMCt | (LGKMCt<<8) | (EXPCt<<4) }; } uint immd = 0; // can be signed or un-signed if (options == "") { if (instr.opCtMin > 0) { log.Error("{0} expected argument(s).", instr.name); return (new OpCode { code = instr.opCode }); } } else { string[] args = Regex.Split(options, @"\s*[,\s]\s*"); if (args.Length != instr.opCtMax) { log.Error("{0} should have {1} argument(s).", instr.name, instr.opCtMax, instr.opCtMax); return (new OpCode { code = instr.opCode}); } immd = ParseOperand.parseSignedNumber(args[0], 16, 1, log); } if ((immd & 0xffff0000) != 0) log.Error("The immediate value seems to use more then 16 bits."); return new OpCode { code = instr.opCode | immd }; }
/// <summary> /// VINTRP encoding format /// ENCODING(6)-26|VDST(8)-18|OP(2)-16|ATTR(6)-10|ATTRCHAN(2)-8|VSRC(8)-0| /// </summary> private static OpCode encodeVINTRP(InstInfo instr, string options, Log log) { // Field beg end dataType size notes (from AMD ISA Manual) // VSRC 0 7 enum 8 Vector General-Purpose Registers (VGPR) containing the i/j coordinate by which to multiply one of the parameter components. // ATTRCHAN 8 9 enum 2 Attribute component to interpolate. See Section 10.1 on page 10-1. // ATTR 10 15 int 6 Attribute to interpolate. // OP 16 17 enum 2 0:V_INTERP_P1_F32: D = P10 * S + P0; parameter interpolation. 1:V_INTERP_P2_F32: D = P20 * S + D; parameter interpolation. 2: V_INTERP_MOV_F32: D = {P10,P20,P0}[S]; parameter load. 3: reserved. // VDST 18 25 enum 8 Vector General-Purpose Registers (VGPR 0-255) to which results are written, and, optionally, from which they are read when accumulating results. // ENCODING 26 31 enum 6 Must be 1 1 0 0 1 0. string attrchanString = "0"; uint vdst = 0, vsrc = 0, attr = 0, attrchan = 0; if (instr.name == "v_interp_mov_f32") { Match m = Regex.Match(options, @"v(\d+)\s*[,\s]\s*(p?)(\d+)\s*[,\s]\s*" + // first two opps @"(?:attr(\d+)\.([xyzw0123])|" + // for v_interp_mov_f32 v0, p0, attr0.z format @"(?<5>\d+)\s*[,\s]\s*(?<4>\d+)\s*[,\s]\s*\[\s*m0\s*\])"); // for v_interp_mov_f32 v0, p0, 3, 0, [m0] format if (!m.Success) log.Error("v_interp_mov_f32 should be in the format 'v1, p20, attr0.x' or 'v1, p20, 0, 0, [m0]'."); else { vdst = uint.Parse(m.Groups[1].Value); vsrc = uint.Parse(m.Groups[3].Value); attr = uint.Parse(m.Groups[4].Value); attrchanString = m.Groups[5].Value; if (m.Groups[2].Value == "p") { if (vsrc == 10) vsrc = 0; else if (vsrc == 20) vsrc = 1; else if (vsrc == 0) vsrc = 2; } if (vsrc > 2) log.Error("v_interp_mov_f32 p should be p10,p20,p0 or 0,1,2)"); } } else if (instr.name == "v_interp_p1_f32") { Match m = Regex.Match(options, @"v(\d+)\s*[,\s]\s*(v)(\d+)\s*[,\s]\s*" + // first two opps @"(?:attr(\d+)\.([xyzw0123])|" + // for v_interp_p1_f32 v0, p0, attr0.z format @"(?<5>\d+)\s*[,\s]\s*(?<4>\d+)\s*[,\s]\s*\[\s*m0\s*\])"); // for v_interp_p1_f32 v0, v0, 3, 0, [m0] format if (!m.Success) log.Error("v_interp_p1_f32 should be in the format 'v2, v4, attr0.x' or 'v2, v4, 0, 0, [m0]'."); else { vdst = uint.Parse(m.Groups[1].Value); vsrc = uint.Parse(m.Groups[3].Value); attr = uint.Parse(m.Groups[4].Value); attrchanString = m.Groups[5].Value; if (vsrc > 255) log.Error("v_interp_p1_f32 vsrc should be less then 256."); } } else if (instr.name == "v_interp_p2_f32") { Match m = Regex.Match(options, @"v(\d+)\s*[,\s]\s*(?:\[v(\d+)\]\s*[,\s]\s*)?v(\d+)\s*[,\s]\s*" + // first two opps @"(?:attr(\d+)\.([xyzw0123])|" + // for v_interp_p2_f32 v0, p0, attr0.z format @"(?<5>\d+)\s*[,\s]\s*(?<4>\d+)\s*[,\s]\s*\[\s*m0\s*\])"); // for v_interp_p2_f32 v0, v0, 3, 0, [m0] format if (!m.Success) log.Error("v_interp_p2_f32 should be in the format 'v2, [v2], v4, attr0.x' or 'v2, v4, 0, 0, [m0]'."); else { vdst = uint.Parse(m.Groups[1].Value); vsrc = uint.Parse(m.Groups[3].Value); attr = uint.Parse(m.Groups[4].Value); attrchanString = m.Groups[5].Value; if (vsrc > 255) log.Error("v_interp_p2_f32 vsrc should be less then 256."); } if (m.Groups[2].Success) if (m.Groups[1].Value != m.Groups[2].Value) log.Error("The first two vector register numbers do not match. (i.e. v_interp_p2_f32 v7 [v7]..."); } if (attrchanString == "x") attrchan = 0; else if (attrchanString == "y") attrchan = 1; else if (attrchanString == "z") attrchan = 2; else if (attrchanString == "w") attrchan = 3; else attrchan = uint.Parse(attrchanString); if (vdst > 255) { log.Error("{0} vdst should be less then 256.", instr.name); vdst = 0; } if (attr > 31) { log.Error("{0} attr should be 0 to 31.", instr.name); attr = 0; } if (attrchan > 3) { log.Error("{0} attrchan should be x,y,z,w or 0,1,2,3)", instr.name); attrchan = 0; } return new OpCode { code = instr.opCode | (vdst << 18) | (attr << 10) | (attrchan << 8) | vsrc }; }
public override async Task UpdateBalanceAsync( CancellationToken cancellationToken = default) { var fa2 = FA2; var txs = (await DataRepository .GetTransactionsAsync(Currency, fa2.TransactionType) .ConfigureAwait(false)) .Cast <TezosTransaction>() .ToList(); var internalTxs = txs.Aggregate(new List <TezosTransaction>(), (list, tx) => { if (tx.InternalTxs != null) { list.AddRange(tx.InternalTxs); } return(list); }); // calculate balances var totalBalanceSum = 0m; var totalUnconfirmedIncome = 0m; var totalUnconfirmedOutcome = 0m; var addresses = new Dictionary <string, WalletAddress>(); foreach (var tx in txs.Concat(internalTxs)) { var selfAddresses = new HashSet <string>(); var isFromSelf = await IsSelfAddressAsync(tx.From, cancellationToken) .ConfigureAwait(false); //if (tx.Type.HasFlag(BlockchainTransactionType.Output)) if (isFromSelf) { selfAddresses.Add(tx.From); } var isToSelf = await IsSelfAddressAsync(tx.To, cancellationToken) .ConfigureAwait(false); //if (tx.Type.HasFlag(BlockchainTransactionType.Input)) if (isToSelf) { selfAddresses.Add(tx.To); } foreach (var address in selfAddresses) { var isIncome = address == tx.To; var isOutcome = address == tx.From; var isConfirmed = tx.IsConfirmed; var isFailed = tx.State == BlockchainTransactionState.Failed; var income = isIncome && !isFailed ? tx.Amount.FromTokenDigits(fa2.DigitsMultiplier) : 0; var outcome = isOutcome && !isFailed ? -tx.Amount.FromTokenDigits(fa2.DigitsMultiplier) : 0; if (addresses.TryGetValue(address, out var walletAddress)) { walletAddress.Balance += isConfirmed ? income + outcome : 0; walletAddress.UnconfirmedIncome += !isConfirmed ? income : 0; walletAddress.UnconfirmedOutcome += !isConfirmed ? outcome : 0; } else { walletAddress = await DataRepository .GetWalletAddressAsync(Currency, address) .ConfigureAwait(false); if (walletAddress == null) { continue; } walletAddress.Balance = isConfirmed ? income + outcome : 0; walletAddress.UnconfirmedIncome = !isConfirmed ? income : 0; walletAddress.UnconfirmedOutcome = !isConfirmed ? outcome : 0; walletAddress.HasActivity = true; addresses.Add(address, walletAddress); } totalBalanceSum += isConfirmed ? income + outcome : 0; totalUnconfirmedIncome += !isConfirmed ? income : 0; totalUnconfirmedOutcome += !isConfirmed ? outcome : 0; } } Balance = totalBalanceSum; var totalBalance = 0m; foreach (var wa in addresses.Values) { var fa2Api = fa2.BlockchainApi as ITokenBlockchainApi; var balanceResult = await fa2Api .TryGetTokenBigMapBalanceAsync( address : wa.Address, pointer : fa2.TokenPointerBalance, cancellationToken : cancellationToken) .ConfigureAwait(false); if (balanceResult.HasError) { Log.Error("Error while getting token balance for {@address} with code {@code} and description {@description}", wa.Address, balanceResult.Error.Code, balanceResult.Error.Description); continue; // todo: may be return? } wa.Balance = balanceResult.Value.FromTokenDigits(fa2.DigitsMultiplier); totalBalance += wa.Balance; } if (totalBalanceSum != totalBalance) { Log.Warning("Transaction balance sum is different from the actual {@name} token balance", fa2.Name); Balance = totalBalance; } // upsert addresses await DataRepository .UpsertAddressesAsync(addresses.Values) .ConfigureAwait(false); UnconfirmedIncome = totalUnconfirmedIncome; UnconfirmedOutcome = totalUnconfirmedOutcome; RaiseBalanceUpdated(new CurrencyEventArgs(Currency)); }
/// <summary> /// SOPC encoding format /// |ENCODING(9)-23|OP(7)-16|SSRC1(8)-8|SSRC0(8)-0| /// </summary> private static OpCode encodeSOPC(InstInfo instr, string options, Log log) { // Field beg end dataType size notes (from AMD ISA Manual) // SSRC0 0 7 enum 8 Source 0. First operand for the instruction. // SSRC1 8 15 enum 8 Source 1. Second operand for instruction. Same codes as for SSRC0, above. // OP 16 22 enum 7 // ENCODING 23 31 enum 9 Must be 1 0 1 1 1 1 1 1 0. string[] args = Regex.Split(options, @"\s*[,\s]\s*"); OpCode op_code = new OpCode { code = instr.opCode }; if (args.Length != 2) { log.Error("SOPC instructions should have 2 arguments."); return op_code; } // SSRC0 (argument 1) OpInfo ssrc0 = ParseOperand.parseOperand(args[0], OpType.SCALAR_SRC, 1, log); if (ssrc0.flags.HasFlag(OpType.LITERAL)) op_code.literal = ssrc0.value; // SSRC1 (argument 2) OpInfo ssrc1 = ParseOperand.parseOperand(args[1], OpType.SCALAR_SRC, 2, log); if (ssrc1.flags.HasFlag(OpType.LITERAL)) op_code.literal = ssrc1.value; if ((ssrc0.flags.HasFlag(OpType.LITERAL)) && (ssrc1.flags.HasFlag(OpType.LITERAL))) log.Error("cannot have two literals"); op_code.code |= (ssrc1.reg << 8) | ssrc0.reg; return op_code; }
/// <summary> /// SOP2 encoding format /// |ENCODING(2)-30|OP(7)-23|SDST(7)-16|SSRC1(8)-8|SSRC0(8)-0| /// </summary> private static OpCode encodeSOP2(InstInfo instr, string options, Log log) { // Field beg end dataType size notes (from AMD ISA Manual) // SSRC0 0 7 enum 8 Source 0. First operand for the instruction. // SSRC1 8 15 enum 8 Source 1. Second operand for instruction. // SDST 16 22 enum 7 Scalar destination for instruction. Same codes as for SSRC0, above, except that this can use only codes 0 to 127. // OP 23 29 enum 7 Opcode. // ENCODING 30 31 enum 2 Must be 1 0. string[] args = Regex.Split(options, @"\s*[,\s]\s*"); OpCode op_code = new OpCode { code = instr.opCode }; if (args.Length != 3) { log.Error("SOP2 instructions should have 3 arguments."); return op_code; } // SDST (argument 1) uint sdst_val = ParseOperand.parseOperand(args[0], OpType.SCALAR_DST, 1, log).value; // SSRC0 (argument 2) OpInfo ssrc0 = ParseOperand.parseOperand(args[1], OpType.SCALAR_SRC, 2, log); if (ssrc0.flags.HasFlag(OpType.LITERAL)) op_code.literal = ssrc0.value; // SSRC1 (argument 3) OpInfo ssrc1 = ParseOperand.parseOperand(args[2], OpType.SCALAR_SRC, 3, log); if (ssrc1.flags.HasFlag(OpType.LITERAL)) op_code.literal = ssrc1.value; if ((ssrc0.flags.HasFlag(OpType.LITERAL)) && (ssrc1.flags.HasFlag(OpType.LITERAL))) log.Error("cannot have two literals"); op_code.code |= (sdst_val << 16) | (ssrc1.reg << 8) | ssrc0.reg; return op_code; }
/// <summary> /// SOP1 encoding format /// |ENCODING(9)-23|SDST(7)-16|OP(8)-8|SSRC0(8)-0| /// </summary> private static OpCode encodeSOP1(InstInfo instr, string options, Log log) { // Field beg end dataType size notes (from AMD ISA Manual) // SSRC0 0 7 enum 8 Source 0. First operand for the instruction. // OP 8 15 enum 8 0 – 2 reserved. // SDST 16 22 enum 7 Scalar destination for instruction. Same codes as for SSRC0, above, except that this can use only codes 0 to 127. // ENCODING 23 31 enum 9 Must be 1 0 1 1 1 1 1 0 1. string[] args = Regex.Split(options, @"\s*,\s*"); int argCt = args.Length; if (argCt == 1) if (args[0] == "") argCt = 0; OpCode op_code = new OpCode { code = instr.opCode }; switch (instr.name) { case "s_setpc_b64": if (argCt != 1) { log.Error("s_setpc_b64 should have a jump destination only.(S reg or constant"); return op_code; } uint ssrc = ParseOperand.parseOperand(args[0], OpType.SCALAR_SRC, 1, log).value; return new OpCode { code = instr.opCode | ssrc }; case "s_getpc_b64": if (argCt != 1) { log.Error("s_getpc_b64 takes a 64-bit S reg only."); return op_code; } uint sdst = ParseOperand.parseOperand(args[0], OpType.SCALAR_DST, 1, log).value; return new OpCode { code = instr.opCode | (sdst << 16) }; case "s_rfe_b64": if (argCt == 0) log.Error("s_rfe_b64 does not take any params."); return op_code; case "s_cbranch_join": if (argCt != 1) { log.Error("s_cbranch_join only takes one argument.(the saved CSP value)"); return op_code; } uint ssrc2 = ParseOperand.parseOperand(args[0], OpType.SCALAR_SRC, 1, log).value; return new OpCode { code = instr.opCode | ssrc2 }; case "s_set_gpr_idx_idx": if (argCt != 1) { log.Error("s_set_gpr_idx_idx only takes one argument.(M0[7:0] = S0.U[7:0])"); return op_code; } uint ssrc3 = ParseOperand.parseOperand(args[0], OpType.SCALAR_SRC, 1, log).value; return new OpCode { code = instr.opCode | ssrc3 }; default: if (argCt != 2) { log.Error("SOP1 instructions should have 2 arguments."); return op_code; } // SDST (arg 1) - Destination for instruction. uint sDst = ParseOperand.parseOperand(args[0], OpType.SCALAR_DST, 1, log).value; // SSRC0 (arg 2) OpInfo ssrc0 = ParseOperand.parseOperand(args[1], OpType.SCALAR_SRC, 2, log); if (ssrc0.flags.HasFlag(OpType.LITERAL)) op_code.literal = ssrc0.value; op_code.code |= (sDst << 16) | ssrc0.reg; return op_code; } }
/// <summary> /// SMRD encoding format /// |ENCODING(5)-27|OP(5)-22|SDST(7)-15|SBASE(6)-9|IMM(1)-8|OFFSET(int,8)-0| /// </summary> private static OpCode encodeSMRD(InstInfo instr, string options, Log log) { // Field beg end dataType size notes (from AMD ISA Manual) // OFFSET 0 7 int 8 Unsigned eight-bit Dword offset to the address specified in SBASE. // IMM 8 8 enum 1 Boolean.[IMM = 0:Specifies an SGPR address that supplies a Dword offset for the memory operation (see enumeration)., IMM = 1:Specifies an 8-bit unsigned Dword offset.] // SBASE 9 14 enum 6 Bits [6:1] of an aligned pair of SGPRs specifying {size[15:0], base[47:0]}, where base and size are in Dword units. The low-order bits are in the first SGPR. // SDST 15 21 enum 7 Destination for instruction. // OP 22 26 enum 5 // ENCODING 27 31 enum 5 Must be 1 1 0 0 0. OpCode op_code = new OpCode { code = instr.opCode }; if (instr.name == "s_dcache_inv") return op_code; if (instr.name == "s_memtime") { uint sgpr = ParseOperand.parseOnlySGPR(options, 0, log, OpType.SGPR); return (new OpCode { code = instr.opCode | (sgpr << 15) | (1 << 7)}); } string[] args = Regex.Split(options, @"\s*[,\s]\s*"); if ((args.Length < 2) | (args.Length > 4)) log.Error("S_Load/S_Buffer should contain 2 to 4 arguments."); // SDST (argument 0) - Destination for instruction. uint sdst_val = ParseOperand.parseOperand(args[0], OpType.SGPR | OpType.VCC | OpType.TRAP | OpType.M0 | OpType.EXEC, 1, log).value; // SBASE (argument 1) - Specifies the SGPR-pair that holds the base byte-address for the fetch. uint sbase_op = ParseOperand.parseOperand(args[1], OpType.SGPR | OpType.VCC | OpType.TRAP | OpType.M0 | OpType.EXEC, 2, log).reg; if ((sbase_op & 0x01) > 0) log.Error("S_Load/S_Buffer must contain an even reg number for the SBASE."); // OFFSET (argument 2) - Either holds a ubyte offset or points to a SGPR that contains a byte offset (inline constants not allowed) if (args.Length > 2) // if we don't have an offset then lets not set anything (leave zero) { OpInfo offset = ParseOperand.parseOperand(args[2], OpType.SCALAR_SRC, 3, log); if ((offset.dataDisc & DataDesc.NEGITIVE) != 0) log.Error("offset cannot be negative because it is unsigned"); if (DataDesc.UINT.HasFlag(offset.dataDisc)) { // if larger then 256 then use literal value if (offset.value < 256) op_code.code |= (1 << 8) | offset.value; else { op_code.code |= 255; op_code.literal = offset.value; } } else op_code.code |= offset.reg; } op_code.code |= (sdst_val << 15) | ((sbase_op >> 1) << 9); return op_code; }