public void Configure(IApplicationBuilder app, IHostingEnvironment env) { app.Use(async(context, next) => { try { await next.Invoke(); } catch (Exception e) { SentrySdk.CaptureException(e); _logger.Error(e); throw; } }); #if DEBUG app.UseDeveloperExceptionPage(); #endif var dir = new DirectoryInfo(Path.Combine(ServerSettings.ApplicationPath, "webui")); if (!dir.Exists) { dir.Create(); var backup = new DirectoryInfo(Path.Combine(Path.GetDirectoryName(Assembly.GetEntryAssembly().Location), "webui")); if (backup.Exists) { CopyFilesRecursively(backup, dir); } } app.UseStaticFiles(new StaticFileOptions { FileProvider = new WebUiFileProvider(dir.FullName), RequestPath = "/webui", ServeUnknownFileTypes = true }); app.UseSwagger(); app.UseSwaggerUI( options => { // build a swagger endpoint for each discovered API version var provider = app.ApplicationServices.GetRequiredService <IApiVersionDescriptionProvider>(); foreach (var description in provider.ApiVersionDescriptions) { options.SwaggerEndpoint($"/swagger/{description.GroupName}/swagger.json", description.GroupName.ToUpperInvariant()); } }); // Important for first run at least app.UseAuthentication(); app.UseSignalR(conf => { conf.MapHub <EventsHub>("/signalr/events"); conf.MapHub <LoggingHub>("/signalr/logging"); }); app.UseCors(options => options.AllowAnyOrigin().AllowAnyMethod().AllowAnyHeader()); app.UseMvc(); }
private static void Main() { //"The underlying connection was closed: An unexpected error occurred on a send." error fix ServicePointManager.SecurityProtocol |= SecurityProtocolType.Tls11 | SecurityProtocolType.Tls12; Console.WriteLine($"CONFIG {{ MachineName: {MachineName}, SentryEnabled: {SentryEnabled}, SuccessMessages: {SuccessMessages} }}"); using (SentryEnabled ? SentrySdk.Init(ConfigurationManager.AppSettings["SentryDSN"]) : null) { if (SentryEnabled) { SentrySdk.ConfigureScope(scope => { scope.SetTag("Environment.MachineName", System.Environment.MachineName); scope.SetTag("BackupDir", ConfigurationManager.AppSettings["BackupDir"]); scope.SetTag("ExcludedDBs", ConfigurationManager.AppSettings["ExcludedDBs"]); }); } var timer = Stopwatch.StartNew(); #region Settings var backupSet = DateTime.Now.ToString("yyyy.MM.dd-HH.mm.ss"); var tempDir = Path.GetTempPath() + backupSet + "\\"; var backupDir = ConfigurationManager.AppSettings["BackupDir"]; var tempZip = $"{tempDir}{backupSet}.zip"; var backupZip = $"{backupDir}{backupSet}.zip"; List <string> databasesToBackup = ConfigurationManager.AppSettings["DBs"].Split(';').ToList(); List <string> databasesToExclude = ConfigurationManager.AppSettings["ExcludedDBs"].Split(';').ToList(); #endregion try { #region Create backup dir if (!Directory.Exists(backupDir)) { Directory.CreateDirectory(backupDir); Console.WriteLine($"Created backup dir: {backupDir}"); } #endregion #region Create temporary backup dir if (!Directory.Exists(tempDir)) { Directory.CreateDirectory(tempDir); Console.WriteLine($"Created temporary dir: {tempDir}"); } var secInfo = Directory.GetAccessControl(tempDir); secInfo.AddAccessRule( new FileSystemAccessRule( new SecurityIdentifier(WellKnownSidType.WorldSid, null), FileSystemRights.Modify | FileSystemRights.Synchronize, InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit, PropagationFlags.None, AccessControlType.Allow ) ); Directory.SetAccessControl(tempDir, secInfo); Console.WriteLine($"Set permissions for dir: {tempDir} @ Everyone"); #endregion #region Backup specified databases using (var cnn = new SqlConnection(ConfigurationManager.ConnectionStrings["default"].ConnectionString)) { cnn.Open(); using (var cmd = new SqlCommand("", cnn)) { if (databasesToBackup.Contains("*")) { cmd.CommandText = "SELECT Name FROM sys.databases;"; using (var rdr = cmd.ExecuteReader()) { databasesToBackup.Clear(); while (rdr.Read()) { var dbName = rdr["Name"].ToString(); if (!databasesToExclude.Contains(dbName)) { databasesToBackup.Add(dbName); } } } } foreach (var database in databasesToBackup.Where(database => database.Length > 0)) { Console.WriteLine($"BACKUP DATABASE [{database}]"); cmd.CommandText = $"BACKUP DATABASE [{database}] TO DISK = '{tempDir}{database}.bak' WITH FORMAT;"; cmd.ExecuteNonQuery(); } if (SentryEnabled) { SentrySdk.ConfigureScope(scope => { scope.SetTag("DBsToBackup", string.Join(";", databasesToBackup)); }); } } } #endregion #region Zip backup set to tempDir and move to backupDir using (var zip = new ZipFile()) { Console.WriteLine($"Compressing backup set to: {tempZip}"); zip.AddDirectory(tempDir); zip.Save(tempZip); } File.Copy(tempZip, backupZip, true); #endregion timer.Stop(); var elapsedMs = timer.ElapsedMilliseconds; decimal elapsedS = (decimal)elapsedMs / 1000; var message = $"SQL DB backup on '{MachineName}' completed successfully in {elapsedS.ToString("0.00")}s!"; if (SuccessMessages && SentryEnabled) { SentrySdk.CaptureMessage(message); } Console.WriteLine(message); } catch (Exception ex) { Console.ForegroundColor = ConsoleColor.Red; Console.WriteLine($"Error: {ex.Message}"); if (SentryEnabled) { SentrySdk.CaptureException(ex); } } finally { #region Remove temporary backup dir if (Directory.Exists(tempDir)) { Directory.Delete(tempDir, true); } #endregion } } }
public static void CaptureException(Exception e) { SentrySdk.CaptureException(e); Logger.LogCritical(e.Message); }
public Legalize(PKM pk, string version) { CancellationTokenSource cts = new CancellationTokenSource(10000); try { var al = new AutoLegality(pk, version, cts); if (al.OkayToRun) { PKM pkmn; Thread thread = new Thread(() => { al.LegalizePokemon(cts); }); thread.Start(); while (true) { if (cts.IsCancellationRequested) { thread.Interrupt(); pkmn = al.GetLegalPK(); break; } Thread.Sleep(100); } Success = al.Successful; Report = al.Report.Split('\n'); Ran = al.Ran; if (Success) { try { Pokemon = Convert.ToBase64String(pkmn.DecryptedBoxData); Species = new PokemonSummary(pkmn, GameInfo.Strings).Species; try { QR = Utils.GenerateQR(QRMessageUtil.GetMessage(pkmn)); } catch { QR = ""; } } catch { Pokemon = ""; Species = ""; Success = false; Ran = true; Report = new[] { "Stuck in legalization!" }; } } else { Pokemon = ""; } } else { Ran = false; Success = false; Report = new[] { "Could not run legalization!" }; } } catch (Exception e) { cts.Cancel(); if (SentrySdk.IsEnabled) { SentrySdk.ConfigureScope(scope => { scope.Contexts["pokemon"] = new { Version = version, Base64 = Convert.ToBase64String(pk.DecryptedBoxData) }; }); SentrySdk.CaptureException(e); } } }
/// <summary> /// Called when [file changed]. /// </summary> /// <param name="newline">The newline.</param> private void OnFileChanged(string newline) { if (string.IsNullOrEmpty(newline)) { return; } try { // TradeEvent need to be parse before whisper var tradeEvent = TradeEvent.TryParse(newline); if (tradeEvent != null) { this.IncomingOffer?.Invoke(this, tradeEvent); return; } var outgoingTradeEvent = OutgoingTradeEvent.TryParse(newline); if (outgoingTradeEvent != null) { this.OutgoingOffer?.Invoke(this, outgoingTradeEvent); return; } var levelUpEvent = PlayerLevelUpEvent.TryParse(newline); if (levelUpEvent != null) { this.PlayerLevelUp?.Invoke(this, levelUpEvent); return; } var whisperEvent = WhisperEvent.TryParse(newline); if (whisperEvent != null) { this.Whispered?.Invoke(this, whisperEvent); return; } var locationEvent = LocationChangedEvent.TryParse(newline); if (locationEvent != null) { Models.PoeApplicationContext.Location = locationEvent.Location; this.LocationChanged?.Invoke(this, locationEvent); return; } var afkEvent = AfkEvent.TryParse(newline); if (afkEvent != null) { if (Models.PoeApplicationContext.IsAfk != afkEvent.AfkEnable) { Models.PoeApplicationContext.IsAfk = afkEvent.AfkEnable; } this.AfkChanged?.Invoke(this, afkEvent); return; } var tradeAcceptedEvent = TradeAcceptedEvent.TryParse(newline); if (tradeAcceptedEvent != null) { this.TradeAccepted?.Invoke(this, tradeAcceptedEvent); return; } var monsterEvent = MonstersRemainEvent.TryParse(newline); if (monsterEvent != null) { this.RemainingMonsters?.Invoke(this, monsterEvent); return; } var playerJoinEvent = PlayerJoinedEvent.TryParse(newline); if (playerJoinEvent != null) { this.PlayerJoined?.Invoke(this, playerJoinEvent); return; } var playerLeftEvent = PlayerLeftEvent.TryParse(newline); if (playerLeftEvent != null) { this.PlayerLeft?.Invoke(this, playerLeftEvent); return; } Logger.Trace($"Not parsed: {newline}"); } catch (Exception ex) { var lineError = $"Line in error: {newline}"; var exception = new Exception(lineError, ex); Logger.Error(exception, exception.Message); #if !DEBUG SentrySdk.AddBreadcrumb(message: lineError, level: Sentry.Protocol.BreadcrumbLevel.Error); SentrySdk.CaptureException(ex); #endif } }
private async Task MessageReceived(SocketMessage messageParam) { // Don't process the command if it was a System Message var message = messageParam as SocketUserMessage; if (message == null) { return; } // Create a number to track where the prefix ends and the command begins var argPos = 0; // Determine if the message is a command, based on if it starts with '!' or a mention prefix if (!(message.HasStringPrefix(_state.Prefix, ref argPos) || message.HasMentionPrefix(_client.CurrentUser, ref argPos))) { return; } // Create a Command Context var context = new CommandContext(_client, message); // TODO: This only handles messages from servers, not DMs. Need to implement support for DMs. if (context.User is SocketGuildUser user) { // Other bots shouldn't be able to trigger commands if (user.IsBot) { return; } foreach (var role in user.Roles) { if (_state.BannedRoles.Contains(role.Name.ToLower())) { await context.Channel.SendMessageAsync($"Role \"{role.Name}\" is banned from using bot commands."); return; } } } else { return; } SentrySdk.WithScope(async sentryScope => { sentryScope.User = new User { Id = user.Id.ToString(), Username = $"{user.Username}#{user.DiscriminatorValue}" }; sentryScope.SetExtra("command", message.Content); sentryScope.SetExtra("message_channel", $"#{message.Channel.Name} ({message.Channel.Id})"); // Execute the command. (result does not indicate a return value, // rather an object stating if the command executed successfully) using (var serviceScope = _services.CreateScope()) { var result = await _commands.ExecuteAsync(context, argPos, serviceScope.ServiceProvider); if (result.IsSuccess) { return; } switch (result.Error) { case CommandError.Exception: if (result is ExecuteResult execResult) { await Console.Error.WriteLineAsync($"Error encountered when handling command {message}:"); await Console.Error.WriteLineAsync(execResult.Exception.ToString()); SentrySdk.CaptureException(execResult.Exception); } break; case CommandError.UnknownCommand: break; case CommandError.ParseFailed: await context.Channel.SendMessageAsync(result.ErrorReason); await Console.Error.WriteLineAsync($"Error: {result.ErrorReason}"); break; case CommandError.BadArgCount: await context.Channel.SendMessageAsync(result.ErrorReason); await Console.Error.WriteLineAsync($"Error: {result.ErrorReason}"); break; case CommandError.ObjectNotFound: await context.Channel.SendMessageAsync(result.ErrorReason); await Console.Error.WriteLineAsync($"Error: {result.ErrorReason}"); break; case CommandError.MultipleMatches: await context.Channel.SendMessageAsync(result.ErrorReason); await Console.Error.WriteLineAsync($"Error: {result.ErrorReason}"); break; case CommandError.UnmetPrecondition: await context.Channel.SendMessageAsync($"<@{message.Author.Id}>: {result.ErrorReason}"); break; case CommandError.Unsuccessful: await context.Channel.SendMessageAsync(result.ErrorReason); await Console.Error.WriteLineAsync($"Error: {result.ErrorReason}"); break; default: await Console.Error.WriteLineAsync($"Unknown result type: {result.Error}"); await Console.Error.WriteLineAsync($"Error: {result.ErrorReason}"); break; } if (Debugger.IsAttached) { Debugger.Break(); } } }); await _state.PersistState(); }
private static async Task Main() { // When the SDK is disabled, no callback is executed: await SentrySdk.ConfigureScopeAsync(async scope => { // Never executed: // This could be any async I/O operation, like a DB query await Task.Yield(); scope.SetExtra("Key", "Value"); }); // Enable the SDK using (SentrySdk.Init(o => { // Send stack trace for events that were not created from an exception // e.g: CaptureMessage, log.LogDebug, log.LogInformation ... o.AttachStacktrace = true; // Sentry won't consider code from namespace LibraryX.* as part of the app code and will hide it from the stacktrace by default // To see the lines from non `AppCode`, select `Full`. Will include non App code like System.*, Microsoft.* and LibraryX.* o.AddInAppExclude("LibraryX."); // Before excluding all prefixed 'LibraryX.', any stack trace from a type namespaced 'LibraryX.Core' will be considered InApp. o.AddInAppInclude("LibraryX.Core"); // Send personal identifiable information like the username logged on to the computer and machine name o.SendDefaultPii = true; // To enable event sampling, uncomment: // o.SampleRate = 0.5f; // Randomly drop (don't send to Sentry) half of events // Modifications to event before it goes out. Could replace the event altogether o.BeforeSend = @event => { // Drop an event altogether: if (@event.Tags.ContainsKey("SomeTag")) { return(null); } return(@event); }; // Allows inspecting and modifying, returning a new or simply rejecting (returning null) o.BeforeBreadcrumb = crumb => { // Don't add breadcrumbs with message containing: if (crumb.Message?.Contains("bad breadcrumb") == true) { return(null); } return(crumb); }; // Ignore exception by its type: o.AddExceptionFilterForType <XsltCompileException>(); // Configure the background worker which sends events to sentry: // Wait up to 5 seconds before shutdown while there are events to send. o.ShutdownTimeout = TimeSpan.FromSeconds(5); // Enable SDK logging with Debug level o.Debug = true; // To change the verbosity, use: // o.DiagnosticsLevel = SentryLevel.Info; // To use a custom logger: // o.DiagnosticLogger = ... // Using a proxy: o.HttpProxy = null; //new WebProxy("https://*****:*****@user{timestamp}.com"; SentrySdk.CaptureUserFeedback(new UserFeedback(eventId, email, "this is a sample user feedback", user)); var error = new Exception("Attempting to send this multiple times"); // Only the first capture will be sent to Sentry for (var i = 0; i < 3; i++) { // The SDK is able to detect duplicate events: // This is useful, for example, when multiple loggers log the same exception. Or exception is re-thrown and recaptured. SentrySdk.CaptureException(error); } var count = 10; for (var i = 0; i < count; i++) { const string msg = "{0} of {1} items we'll wait to flush to Sentry!"; SentrySdk.CaptureEvent(new SentryEvent { Message = new SentryMessage { Message = msg, Formatted = string.Format(msg, i, count) }, Level = SentryLevel.Debug }); } // Console output will show queue being flushed. Task completes then and timeout is never reached (you don't need to wait a day :) await SentrySdk.FlushAsync(TimeSpan.FromDays(1)); // ------------------------- // A custom made client, that could be registered with DI, // would get disposed by the container on app shutdown var evt = new SentryEvent(); evt.Message = "Starting new client"; evt.AddBreadcrumb("Breadcrumb directly to the event"); evt.User.Username = "******"; // Group all events with the following fingerprint: evt.SetFingerprint(new [] { "NewClientDebug" }); evt.Level = SentryLevel.Debug; SentrySdk.CaptureEvent(evt); // Using a different DSN: using (var adminClient = new SentryClient(new SentryOptions { Dsn = AdminDsn })) { // Make believe web framework middleware var middleware = new AdminPartMiddleware(adminClient, null); var request = new { Path = "/admin" }; // made up request middleware.Invoke(request); } // Dispose the client which flushes any queued events SentrySdk.CaptureException( new Exception("Error outside of the admin section: Goes to the default DSN")); } // On Dispose: SDK closed, events queued are flushed/sent to Sentry }
// Initialization code. Don't use any Avalonia, third-party APIs or any // SynchronizationContext-reliant code before AppMain is called: things aren't initialized // yet and stuff might break. public static async Task Main(string[] args) { var config = new LoggerConfiguration() .WriteTo.Sentry(o => { o.MinimumBreadcrumbLevel = Serilog.Events.LogEventLevel.Debug; o.MinimumEventLevel = Serilog.Events.LogEventLevel.Fatal; }) .WriteTo.File(PlatformUtils.CombineDataPath("application.log")) .WriteTo.Console(); config = !string.IsNullOrEmpty(Environment.GetEnvironmentVariable("VERBOSE")) ? config.MinimumLevel.Verbose() : config.MinimumLevel.Debug(); Log.Logger = config.CreateLogger(); System.Text.Encoding.RegisterProvider(System.Text.CodePagesEncodingProvider.Instance); Trace.Listeners.Add(new ConsoleTraceListener()); SentrySdk.Init(o => { o.Dsn = "https://[email protected]/5462682"; o.MaxBreadcrumbs = 120; o.SendDefaultPii = true; #if DEBUG o.Environment = "staging"; #else o.Environment = "production"; #endif o.BeforeSend = sentryEvent => { try { sentryEvent.SetTag("arch", System.Runtime.InteropServices.RuntimeInformation.ProcessArchitecture.ToString()); sentryEvent.SetTag("bluetooth-mac", SettingsProvider.Instance.RegisteredDevice.MacAddress); sentryEvent.SetTag("sw-version", DeviceMessageCache.Instance.DebugGetAllData?.SoftwareVersion ?? "null"); sentryEvent.SetExtra("arch", System.Runtime.InteropServices.RuntimeInformation.ProcessArchitecture.ToString()); sentryEvent.SetExtra("bluetooth-mac", SettingsProvider.Instance.RegisteredDevice.MacAddress); sentryEvent.SetExtra("bluetooth-model-saved", SettingsProvider.Instance.RegisteredDevice.Model); sentryEvent.SetExtra("custom-locale", SettingsProvider.Instance.Locale); sentryEvent.SetExtra("sw-version", DeviceMessageCache.Instance.DebugGetAllData?.SoftwareVersion ?? "null"); sentryEvent.SetExtra("current-page", MainWindow.Instance.Pager.CurrentPage); sentryEvent.SetTag("bluetooth-model", BluetoothImpl.Instance.ActiveModel.ToString()); sentryEvent.SetExtra("bluetooth-model", BluetoothImpl.Instance.ActiveModel); sentryEvent.SetExtra("bluetooth-connected", BluetoothImpl.Instance.IsConnected); } catch (Exception ex) { sentryEvent.SetExtra("beforesend-error", ex); Log.Error("Sentry.BeforeSend: Error while adding attachments: " + ex.Message); } return(sentryEvent); }; }); /* Fix Avalonia font issue */ if (PlatformUtils.IsLinux) { try { Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US"); Thread.CurrentThread.CurrentUICulture = new CultureInfo("en-US"); } catch (CultureNotFoundException ex) { Log.Warning("Startup: Culture en-US unavailable. Falling back to C. " + ex); Thread.CurrentThread.CurrentCulture = new CultureInfo("C"); Thread.CurrentThread.CurrentUICulture = new CultureInfo("C"); } } try { await SingleInstanceWatcher.Setup(); BuildAvaloniaApp().StartWithClassicDesktopLifetime(args, ShutdownMode.OnExplicitShutdown); } catch (Exception ex) { SentrySdk.CaptureException(ex); Log.Error(ex.ToString()); } }
/// <summary> /// Download main Vndb Data /// </summary> /// <param name="gameId"></param> /// <param name="isRepairing"></param> /// <returns></returns> public async Task GetDataAsync(int gameId, bool isRepairing) { uint vnId = (uint)gameId; try { const int max = 100; const int countWithTagTrait = 9; const int countWithoutTagTrait = 7; double increment; if (isRepairing || !App.DidDownloadTagTraitDump) { increment = (double)max / countWithTagTrait; } else { increment = (double)max / countWithoutTagTrait; } using (var client = new VndbSharp.Vndb(true)) { RootViewModel.StatusBarPage.IsWorking = true; RootViewModel.StatusBarPage.StatusString = App.ResMan.GetString("Working"); double current = increment; RootViewModel.StatusBarPage.IsProgressBarVisible = true; RootViewModel.StatusBarPage.ProgressBarValue = 0; RootViewModel.StatusBarPage.IsProgressBarInfinite = false; RequestOptions ro = new RequestOptions { Count = 25 }; stopwatch.Start(); RootViewModel.StatusBarPage.InfoText = App.ResMan.GetString("DownVnInfo"); var visualNovel = await GetVisualNovelAsync(client, vnId); current += increment; RootViewModel.StatusBarPage.ProgressBarValue = current; RootViewModel.StatusBarPage.InfoText = App.ResMan.GetString("DownCharacterInfo"); var characters = await GetCharactersAsync(client, vnId, ro); current += increment; RootViewModel.StatusBarPage.ProgressBarValue = current; stopwatch.Stop(); stopwatch.Reset(); if (_didErrorOccur) { App.Logger.Error("Failed to get all of the Vndb Info from the API, one of the items was null"); //stop the progressbar here, and force it to show an error icon RootViewModel.StatusBarPage.IsWorking = false; RootViewModel.StatusBarPage.InfoText = ""; } else { //run code to add info to database await SaveVnDataToDb.SortVnInfoAsync(visualNovel, characters, increment, current, isRepairing); } } } catch (Exception ex) { App.Logger.Error(ex, "An error occurred when trying to get the vndb data from the API"); SentrySdk.CaptureException(ex); StatusBarViewModel.ResetValues(); throw; } }
/// <summary> /// Checks data from import table, then updates the import db /// <see cref="ImportDataAsync"/> /// </summary> /// <returns></returns> public async Task ImportDataAsync() { try { var entryCount = UserDataGamesCollection.Count; var goodEntries = new List <UserDataGames>(); if (entryCount < 1) { return; } for (int i = 0; i < entryCount; i++) { var entry = UserDataGamesCollection.First(); entry.ClearAllErrors(); var result = await _validator.ValidateAsync(entry); if (result.Errors.Count > 0) { var error = result.Errors.First(); entry.SetError(error.PropertyName, error.ErrorMessage); _windowManager.ShowMessageBox(App.ResMan.GetString("ValidationFailedRecheck"), App.ResMan.GetString("ValidationFailed")); return; } var goodEntry = new UserDataGames() { Index = entry.Index, Categories = entry.Categories, Title = entry.Title, SourceType = entry.SourceType, IconPath = entry.IconPath, GameId = entry.GameId, Arguments = entry.Arguments, CoverPath = entry.CoverPath, ExePath = entry.ExePath, ExeType = entry.ExeType, GameName = entry.GameName, Id = entry.Id, LastPlayed = entry.LastPlayed, PlayTime = entry.PlayTime }; goodEntries.Add(goodEntry); UserDataGamesCollection.RemoveAt(0); UserDataGamesCollection.Refresh(); } var cred = CredentialManager.GetCredentials(App.CredDb); if (cred == null || cred.UserName.Length < 1) { return; } var dbString = $"Filename={Path.Combine(App.ConfigDirPath, @"database\Import.db")};Password={App.ImportExportDbKey}"; using (var db = new LiteDatabase(dbString)) { var userGames = db.GetCollection <UserDataGames>(DbUserData.UserData_Games.ToString()); userGames.DeleteAll(); userGames.InsertBulk(goodEntries); db.Rebuild(new RebuildOptions { Password = cred.Password }); } File.Delete(Path.Combine(App.ConfigDirPath, App.DbPath)); File.Move(Path.Combine(App.ConfigDirPath, @"database\Import.db"), Path.Combine(App.ConfigDirPath, App.DbPath)); if (File.Exists(@$ "{App.AssetDirPath}\Images.zip")) { ZipFile.ExtractToDirectory(@$ "{App.AssetDirPath}\Images.zip", @$ "{App.AssetDirPath}\sources"); File.Delete(@$ "{App.AssetDirPath}\Images.zip"); } if (File.Exists(@$ "{App.AssetDirPath}\Import.db")) { File.Delete(@$ "{App.AssetDirPath}\Import.db"); } _windowManager.ShowMessageBox(App.ResMan.GetString("UserDataImported"), App.ResMan.GetString("ImportComplete")); RequestClose(); } catch (Exception ex) { App.Logger.Error(ex, "Failed to import data"); SentrySdk.CaptureException(ex); throw; } }
public async Task Run( bool noMiner = false, [Option("app-protocol-version", new[] { 'V' }, Description = "App protocol version token")] string appProtocolVersionToken = null, [Option('G')] string genesisBlockPath = null, [Option('H')] string host = null, [Option('P')] ushort?port = null, [Option('D')] int minimumDifficulty = 5000000, [Option("private-key")] string privateKeyString = null, string storeType = null, string storePath = null, [Option("ice-server", new [] { 'I', })] string[] iceServerStrings = null, [Option("peer")] string[] peerStrings = null, [Option("trusted-app-protocol-version-signer", new[] { 'T' }, Description = "Trustworthy signers who claim new app protocol versions")] string[] trustedAppProtocolVersionSigners = null, bool rpcServer = false, string rpcListenHost = "0.0.0.0", int?rpcListenPort = null, [Option("graphql-server")] bool graphQLServer = false, [Option("graphql-host")] string graphQLHost = "0.0.0.0", [Option("graphql-port")] int?graphQLPort = null, [Option("libplanet-node")] bool libplanetNode = false, [Option("workers", Description = "Number of workers to use in Swarm")] int workers = 5, [Option( "confirmations", Description = "The number of required confirmations to recognize a block. 0 by default." )] int confirmations = 0, [Option( "max-transactions", Description = "The number of maximum transactions can be included in a single block. " + "Unlimited if the value is less then or equal to 0. 100 by default." )] int maximumTransactions = 100, [Option("strict-rendering", Description = "Flag to turn on validating action renderer.")] bool strictRendering = false, [Option("dev", Description = "Flag to turn on the dev mode. false by default.")] bool isDev = false, [Option( "dev.block-interval", Description = "The time interval between blocks. It's unit is milliseconds. Works only when dev mode is on. 10000 (ms) by default.")] int blockInterval = 10000, [Option( "dev.reorg-interval", Description = "The size of reorg interval. Works only when dev mode is on. 0 by default.")] int reorgInterval = 0, [Option(Description = "The log minimum level during headless execution. debug by default.")] string logMinimumLevel = "debug", [Option(Description = "The Cognito identity for AWS CloudWatch logging.")] string awsCognitoIdentity = null, [Option(Description = "The access key for AWS CloudWatch logging.")] string awsAccessKey = null, [Option(Description = "The secret key for AWS CloudWatch logging.")] string awsSecretKey = null, [Option(Description = "The AWS region for AWS CloudWatch (e.g., us-east-1, ap-northeast-2).")] string awsRegion = null ) { #if SENTRY || !DEBUG try { #endif // Setup logger. var loggerConf = new LoggerConfiguration() .WriteTo.Console(outputTemplate: LogTemplate) .ConfigureMinimumLevel(logMinimumLevel); #if SENTRY || !DEBUG loggerConf = loggerConf .WriteTo.Sentry(o => { o.InitializeSdk = false; }); #endif bool useBasicAwsCredentials = !(awsAccessKey is null) && !(awsSecretKey is null); bool useCognitoCredentials = !(awsCognitoIdentity is null); if (useBasicAwsCredentials && useCognitoCredentials) { const string message = "You must choose to use only one credential between basic credential " + "(i.e., --aws-access-key, --aws-secret-key) and " + "Cognito credential (i.e., --aws-cognito-identity)."; throw new CommandExitedException(message, -1); } if (useBasicAwsCredentials ^ useCognitoCredentials && !(awsRegion is null)) { var regionEndpoint = RegionEndpoint.GetBySystemName(awsRegion); AWSCredentials credentials = useCognitoCredentials ? (AWSCredentials) new CognitoAWSCredentials(awsCognitoIdentity, regionEndpoint) : (AWSCredentials) new BasicAWSCredentials(awsAccessKey, awsSecretKey); var guid = LoadAWSSinkGuid() ?? Guid.NewGuid(); StoreAWSSinkGuid(guid); var awsSink = new AWSSink( credentials, regionEndpoint, "9c-standalone-logs", guid.ToString()); loggerConf.WriteTo.Sink(awsSink); } Log.Logger = loggerConf.CreateLogger(); if (!graphQLServer && !libplanetNode) { throw new CommandExitedException( "Either --graphql-server or --libplanet-node must be present.", -1 ); } var tasks = new List <Task>(); try { IHostBuilder graphQLHostBuilder = Host.CreateDefaultBuilder(); var standaloneContext = new StandaloneContext { KeyStore = Web3KeyStore.DefaultKeyStore, }; if (graphQLServer) { var graphQLNodeServiceProperties = new GraphQLNodeServiceProperties { GraphQLServer = graphQLServer, GraphQLListenHost = graphQLHost, GraphQLListenPort = graphQLPort, }; var graphQLService = new GraphQLService(graphQLNodeServiceProperties); graphQLHostBuilder = graphQLService.Configure(graphQLHostBuilder, standaloneContext); tasks.Add(graphQLHostBuilder.RunConsoleAsync(Context.CancellationToken)); await WaitForGraphQLService(graphQLNodeServiceProperties, Context.CancellationToken); } if (appProtocolVersionToken is null) { throw new CommandExitedException( "--app-protocol-version must be present.", -1 ); } if (genesisBlockPath is null) { throw new CommandExitedException( "--genesis-block-path must be present.", -1 ); } RpcNodeServiceProperties?rpcProperties = null; var properties = NineChroniclesNodeServiceProperties .GenerateLibplanetNodeServiceProperties( appProtocolVersionToken, genesisBlockPath, host, port, minimumDifficulty, privateKeyString, storeType, storePath, 100, iceServerStrings, peerStrings, trustedAppProtocolVersionSigners, noMiner, workers: workers, confirmations: confirmations, maximumTransactions: maximumTransactions); if (rpcServer) { rpcProperties = NineChroniclesNodeServiceProperties .GenerateRpcNodeServiceProperties(rpcListenHost, rpcListenPort); properties.Render = true; } var nineChroniclesProperties = new NineChroniclesNodeServiceProperties() { Rpc = rpcProperties, Libplanet = properties }; NineChroniclesNodeService nineChroniclesNodeService = StandaloneServices.CreateHeadless( nineChroniclesProperties, standaloneContext, strictRendering: strictRendering, isDev: isDev, blockInterval: blockInterval, reorgInterval: reorgInterval); standaloneContext.NineChroniclesNodeService = nineChroniclesNodeService; if (libplanetNode) { if (!properties.NoMiner) { nineChroniclesNodeService.PrivateKey = properties.PrivateKey; nineChroniclesNodeService.StartMining(); } IHostBuilder nineChroniclesNodeHostBuilder = Host.CreateDefaultBuilder(); nineChroniclesNodeHostBuilder = nineChroniclesNodeService.Configure(nineChroniclesNodeHostBuilder); tasks.Add( nineChroniclesNodeHostBuilder.RunConsoleAsync(Context.CancellationToken)); } await Task.WhenAll(tasks); } catch (TaskCanceledException) { Log.Information("Terminated by the cancellation."); } catch (Exception e) { Log.Error(e, "Unexpected exception occurred during Run. {e}", e); } #if SENTRY || !DEBUG } catch (CommandExitedException) { throw; } catch (Exception exceptionToCapture) { SentrySdk.CaptureException(exceptionToCapture); throw; } #endif }