internal FormatDetectionStep(PreprocessingStepParams srcFile, IExtensionsRegistry extentions, IStepsFactory preprocessingStepsFactory, IFileSystem fileSystem)
{
this.sourceFile = srcFile;
this.preprocessingStepsFactory = preprocessingStepsFactory;
this.extentions = extentions;
this.fileSystem = fileSystem;
}
public PreprocessingStepsFactory(
Workspaces.IWorkspacesManager workspacesManager,
AppLaunch.ILaunchUrlParser appLaunch,
ISynchronizationContext invoke,
IExtensionsRegistry extentions,
Progress.IProgressAggregator progressAggregator,
Persistence.IWebContentCache cache,
ICredentialsCache credCache,
ILogProviderFactoryRegistry logProviderFactoryRegistry,
WebViewTools.IWebViewTools webBrowserDownloader,
ILogsDownloaderConfig logsDownloaderConfig,
RegularExpressions.IRegexFactory regexFactory
)
{
this.workspacesManager = workspacesManager;
this.appLaunch = appLaunch;
this.invoke = invoke;
this.extentions = extentions;
this.progressAggregator = progressAggregator;
this.cache = cache;
this.credCache = credCache;
this.logProviderFactoryRegistry = logProviderFactoryRegistry;
this.webViewTools = webBrowserDownloader;
this.logsDownloaderConfig = logsDownloaderConfig;
this.regexFactory = regexFactory;
}
public LogSourcesPreprocessingManager(
ISynchronizationContext invokeSynchronize,
IFormatAutodetect formatAutodetect,
IExtensionsRegistry extensions,
IPreprocessingManagerExtension builtinStepsExtension,
Telemetry.ITelemetryCollector telemetry,
ITempFilesManager tempFilesManager,
ILogSourcesManager logSourcesManager,
IShutdown shutdown,
ITraceSourceFactory traceSourceFactory,
IChangeNotification changeNotification
)
{
this.traceSourceFactory = traceSourceFactory;
this.trace = traceSourceFactory.CreateTraceSource("PreprocessingManager", "prepr");
this.invokeSynchronize = invokeSynchronize;
this.formatAutodetect = formatAutodetect;
this.providerYieldedCallback = prov => logSourcesManager.Create(prov.Factory, prov.ConnectionParams).Visible = !prov.IsHiddenLog;
this.extensions = extensions;
this.telemetry = telemetry;
this.tempFilesManager = tempFilesManager;
this.logSourcesManager = logSourcesManager;
this.changeNotification = changeNotification;
extensions.Register(builtinStepsExtension);
shutdown.Cleanup += (sender, e) =>
{
shutdown.AddCleanupTask(this.DeleteAllPreprocessings());
};
}
public Model(
IManager manager,
IStepsFactory stepsFactory,
IExtensionsRegistry extentionsRegistry
)
{
this.Manager = manager;
this.StepsFactory = stepsFactory;
this.ExtensionsRegistry = extentionsRegistry;
}
static void SetFileProvides(IServiceCollection services, IExtensionsRegistry registry, ILoggerFactory loggerFactory)
{
var hostingEnvironment = services.BuildServiceProvider().GetRequiredService <IHostingEnvironment>();
hostingEnvironment.WebRootFileProvider = new ExtensionsFileProviderAggregator(loggerFactory
, (registry as ExtensionsRegistry)?.Extensions
, hostingEnvironment.WebRootFileProvider).Composite;
hostingEnvironment.ContentRootFileProvider = new ExtensionsFileProviderAggregator(loggerFactory
, (registry as ExtensionsRegistry)?.Extensions
, hostingEnvironment.ContentRootFileProvider).Composite;
}
public void Setup()
{
workspacesManager = Substitute.For <IWorkspacesManager>();
appLaunch = Substitute.For <ILaunchUrlParser>();
preprocessingStepsFactory = Substitute.For <IStepsFactory>();
extensions = Substitute.For <IExtensionsRegistry>();
preprocessingStepsFactory.CreateURLTypeDetectionStep(null).ReturnsForAnyArgs(
callInfo => new URLTypeDetectionStep(
callInfo.Arg <PreprocessingStepParams>(), preprocessingStepsFactory, workspacesManager, appLaunch, extensions));
callback = Substitute.For <IPreprocessingStepCallback>();
}
internal URLTypeDetectionStep(
PreprocessingStepParams srcFile,
IStepsFactory preprocessingStepsFactory,
Workspaces.IWorkspacesManager workspacesManager,
AppLaunch.ILaunchUrlParser appLaunch,
IExtensionsRegistry extensions
)
{
this.sourceFile = srcFile;
this.preprocessingStepsFactory = preprocessingStepsFactory;
this.workspacesManager = workspacesManager;
this.appLaunch = appLaunch;
this.extensions = extensions;
}
// make extensions available to MVC application, configures extensions and configures extension services (SRP, split?)
static void AddApplicationParts(IMvcBuilder mvcBuilder, IExtensionsRegistry registry, IServiceCollection services, IConfiguration configuration, ILoggerFactory loggerFactory)
{
foreach (var extension in (registry as ExtensionsRegistry)?.Extensions)
{
var assembly = extension.GetType().Assembly;
mvcBuilder.AddApplicationPart(assembly);
if (extension is IExtensionWithViews)
{
// load compiled views
var directory = extension.Location;
var viewsAssemblyName = (extension as IExtensionWithViews).Views;
var logger = loggerFactory.CreateLogger(nameof(ExtensionsConfigurator));
var viewsAssembly = ExtensionsLoader.LoadAssembly(Path.Combine(directory, viewsAssemblyName), logger);
mvcBuilder.AddApplicationPart(viewsAssembly);
}
extension.ConfigureServices(services, configuration);
}
}
public RequestMiddleware(RequestDelegate next, IExtensionsRegistry registry, IActionDescriptorCollectionProvider actionDescriptorCollectionProvider)
{
this.next = next;
this.registry = registry;
this.routes = new Dictionary <string, IExtension>();
var extAssemblyNames = this.registry.Extensions.Select(t => Path.GetFileName(t.Location));
var extensionControllers = actionDescriptorCollectionProvider.ActionDescriptors.Items.Where(x =>
{
var parts = x.DisplayName.Split('.');
var extensionAssemblyFileName = parts.Length > 0 ? parts[0] : string.Empty;
if (extAssemblyNames.Any(t => t == extensionAssemblyFileName))
{
var route = $"/{x.AttributeRouteInfo?.Template}";
var extension = this.registry.Extensions.SingleOrDefault(x => Path.GetFileName(x.Location) == extensionAssemblyFileName);
/*
* There might be duplicates because of same roots but different verbs (GET, POST, PUT, DELETE)
*/
if (this.routes.ContainsKey(route) == false)
{
this.routes.Add(route, extension);
}
else
{
var existingExtension = this.routes[route];
if (existingExtension != extension)
{
throw new InvalidOperationException($"Route '{route}' is handled by more than on extension.");
}
}
}
return(true);
}).ToArray();
}
public CustomSwaggerFilter(IHttpContextAccessor contextAccessor, IExtensionsRegistry registry, int v)
{
this.contextAccessor = contextAccessor;
this.registry = registry;
}
static void ReplaceControllerFeatureProvider(IServiceCollection services, IExtensionsRegistry registry, ILoggerFactory loggerFactory)
{
var provider = services.BuildServiceProvider();
var partManager = provider.GetRequiredService <ApplicationPartManager>();
var controllerFeatureProvider = partManager.FeatureProviders.SingleOrDefault(p => p is ControllerFeatureProvider);
partManager.FeatureProviders.Remove(controllerFeatureProvider);
partManager.FeatureProviders.Add(new ExtensionsControllerFeatureProvider(registry, loggerFactory));
}
public HomeController(IExtensionsRegistry registry)
{
this.registry = registry;
}
public WebApisController(IExtensionsRegistry extensionsRegistry, SwaggerSelector selectorService)
{
this.extensionsRegistry = extensionsRegistry;
this.selectorService = selectorService;
}
private ExtensionsLoader(ILoggerFactory factory, IExtensionsRegistry registry)
{
this.factory = factory ?? throw new ArgumentNullException(nameof(factory));
this.logger = factory.CreateLogger <ExtensionsLoader>();
this.registry = registry;
}
public ExtensionsControllerFeatureProvider(IExtensionsRegistry registry, ILoggerFactory loggerFactory)
{
this.logger = loggerFactory.CreateLogger <ExtensionsControllerFeatureProvider>();
this.registry = registry;
}
