public Logger(Serilog.ILogger logger)
{
_logger = logger;
}
public PluginHttpApi(
ILogger logger,
ILifetimeScope lifetimeScope)
{
_logger = logger;
_lifetimeScope = lifetimeScope;
}
public PluginManagerFactory(ILogger logger, IConfiguration configuration, IMessageQueue messageQueue, IIsolatedEnvironmentFactory isolatedEnvironmentFactory)
{
_logger = logger;
_configuration = configuration;
_messageQueue = messageQueue;
_isolatedEnvironmentFactory = isolatedEnvironmentFactory;
}
public SerilogLog(Serilog.ILogger logger, bool demoteDebug = false)
{
if (logger == null)
throw new ArgumentNullException(nameof(logger));
_logger = logger;
_demoteDebug = demoteDebug;
}
public SerilogLog(ILogger logger)
{
if (logger == null)
{
throw new ArgumentNullException("logger");
}
_logger = logger;
}
public PluginBootstrapperTask(ILogger logger,
IConfiguration configuration,
IPackageRepository packageRepository,
IPackageManager packageManager)
{
_logger = logger;
_configuration = configuration;
_packageRepository = packageRepository;
_packageManager = packageManager;
}
public SerilogLog(ILogger logger, bool demoteDebug = false)
{
if (logger == null)
{
throw new ArgumentNullException("logger");
}
_logger = logger;
this._demoteDebug = demoteDebug;
}
public PluginEngine(ILogger logger, IPackageManager packageManager, IDevelopmentPluginInstaller devPluginInstaller, IPluginManagerFactory pluginManagerFactory)
{
if (logger == null) throw new ArgumentNullException("logger");
if (packageManager == null) throw new ArgumentNullException("packageManager");
if (devPluginInstaller == null) throw new ArgumentNullException("devPluginInstaller");
if (pluginManagerFactory == null) throw new ArgumentNullException("pluginManagerFactory");
_logger = logger;
_packageManager = packageManager;
_devPluginInstaller = devPluginInstaller;
_pluginManagerFactory = pluginManagerFactory;
}
public PluginManager(ILogger logger, IConfiguration configuration, IMessageQueue messageQueue, IDirectory baseDirectory, IIsolatedEnvironment environment, IPackage package)
{
ErrorCount = 0;
if (logger == null) throw new ArgumentNullException("logger");
if (configuration == null) throw new ArgumentNullException("configuration");
if (baseDirectory == null) throw new ArgumentNullException("baseDirectory");
if (environment == null) throw new ArgumentNullException("environment");
if (package == null) throw new ArgumentNullException("package");
State = PluginState.Unloaded;
_logger = logger;
_configuration = configuration;
_messageQueue = messageQueue;
_baseDirectory = baseDirectory;
_isolatedEnvironment = environment;
_package = package;
_lazyManifest = new Lazy<IManifest>(_package.GetManifest);
_isolatedEnvironment.UnhandledError += OnUnhandledError;
}
public SerilogLoggerFactory(ISerilogLogger logger)
{
_logger = logger;
}
public FiltrodeExcepcion(Serilog.ILogger logger)
{
this.logger = logger;
}
public SerilogLogger(Serilog.ILogger serilogLogger)
{
_serilogLogger = serilogLogger;
}
internal PluginManager(IConfigurationRepository configDb, ISafeguardLogic safeguardLogic)
{
_configDb = configDb;
_safeguardLogic = safeguardLogic;
_logger = Serilog.Log.Logger;
}
public StockRepository(StockDbContext stockContext, Serilog.ILogger logger) : base(stockContext, logger)
{
_context = stockContext;
_logger = logger;
}
public UserController(IPersonRepository personRepository,
Serilog.ILogger logger)
{
_personRepository = personRepository;
_logger = logger;
}
public SerilogAppender(ILogger logger)
{
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
public async Task Configure(bool isPersistent, HubConnection connection, IUiEventBus uiEventBus, ILogger logger)
{
_uiEventBus = uiEventBus;
_logger = logger;
var eventName = typeof(TEvent).FullName.Replace(".", "-");
connection.On(eventName, new Action <EventMetadata, TEvent>(OnReadEvent));
// Should we wait for the subscription? - or should we re-subscribe
logger.Information("Subscribing to {eventName} with method {methodName}", typeof(TEvent).Name, eventName);
await connection.InvokeAsync("SubscribeToEvent", isPersistent, typeof(TEvent).AssemblyQualifiedName);
logger.Information("Subscribed to {eventName}.", typeof(TEvent).Name);
}
public AuthController(AuthService authService, Serilog.ILogger logger) : base()
{
_authService = authService;
_logger = logger;
}
public PasswordChangeNotificationReader(IPublisher publisher, IODispatcher ioDispatcher)
{
_publisher = publisher;
_ioDispatcher = ioDispatcher;
_log = Serilog.Log.ForContext <UserManagementService>();
}
public async Task Configure(bool fromBeginning, HubConnection connection, IUiEventBus uiEventBus, ILogger logger, string projectionType)
{
_uiEventBus = uiEventBus;
_logger = logger;
var eventName = $"{projectionType}.{typeof(TEvent).Name}";
connection.On(eventName, new Action <EventMetadata, TEvent>(OnReadEvent));
// Should we wait for the subscription? - or should we re-subscribe
}
public PlaylistRoutes(
IAiringService airingSvc,
AiringValidator validator,
Serilog.ILogger logger
)
: base("v1")
{
this.RequiresAuthentication();
#region "POST Operations"
Post("/playlist/{airingid}", _ =>
{
// Verify that the user has permission to POST
this.RequiresClaims(c => c.Type == HttpMethod.Post.Verb());
var airingId = (string)_.airingid;
// Bind POST request to data contract
var request = this.Bind <VMAiringRequestModel.PlayListRequest>();
try
{
BLAiringModel.Airing airing;
if (airingSvc.IsAiringExists(airingId))
{
airing = airingSvc.GetBy(airingId, AiringCollection.CurrentCollection);
//Updates the airing with the given Playlist payload
airing.PlayList = Mapper.Map <List <BLAiringModel.PlayItem> >(request.PlayList);
airing.ReleaseBy = request.ReleasedBy;
//Clears the existing delivery details
airing.IgnoredQueues = new List <string>();
airing.DeliveredTo = new List <string>();
//Sets the date with the current date time
airing.ReleaseOn = DateTime.UtcNow;
//Sets the user name
airing.UserName = Context.User().UserName;
}
else
{
var airingErrorMessage = string.IsNullOrWhiteSpace(airingId) ?
"AiringId is required." : "Provided AiringId does not exists or expired.";
// Return status
return(Negotiate.WithModel(airingErrorMessage)
.WithStatusCode(string.IsNullOrWhiteSpace(airingId) ? HttpStatusCode.BadRequest : HttpStatusCode.NotFound));
}
// validate
var results = new List <ValidationResult>
{
validator.Validate(airing,
ruleSet:
AiringValidationRuleSet.PostPlaylist.ToString())
};
// Verify if there are any validation errors. If so, return error
if (results.Any(c => (!c.IsValid)))
{
var message = results.Where(c => (!c.IsValid))
.Select(c => c.Errors.Select(d => d.ErrorMessage)).ToList();
logger.Error("Failure ingesting playlist released asset: {AssetId}", new Dictionary <string, object>()
{
{ "airingid", airingId }, { "mediaid", airing.MediaId }, { "error", message }
});
// Return status
return(Negotiate.WithModel(message)
.WithStatusCode(HttpStatusCode.BadRequest));
}
// If the versions exist, create a mediaid based on the
// provided version informtion,playlists and the network to which this
// asset/airing belongs
if (airing.Versions.Any())
{
airingSvc.AugmentMediaId(ref airing);
}
// Finally, persist the airing data
airingSvc.Save(airing, false, true);
return("Successfully updated the playlist.");
}
catch (Exception e)
{
logger.Error(e, "Failure ingesting playlist to airing. Airingid:{@airingId}", airingId);
throw;
}
});
#endregion
}
public RecuperarDeudasService(RecuperarDeudasRepository repository, Serilog.ILogger logger) : base(repository, logger)
{
Repository = repository;
}
public static bool CertificateValidation(object sender, X509Certificate certificate, X509Chain chain,
SslPolicyErrors sslPolicyErrors, Serilog.ILogger logger, IConfigurationRepository configDb)
{
var trustedChain = configDb.GetTrustedChain();
if (trustedChain.ChainPolicy.ExtraStore.Count == 0)
{
logger.Error("IgnoreSsl is false and there no trusted certificates have been specified.");
return(false);
}
try
{
var cert2 = new X509Certificate2(certificate);
var sans = GetSubjectAlternativeName(new X509Certificate2(certificate), logger);
var safeguardAddress = configDb.SafeguardAddress;
if (!sans.Exists(x => x.Equals(safeguardAddress, StringComparison.InvariantCultureIgnoreCase) ||
(x.StartsWith("*") && safeguardAddress.Substring(safeguardAddress.IndexOf('.'))
.Equals(x.Substring(1), StringComparison.InvariantCultureIgnoreCase))))
{
logger.Debug("Failed to find a matching subject alternative name.");
return(false);
}
if (chain.ChainElements.Count <= 1)
{
var found = trustedChain.ChainPolicy.ExtraStore.Find(X509FindType.FindByThumbprint, cert2.Thumbprint ?? string.Empty, false);
if (found.Count == 1)
{
return(true);
}
}
logger.Debug($"Trusted certificates count = {trustedChain.ChainPolicy.ExtraStore.Count}");
var i = 0;
foreach (var trusted in trustedChain.ChainPolicy.ExtraStore)
{
logger.Debug($"[{i}] - subject = {trusted.SubjectName.Name}");
logger.Debug($"[{i}] - issuer = {trusted.IssuerName.Name}");
logger.Debug($"[{i}] - thumbprint = {trusted.Thumbprint}");
i++;
}
if (!trustedChain.Build(new X509Certificate2(certificate)))
{
logger.Error("Failed SPP SSL certificate validation.");
var chainStatus = trustedChain.ChainStatus;
for (i = 0; i < chainStatus.Length; i++)
{
logger.Debug($"[{i}] - chain status = {chainStatus[i].StatusInformation}");
}
i = 0;
foreach (var chainElement in trustedChain.ChainElements)
{
logger.Debug($"[{i}] - subject = {chainElement.Certificate.SubjectName.Name}");
logger.Debug($"[{i}] - issuer = {chainElement.Certificate.IssuerName.Name}");
logger.Debug($"[{i}] - thumbprint = {chainElement.Certificate.Thumbprint}");
i++;
}
return(false);
}
}
catch (Exception ex)
{
logger.Error($"Failed SPP SSL certificate validation: {ex.Message}");
return(false);
}
return(true);
}
private static List <string> GetSubjectAlternativeName(X509Certificate2 cert, Serilog.ILogger logger)
{
var result = new List <string>();
var subjectAlternativeName = cert.Extensions.Cast <X509Extension>()
.Where(n => n.Oid.Value == "2.5.29.17") //n.Oid.FriendlyName=="Subject Alternative Name")
.Select(n => new AsnEncodedData(n.Oid, n.RawData))
.Select(n => n.Format(true))
.FirstOrDefault();
if (subjectAlternativeName != null)
{
var alternativeNames = subjectAlternativeName.Split(new[] { "\r\n", "\r", "\n", "," }, StringSplitOptions.RemoveEmptyEntries);
foreach (var alternativeName in alternativeNames)
{
logger.Debug($"Found subject alternative name: {alternativeName}");
var groups = Regex.Match(alternativeName, @"^(.*)[=,:](.*)").Groups; // @"^DNS Name=(.*)").Groups;
if (groups.Count > 0 && !String.IsNullOrEmpty(groups[2].Value))
{
result.Add(groups[2].Value);
}
}
}
return(result);
}
public Deporter(Serilog.ILogger logger, IAiringService airingService, AppSettings appsettings)
{
this.appsettings = appsettings;
this.logger = logger;
this.airingServiceHelper = airingService;
}
private async Task <ImmutableArray <SemanticVersion> > GetAllVersionsFromApiInternalAsync(
NuGetPackageId packageId,
string?nuGetSource,
string?nugetConfig,
bool allowPreRelease,
HttpClient httpClient,
ILogger logger,
CancellationToken cancellationToken)
{
ISettings?settings = null;
if (!string.IsNullOrWhiteSpace(nugetConfig))
{
var fileInfo = new FileInfo(nugetConfig);
settings = Settings.LoadSpecificSettings(fileInfo.Directory !.FullName, fileInfo.Name);
}
string?currentDirectory = Directory.GetCurrentDirectory();
settings ??= Settings.LoadDefaultSettings(
currentDirectory,
configFileName: null,
new XPlatMachineWideSetting());
var sources = SettingsUtility.GetEnabledSources(settings).ToArray();
var cache = new SourceCacheContext();
NuGet.Common.ILogger nugetLogger = GetLogger(logger);
var semanticVersions = new HashSet <SemanticVersion>();
foreach (var packageSource in sources)
{
if (!string.IsNullOrWhiteSpace(nuGetSource) &&
!packageSource.Name.Equals(nuGetSource, StringComparison.OrdinalIgnoreCase))
{
continue;
}
SourceRepository repository;
if (packageSource.IsHttp)
{
bool isV3Feed;
if (packageSource.ProtocolVersion == 3)
{
isV3Feed = true;
}
else
{
isV3Feed = await IsV3Feed(packageSource, httpClient, HttpMethod.Head, cancellationToken);
}
repository = isV3Feed
? Repository.Factory.GetCoreV3(packageSource.SourceUri.ToString())
: Repository.Factory.GetCoreV2(packageSource);
}
else
{
repository = Repository.Factory.GetCoreV2(packageSource);
}
if (sources.Length == 1 && sources[0].Credentials is { })
public WorkItemMigrationContext(IMigrationEngine engine, IServiceProvider services, ITelemetryLogger telemetry, ILogger <WorkItemMigrationContext> logger) : base(engine, services, telemetry, logger)
{
contextLog = Serilog.Log.ForContext <WorkItemMigrationContext>();
}
public StocksController(IUnitOfWork unitOfWork, Serilog.ILogger logger)
{
UnitOfWork = unitOfWork;
_logger = logger;
}
protected override void InternalExecute()
{
Log.LogInformation("WorkItemMigrationContext::InternalExecute ");
if (_config == null)
{
throw new Exception("You must call Configure() first");
}
var workItemServer = Engine.Source.GetService <WorkItemServer>();
attachmentEnricher = new TfsAttachmentEnricher(workItemServer, _config.AttachmentWorkingPath, _config.AttachmentMaxSize);
workItemLinkEnricher = Services.GetRequiredService <TfsWorkItemLinkEnricher>();
embededImagesEnricher = Services.GetRequiredService <TfsEmbededImagesEnricher>();
gitRepositoryEnricher = Services.GetRequiredService <TfsGitRepositoryEnricher>();
nodeStructureEnricher = Services.GetRequiredService <TfsNodeStructureEnricher>();
_witClient = new WorkItemTrackingHttpClient(Engine.Target.Config.AsTeamProjectConfig().Collection, Engine.Target.Credentials);
//Validation: make sure that the ReflectedWorkItemId field name specified in the config exists in the target process, preferably on each work item type.
PopulateIgnoreList();
Log.LogInformation("Migrating all Nodes before the work item run.");
nodeStructureEnricher.MigrateAllNodeStructures(_config.PrefixProjectToNodes, _config.NodeBasePaths);
var stopwatch = Stopwatch.StartNew();
//////////////////////////////////////////////////
string sourceQuery =
string.Format(
@"SELECT [System.Id], [System.Tags] FROM WorkItems WHERE [System.TeamProject] = @TeamProject {0} ORDER BY {1}",
_config.WIQLQueryBit, _config.WIQLOrderBit);
var sourceWorkItems = Engine.Source.WorkItems.GetWorkItems(sourceQuery);
contextLog.Information("Replay all revisions of {sourceWorkItemsCount} work items?", sourceWorkItems.Count);
//////////////////////////////////////////////////
contextLog.Information("Found target project as {@destProject}", Engine.Target.WorkItems.Project.Name);
//////////////////////////////////////////////////////////FilterCompletedByQuery
if (_config.FilterWorkItemsThatAlreadyExistInTarget)
{
contextLog.Information("[FilterWorkItemsThatAlreadyExistInTarget] is enabled. Searching for work items that have already been migrated to the target...", sourceWorkItems.Count());
sourceWorkItems = ((TfsWorkItemMigrationClient)Engine.Target.WorkItems).FilterExistingWorkItems(sourceWorkItems, new TfsWiqlDefinition()
{
OrderBit = _config.WIQLOrderBit, QueryBit = _config.WIQLQueryBit
}, (TfsWorkItemMigrationClient)Engine.Source.WorkItems);
contextLog.Information("!! After removing all found work items there are {SourceWorkItemCount} remaining to be migrated.", sourceWorkItems.Count());
}
//////////////////////////////////////////////////
var result = validateConfig.ValidatingRequiredField(Engine.Target.Config.AsTeamProjectConfig().ReflectedWorkItemIDFieldName, sourceWorkItems);
if (!result)
{
var ex = new InvalidFieldValueException("Not all work items in scope contain a valid ReflectedWorkItemId Field!");
Log.LogError(ex, "Not all work items in scope contain a valid ReflectedWorkItemId Field!");
throw ex;
}
//////////////////////////////////////////////////
_current = 1;
_count = sourceWorkItems.Count;
_elapsedms = 0;
_totalWorkItem = sourceWorkItems.Count;
foreach (MigrationTools._EngineV1.DataContracts.WorkItemData sourceWorkItemData in sourceWorkItems)
{
var sourceWorkItem = TfsExtensions.ToWorkItem(sourceWorkItemData);
workItemLog = contextLog.ForContext("SourceWorkItemId", sourceWorkItem.Id);
using (LogContext.PushProperty("sourceWorkItemTypeName", sourceWorkItem.Type.Name))
using (LogContext.PushProperty("currentWorkItem", _current))
using (LogContext.PushProperty("totalWorkItems", _totalWorkItem))
using (LogContext.PushProperty("sourceWorkItemId", sourceWorkItem.Id))
using (LogContext.PushProperty("sourceRevisionInt", sourceWorkItem.Revision))
using (LogContext.PushProperty("targetWorkItemId", null))
{
ProcessWorkItem(sourceWorkItemData, _config.WorkItemCreateRetryLimit);
if (_config.PauseAfterEachWorkItem)
{
Console.WriteLine("Do you want to continue? (y/n)");
if (Console.ReadKey().Key != ConsoleKey.Y)
{
workItemLog.Warning("USER ABORTED");
break;
}
}
}
}
//////////////////////////////////////////////////
stopwatch.Stop();
contextLog.Information("DONE in {Elapsed}", stopwatch.Elapsed.ToString("c"));
}
public IgniteLauncher(string rootPath, ILogger logger, LogLevel minLogLevel)
{
this.rootPath = rootPath;
this.logger = logger;
this.minLogLevel = minLogLevel;
}
public FormBase() : base()
{
logger = Serilog.Log.Logger;
DI.Resolve(this);
}
public AttachmentsController(ULODBEntities db, IComponentContext componentContext, ICacher cacher, Serilog.ILogger logger)
: base(db, componentContext, cacher, logger)
{
}
//,IdentityManager identityManager
public GroupsController(ApplicationDbContext context, IdentityManager identityManager, HttpContextAccessor httpContextAccessor, Serilog.ILogger logger, IMapper mapper)
{
_context = context;
_logger = logger;
_httpContextAccessor = httpContextAccessor;
_identityManager = identityManager;
_mapper = mapper;
}
public static void Use(Serilog.ILogger logger)
{
Logrila.Logging.Logger.UseLogger(new SerilogLogger(
(name) => logger.ForContext(Serilog.Core.Constants.SourceContextPropertyName, name)));
}
public SerilogLogger(ILoggerSerilog logger)
{
Logger = logger;
}
public LGAccountController(LGAccountService lGAccountService, Serilog.ILogger logger) : base()
{
_lGAccountService = lGAccountService;
_logger = logger;
}
/// <summary>
/// Log to the provided Serilog <see cref="Serilog.ILogger" />.
/// </summary>
/// <param name="configuration">The bus configuration to apply the logger to.</param>
/// <param name="logger">The logger.</param>
/// <returns>Bus configuration.</returns>
public static BusBuilderConfiguration WithSerilogLogger(this BusBuilderConfiguration configuration, ISerilogLogger logger)
{
return configuration
.WithLogger(new SerilogLogger(logger));
}
public static void UseSerilog(this IAppBuilder app, ISerilogLogger logger)
{
app.SetLoggerFactory(new SerilogLoggerFactory(logger));
}
public NuGetPackageBuilder(IOctopusFileSystem fileSystem, Serilog.ILogger log)
{
this.fileSystem = fileSystem;
this.log = log;
}
public SerilogLogger(Serilog.ILogger logger)
{
this.logger = logger;
}
public SerilogAdapter(Serilog.ILogger logger)
{
_logger = logger;
}
/// <summary>
/// Log to the provided Serilog <see cref="Serilog.ILogger" />.
/// </summary>
/// <param name="configuration">The bus configuration to apply the logger to.</param>
/// <param name="logger">The logger. Defaults to Serilogs static logger.</param>
/// <returns>Bus configuration.</returns>
public static BusBuilderConfiguration.Config WithSerilogLogger(this BusBuilderConfiguration.Config configuration, ISerilogLogger logger = null)
{
return configuration
.WithLogger(new Logger(logger));
}
public SerilogLogger(ISerilogLogger logger)
{
_logger = logger;
}
public ZipPackageBuilder(IOctopusFileSystem fileSystem, Serilog.ILogger log)
{
this.fileSystem = fileSystem;
this.log = log;
}
public SerilogWrapper(Serilog.ILogger log)
{
_log = log;
}
/// <summary>
///
/// </summary>
public MonitorController()
{
_logger = Serilog.Log.Logger;
}
public static IServiceCollection UseSerilog(this IServiceCollection services,
Serilog.ILogger logger = null, bool dispose = false)
{
services.AddSingleton <ILoggerFactory>(new SerilogLoggerFactory());
return(services);
}
public PackageVersionResolver(Serilog.ILogger log)
{
this.log = log;
}
public XUnitLogger(Serilog.ILogger logger)
{
this.logger = logger;
}
public DevelopmentPluginInstaller(ILogger logger, IFileSystem fileSystem)
{
_logger = logger;
_fileSystem = fileSystem;
}
internal Logger(Serilog.ILogger logger, Func<TraceEventType, LogEventLevel> getLogEventLevel)
{
_logger = logger;
_getLogEventLevel = getLogEventLevel;
}
