public virtual void Startup()
{
if (this.isStarted)
{
return;
}
if (!this.isInitEnvironment)
{
throw new Exception("call init before on start");
}
var rules = new RegisterRuleCollector();
this.OnStarting?.Invoke(this, new IContainerStartupEventArgs(this.typeFinder, this.assemblies, rules));
/*更新容器*/
this.ruleContainer.Update(rules);
//注入生命周期管理
var rule = default(RegisterRule);
this.rootScope = this.ruleContainer.Build(out rule);
this.serviceLocator = new ServiceLocator(this.rootScope)
{
ScopeTracker = this.scopeTracker
};
this.serviceActivator = new ServiceActivator(this.rootScope, this.ruleContainer);
rule.Builder = rule.OptionalBuilder = (r, q, l, c) => { return(((ServiceLocator)this.serviceLocator).BeginLifetimeScope(this.rootScope)); };
this.isStarted = true;
}
/// <summary>
/// Create required components to use Flatwhite cache for WebApi
/// </summary>
/// <param name="app"></param>
/// <param name="config"></param>
public static IAppBuilder UseFlatwhiteCache(this IAppBuilder app, HttpConfiguration config)
{
Global.CacheStrategyProvider = new WebApiCacheStrategyProvider();
_dependencyResolverActivator = new WebApiDependencyResolverActivator(() => config.DependencyResolver);
var allHandlers = config.DependencyResolver
.GetServices(typeof (ICachControlHeaderHandler))
.OfType<ICachControlHeaderHandler>()
.ToList();
if (allHandlers.All(h => h.GetType() != typeof (EtagHeaderHandler)))
{
var cacheResponseBuilder = config.DependencyResolver.GetService(typeof(ICacheResponseBuilder)) as ICacheResponseBuilder
?? new CacheResponseBuilder();
var etagHeaderHandler = new EtagHeaderHandler(cacheResponseBuilder);
allHandlers.Add(etagHeaderHandler);
}
var handlerProvider = config.DependencyResolver.GetService(typeof(ICachControlHeaderHandlerProvider)) as ICachControlHeaderHandlerProvider
?? new CachControlHeaderHandlerProvider();
allHandlers.ForEach(h => handlerProvider.Register(h));
config.MessageHandlers.Add(new CacheMessageHandler(handlerProvider));
return app;
}
public AggregateTipProvider(MainViewModel mainViewModel, IServiceActivator serviceActivator, IProductProvider productProvider, ILoggerFactory loggerFactory)
: base(loggerFactory)
{
MainViewModel = mainViewModel;
ServiceActivator = serviceActivator;
ProductProvider = productProvider;
}
private void ServiceUpdateNofication(ServiceEventArgs eventArgs)
{
if (Activator != null && _register != null && _register.Contains(eventArgs.ServiceType))
{
Activator = null;
}
}
public CfHandler(IServiceActivator activator, IServiceInvoker invoker, ILogger logger, IQueue queue)
{
_activator = activator;
_invoker = invoker;
_logger = logger;
_queue = queue;
}
public DownloaderResolver(string productName, IServiceActivator serviceActivator)
: base(serviceActivator, distros: null)
{
ProductName = productName;
_build = new Lazy <BuildProviderResolver>(CreateBuild);
_match = new Lazy <MatchProviderResolver>(CreateMatch);
_software = new Lazy <SoftwareProviderResolver>(CreateSoftware);
_download = new Lazy <DownloadProviderResolver>(CreateDownload);
}
protected virtual void StartService(IGrouping <int, ThriftService> group)
{
TMultiplexedProcessor multiplexedProcessor = new TMultiplexedProcessor();
IServiceActivator serviceActivator = GlobalSetting.Container.GetService <IServiceActivator>();
if (serviceActivator == null)
{
throw new NullReferenceException("未设置IServiceActivator接口");
}
foreach (ThriftService service in group)
{
object instance = serviceActivator.Create(service.ServiceType);
if (instance == null)
{
throw new NullReferenceException($"无法创建服务{service.ServiceType.FullName}");
}
Type processorType = ThriftServiceHelper.GetProcessorType(service.ServiceType);
if (processorType == null)
{
throw new NullReferenceException($"无法找到服务{service.ServiceType.FullName}对应的Processor类");
}
TProcessor processor = ThriftServiceHelper.CreateProcessor(processorType, instance);
if (processor == null)
{
throw new NullReferenceException($"无法创建Processor{processorType.FullName}");
}
multiplexedProcessor.RegisterProcessor(service.Name, processor);
}
TServerTransport serverTransport = new TServerSocket(group.Key);
serverTransport.Listen();
TServer server = new TThreadPoolServer(multiplexedProcessor, serverTransport);
_servers.Add(server);
Task.Run(() => server.Serve());
}
/// <summary>
/// Create required components to use Flatwhite cache for WebApi
/// </summary>
/// <param name="config"></param>
/// <param name="flatwhiteConfig"></param>
public static HttpConfiguration UseFlatwhiteCache(this HttpConfiguration config, FlatwhiteWebApiConfiguration flatwhiteConfig = null)
{
_fwConfig = flatwhiteConfig ?? new FlatwhiteWebApiConfiguration();
Global.CacheStrategyProvider = new WebApiCacheStrategyProvider();
Global.BackgroundTaskManager = new RegisteredTasks();
_dependencyResolverActivator = new WebApiDependencyResolverActivator(() => config.DependencyResolver);
var allHandlers = config.DependencyResolver
.GetServices(typeof(ICachControlHeaderHandler))
.OfType <ICachControlHeaderHandler>()
.ToList();
if (allHandlers.All(h => h.GetType() != typeof(EtagHeaderHandler)))
{
var cacheResponseBuilder = config.DependencyResolver.GetService(typeof(ICacheResponseBuilder)) as ICacheResponseBuilder
?? new CacheResponseBuilder();
var etagHeaderHandler = new EtagHeaderHandler(cacheResponseBuilder);
allHandlers.Add(etagHeaderHandler);
}
var handlerProvider = config.DependencyResolver.GetService(typeof(ICachControlHeaderHandlerProvider)) as ICachControlHeaderHandlerProvider
?? new CachControlHeaderHandlerProvider();
allHandlers.ForEach(h => handlerProvider.Register(h));
config.MessageHandlers.Add(new CacheMessageHandler(handlerProvider));
if (_fwConfig.EnableStatusController)
{
config.Routes.MapHttpRoute(
name: "_FlatwhiteStatus",
routeTemplate: "_flatwhite/{action}/{id}",
defaults: new { id = RouteParameter.Optional, controller = "FlatwhiteStatus" }
);
}
return(config);
}
/// <summary>
/// Initialize CacheStrategy with an optional service activator. The default one will be used if not provided
/// </summary>
/// <param name="activator">This is used to resove cache store by cache store TYPE if specified</param>
public DefaultCacheStrategy(IServiceActivator activator = null)
{
_activator = activator ?? Global.ServiceActivator;
}
public ScriptableActionProvider(MainViewModel mainViewModel, IServiceActivator serviceActivator)
: base(mainViewModel, serviceActivator)
{
}
public UpdateActionProvider(MainViewModel mainViewModel, ISourceProvider sourceProvider, IServiceActivator serviceActivator)
: base(mainViewModel, sourceProvider, serviceActivator)
{
}
static ServiceActivator()
{
Instance = new ServiceActivator();
}
public BootableActionProvider(MainViewModel mainViewModel, IServiceActivator serviceActivator, IProductProvider productProvider, IBootProvider bootProvider)
: base(mainViewModel, serviceActivator)
{
ProductProvider = productProvider;
BootProvider = bootProvider;
}
public void Initialize(XDoc config)
{
if(_running) {
_log.WarnMethodCall("Initialize: host already initailized");
throw new InvalidOperationException("already initialized");
}
try {
// initialize container
var containerConfig = config["components"];
if(!containerConfig.IsEmpty) {
_log.Debug("registering host level module");
var builder = new ContainerBuilder();
builder.RegisterModule(new XDocAutofacContainerConfigurator(containerConfig, DreamContainerScope.Host));
builder.Update(_container);
}
// make sure we have an IServiceActivator
if(!_container.IsRegistered<IServiceActivator>()) {
var builder = new ContainerBuilder();
builder.RegisterType<DefaultServiceActivator>().As<IServiceActivator>();
builder.Update(_container);
}
_serviceActivator = _container.Resolve<IServiceActivator>();
_running = true;
_shutdown = new ManualResetEvent(false);
_rootRedirect = config["root-redirect"].AsText;
_debugMode = config["debug"].AsText.IfNullOrEmpty("false").ToLowerInvariant();
_memorizeAliases = config["memorize-aliases"].AsBool ?? true;
// add default prologues/epilogues
_defaultPrologues = new[] {
new DreamFeatureStage("dream.in.*", PrologueDreamIn, DreamAccess.Public)
};
_defaultEpilogues = new[] {
new DreamFeatureStage("dream.out.*", EpilogueDreamOut, DreamAccess.Public)
};
// initialize identity
_id = !config["guid"].IsEmpty ? new Guid(config["guid"].AsText) : Guid.NewGuid();
_localMachineUri = new XUri(string.Format("local://{0}", _id.ToString("N")));
_aliases[_localMachineUri] = _localMachineUri;
// initialize environment
string path = config["host-path"].AsText ?? "host";
_publicUri = config["uri.public"].AsUri ?? new XUri("http://*****:*****@type"].AsText ?? "local";
if("s3".EqualsInvariant(_storageType)) {
_storagePath = config["storage/root"].AsText ?? "";
_storageConfig = config["storage"].Clone();
} else {
_storagePath = config["storage/path"].AsText ?? config["storage-dir"].AsText ?? config["service-dir"].AsText;
if(!Path.IsPathRooted(_storagePath)) {
throw new ArgumentException("missing or invalid storage-dir");
}
}
// log initialization settings
_log.DebugMethodCall("Initialize: guid", _id);
_log.DebugMethodCall("Initialize: apikey", config["apikey"].AsText ?? "(auto)");
_log.DebugMethodCall("Initialize: uri.public", _publicUri);
_log.DebugMethodCall("Initialize: storage-type", _storageType);
_log.DebugMethodCall("Initialize: storage-dir", _storagePath);
_log.DebugMethodCall("Initialize: host-path", path);
_log.DebugMethodCall("Initialize: connect-limit", _connectionLimit);
// add path & type information
config = config.Root;
config.Elem("path", path);
config.Elem("class", GetType().FullName);
config.Elem("sid", "sid://mindtouch.com/2007/03/dream/host");
// set root-uri
Plug.AddEndpoint(this);
// check if we need to fill in the TYPE information using the type
XDoc blueprint = CreateServiceBlueprint(GetType());
// start service
if(_connectionLimit > 0) {
_requestQueue = new ProcessingQueue<Action<Action>>(RequestQueueCallback, _connectionLimit);
}
Coroutine.Invoke(StartService, this, blueprint, path, config, new Result<XDoc>()).Wait();
} catch {
_running = false;
_shutdown.Set();
throw;
}
}
public BootableActionProvider(MainViewModel mainViewModel, IServiceActivator serviceActivator, ICategoryProvider categoryProvider, IBootProvider bootProvider)
: base(mainViewModel, serviceActivator)
{
CategoryProvider = categoryProvider;
BootProvider = bootProvider;
}
public InstallActionProvider(MainViewModel mainViewModel, ISourceProvider sourceProvider, IServiceActivator serviceActivator)
: base(mainViewModel, serviceActivator)
{
SourceProvider = sourceProvider;
}
public InstallActionProvider(MainViewModel mainViewModel, ISourceProvider sourceProvider, ICameraProvider cameraProvider, IServiceActivator serviceActivator)
: base(mainViewModel, serviceActivator)
{
SourceProvider = sourceProvider;
CameraProvider = cameraProvider;
CategoryName = CameraViewModel.Info.Canon.FirmwareRevision > 0
? "PS"
: "EOS";
}
public ControllerContainer(IServiceActivator serviceActivator, IOptions <StepsData> options)
: base(serviceActivator)
{
StepsData = options.Value;
}
protected DataProvider(IServiceActivator serviceProvider)
: base(serviceProvider)
{
_data = new Lazy <IDictionary <string, TData> >(GetData);
}
public ActionContainer(IServiceActivator serviceActivator, IOptions <ActionsData> options)
: base(serviceActivator)
{
ActionsData = options.Value;
_actions = new Lazy <IEnumerable <IAction> >(CreateActions);
}
public MatchProviderResolver(IServiceActivator serviceActivator, IDictionary <string, Distro> distros)
: base(serviceActivator, distros)
{
}
public AggregateDownloaderProvider(IServiceActivator serviceActivator, IProductProvider productProvider)
{
ServiceActivator = serviceActivator;
ProductProvider = productProvider;
_downloaderProviders = new Lazy <IEnumerable <IDownloaderProvider> >(GetDownloaderProviders);
}
public ProductTipProvider(IServiceActivator serviceActivator, string productName = null)
: base(serviceActivator)
{
ProductName = productName;
}
public InstallerProvider(IServiceActivator serviceProvider, IOptions <InstallersData> options)
: base(serviceProvider)
{
InstallersData = options.Value;
}
/// <summary>
/// Create an instance of WebApiCacheStrategy with ServiceActivator
/// </summary>
/// <param name="activator"></param>
public WebApiCacheStrategy(IServiceActivator activator = null)
: base(activator)
{
}
public BrowseActionProvider(MainViewModel mainViewModel, IServiceActivator serviceActivator)
: base(mainViewModel, serviceActivator)
{
}
protected ProviderResolver(IServiceActivator serviceActivator, IDictionary <string, Distro> distros)
: base(serviceActivator)
{
Providers = new ConcurrentDictionary <string, TProvider>();
Distros = distros;
}
public PageContainer(IServiceActivator serviceActivator, MainViewModel mainViewModel, IOptions <StepsData> options)
: base(serviceActivator)
{
MainViewModel = mainViewModel;
StepsData = options.Value;
}
protected Provider(IServiceActivator serviceActivator)
{
ServiceActivator = serviceActivator;
}
public ActionProvider(MainViewModel mainViewModel, IServiceActivator serviceActivator)
{
MainViewModel = mainViewModel;
ServiceActivator = serviceActivator;
}
public InstallActionProvider(MainViewModel mainViewModel, IProductProvider productProvider, ISourceProvider sourceProvider, ICameraProvider cameraProvider, IServiceActivator serviceActivator)
: base(mainViewModel, sourceProvider, cameraProvider, serviceActivator)
{
ProductProvider = productProvider;
}
