public bool Initialize(ILogger logger) { if (logger == null) { throw new ArgumentNullException("logger"); } bool success; this.conversionToolPath = GetExeToolPath(logger); if (this.conversionToolPath == null) { logger.LogWarning(Resources.CONV_WARN_FailToFindConversionTool); success = false; } else { Debug.Assert(File.Exists(this.conversionToolPath), "Expecting the code coverage exe to exist. Full name: " + this.conversionToolPath); logger.LogDebug(Resources.CONV_DIAG_CommandLineToolInfo, this.conversionToolPath); success = true; } return success; }
/// <summary> /// Registers the bundles. /// </summary> /// <param name="bundles">The bundles.</param> /// <param name="logger">The logger.</param> public static void RegisterBundles(BundleCollection bundles, ILogger logger) { logger.LogDebug("START: ModuleConfig.RegisterBundles"); try { logger.Indent(); logger.LogDebug("GetViewModules"); var vModules = MEFConfig.Container.GetExports<IViewModule>(); // process each module logger.LogDebug("Iterating ViewModules"); logger.Indent(); foreach (var module in vModules) { // get the non lazy module value var mod = module.Value; // as IViewModule; if (mod != null) { // add any bundles the module may need mod.RegisterBundles(bundles); } logger.LogDebug(mod.GetType().FullName); } logger.UnIndent(); } finally { logger.UnIndent(); logger.LogDebug("END: ModuleConfig.RegisterBundles"); } }
public const int DelayBetweenRetriesInMilliseconds = 499; // Period to wait between retries #region Public methods /// <summary> /// Attempts to load the analysis config from the specified directory. /// Will retry if the file is locked. /// </summary> /// <returns>The loaded configuration, or null if the file does not exist or could not be /// loaded e.g. due to being locked</returns> public static AnalysisConfig TryGetConfig(string configDir, ILogger logger) { if (logger == null) { throw new ArgumentNullException("logger"); } AnalysisConfig config = null; if (string.IsNullOrEmpty(configDir)) // not specified { return null; } string fullAnalysisPath = Path.Combine(configDir, FileConstants.ConfigFileName); logger.LogDebug(Resources.Shared_ReadingConfigFile, fullAnalysisPath); if (!File.Exists(fullAnalysisPath)) { logger.LogDebug(Resources.Shared_ConfigFileNotFound); return null; } bool succeeded = Utilities.Retry(MaxConfigRetryPeriodInMilliseconds, DelayBetweenRetriesInMilliseconds, logger, () => DoLoadConfig(fullAnalysisPath, logger, out config)); if (succeeded) { logger.LogDebug(Resources.Shared_ReadingConfigSucceeded, fullAnalysisPath); } else { logger.LogError(Resources.Shared_ReadingConfigFailed, fullAnalysisPath); } return config; }
private static LoggerVerbosity ComputeVerbosity(string sonarVerboseValue, string sonarLogValue, ILogger logger) { if (!String.IsNullOrWhiteSpace(sonarVerboseValue)) { if (sonarVerboseValue.Equals("true", StringComparison.Ordinal)) { logger.LogDebug(Resources.MSG_SonarVerboseWasSpecified, sonarVerboseValue, LoggerVerbosity.Debug); return LoggerVerbosity.Debug; } else if (sonarVerboseValue.Equals("false", StringComparison.Ordinal)) { logger.LogDebug(Resources.MSG_SonarVerboseWasSpecified, sonarVerboseValue, LoggerVerbosity.Info); return LoggerVerbosity.Info; } else { logger.LogWarning(Resources.WARN_SonarVerboseNotBool, sonarVerboseValue); } } if (!String.IsNullOrWhiteSpace(sonarLogValue)) { if (sonarLogValue.Split('|').Any(s => s.Equals(SonarLogDebugValue, StringComparison.Ordinal))) { logger.LogDebug(Resources.MSG_SonarLogLevelWasSpecified, sonarLogValue); return LoggerVerbosity.Debug; } } return DefaultLoggingVerbosity; }
public async Task HandleEvent(object evt, long?position) { var updateTask = GetUpdate(evt); var update = updateTask == NoOp ? null : await updateTask; if (update == null) { _log?.LogDebug("No handler for {Event}", evt.GetType().Name); return; } _log?.LogDebug("Projecting {Event}", evt); var task = update switch { OtherOperation <T> operation => operation.Task, CollectionOperation <T> col => col.Execute(Collection), UpdateOperation <T> upd => ExecuteUpdate(upd), _ => Task.CompletedTask }; await task; Task ExecuteUpdate(UpdateOperation <T> upd) => Collection.UpdateOneAsync( upd.Filter, upd.Update.Set(x => x.Position, position), new UpdateOptions { IsUpsert = true } ); }
public static List<string> FindWeaverConfigs(string solutionDirectoryPath, string projectDirectory, ILogger logger) { var files = new List<string>(); var fodyDirConfigFilePath = Path.Combine(AssemblyLocation.CurrentDirectory, "FodyWeavers.xml"); if (File.Exists(fodyDirConfigFilePath)) { files.Add(fodyDirConfigFilePath); logger.LogDebug(string.Format("Found path to weavers file '{0}'.", fodyDirConfigFilePath)); } var solutionConfigFilePath = Path.Combine(solutionDirectoryPath, "FodyWeavers.xml"); if (File.Exists(solutionConfigFilePath)) { files.Add(solutionConfigFilePath); logger.LogDebug(string.Format("Found path to weavers file '{0}'.", solutionConfigFilePath)); } var projectConfigFilePath = Path.Combine(projectDirectory, "FodyWeavers.xml"); if (File.Exists(projectConfigFilePath)) { files.Add(projectConfigFilePath); logger.LogDebug(string.Format("Found path to weavers file '{0}'.", projectConfigFilePath)); } if (files.Count == 0) { var pathsSearched = string.Join("', '", fodyDirConfigFilePath, solutionConfigFilePath, projectConfigFilePath); logger.LogDebug(string.Format("Could not find path to weavers file. Searched '{0}'.", pathsSearched)); } return files; }
/// <summary> /// Start the Application. /// </summary> protected void Application_Start() { System.Diagnostics.Trace.WriteLine("{0} :: Application Starting".FormatWith(DateTime.Now.ToString("HH:mm:ss.ff"))); // MEF will load all the modules from the specified path. // Currently this is just the normal bin folder as having them // anywhere else can cause problems for the views System.Diagnostics.Trace.WriteLine("{0} :: Initialising MEF".FormatWith(DateTime.Now.ToString("HH:mm:ss.ff"))); MEFConfig.RegisterMEF(this, Server.MapPath(@"~\bin\")); _logger = MEFConfig.Container.GetExport<ILogger>().Value; _settings = MEFConfig.Container.GetExport<ISettings>().Value; // once mef is configured we can check the database CheckDatabase(); _logger.Indent(); try { _logger.LogDebug("Configuring View Engine"); // Setup a custom view engine. // This knows how to deal with views in module folders. ViewEngines.Engines.Clear(); // WARNING!!! Helpers assume that JonesieViewEngine is the first index in the ViewEngines array!!! Changing this // will break a lot of things. ViewEngines.Engines.Add(new JonesieViewEngine(MEFConfig.Container.GetExports<IViewModule>())); // Just the usual MVC startup fluff AreaRegistration.RegisterAllAreas(); AuthConfig.RegisterAuth(_settings); WebApiConfig.Register(GlobalConfiguration.Configuration); FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters); // need to map the SignalR hub early RouteTable.Routes.MapHubs(); // register routes for service and view modules and bundles for view modules ModuleConfig.RegisterRoutes(RouteTable.Routes, GlobalConfiguration.Configuration.Routes, _logger); ModuleConfig.RegisterBundles(BundleTable.Bundles, _logger); // now that everything else is done we can tell the modules to go ahead and get ready ModuleConfig.InitialiseModules(_logger); // register the default routes and bundle after the modules RouteConfig.RegisterRoutes(RouteTable.Routes); BundleConfig.RegisterBundles(BundleTable.Bundles); // we need to do this early so we can use IsInRole for security trimming the menus _logger.LogDebug("Initialising Web Security"); WebSecurity.InitializeDatabaseConnection("DefaultConnection", "UserProfile", "UserId", "UserName", false); } finally { _logger.UnIndent(); } _logger.LogDebug("Application Started"); }
/// <summary> /// Builds and returns the download URLs for all code coverage reports for the specified build /// </summary> public IEnumerable<string> GetCodeCoverageReportUrls(string tfsUri, string buildUri, ILogger logger) { if (string.IsNullOrWhiteSpace(tfsUri)) { throw new ArgumentNullException("tfsUri"); } if (string.IsNullOrWhiteSpace(buildUri)) { throw new ArgumentNullException("buildUri"); } if (logger == null) { throw new ArgumentNullException("logger"); } List<string> urls = new List<string>(); logger.LogDebug(Resources.URL_DIAG_ConnectingToTfs); using (TfsTeamProjectCollection collection = TfsTeamProjectCollectionFactory.GetTeamProjectCollection(new Uri(tfsUri))) { IBuildServer buildServer = collection.GetService<IBuildServer>(); logger.LogDebug(Resources.URL_DIAG_FetchingBuildInfo); IBuildDetail build = buildServer.GetMinimalBuildDetails(new Uri(buildUri)); string projectName = build.TeamProject; logger.LogDebug(Resources.URL_DIAG_FetchingCoverageReportInfo); ITestManagementService tcm = collection.GetService<ITestManagementService>(); ITestManagementTeamProject testProject = tcm.GetTeamProject(projectName); // TODO: investigate further. It looks as if we might be requesting the coverage reports // before the service is able to provide them. // For the time being, we're retrying with a time out. IBuildCoverage[] coverages = null; Utilities.Retry(TimeoutInMs, RetryPeriodInMs, logger, () => { return TryGetCoverageInfo(testProject, buildUri, out coverages); }); foreach (IBuildCoverage coverage in coverages) { logger.LogDebug(Resources.URL_DIAG_CoverageReportInfo, coverage.Configuration.Id, coverage.Configuration.BuildPlatform, coverage.Configuration.BuildPlatform); string coverageFileUrl = CoverageReportUrlProvider.GetCoverageUri(build, coverage); Debug.WriteLine(coverageFileUrl); urls.Add(coverageFileUrl); } } logger.LogDebug(Resources.URL_DIAG_Finished); return urls; }
/// <summary> /// Add or updates arbitrary storage configuration for a tenant. /// </summary> /// <param name="tenantStore">The tenant store.</param> /// <param name="tenant">The tenant to enroll.</param> /// <param name="configurationItems">Configuration to add.</param> /// <param name="logger">Optional logger.</param> /// <returns>A task which completes when the configuration has been added.</returns> public static async Task AddOrUpdateStorageConfigurationAsync(this ITenantStore tenantStore, ITenant tenant, ConfigurationItem[] configurationItems, ILogger?logger = null) { if (tenant == null) { throw new ArgumentNullException(nameof(tenant)); } tenant.EnsureTenantIsOfType(MarainTenantType.Client); if (configurationItems == null) { throw new ArgumentNullException(nameof(configurationItems)); } logger?.LogDebug( "Add configuration for tenant '{tenantName}' with Id '{tenantId}'", tenant.Name, tenant.Id); configurationItems.ValidateAndThrow(); IEnumerable <KeyValuePair <string, object> > propertiesToAddToTenant = PropertyBagValues.Empty; foreach (ConfigurationItem configurationItem in configurationItems) { logger?.LogDebug( "Adding configuration entry to tenant '{tenantName}' with Id '{tenantId}'", tenant.Name, tenant.Id); propertiesToAddToTenant = configurationItem.AddConfiguration(propertiesToAddToTenant); } logger?.LogDebug( "Updating tenant '{tenantName}' with Id '{tenantId}'", tenant.Name, tenant.Id); tenant = await tenantStore.UpdateTenantAsync( tenant.Id, propertiesToSetOrAdd : propertiesToAddToTenant) .ConfigureAwait(false); logger?.LogInformation( "Successfully added configuration to tenant '{tenantName}' with Id '{tenantId}'", tenant.Name, tenant.Id); }
private static bool TryCreateRuleset(ISonarQubeServer server, TeamBuildSettings settings, string projectKey, ILogger logger) { logger.LogDebug(Resources.SLAP_FetchingSonarLintRuleset); string rulesetContent; string parametersContent; if (TryGetProfileExportForProject(server, projectKey, logger, out rulesetContent, out parametersContent)) { if (IsValidRuleset(rulesetContent)) { string ruleSetFilePath = GetRulesetFilePath(settings); logger.LogDebug(Resources.SLAP_SonarLintRulesetCreated, ruleSetFilePath); File.WriteAllText(ruleSetFilePath, rulesetContent); string parametersFilePath = GetParametersFilePath(settings); logger.LogDebug(Resources.SLAP_SonarLintParametersCreated, parametersFilePath); File.WriteAllText(parametersFilePath, parametersContent); return true; } else { logger.LogError(Resources.SLAP_InvalidRulesetReturned); } } return false; }
public async Task HandleEvent(object evt, long?position) { var updateTask = GetUpdate(evt); var update = updateTask == NoOp ? null : await updateTask; if (update == null) { _log?.LogDebug("No handler for {Event}", evt.GetType().Name); return; } update.Update.Set(x => x.Position, position); _log?.LogDebug("Projecting {Event}", evt); await _collection.UpdateOneAsync(update.Filter, update.Update, new UpdateOptions { IsUpsert = true }); }
public BundleService(IApplicationEnvironment appEnvironment, ILogger<BundleService> logger) { _appEnvironment = appEnvironment; _logger = logger; _logger.LogDebug("Application base path: \"{0}\"", _appEnvironment.ApplicationBasePath); _logger.LogInformation("BundleService created"); }
public RequestPathAuthenticationPolicy(WebsiteSettings settings, ILogger logger) { _settings = settings; _logger = logger; var ignoredFilesSetting = _settings.AnonymousAccessFileExtensions; if (ignoredFilesSetting.IsEmpty()) { _logger.LogDebug("Whitelisting authentication for default file extensions: {0}", DefaultExtensionWhiteList); ignoredFilesSetting = DefaultExtensionWhiteList; } else { _logger.LogDebug("Whitelisting authentication for file extensions from settings : {0}", ignoredFilesSetting); } _whiteListExtensions = new HashSet<string>(GetWhiteListedExtensions(ignoredFilesSetting), StringComparer.OrdinalIgnoreCase); }
/// <summary> /// Sets up the client to run the SonarLint analyzer as part of the build /// i.e. creates the Rolsyn ruleset and provisions the analyzer assemblies /// </summary> public static void SetupAnalyzers(ISonarQubeServer server, TeamBuildSettings settings, string projectKey, ILogger logger) { if (server == null) { throw new ArgumentNullException("server"); } if (settings == null) { throw new ArgumentNullException("settings"); } if (string.IsNullOrWhiteSpace(projectKey)) { throw new ArgumentNullException("projectKey"); } if (logger == null) { throw new ArgumentNullException("logger"); } if (IsCSharpPluginInstalled(server)) { if (TryCreateRuleset(server, settings, projectKey, logger)) { FetchBinaries(server, settings, logger); } } else { logger.LogDebug(Resources.SLAP_CSharpPluginNotInstalled); } }
private void OnBasicReturn(object?model, BasicReturnEventArgs args) { if (_logTraceEnabled) { _logger?.LogDebug( "BasicReturn: {ReplyCode}-{ReplyText} {MessageId}", args.ReplyCode, args.ReplyText, args.BasicProperties.MessageId ); } if (args.BasicProperties != null && args.BasicProperties.Headers.TryGetValue("publishTag", out var value) && value is byte[] bytes) { if (!ulong.TryParse(Encoding.UTF8.GetString(bytes), out var id)) { return; } if (_publishTasks.TryRemove(id, out var published)) { _logger?.LogWarning("returned! with {PublishTag}", id); published.PublishReturned(args.ReplyCode, args.ReplyText); } } }
private static void CopyIfDifferent(string sourcePath, IEnumerable<string> destinationDirs, ILogger logger) { string sourceContent = GetReadOnlyFileContent(sourcePath); string fileName = Path.GetFileName(sourcePath); foreach (string destinationDir in destinationDirs) { string destinationPath = Path.Combine(destinationDir, fileName); if (!File.Exists(destinationPath)) { Directory.CreateDirectory(destinationDir); // creates all the directories in the path if needed File.Copy(sourcePath, destinationPath, overwrite: false); logger.LogDebug(Resources.MSG_InstallTargets_Copy, fileName, destinationDir); } else { string destinationContent = GetReadOnlyFileContent(destinationPath); if (!String.Equals(sourceContent, destinationContent, StringComparison.Ordinal)) { File.Copy(sourcePath, destinationPath, overwrite: true); logger.LogDebug(Resources.MSG_InstallTargets_Overwrite, fileName, destinationDir); } else { logger.LogDebug(Resources.MSG_InstallTargets_UpToDate, fileName, destinationDir); } } } }
/// <summary> /// Gets a zip file containing the pre/post processors from the server /// </summary> /// <param name="hostUrl">The server Url</param> public bool TryUpdate(string hostUrl, string targetDir, ILogger logger) { if (string.IsNullOrWhiteSpace(hostUrl)) { throw new ArgumentNullException("hostUrl"); } if (string.IsNullOrWhiteSpace(targetDir)) { throw new ArgumentNullException("targetDir"); } if (logger == null) { throw new ArgumentNullException("logger"); } string integrationUrl = GetDownloadZipUrl(hostUrl); string downloadedZipFilePath = Path.Combine(targetDir, BootstrapperSettings.SonarQubeIntegrationFilename); // SONARMSBRU-169 Support TLS versions 1.0, 1.1 and 1.2 ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12 | SecurityProtocolType.Tls11 | SecurityProtocolType.Tls; using (WebClient client = new WebClient()) { try { logger.LogDebug(Resources.MSG_DownloadingZip, BootstrapperSettings.SonarQubeIntegrationFilename, integrationUrl, downloadedZipFilePath); client.DownloadFile(integrationUrl, downloadedZipFilePath); } catch (WebException ex) { if (Utilities.HandleHostUrlWebException(ex, hostUrl, logger)) { return false; } logger.LogError(Resources.ERROR_FailedToUpdateRunnerBinaries, ex); return false; } logger.LogDebug(Resources.MSG_ExtractingFiles, targetDir); ZipFile.ExtractToDirectory(downloadedZipFilePath, targetDir); return true; } }
/// <summary> /// Ensures that the specified directory exists and is empty /// </summary> public static void EnsureEmptyDirectory(string directory, ILogger logger) { if (string.IsNullOrWhiteSpace(directory)) { throw new ArgumentNullException("directory"); } if (logger == null) { throw new ArgumentNullException("logger"); } if (Directory.Exists(directory)) { logger.LogDebug(Resources.MSG_DeletingDirectory, directory); Directory.Delete(directory, true); } logger.LogDebug(Resources.MSG_CreatingDirectory, directory); Directory.CreateDirectory(directory); }
/// <summary> /// Retries the specified operation until the specified timeout period expires /// </summary> /// <param name="logger"></param> /// <param name="op">The operation to perform. Should return true if the operation succeeded, otherwise false.</param> /// <returns>True if the operation succeed, otherwise false</returns> public static bool Retry(int timeoutInMilliseconds, int pauseBetweenTriesInMilliseconds, ILogger logger, Func<bool> op) { if(timeoutInMilliseconds < 1) { throw new ArgumentOutOfRangeException("timeoutInMilliseconds"); } if (pauseBetweenTriesInMilliseconds < 1) { throw new ArgumentOutOfRangeException("pauseBetweenTriesInMilliseconds"); } if (logger == null) { throw new ArgumentNullException("logger"); } if (op == null) { throw new ArgumentNullException("op"); } logger.LogDebug(Resources.MSG_BeginningRetry, timeoutInMilliseconds, pauseBetweenTriesInMilliseconds); Stopwatch timer = Stopwatch.StartNew(); bool succeeded = op(); while (!succeeded && timer.ElapsedMilliseconds < timeoutInMilliseconds) { logger.LogDebug(Resources.MSG_RetryingOperation); System.Threading.Thread.Sleep(pauseBetweenTriesInMilliseconds); succeeded = op(); } timer.Stop(); if (succeeded) { logger.LogDebug(Resources.MSG_RetryOperationSucceeded, timer.ElapsedMilliseconds); } else { logger.LogDebug(Resources.MSG_RetryOperationFailed, timer.ElapsedMilliseconds); } return succeeded; }
/// <summary> /// Starts the hosted service and initializes the consumer or producer by either setting up the consumption of /// messages or by starting the producer's message queueing functionality. /// /// For details on the default implementations of consumers and producers, see <see cref="RabbitMqConsumer{T}"/> /// and <see cref="RabbitMqProducer{T}"/>. /// </summary> /// <param name="cancellationToken"/> /// <returns/> public virtual Task StartAsync(CancellationToken cancellationToken) { Debug.Assert( _isProperlyInitialized, $"This {nameof(RabbitMqService<T>)} instance should have been created through a call to " + $"{nameof(RabbitMqService<T>)}.{nameof(Create)}."); _logger?.LogInformation($"RabbitMqService {_rmqConfig.Id} is starting."); if (Bus.IsConnected) { _logger?.LogDebug($"Connected to RabbitMQ with configuration {_rmqConfig.Id}."); } Bus.Connected += (sender, args) => _logger?.LogDebug($"Connected to RabbitMQ with configuration {_rmqConfig.Id}."); Bus.Disconnected += (sender, args) => _logger?.LogDebug($"Disconnected from RabbitMQ with configuration {_rmqConfig.Id}."); // run the setup callbacks on connection if (Bus.IsConnected) { _onConnected.ForEach(callback => HandleCallbackError(callback)(Bus, _rmqConfig, cancellationToken, _logger)); } _onConnected.ForEach(callback => Bus.Connected += (sender, args) => HandleCallbackError(callback)(Bus, _rmqConfig, cancellationToken, _logger)); if (_isConsumer) { InitializeConsumer(cancellationToken); } else { InitializeProducer(cancellationToken); } return(Task.CompletedTask); }
protected override void OnEventWritten(EventWrittenEventArgs eventData) { base.OnEventWritten(eventData); if (!IsHttpEventSource(eventData.EventSource)) { return; } string message; lock (_messageBuilder) { _messageBuilder.Append("<- Event "); _messageBuilder.Append(eventData.EventSource.Name); _messageBuilder.Append(" - "); _messageBuilder.Append(eventData.EventName); _messageBuilder.Append(" : "); #if !NET472 _messageBuilder.AppendJoin(',', eventData.Payload !); #else _messageBuilder.Append(string.Join(",", eventData.Payload !.ToArray())); #endif _messageBuilder.Append(" ->"); message = _messageBuilder.ToString(); _messageBuilder.Clear(); } // We don't know the state of the logger after dispose. // Ensure that any messages written in the background aren't // logged after the listener has been disposed in the test. lock (_lock) { if (!_disposed) { // EventListener base constructor subscribes to events. // It is possible to start getting events before the // super constructor is run and logger is assigned. _logger?.LogDebug(message); } } }
/// <summary> /// Creates a new tenant representing a Marain service that tenants can enroll to use. /// </summary> /// <param name="tenantStore">The tenant store.</param> /// <param name="manifest"> /// The manifest for the service. The service name in the manifest must be unique across all service tenants. /// </param> /// <param name="logger">Optional logger.</param> /// <returns>The new tenant.</returns> public static async Task <ITenant> CreateServiceTenantAsync(this ITenantStore tenantStore, ServiceManifest manifest, ILogger?logger = null) { if (manifest == null) { throw new ArgumentNullException(nameof(manifest)); } logger?.LogDebug("Validating service manifest for service creation."); await manifest.ValidateAndThrowAsync(tenantStore).ConfigureAwait(false); ITenant parent = await tenantStore.GetServiceTenantParentAsync().ConfigureAwait(false); logger?.LogDebug( "Creating new service tenant '{serviceName}' with well-known GUID '{wellKnownGuid}'", manifest.ServiceName, manifest.WellKnownTenantGuid); ITenant newTenant = await tenantStore.CreateWellKnownChildTenantAsync( parent.Id, manifest.WellKnownTenantGuid, manifest.ServiceName).ConfigureAwait(false); logger?.LogDebug( "New service tenant '{serviceName}' created with Id '{tenantId}'; updating tenant type and manifest.", newTenant.Name, newTenant.Id); IEnumerable <KeyValuePair <string, object> > properties = PropertyBagValues.Build(p => p .AddServiceManifest(manifest) .AddMarainTenantType(MarainTenantType.Service)); await tenantStore.UpdateTenantAsync( newTenant.Id, propertiesToSetOrAdd : properties).ConfigureAwait(false); logger?.LogInformation( "Created new service tenant '{serviceName}' with Id '{tenantId}'.", newTenant.Name, newTenant.Id); return(newTenant); }
public /* for test */ static ProjectInfoAnalysisResult GenerateFile(AnalysisConfig config, ILogger logger, IRoslynV1SarifFixer fixer) { if (config == null) { throw new ArgumentNullException("config"); } if (logger == null) { throw new ArgumentNullException("logger"); } string fileName = Path.Combine(config.SonarOutputDir, ProjectPropertiesFileName); logger.LogDebug(Resources.MSG_GeneratingProjectProperties, fileName); IEnumerable<ProjectInfo> projects = ProjectLoader.LoadFrom(config.SonarOutputDir); if (projects == null || !projects.Any()) { logger.LogError(Resources.ERR_NoProjectInfoFilesFound); return new ProjectInfoAnalysisResult(); } FixSarifReport(logger, projects, fixer); PropertiesWriter writer = new PropertiesWriter(config); ProjectInfoAnalysisResult result = ProcessProjectInfoFiles(projects, writer, logger); IEnumerable<ProjectInfo> validProjects = result.GetProjectsByStatus(ProjectInfoValidity.Valid); if (validProjects.Any()) { // Handle global settings AnalysisProperties properties = GetAnalysisPropertiesToWrite(config, logger); writer.WriteGlobalSettings(properties); string contents = writer.Flush(); result.FullPropertiesFilePath = fileName; File.WriteAllText(result.FullPropertiesFilePath, contents, Encoding.ASCII); } else { // if the user tries to build multiple configurations at once there will be duplicate projects if (result.GetProjectsByStatus(ProjectInfoValidity.DuplicateGuid).Any()) { logger.LogError(Resources.ERR_NoValidButDuplicateProjects); } else { logger.LogError(Resources.ERR_NoValidProjectInfoFiles); } } return result; }
public async Task <string?> TryGetEncryptedSeed() { if (!File.Exists(SeedFilePath)) { return(null); } _logger?.LogDebug($"reading seed from {SeedFilePath}"); var encryptedSeed = await File.ReadAllTextAsync(SeedFilePath); return(string.IsNullOrEmpty(encryptedSeed) ? null : encryptedSeed); }
public static void ExecuteAndVerifyResult(this Process process, ILogger logger, ResultExpectation resultExpectation = ResultExpectation.MustNotFail) { Guard.That(process).IsNotNull(); Guard.That(resultExpectation).IsValidValue(); Guard.That(logger).IsNotNull(); logger.LogDebug("Running process \"{0}\"", process.Options.CommandLine); ProcessResult result = process.Run(); VerifyProcessRan(process, result); VerifyExitCode(process, result, resultExpectation, logger); }
public async Task PullImageAsync(string imageName, string tag, CancellationToken cancellationToken = default) { var images = await _dockerClient.Images.ListImagesAsync( new ImagesListParameters { All = true, Filters = new Dictionary <string, IDictionary <string, bool> > { ["reference"] = new Dictionary <string, bool> { [$"{imageName}:{tag}"] = true } } }, cancellationToken); if (!images.Any()) { _logger?.LogInformation($"Pulling the image {imageName}:{tag}"); // Pull the image. try { await _dockerClient.Images.CreateImageAsync( new ImagesCreateParameters { FromImage = imageName, Tag = tag }, null, new Progress <JSONMessage>(m => _logger?.LogDebug($"Pulling image {imageName}:{tag}:\n{m.ProgressMessage}")), cancellationToken); } catch (Exception exc) { _logger?.LogError(exc, $"Unable to pull the image {imageName}:{tag}"); throw; } } }
/// <summary> /// Creates a new tenant representing a client, using a well known Guid. /// </summary> /// <param name="tenantStore">The tenant store.</param> /// <param name="wellKnownGuid">The well known Guid to use when creating the tenant.</param> /// <param name="clientName">The name of the new tenant.</param> /// <param name="parentId">Optional ID of parent Client tenant.</param> /// <param name="logger">Optional logger.</param> /// <returns>The new tenant.</returns> public static async Task <ITenant> CreateClientTenantWithWellKnownGuidAsync(this ITenantStore tenantStore, Guid wellKnownGuid, string clientName, string?parentId = null, ILogger?logger = null) { if (string.IsNullOrWhiteSpace(clientName)) { throw new ArgumentException(nameof(clientName)); } ITenant parent; if (!string.IsNullOrEmpty(parentId)) { parent = await tenantStore.GetTenantOfTypeAsync(parentId, MarainTenantType.Client).ConfigureAwait(false); } else { parent = await tenantStore.GetClientTenantParentAsync().ConfigureAwait(false); } logger?.LogDebug("Creating new client tenant '{clientName}' with GUID '{wellKnownGuid}'", clientName, wellKnownGuid); ITenant newTenant = await tenantStore.CreateWellKnownChildTenantAsync( parent.Id, wellKnownGuid, clientName).ConfigureAwait(false); logger?.LogDebug( "New client tenant '{clientName}' created with Id '{tenantId}'; updating tenant type.", newTenant.Name, newTenant.Id); await tenantStore.UpdateTenantAsync( newTenant.Id, propertiesToSetOrAdd : PropertyBagValues.Build(p => p.AddMarainTenantType(MarainTenantType.Client))).ConfigureAwait(false); logger?.LogInformation( "Created new client tenant '{clientName}' with Id '{tenantId}'.", newTenant.Name, newTenant.Id); return(newTenant); }
public static X509Certificate2 GetCredentialFromConfig(IConfigurationSection options, ILogger?logger) { string keyType = options.GetValue <string>(KeyType); logger?.LogDebug($"CredentialsHelper keyType is {keyType}"); switch (keyType) { case KeyTypeTemporary: logger?.LogDebug($"CredentialsHelper adding Temporary Signing Credential"); //return GetCertificateTemporary(); // TODO break; case KeyTypeKeyFile: return(GetCertificateFromFile(options, logger)); case KeyTypeKeyStore: return(GetCertificateFromStore(options, logger)); } throw new Exception($"keyType {keyType} not found"); }
private static async Task <ITenant> CreateDelegatedTenant(this ITenantStore tenantStore, ITenant accessingTenant, ITenant serviceTenant, ILogger?logger = null) { string delegatedTenantName = TenantNames.DelegatedTenant(serviceTenant.Name, accessingTenant.Name); logger?.LogDebug("Creating new delegated tenant '{delegatedTenantName}'", delegatedTenantName); ITenant delegatedTenant = await tenantStore.CreateChildTenantAsync(serviceTenant.Id, delegatedTenantName).ConfigureAwait(false); logger?.LogDebug( "New delegated tenant '{delegatedTenantName}' created with Id '{tenantId}'; updating tenant type.", delegatedTenant.Name, delegatedTenant.Id); delegatedTenant = await tenantStore.UpdateTenantAsync( delegatedTenant.Id, propertiesToSetOrAdd : PropertyBagValues.Build(p => p.AddMarainTenantType(MarainTenantType.Delegated))) .ConfigureAwait(false); logger?.LogInformation( "Created new delegated tenant '{delegatedTenantName}' with Id '{tenantId}'.", delegatedTenant.Name, delegatedTenant.Id); return(delegatedTenant); }
public async Task <ContainerRuntimeInfo> RunContainerAsync(ContainerParameters containerParameters, CancellationToken cancellationToken = default) { var(name, reusable) = (containerParameters.Name, containerParameters.Reusable); // Try to find container in docker session var startedContainer = await GetContainerAsync(name, cancellationToken); // If container already exist - remove that if (startedContainer != null) { // TODO: check status and network if (!reusable) { await _dockerClient.Containers.RemoveContainerAsync( startedContainer.ID, new ContainerRemoveParameters { Force = true }, cancellationToken); startedContainer = await CreateContainer(containerParameters, cancellationToken); } } else { startedContainer = await CreateContainer(containerParameters, cancellationToken); } _logger?.LogInformation($"Container '{name}' has been run."); _logger?.LogDebug($"Container state: {startedContainer.State}"); _logger?.LogDebug($"Container status: {startedContainer.Status}"); _logger?.LogDebug( $"Container IPAddress: {startedContainer.NetworkSettings.Networks.FirstOrDefault().Key} - {startedContainer.NetworkSettings.Networks.FirstOrDefault().Value.IPAddress}"); var ipAddress = startedContainer.NetworkSettings.Networks.FirstOrDefault().Value.IPAddress; var ports = startedContainer.Ports.DistinctBy(p => p.PrivatePort).ToDictionary(p => p.PrivatePort, p => p.PublicPort); return(new(startedContainer.ID, ipAddress, ports)); }
/// <summary> /// id is not null, valueSubscription is not null /// </summary> /// <param name="id"></param> /// <param name="clientObj"></param> public void AddItem(string id, object clientObj) { Logger?.LogDebug("XiListItemsManager.AddItem() " + id); ClientObjectInfo?modelItem; if (!_clientObjectInfosDictionary.TryGetValue(clientObj, out modelItem)) { modelItem = new ClientObjectInfo(id); _clientObjectInfosDictionary.Add(clientObj, modelItem); modelItem.ClientObj = clientObj; _xiItemsMustBeAddedOrRemoved = true; } }
private static ContractDescription CreateDescription(Type serviceType, ILogger?logger) { var contractDescription = new ContractDescription(serviceType); foreach (var interfaceDescription in contractDescription.Interfaces) { logger?.LogDebug("{0}: {1} is not service contract.", serviceType.FullName, interfaceDescription.InterfaceType.FullName); } foreach (var interfaceDescription in contractDescription.Services) { foreach (var method in interfaceDescription.Methods) { logger?.LogDebug("{0}: {1}", serviceType.FullName, method.Error); } foreach (var method in interfaceDescription.NotSupportedOperations) { logger?.LogError("{0}: {1}", serviceType.FullName, method.Error); } } return(contractDescription); }
internal static IPrintService Create(IConfigService configService, ILogger logger) { IPrintService printService = null; PrintServiceConfig printServiceConfig = configService.Get<PrintServiceConfig>("PrintManager", "ServiceConfig", null); if (null == printServiceConfig) { printService = new PrintServiceNull(); logger.LogDebug("PrintService", "Print Service not configured. All request to print will throw exception"); } else { printService = new PrintService(printServiceConfig, logger); } return printService; }
private IEnumerable <ComparisonResult> CompareMatchingItems(ItemMatch <T> match, ComparerOptions options) { var results = EvaluateMatch(match, options); foreach (var result in results) { _logger?.LogDebug(result.Message); if (result.ChangeType == SemVerChangeType.None) { // Don't add comparison results to the outcome where it looks like there is no change continue; } yield return(result); } }
/// <summary> /// Start all listeners. /// </summary> /// <returns>the task.</returns> public async Task StartAsync() { _logger?.LogDebug("Server configured for listening on {address}:{port}", _address, _port); List <IPAddress> addresses; if (string.IsNullOrEmpty(_address) || _address == IPAddress.Any.ToString()) { // "0.0.0.0" addresses = new List <IPAddress> { IPAddress.Any }; } else if (_address == IPAddress.IPv6Any.ToString()) { // "::" addresses = new List <IPAddress> { IPAddress.IPv6Any }; } else if (_address == "*") { addresses = new List <IPAddress> { IPAddress.Any, IPAddress.IPv6Any }; } else { var dnsAddresses = await Dns.GetHostAddressesAsync(_address).ConfigureAwait(false); addresses = dnsAddresses .Where(x => x.AddressFamily == AddressFamily.InterNetwork || x.AddressFamily == AddressFamily.InterNetworkV6) .ToList(); } try { Port = StartListening(addresses, _port); } catch { Stop(); throw; } }
/// <summary> /// Registers the routes. /// </summary> /// <param name="viewRoutes">The view routes.</param> /// <param name="apiRoutes">The API routes.</param> /// <param name="logger">The logger.</param> public static void RegisterRoutes(RouteCollection viewRoutes, HttpRouteCollection apiRoutes, ILogger logger) { logger.LogDebug("START: ModuleConfig.RegisterRoutes"); try { logger.Indent(); logger.LogDebug("GetViewModules"); var vModules = MEFConfig.Container.GetExports<IViewModule>(); logger.LogDebug("GetServiceModules"); var sModules = MEFConfig.Container.GetExports<IServiceModule>(); logger.LogDebug("Iterating ViewModules"); logger.Indent(); foreach (var module in vModules) { var mod = module.Value; mod.RegisterRoutes(viewRoutes); logger.LogDebug(mod.GetType().FullName); } logger.UnIndent(); logger.LogDebug("Iterating ServiceModules"); logger.Indent(); foreach (var module in sModules) { var mod = module.Value; mod.RegisterRoutes(apiRoutes); logger.LogDebug(mod.GetType().FullName); } logger.UnIndent(); } finally { logger.UnIndent(); logger.LogDebug("END: ModuleConfig.RegisterRoutes"); } }
private void Connect() { try { var res = base.ConnectServer(); if (IsConnected) { _Logger?.LogDebug("Server \"{ServerName}\" with address \"{ServerAddress}\" connected.", _PortName, ServerAddress); } else { _Logger?.LogWarning("Could not connect server \"{ServerName}\" with address \"{ServerAddress}\".", _PortName, ServerAddress); } } catch (AdsException ex) { _Logger?.LogError(ex, "Could not register server \"{ServerName}\".", _PortName); } }
private static int PreProcess(IBuildAgentUpdater updater, IBootstrapperSettings settings, ILogger logger) { string downloadBinPath = settings.DownloadDirectory; logger.LogInfo(Resources.MSG_PreparingDirectories); if (!Utilities.TryEnsureEmptyDirectories(logger, settings.TempDirectory, downloadBinPath)) { return ErrorCode; } string server = settings.SonarQubeUrl; Debug.Assert(!string.IsNullOrWhiteSpace(server), "Not expecting the server url to be null/empty"); logger.LogDebug(Resources.MSG_ServerUrl, server); logger.LogInfo(Resources.MSG_CheckingForUpdates); if (!updater.TryUpdate(server, downloadBinPath, logger)) { logger.LogError(Resources.ERROR_FailedToUpdateRunnerBinaries); return ErrorCode; } if (!updater.CheckBootstrapperApiVersion(settings.SupportedBootstrapperVersionsFilePath, settings.BootstrapperVersion)) { logger.LogError(Resources.ERROR_VersionMismatch); return ErrorCode; } var preprocessorFilePath = settings.PreProcessorFilePath; ProcessRunnerArguments runnerArgs = new ProcessRunnerArguments(preprocessorFilePath, logger) { CmdLineArgs = settings.ChildCmdLineArgs, WorkingDirectory = settings.TempDirectory, }; ProcessRunner runner = new ProcessRunner(); runner.Execute(runnerArgs); return runner.ExitCode; }
private async void HoldSubscription() { while (workingTaskCancellationTokenSource != null && !workingTaskCancellationTokenSource.Token.IsCancellationRequested) { try { subscription = _subscriptionFactory.Invoke(); subscriptionListener = new ServerToClientStreamListener <TReceivedEvent>(subscription); subscriptionListener.ServerEventReceived += _eventHandler.Invoke; _logger?.LogDebug($"Subscription of type {nameof(TReceivedEvent)} prepared. Beginning to listen..."); await subscriptionListener.ListenAsync(); } catch (RpcException) { _logger?.LogWarning($"Encountered a RpcException while trying to configure the {nameof(TReceivedEvent)} subscription. Retrying in {retryTimeoutMilliseconds / 1000} seconds..."); await Task.Delay(retryTimeoutMilliseconds); } catch (Exception ex) { _logger?.LogError($"Encountered an unexpected exception while trying to configure the {nameof(TReceivedEvent)} subscription: {ex} ({ex.Message}). Retrying in {retryTimeoutMilliseconds / 1000} seconds..."); await Task.Delay(retryTimeoutMilliseconds); } } }
private static void SetEnvironmentVariables(ProcessStartInfo psi, IDictionary<string, string> envVariables, ILogger logger) { if (envVariables == null) { return; } foreach (KeyValuePair<string, string> envVariable in envVariables) { Debug.Assert(!String.IsNullOrEmpty(envVariable.Key), "Env variable name cannot be null or empty"); if (psi.EnvironmentVariables.ContainsKey(envVariable.Key)) { logger.LogDebug(Resources.MSG_Runner_OverwritingEnvVar, envVariable.Key, psi.EnvironmentVariables[envVariable.Key], envVariable.Value); } else { logger.LogDebug(Resources.MSG_Runner_SettingEnvVar, envVariable.Key, envVariable.Value); } psi.EnvironmentVariables[envVariable.Key] = envVariable.Value; } }
private static string TryGetDefaultPropertiesFilePath(string defaultDirectory, ILogger logger) { string fullPath = Path.Combine(defaultDirectory, DefaultFileName); if (File.Exists(fullPath)) { logger.LogDebug(Resources.MSG_Properties_DefaultPropertiesFileFound, fullPath); return fullPath; } else { logger.LogDebug(Resources.MSG_Properties_DefaultPropertiesFileNotFound, fullPath); return null; } }
/// <summary> /// Attempt to find a properties file - either the one specified by the user, or the default properties file. /// Returns true if the path to a file could be resolved, othewise false. /// </summary> private static bool ResolveFilePath(string propertiesFilePath, string defaultPropertiesFileDirectory, ILogger logger, out AnalysisProperties properties) { properties = null; bool isValid = true; string resolvedPath = propertiesFilePath ?? TryGetDefaultPropertiesFilePath(defaultPropertiesFileDirectory, logger); if (resolvedPath != null) { if (File.Exists(resolvedPath)) { try { logger.LogDebug(Resources.MSG_Properties_LoadingPropertiesFromFile, resolvedPath); properties = AnalysisProperties.Load(resolvedPath); } catch (InvalidOperationException) { logger.LogError(Resources.ERROR_Properties_InvalidPropertiesFile, resolvedPath); isValid = false; } } else { logger.LogError(Resources.ERROR_Properties_GlobalPropertiesFileDoesNotExist, resolvedPath); isValid = false; } } return isValid; }
public void Bind(IServiceMethodBinder <TService> binder) { var contract = EmitContractBuilder.CreateFactory(_contractType)(binder.MarshallerFactory); var channelInstance = EmitServiceEndpointBuilder.CreateFactory(_channelType)(); var serviceType = typeof(TService); foreach (var interfaceDescription in _description.Services) { foreach (var operation in interfaceDescription.Operations) { var message = operation.Message; var channelMethod = _channelType.InstanceMethod(operation.OperationName); var metadata = TryGetMethodMetadata(interfaceDescription.InterfaceType, message.Operation); var grpcMethodMethod = (IMethod)_contractType.InstanceFiled(operation.GrpcMethodName).GetValue(contract); object?requestHeaderMarshaller = null; if (message.HeaderRequestType != null) { requestHeaderMarshaller = _contractType.InstanceFiled(operation.GrpcMethodInputHeaderName).GetValue(contract); } object?responseHeaderMarshaller = null; if (message.HeaderResponseType != null) { responseHeaderMarshaller = _contractType.InstanceFiled(operation.GrpcMethodOutputHeaderName).GetValue(contract); } _logger?.LogDebug("Bind service method {0}.{1}.", serviceType.FullName, message.Operation.Name); if (grpcMethodMethod.Type == MethodType.Unary) { var addMethod = _serviceBinderAddUnaryMethod .MakeGenericMethod(message.RequestType, message.ResponseType) .CreateDelegate <Action <IServiceMethodBinder <TService>, IMethod, MethodInfo, IList <object>, MethodInfo, object> >(); addMethod(binder, grpcMethodMethod, message.Operation, metadata, channelMethod, channelInstance); } else if (grpcMethodMethod.Type == MethodType.ClientStreaming) { var addMethod = _serviceBinderAddClientStreamingMethod .MakeGenericMethod( message.HeaderRequestType ?? typeof(Message), message.RequestType.GenericTypeArguments[0], message.ResponseType) .CreateDelegate <Action <IServiceMethodBinder <TService>, IMethod, MethodInfo, object?, IList <object>, MethodInfo, object> >(); addMethod(binder, grpcMethodMethod, message.Operation, requestHeaderMarshaller, metadata, channelMethod, channelInstance); } else if (grpcMethodMethod.Type == MethodType.ServerStreaming) { var addMethod = _serviceBinderAddServerStreamingMethod .MakeGenericMethod( message.RequestType, message.HeaderResponseType ?? typeof(Message), message.ResponseType.GenericTypeArguments[0]) .CreateDelegate <Action <IServiceMethodBinder <TService>, IMethod, MethodInfo, object?, IList <object>, MethodInfo, object> >(); addMethod(binder, grpcMethodMethod, message.Operation, responseHeaderMarshaller, metadata, channelMethod, channelInstance); } else if (grpcMethodMethod.Type == MethodType.DuplexStreaming) { var addMethod = _serviceBinderAddDuplexStreamingMethod .MakeGenericMethod( message.HeaderRequestType ?? typeof(Message), message.RequestType.GenericTypeArguments[0], message.HeaderResponseType ?? typeof(Message), message.ResponseType.GenericTypeArguments[0]) .CreateDelegate <Action <IServiceMethodBinder <TService>, IMethod, MethodInfo, object?, object?, IList <object>, MethodInfo, object> >(); addMethod(binder, grpcMethodMethod, message.Operation, requestHeaderMarshaller, responseHeaderMarshaller, metadata, channelMethod, channelInstance); } else { throw new NotImplementedException("{0} operation is not implemented.".FormatWith(grpcMethodMethod.Type)); } } } }
public IActionResult getUsers([FromQuery] string filter, [RequiredFromQuery] int startIndex, [RequiredFromQuery] int count) { _logger.LogDebug("Enter getAllUsers by Filter "); SCIMFilter myFilter = null; if (!string.IsNullOrEmpty(filter)) { myFilter = SCIMFilter.TryParse(filter); } PaginationProperties pp = new PaginationProperties(count, startIndex); try { cvs_SCIM20.Okta.SCIM.Models.SCIMUserQueryResponse rGetUsers = _connector.getUsers(pp, myFilter); if (rGetUsers == null) { _logger.LogDebug("Exit no users not found"); return(NotFound()); } else { _logger.LogDebug("Exit Successfully user found "); return(Ok(rGetUsers)); } } catch (EntityNotFoundException e) { _logger.LogDebug("Exit entity not found trying to get user"); return(NotFound()); } catch (Exception e) { _logger.LogDebug("Exit Error at getUser "); _logger.LogError(e.ToString()); return(StatusCode(StatusCodes.Status500InternalServerError, e)); } }
/// <summary> /// Enrolls the specified tenant in the service. /// </summary> /// <param name="tenantStore">The tenant store.</param> /// <param name="enrollingTenant">The tenant to enroll.</param> /// <param name="serviceTenant">The service to enroll in.</param> /// <param name="configurationItems">Configuration for the enrollment.</param> /// <param name="logger">Optional logger.</param> /// <returns>A task which completes when the enrollment has finished.</returns> public static async Task EnrollInServiceAsync( this ITenantStore tenantStore, ITenant enrollingTenant, ITenant serviceTenant, EnrollmentConfigurationItem[] configurationItems, ILogger?logger = null) { if (enrollingTenant == null) { throw new ArgumentNullException(nameof(enrollingTenant)); } enrollingTenant.EnsureTenantIsOfType(MarainTenantType.Client, MarainTenantType.Delegated); if (serviceTenant == null) { throw new ArgumentNullException(nameof(serviceTenant)); } serviceTenant.EnsureTenantIsOfType(MarainTenantType.Service); if (configurationItems == null) { throw new ArgumentNullException(nameof(configurationItems)); } logger?.LogDebug( "Enrolling tenant '{enrollingTenantName}' with Id '{enrollingTenantId}' from service '{serviceTenantName}' with Id '{serviceTenantId}'", enrollingTenant.Name, enrollingTenant.Id, serviceTenant.Name, serviceTenant.Id); // First we need to ensure that all the required config items for both the service being enrolled in, // as well as any dependent services is provided. ServiceManifestRequiredConfigurationEntry[] requiredConfig = await tenantStore.GetServiceEnrollmentConfigurationRequirementsAsync(serviceTenant).ConfigureAwait(false); logger?.LogDebug("Validating supplied configuration against required config."); configurationItems.ValidateAndThrow(requiredConfig); ServiceManifest manifest = serviceTenant.GetServiceManifest(); // Now, match up the required config items for this service to the relevent supplied config (we may // have been supplied with config for dependent services as well, so we can't just attach all // of the supplied config items to the enrolling tenant - some of it could belong on delegated // tenants. logger?.LogDebug( "Attaching required configuration items to tenant '{serviceTenantName}' with Id '{serviceTenantId}'", serviceTenant.Name, serviceTenant.Id); IEnumerable <(ServiceManifestRequiredConfigurationEntry RequiredConfigurationEntry, EnrollmentConfigurationItem ProvidedConfigurationItem)> matchedConfigItems = manifest.RequiredConfigurationEntries.Select( requiredConfigItem => (requiredConfigItem, configurationItems.Single(item => item.Key == requiredConfigItem.Key))); IEnumerable <KeyValuePair <string, object> > propertiesToAddToEnrollingTenant = PropertyBagValues.Empty; foreach ((ServiceManifestRequiredConfigurationEntry RequiredConfigurationEntry, EnrollmentConfigurationItem ProvidedConfigurationItem)current in matchedConfigItems) { logger?.LogDebug( "Adding configuration entry '{requiredConfigurationEntryKey}' to tenant '{serviceTenantName}' with Id '{serviceTenantId}'", current.RequiredConfigurationEntry.Key, serviceTenant.Name, serviceTenant.Id); propertiesToAddToEnrollingTenant = current.RequiredConfigurationEntry.AddToTenantProperties( propertiesToAddToEnrollingTenant, current.ProvidedConfigurationItem); } // Add an enrollment entry to the tenant. logger?.LogDebug( "Adding service enrollment to tenant '{serviceTenantName}' with Id '{serviceTenantId}'", serviceTenant.Name, serviceTenant.Id); propertiesToAddToEnrollingTenant = propertiesToAddToEnrollingTenant.AddServiceEnrollment( enrollingTenant, serviceTenant.Id); // Update the tenant now, so that the tenant type is correctly set - otherwise // recursive enrollments will fail logger?.LogDebug( "Updating tenant '{enrollingTenantName}' with Id '{enrollingTenantId}'", enrollingTenant.Name, enrollingTenant.Id); enrollingTenant = await tenantStore.UpdateTenantAsync( enrollingTenant.Id, propertiesToSetOrAdd : propertiesToAddToEnrollingTenant) .ConfigureAwait(false); propertiesToAddToEnrollingTenant = PropertyBagValues.Empty; // If this service has dependencies, we need to create a new delegated tenant for the service to use when // accessing those dependencies. if (manifest.DependsOnServiceTenants.Count > 0) { logger?.LogDebug( "Service '{serviceTenantName}' has dependencies. Creating delegated tenant for enrollment.", serviceTenant.Name); ITenant delegatedTenant = await tenantStore.CreateDelegatedTenant(enrollingTenant, serviceTenant).ConfigureAwait(false); // Now enroll the new delegated tenant for all of the dependent services. await Task.WhenAll(manifest.DependsOnServiceTenants.Select( dependsOnService => tenantStore.EnrollInServiceAsync( delegatedTenant, dependsOnService.Id, configurationItems))).ConfigureAwait(false); // Add the delegated tenant Id to the enrolling tenant logger?.LogDebug( "Setting delegated tenant for client '{enrollingTenantName}' with Id '{enrollingTenantId}' in service '{serviceTenantName}' with Id '{serviceTenantId}' to new tenant '{delegatedTenantName}' with Id '{delegatedTenantId}'.", enrollingTenant.Name, enrollingTenant.Id, serviceTenant.Name, serviceTenant.Id, delegatedTenant.Name, delegatedTenant.Id); propertiesToAddToEnrollingTenant = propertiesToAddToEnrollingTenant.SetDelegatedTenantForService( enrollingTenant, serviceTenant, delegatedTenant); logger?.LogDebug( "Updating tenant '{enrollingTenantName}' with Id '{enrollingTenantId}'", enrollingTenant.Name, enrollingTenant.Id); await tenantStore.UpdateTenantAsync( enrollingTenant.Id, propertiesToSetOrAdd : propertiesToAddToEnrollingTenant) .ConfigureAwait(false); } logger?.LogInformation( "Successfully enrolled tenant '{enrollingTenantName}' with Id '{enrollingTenant.Id}' for service '{serviceTenantName}' with Id '{serviceTenantId}'", enrollingTenant.Name, enrollingTenant.Id, serviceTenant.Name, serviceTenant.Id); }
/// <summary> /// Unenrolls the specified tenant from the service. /// </summary> /// <param name="tenantStore">The tenant store.</param> /// <param name="enrolledTenant">The tenant that is currently enrolled.</param> /// <param name="serviceTenant">The service they need to be unenrolled from.</param> /// <param name="logger">Optional logger.</param> /// <returns>A task which completes when the unenrollment has finished.</returns> public static async Task UnenrollFromServiceAsync( this ITenantStore tenantStore, ITenant enrolledTenant, ITenant serviceTenant, ILogger?logger = null) { if (!enrolledTenant.IsEnrolledForService(serviceTenant.Id)) { throw new InvalidOperationException( $"Cannot unenroll tenant '{enrolledTenant.Name}' with Id '{enrolledTenant.Id}' from service with Id '{serviceTenant.Id}' because it is not currently enrolled"); } logger?.LogDebug( "Unenrolling tenant '{enrolledTenantName}' with Id '{enrolledTenantId}' from service '{serviceTenantName}' with Id '{serviceTenantId}'", enrolledTenant.Name, enrolledTenant.Id, serviceTenant.Name, serviceTenant.Id); var propertiesToRemove = new List <string>(); ServiceManifest manifest = serviceTenant.GetServiceManifest(); // If there are dependencies, we first need to unenroll from each of those and then remove the delegated tenant. if (manifest.DependsOnServiceTenants.Count > 0) { logger?.LogDebug( "Service '{serviceTenantName}' has dependencies. Retrieving delegated tenant for unenrollment.", serviceTenant.Name); string delegatedTenantId = enrolledTenant.GetDelegatedTenantIdForServiceId(serviceTenant.Id); logger?.LogDebug( "Retrieved delegated tenant with Id '{delegatedTenantId}. Unenrolling from dependencies.", delegatedTenantId); foreach (ServiceDependency current in manifest.DependsOnServiceTenants) { await tenantStore.UnenrollFromServiceAsync(delegatedTenantId, current.Id).ConfigureAwait(false); } // Now delete the delegated tenant. logger?.LogDebug( "Deleting delegated tenant with Id '{delegatedTenantId}'.", delegatedTenantId); await tenantStore.DeleteTenantAsync(delegatedTenantId).ConfigureAwait(false); propertiesToRemove.AddRange(enrolledTenant.GetPropertiesToRemoveDelegatedTenantForService(serviceTenant)); } if (manifest.RequiredConfigurationEntries.Count > 0) { // Now remove any config for the service that's being unenrolled from. logger?.LogDebug( "Removing configuration for service '{serviceTenantName}' from '{enrolledTenantName}'", serviceTenant.Name, enrolledTenant.Name); foreach (ServiceManifestRequiredConfigurationEntry current in manifest.RequiredConfigurationEntries) { logger?.LogDebug( "Removing configuration item '{requiredConfigurationEntryKey}' for service '{serviceTenantName}' from '{enrolledTenantName}'", current.Key, serviceTenant.Name, enrolledTenant.Name); propertiesToRemove.AddRange(current.GetPropertiesToRemoveFromTenant(enrolledTenant)); } } // Finally, remove the enrollment entry for the service. logger?.LogDebug( "Removing enrollment entry for service '{serviceTenantName}' from '{enrolledTenantName}'", serviceTenant.Name, enrolledTenant.Name); IEnumerable <KeyValuePair <string, object> > propertiesToChange = enrolledTenant.GetPropertyUpdatesToRemoveServiceEnrollment(serviceTenant.Id); logger?.LogDebug( "Updating tenant '{enrolledTenantName}'", enrolledTenant.Name); await tenantStore.UpdateTenantAsync( enrolledTenant.Id, propertiesToSetOrAdd : propertiesToChange, propertiesToRemove : propertiesToRemove).ConfigureAwait(false); logger?.LogInformation( "Successfully unenrolled tenant '{enrolledTenantName}' with Id '{enrolledTenantId}' from service '{serviceTenantName}' with Id '{serviceTenantId}'", enrolledTenant.Name, enrolledTenant.Id, serviceTenant.Name, serviceTenant.Id); }
/// <inheritdoc /> #pragma warning disable CA1502 // TODO: Decomplexify #pragma warning disable CA1506 public async Task RunAsync(bool runConfigure, string[] args, CancellationToken cancellationToken) { logger.LogInformation("Host watchdog starting..."); logger.LogDebug("PID: {0}", Process.GetCurrentProcess().Id); string updateDirectory = null; try { var isWindows = RuntimeInformation.IsOSPlatform(OSPlatform.Windows); var dotnetPath = GetDotnetPath(isWindows); if (dotnetPath == default) { logger.LogCritical("Unable to locate dotnet executable in PATH! Please ensure the .NET Core runtime is installed and is in your PATH!"); return; } logger.LogInformation("Detected dotnet executable at {0}", dotnetPath); var executingAssembly = Assembly.GetExecutingAssembly(); var rootLocation = Path.GetDirectoryName(executingAssembly.Location); var assemblyStoragePath = Path.Combine(rootLocation, "lib"); // always always next to watchdog var defaultAssemblyPath = Path.GetFullPath(Path.Combine(assemblyStoragePath, "Default")); if (Debugger.IsAttached) { // VS special tactics // just copy the shit where it belongs Directory.Delete(assemblyStoragePath, true); Directory.CreateDirectory(defaultAssemblyPath); var sourcePath = "../../../../Tgstation.Server.Host/bin/Debug/netcoreapp3.1"; foreach (string dirPath in Directory.GetDirectories(sourcePath, "*", SearchOption.AllDirectories)) { Directory.CreateDirectory(dirPath.Replace(sourcePath, defaultAssemblyPath)); } foreach (string newPath in Directory.GetFiles(sourcePath, "*.*", SearchOption.AllDirectories)) { File.Copy(newPath, newPath.Replace(sourcePath, defaultAssemblyPath), true); } const string AppSettingsYaml = "appsettings.yml"; var rootYaml = Path.Combine(rootLocation, AppSettingsYaml); File.Delete(rootYaml); File.Move(Path.Combine(defaultAssemblyPath, AppSettingsYaml), rootYaml); } else { Directory.CreateDirectory(assemblyStoragePath); } var assemblyName = String.Join(".", nameof(Tgstation), nameof(Server), nameof(Host), "dll"); var assemblyPath = Path.Combine(defaultAssemblyPath, assemblyName); if (assemblyPath.Contains("\"")) { logger.LogCritical("Running from paths with \"'s in the name is not supported!"); return; } if (!File.Exists(assemblyPath)) { logger.LogCritical("Unable to locate host assembly!"); return; } string watchdogVersion = executingAssembly.GetName().Version.ToString(); while (!cancellationToken.IsCancellationRequested) { using (logger.BeginScope("Host invocation")) { updateDirectory = Path.GetFullPath(Path.Combine(assemblyStoragePath, Guid.NewGuid().ToString())); logger.LogInformation("Update path set to {0}", updateDirectory); using (var process = new Process()) { process.StartInfo.FileName = dotnetPath; process.StartInfo.WorkingDirectory = rootLocation; // for appsettings var arguments = new List <string> { $"\"{assemblyPath}\"", $"\"{updateDirectory}\"", $"\"{watchdogVersion}\"", }; if (args.Any(x => x.Equals("--attach-host-debugger", StringComparison.OrdinalIgnoreCase))) { arguments.Add("--attach-debugger"); } if (runConfigure) { logger.LogInformation("Running configuration check and wizard if necessary..."); arguments.Add("General:SetupWizardMode=Only"); } arguments.AddRange(args); process.StartInfo.Arguments = String.Join(" ", arguments); process.StartInfo.UseShellExecute = false; // runs in the same console var tcs = new TaskCompletionSource <object>(); process.Exited += (a, b) => { tcs.TrySetResult(null); }; process.EnableRaisingEvents = true; logger.LogInformation("Launching host..."); var killedHostProcess = false; try { process.Start(); using (var processCts = new CancellationTokenSource()) using (processCts.Token.Register(() => tcs.TrySetResult(null))) using (cancellationToken.Register(() => { if (!Directory.Exists(updateDirectory)) { logger.LogInformation("Cancellation requested! Writing shutdown lock file..."); File.WriteAllBytes(updateDirectory, Array.Empty <byte>()); } else { logger.LogWarning("Cancellation requested while update directory exists!"); } logger.LogInformation("Will force close host process if it doesn't exit in 10 seconds..."); try { processCts.CancelAfter(TimeSpan.FromSeconds(10)); } catch (ObjectDisposedException) { // race conditions } })) await tcs.Task.ConfigureAwait(false); } catch (InvalidOperationException) { } finally { try { if (!process.HasExited) { killedHostProcess = true; process.Kill(); process.WaitForExit(); } } catch (InvalidOperationException) { } logger.LogInformation("Host exited!"); } if (runConfigure) { logger.LogInformation("Exiting due to configuration check..."); return; } switch (process.ExitCode) { case 0: return; case 1: if (!cancellationToken.IsCancellationRequested) { logger.LogInformation("Watchdog will restart host..."); // just a restart } else { logger.LogWarning("Host requested restart but watchdog shutdown is in progress!"); } break; case 2: // update path is now an exception document logger.LogCritical("Host crashed, propagating exception dump..."); var data = File.ReadAllText(updateDirectory); try { File.Delete(updateDirectory); } catch (Exception e) { logger.LogWarning(e, "Unable to delete exception dump file at {0}!", updateDirectory); } #pragma warning disable CA2201 // Do not raise reserved exception types throw new Exception(String.Format(CultureInfo.InvariantCulture, "Host propagated exception: {0}", data)); #pragma warning restore CA2201 // Do not raise reserved exception types default: if (killedHostProcess) { logger.LogWarning("Watchdog forced to kill host process!"); cancellationToken.ThrowIfCancellationRequested(); } #pragma warning disable CA2201 // Do not raise reserved exception types throw new Exception(String.Format(CultureInfo.InvariantCulture, "Host crashed with exit code {0}!", process.ExitCode)); #pragma warning restore CA2201 // Do not raise reserved exception types } } // HEY YOU // BE WARNED THAT IF YOU DEBUGGED THE HOST PROCESS THAT JUST LAUNCHED THE DEBUGGER WILL HOLD A LOCK ON THE DIRECTORY // THIS MEANS THE FIRST DIRECTORY.MOVE WILL THROW if (Directory.Exists(updateDirectory)) { logger.LogInformation("Applying server update..."); if (isWindows) { // windows dick sucking resource unlocking GC.Collect(Int32.MaxValue, GCCollectionMode.Default, true); await Task.Delay(TimeSpan.FromSeconds(5), cancellationToken).ConfigureAwait(false); } var tempPath = Path.Combine(assemblyStoragePath, Guid.NewGuid().ToString()); try { Directory.Move(defaultAssemblyPath, tempPath); try { Directory.Move(updateDirectory, defaultAssemblyPath); logger.LogInformation("Server update complete, deleting old server..."); try { Directory.Delete(tempPath, true); } catch (Exception e) { logger.LogWarning(e, "Error deleting old server at {0}!", tempPath); } } catch (Exception e) { logger.LogError(e, "Error moving updated server directory, attempting revert!"); Directory.Delete(defaultAssemblyPath, true); Directory.Move(tempPath, defaultAssemblyPath); logger.LogInformation("Revert successful!"); } } catch (Exception e) { logger.LogWarning(e, "Failed to move out active host assembly!"); } } } } } catch (OperationCanceledException ex) { logger.LogDebug(ex, "Exiting due to cancellation..."); if (!Directory.Exists(updateDirectory)) { File.Delete(updateDirectory); } else { Directory.Delete(updateDirectory, true); } } catch (Exception ex) { logger.LogCritical(ex, "Host watchdog error!"); } finally { logger.LogInformation("Host watchdog exiting..."); } }
private bool DoExecute(ProcessedArgs args, ILogger logger) { if (args == null) { throw new ArgumentNullException("args"); } if (logger == null) { throw new ArgumentNullException("logger"); } logger.Verbosity = VerbosityCalculator.ComputeVerbosity(args.AggregateProperties, logger); InstallLoaderTargets(args, logger); TeamBuildSettings teamBuildSettings = TeamBuildSettings.GetSettingsFromEnvironment(logger); // We're checking the args and environment variables so we can report all // config errors to the user at once if (teamBuildSettings == null) { logger.LogError(Resources.ERROR_CannotPerformProcessing); return false; } // Create the directories logger.LogDebug(Resources.MSG_CreatingFolders); if (!Utilities.TryEnsureEmptyDirectories(logger, teamBuildSettings.SonarConfigDirectory, teamBuildSettings.SonarOutputDirectory)) { return false; } IDictionary<string, string> serverSettings; if (!FetchArgumentsAndRulesets(args, teamBuildSettings.SonarConfigDirectory, logger, out serverSettings)) { return false; } AnalysisConfigGenerator.GenerateFile(args, teamBuildSettings, serverSettings, logger); return true; }
private void InstallLoaderTargets(ProcessedArgs args, ILogger logger) { if (args.InstallLoaderTargets) { this.targetInstaller.InstallLoaderTargets(logger); } else { logger.LogDebug(Resources.MSG_NotCopyingTargets); } }
public IDictionary<string, string> GetProperties(string projectKey, ILogger logger) { if (string.IsNullOrWhiteSpace(projectKey)) { throw new ArgumentNullException("projectKey"); } if (logger == null) { throw new ArgumentNullException("logger"); } string ws = GetUrl("/api/properties?resource={0}", projectKey); logger.LogDebug(Resources.MSG_FetchingProjectProperties, projectKey, ws); var contents = this.downloader.Download(ws); var properties = JArray.Parse(contents); var result = properties.ToDictionary(p => p["key"].ToString(), p => p["value"].ToString()); // http://jira.sonarsource.com/browse/SONAR-5891 if (!result.ContainsKey("sonar.cs.msbuild.testProjectPattern")) { result["sonar.cs.msbuild.testProjectPattern"] = SonarProperties.DefaultTestProjectPattern; } return result; }
public async Task <ICommandContext> ExecuteAsync(ICommandActor actor, string[] args, string prefix) { if (args == null || args.Length == 0) { throw new Exception("Can not execute command with null or empty args"); } m_Logger.LogInformation($"Actor {actor.Type}/{actor.DisplayName} ({actor.Id}) has executed command \"{string.Join(" ", args)}\"."); var currentCommandAccessor = m_LifetimeScope.Resolve <ICurrentCommandContextAccessor>(); var commandContextBuilder = m_LifetimeScope.Resolve <ICommandContextBuilder>(); var stringLocalizer = m_LifetimeScope.Resolve <IOpenModStringLocalizer>(); var commandsRegistrations = await m_CommandStore.GetCommandsAsync(); var commandContext = commandContextBuilder.CreateContext(actor, args, prefix, commandsRegistrations); var commandExecutingEvent = new CommandExecutingEvent(actor, commandContext); await m_EventBus.EmitAsync(m_Runtime, this, commandExecutingEvent); if (commandExecutingEvent.IsCancelled) { return(commandExecutingEvent.CommandContext); } try { if (commandContext.Exception != null) { throw commandContext.Exception; } currentCommandAccessor.Context = commandContext; var permission = m_CommandPermissionBuilder.GetPermission(commandContext.CommandRegistration); var permissionChecker = m_Runtime.Host.Services.GetRequiredService <IPermissionChecker>(); if (!string.IsNullOrWhiteSpace(permission) && await permissionChecker.CheckPermissionAsync(actor, permission) != PermissionGrantResult.Grant) { throw new NotEnoughPermissionException(stringLocalizer, permission); } Stopwatch sw = new Stopwatch(); sw.Start(); var command = commandContext.CommandRegistration.Instantiate(commandContext.ServiceProvider); await command.ExecuteAsync(); m_Logger.LogDebug($"Command \"{string.Join(" ", args)}\" executed in {sw.ElapsedMilliseconds}ms"); sw.Reset(); currentCommandAccessor.Context = null; } catch (UserFriendlyException ex) { commandContext.Exception = ex; } catch (Exception ex) { commandContext.Exception = ex; } finally { var commandExecutedEvent = new CommandExecutedEvent(actor, commandContext); await m_EventBus.EmitAsync(m_Runtime, this, commandExecutedEvent); if (commandContext.Exception != null && !commandExecutedEvent.ExceptionHandled) { if (commandContext.Exception is UserFriendlyException) { await actor.PrintMessageAsync(commandContext.Exception.Message, Color.DarkRed); } else { await actor.PrintMessageAsync("An internal error occured during the command execution.", Color.DarkRed); m_Logger.LogError(commandContext.Exception, $"Exception occured on command \"{string.Join(" ", args)}\" by actor {actor.Type}/{actor.DisplayName} ({actor.Id})"); } } await commandContext.DisposeAsync(); } return(commandContext); }
private void Inspect(QuizContext quizContext) { var ids = string.Join(", ", quizContext.Questions.Select(x => x.Id)); _logger.LogDebug($"***DB*** has now: {ids} question"); }
public CarsContext(ILoggerFactory loggerFactory) { _logger = loggerFactory.CreateLogger<CarsContext>(); _logger.LogDebug("Constructing CarsContext"); }
public ClientManager(IMessageHandler messageHandler, IReactionHandler reactionHandler, ILogger <ClientManager> logger, IDiscordClient client, TwitchClient twitchClient) { _logger = logger; _client = client; _twitchClient = twitchClient; switch (_client) { case DiscordSocketClient discordSocketClient: // Create and attach restart service _reliabilityService = new ReliabilityService(discordSocketClient, true, Config.ServiceProvider.GetService <ILogger <ReliabilityService> >()); _reliabilityService.Attach(); // Attach event handlers discordSocketClient.MessageReceived += messageHandler.HandleAsync; discordSocketClient.ReactionAdded += reactionHandler.HandleAsync; discordSocketClient.UserJoined += OnUserJoinAsync; discordSocketClient.UserLeft += OnUserLeaveAsync; discordSocketClient.UserBanned += OnUserBanAsync; discordSocketClient.Ready += () => { _ready = true; return(Task.CompletedTask); }; // Add logging discordSocketClient.Log += logMessage => { switch (logMessage.Severity) { case LogSeverity.Critical: _logger.LogCritical(logMessage.Exception, logMessage.Message); break; case LogSeverity.Error: _logger.LogError(logMessage.Exception, logMessage.Message); break; case LogSeverity.Warning: _logger.LogWarning(logMessage.Exception, logMessage.Message); break; case LogSeverity.Info: _logger.LogInformation(logMessage.Exception, logMessage.Message); break; case LogSeverity.Verbose: _logger.LogDebug(logMessage.Exception, logMessage.Message); break; case LogSeverity.Debug: _logger.LogTrace(logMessage.Exception, logMessage.Message); break; default: throw new ArgumentOutOfRangeException(); } return(Task.CompletedTask); }; break; } }
private static void GenerateFxCopRuleset(ISonarQubeServer server, string projectKey, string requiredPluginKey, string language, string repository, string path, ILogger logger) { logger.LogDebug(Resources.MSG_GeneratingRuleset, path); RulesetGenerator.Generate(server, requiredPluginKey, language, repository, projectKey, path); }
private ICollection <IMigration> GetMigrations( IEnumerable <string> fileNames, Func <string, string> sqlScriptReadFunc, IDbProvider dbProvider, string?prefix, IReadOnlyDictionary <string, string> variables, ILogger?migrationLogger) { if (fileNames == null) { throw new ArgumentNullException(nameof(fileNames)); } if (sqlScriptReadFunc == null) { throw new ArgumentNullException(nameof(sqlScriptReadFunc)); } if (dbProvider == null) { throw new ArgumentNullException(nameof(dbProvider)); } var scripts = new Dictionary <DbVersion, ScriptInfo>(); var regex = String.IsNullOrWhiteSpace(prefix) ? new Regex($"{MigrationConstants.MigrationFileNamePattern}", RegexOptions.IgnoreCase) : new Regex($"{prefix}{MigrationConstants.MigrationFileNamePattern}", RegexOptions.IgnoreCase); foreach (var fileName in fileNames) { var match = regex.Match(fileName); if (!match.Success) { // it's normal that some files doesn't match a regex, but we log, it's safer migrationLogger?.LogDebug($"\"{fileName}\" has incorrect name for script migration."); continue; } if (!DbVersion.TryParse(match.Groups[1].Value, out var version)) { migrationLogger?.LogWarning($"\"{fileName}\" has incorrect version migration."); continue; } if (!scripts.ContainsKey(version)) { scripts[version] = new ScriptInfo(version); } var scriptInfo = scripts[version]; var script = sqlScriptReadFunc.Invoke(fileName); // extract options for current migration scriptInfo.Options = ExtractMigrationOptions(script); // split into batches var batches = new List <ScriptMigrationBatch>(); var batchNameRegex = new Regex(@"--\s*BATCH:\s*(.*)\s*\n(.*)", RegexOptions.IgnoreCase); var batchIndex = 0; // Use positive lookahead to split script into batches. foreach (var batch in Regex.Split(script, @"(?=--\s*BATCH:)")) { if (String.IsNullOrWhiteSpace(batch)) { continue; } var batchNameMatch = batchNameRegex.Match(batch); batches.Add(new ScriptMigrationBatch( batchIndex++, batchNameMatch.Success ? batchNameMatch.Groups[1].Value : null, batch)); } if (match.Groups[6].Success) { if (scriptInfo.DownScript.Count > 0) { throw new InvalidOperationException( $"There is more than one downgrade script with version {version}"); } scriptInfo.DownScript.AddRange(batches); } else { if (scriptInfo.UpScript.Count > 0) { throw new InvalidOperationException( $"There is more than one upgrade script with version {version}"); } scriptInfo.UpScript.AddRange(batches); } var comment = match.Groups[9]; scriptInfo.Comment = comment.Success ? comment.Value : null; } return(scripts .Select(scriptInfo => CreateScriptMigration( scriptInfo.Key, scriptInfo.Value, dbProvider, variables, migrationLogger)) .ToArray()); }
private static void AddOrSetProperty(string key, string value, AnalysisProperties properties, ILogger logger) { Property property; Property.TryGetProperty(key, properties, out property); if (property == null) { logger.LogDebug(Resources.MSG_SettingAnalysisProperty, key, value); property = new Property() { Id = key, Value = value }; properties.Add(property); } else { if (string.Equals(property.Value, value, StringComparison.InvariantCulture)) { logger.LogDebug(Resources.MSG_MandatorySettingIsCorrectlySpecified, key, value); } else { logger.LogWarning(Resources.WARN_OverridingAnalysisProperty, key, value); property.Value = value; } } }
public static void OnHalfOpenDefault(ILogger <AgonesCircuitDelegate> logger) { logger.LogDebug("OnHalfOpen: Circuit in test mode, one request will be allowed."); }
private static bool MonitorHostProcess(CommandOption host, ILogger logger) { if (!host.HasValue()) { logger.LogError($"Option \"{host.LongName}\" is missing."); return false; } int hostPID; if (int.TryParse(host.Value(), out hostPID)) { var hostProcess = Process.GetProcessById(hostPID); hostProcess.EnableRaisingEvents = true; hostProcess.Exited += (s, e) => { Process.GetCurrentProcess().Kill(); }; logger.LogDebug($"Server will exit when process {hostPID} exits."); return true; } else { logger.LogError($"Option \"{host.LongName}\" is not a valid Int32 value."); return false; } }
private async Task <Response> DoSendAsync(Command command, CancellationToken cancellationToken) { try { var stream = _stream ?? throw new ObjectDisposedException(nameof(TcpViscaTransport)); var buffer = _buffer ?? throw new ObjectDisposedException(nameof(TcpViscaTransport)); var messageSize = command.MessageSize; var bufferLength = buffer.Length; if (messageSize > bufferLength) { var currentBuffer = Interlocked.CompareExchange(ref _buffer, null !, buffer); // Already disposed if (currentBuffer is null) { throw new ObjectDisposedException(nameof(TcpViscaTransport)); } // Return buffer ArrayPool <byte> .Shared.Return(buffer); // Get a bigger buffer! buffer = ArrayPool <byte> .Shared.Rent(messageSize); Interlocked.Exchange(ref _buffer, buffer); _logger.LogWarning( $"The '{command.Name} command requested a message size of '{messageSize}' which exceeded the current buffer's size '{bufferLength}', so a new buffer of size '{buffer.Length}' was created. This is unexpected and exceeds the current VISCA specification so may cause problems on some devices!"); } // Write the message into our current buffer. command.WriteMessage(buffer.AsSpan(0, messageSize), DeviceId); _logger?.LogDebug( $"Sending '{command.Name}' data to '{EndPoint}': {buffer.Take(messageSize).ToHex()}"); await stream.WriteAsync(buffer, 0, messageSize, cancellationToken) .ConfigureAwait(false); int read; Response response; var socket = -1; if (command.Type == CommandType.Command) { // We expect an ACK read = await stream.ReadAsync(buffer, cancellationToken).ConfigureAwait(false); if (read < 1) { _logger?.LogError($"No data returned from '{EndPoint}' whilst executing '{command.Name}'."); return(command.UnknownResponse); } response = command.GetResponse(buffer.AsSpan(0, read), _logger); _logger?.LogDebug( $"Received '{response.Type}' response to '{command.Name}' from '{EndPoint}': {buffer.Take(read).ToHex()}"); if (response.Type != ResponseType.ACK) { // The IFClear returns a completion without an ACK (as per spec.) if (command != ViscaCommands.IFClear && response.Type != ResponseType.Completion) { _logger?.LogWarning( $"Received a '{response.Type}' response from '{EndPoint}' whilst executing '{command.Name}' instead of an '{nameof(ResponseType.ACK)}' response."); } return(response); } if (response.DeviceId != DeviceId) { } socket = response.Socket; // Continue to wait for completion response } read = await stream.ReadAsync(buffer, cancellationToken).ConfigureAwait(false); if (read < 1) { _logger?.LogError($"No data returned from '{EndPoint}' whilst executing '{command.Name}'."); return(command.UnknownResponse); } response = command.GetResponse(buffer.AsSpan(0, read), _logger); _logger?.LogDebug( $"Received '{response.Type}' response to '{command.Name}' from '{EndPoint}': {buffer.Take(read).ToHex()}"); if (response.DeviceId != DeviceId) { _logger?.LogWarning( $"The device Id '{response.DeviceId}' in the '{response.Type}' response from '{EndPoint}' whilst executing '{command.Name}' did not match the expected device Id '{DeviceId}'."); } if (socket > -1 && response.Socket != socket) { _logger?.LogWarning( $"The socket '{response.Socket}' in the '{response.Type}' response from '{EndPoint}' whilst executing '{command.Name}' did not match the socket '{socket}' returned from the '{nameof(ResponseType.ACK)}' response."); } return(response); } catch (Exception exception) { _logger?.LogError(exception, $"Failed to send '{command.Name}' to '{EndPoint}'."); return(command.UnknownResponse); } }