/// <summary>
        /// 
        /// </summary>
        /// <param name="appHost"></param>
        public void Register( IAppHost appHost )
        {
            Verify.ArgumentNotNull(appHost, "appHost");

            _appHost = appHost;
            _appHost.GlobalRequestFilters.Add((req, res, dto) => ProcessRequest(req, res, dto));
        }

 public S3VirtualPathProvider(IAmazonS3 client, string bucketName, IAppHost appHost)
     : base(appHost)
 {
     this.AmazonS3 = client;
     this.BucketName = bucketName;
     this.rootDirectory = new S3VirtualDirectory(this, null);
 }

        public void AfterPluginsLoaded(IAppHost appHost)
        {
            var container = appHost.GetContainer();

            if (container.Exists<IpModuleManager>())
            {
                var manager = container.Resolve<IpModuleManager>();

                manager.DeviceStatusChanged += (sender, args) =>
                {
                    logger.DebugFormat("{0}:{1}[{2}]", args.Device.Name, args.Device.Status, args.Device.ZoneId);
                    var settings = container.Resolve<SmartThingsSettings>();
                    var cb = new SmartThingsCallbacks(settings);
                    cb.PutDeviceUpdate(args.Device);
                };

                manager.PartitionStatusChanged += (sender, args) =>
                {
                    logger.DebugFormat("{0}:{1}", args.Partition.Name, args.Partition.Status);
                    var settings = container.Resolve<SmartThingsSettings>();
                    var cb = new SmartThingsCallbacks(settings);
                    cb.PutPartitionUpdate(args.Partition);
                };
            }
            else
            {
                logger.Error("Cannot find Ip Module Manager to register device and partition status changes events for SmartThings");
            }

        }

        public void Register(IAppHost appHost)
        {
            appHost.GlobalResponseFilters.Add(filter);

            if (ApplyToMessaging)
                appHost.GlobalMessageResponseFilters.Add(filter);
        }

 /// <summary>
 /// Activate the validation mechanism, so every request DTO with an existing validator
 /// will be validated.
 /// </summary>
 /// <param name="appHost">The app host</param>
 public void Register(IAppHost appHost)
 {
     if (Enabled) return;
     Enabled = true;
     var filter = new ValidationFilters();
     appHost.RequestFilters.Add(filter.RequestFilter);
 }

        public void Register(IAppHost appHost)
        {
            if (alreadyConfigured) return;
                alreadyConfigured = true;

            appHost.GlobalRequestFilters.Add(ExtractTokenFromRequestFilter);
        }

        public void Register(IAppHost appHost)
        {
            appHost.CatchAllHandlers.Add(ProcessRequest);

            appHost.GetPlugin<MetadataFeature>()
                .AddDebugLink($"?{Keywords.Debug}={Keywords.RequestInfo}", "Request Info");
        }

        protected AbstractVirtualPathProviderBase(IAppHost appHost)
        {
            if (appHost == null)
                throw new ArgumentNullException("appHost");

            AppHost = appHost;
        }

 public void Register(IAppHost appHost)
 {
     // Get all of the services in this assembly that inherit from ServiceStackService
     GetType().Assembly.GetTypes().Where(a => a.BaseType == typeof(Service)).ToList()
         // Register the Service
         .Each(service => appHost.RegisterService(service));
 }

 public void Register(IAppHost appHost)
 {
     if (ResourceFilterPattern != null)
         SwaggerResourcesService.resourceFilterRegex = new Regex(ResourceFilterPattern, RegexOptions.Compiled);
     appHost.RegisterService(typeof (SwaggerResourcesService), new string[] {"/resources"});
     appHost.RegisterService(typeof(SwaggerApiService), new string[] { "/resource/{Name*}" });
 }

        public void Register(IAppHost appHost)
        {
            appHost.Register<INativeTypesMetadata>(
                new NativeTypesMetadata(appHost.Metadata, MetadataTypesConfig));

            appHost.RegisterService<NativeTypesService>();
        }

        public AspNetWindowsAuthProvider(IAppHost appHost)
        {
            Provider = Name;
            AuthRealm = Realm;

            AllRoles = new List<string>();
            LimitAccessToRoles = new List<string>();

            if (!(appHost is AppHostBase))
            {
                throw new NotSupportedException(
                    "AspNetWindowsAuthProvider is only supported on ASP.NET hosts");
            }

            //Add all pre-defined Roles used to in App to 'AllRoles'
            appHost.AfterInitCallbacks.Add(host =>
            {
                var requiredRoles = host.Metadata.OperationsMap
                    .SelectMany(x => x.Key.AllAttributes<RequiredRoleAttribute>()
                        .Concat(x.Value.ServiceType.AllAttributes<RequiredRoleAttribute>()))
                    .SelectMany(x => x.RequiredRoles);

                requiredRoles.Each(x => AllRoles.AddIfNotExists(x));
            });
        }

 public void Register( IAppHost appHost )
 {
     this.AppHost = appHost;
     this.ViewManager = new ViewManager( appHost, this.ViewConfig );
     this.BuildManager = new BuildManager( appHost, this.BuildConfig );
     this.PageResolver = new PageResolver( appHost, this.ResolveConfig, this.ViewManager, this.BuildManager );
 }

        public void Register(IAppHost appHost)
        {
            if (isInstalled) return;
            isInstalled = true;

            if (!string.IsNullOrEmpty(allowedOrigins) && allowOriginWhitelist == null)
                appHost.Config.GlobalResponseHeaders.Add(HttpHeaders.AllowOrigin, allowedOrigins);
            if (!string.IsNullOrEmpty(allowedMethods))
                appHost.Config.GlobalResponseHeaders.Add(HttpHeaders.AllowMethods, allowedMethods);
            if (!string.IsNullOrEmpty(allowedHeaders))
                appHost.Config.GlobalResponseHeaders.Add(HttpHeaders.AllowHeaders, allowedHeaders);
            if (allowCredentials)
                appHost.Config.GlobalResponseHeaders.Add(HttpHeaders.AllowCredentials, "true");

            if (allowOriginWhitelist != null)
            {
                appHost.GlobalRequestFilters.Add((httpReq, httpRes, requestDto) =>
                    {
                        var origin = httpReq.Headers.Get("Origin");
                        if (allowOriginWhitelist.Contains(origin))
                        {
                            httpRes.AddHeader(HttpHeaders.AllowOrigin, origin);
                        }
                    });
            }
        }

        public void Register(IAppHost appHost)
        {
            appHost.Routes.Add(typeof(GetAssetClassRequest), "/rest/assetclasses", "GET");
            appHost.Routes.Add(typeof(GetAssetClassRequest), "/rest/assetclasses/{AssetClass}", "GET");

            appHost.RegisterService(typeof(AssetClassService), "");
        }

        public void Register(IAppHost appHost)
        {
            appHost.RegisterService<RequestLogsService>(AtRestPath);

            var requestLogger = RequestLogger ?? new InMemoryRollingRequestLogger(Capacity);
            requestLogger.EnableSessionTracking = EnableSessionTracking;
            requestLogger.EnableResponseTracking = EnableResponseTracking;
            requestLogger.EnableRequestBodyTracking = EnableRequestBodyTracking;
            requestLogger.EnableErrorTracking = EnableErrorTracking;
            requestLogger.RequiredRoles = RequiredRoles;
            requestLogger.ExcludeRequestDtoTypes = ExcludeRequestDtoTypes;
            requestLogger.HideRequestBodyForRequestDtoTypes = HideRequestBodyForRequestDtoTypes;

            appHost.Register(requestLogger);

            if (EnableRequestBodyTracking)
            {
                appHost.PreRequestFilters.Insert(0, (httpReq, httpRes) => {
                    httpReq.UseBufferedStream = EnableRequestBodyTracking;
                });
            }

            appHost.GetPlugin<MetadataFeature>()
                .AddDebugLink(AtRestPath, "Request Logs");
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="appHost"></param>
        public void Register(IAppHost appHost)
        {
            var inMemoryProvider = new RecursiveInMemoryVirtualPathProvider(appHost);
            // Create a "Views" directory for dumping all our discovered views in
            var viewsDir = new InMemoryVirtualDirectory(inMemoryProvider, inMemoryProvider.rootDirectory)
            {
                DirName = "Views",
                files = new List<InMemoryVirtualFile>(),
                dirs = new List<InMemoryVirtualDirectory>()
            };
            inMemoryProvider.rootDirectory.dirs.Add(viewsDir);

            foreach (var asm in _assemblies)
            {
                foreach (string resource in asm.GetManifestResourceNames())
                {
                        // Get just the file name. Internally, ServiceStack dumps all these in a giant "/Views" directory anyway, so let's just do that.
                        string path = string.Join(".", resource.Split('.').Reverse().Take(2).Reverse());
                        viewsDir.AddFile(path, new StreamReader(asm.GetManifestResourceStream(resource)).ReadToEnd());
                }
            }

            var razorPlugin = new RazorFormat
            {
                VirtualPathProvider = inMemoryProvider,
                EnableLiveReload = false
            };

            appHost.LoadPlugin(razorPlugin);
        }

        public void AfterPluginsLoaded(IAppHost appHost)
        {
            var container = appHost.GetContainer();

            if (container.Exists<IpModuleManager>())
            {
                var manager = container.Resolve<IpModuleManager>();

                manager.DeviceStatusChanged += (sender, args) =>
                {
                    var cb = container.Resolve<IParadoxEventCallbacks>();
                    cb.PutDeviceUpdate(args.Device);
                };

                manager.PartitionStatusChanged += (sender, args) =>
                {
                    var cb = container.Resolve<IParadoxEventCallbacks>();
                    cb.PutPartitionUpdate(args.Partition);
                };
            }
            else
            {
                logger.Error("Cannot find Ip Module Manager to register device and partition status changes events for MQTT");
            }
        }

        public void Register(IAppHost appHost)
        {
            appHost.CatchAllHandlers.Add(ProcessRequest);

            appHost.GetPlugin<MetadataFeature>()
                .AddDebugLink("?debug=requestinfo", "Request Info");
        }

 /// <summary> Adds a request filter to apphost </summary>
 /// <param name="appHost"> the app host</param>
 public void Register(IAppHost appHost) {           
     appHost.RequestFilters.Add( (request, response, dto) => {
       if (!AcceptedRequests.Contains(request.ContentType, StringComparer.OrdinalIgnoreCase)) {
           response.StatusCode = 406;
           response.Close();
       }              
     });
 }