I've been working quite a bit with Windows Services in
the recent months, and well, it turns out that Windows Services are quite a bear to debug, deploy, update and maintain.
The process
of getting services set up, debugged and updated is a major chore that has to be extensively documented and or automated specifically. On most projects when a service is built, people
end up scrambling for
the right 'process' to use for administration. Web app deployment and maintenance on
the other hand are common and well understood today, as we are constantly dealing with Web apps. There's plenty
of infrastructure and tooling built into Web Tools like Visual Studio to facilitate
the process. By comparison Windows Services or anything self-hosted for that matter seems convoluted.In fact, in a recent blog post I mentioned that on a recent project I'd been using self-hosting for SignalR inside
of a Windows service, because
the application is in fact a 'service' that also needs to send out lots
of messages via SignalR. But
the reality is that it could just as well be an IIS application with a service component that runs in
the background. Either way you look at it, it's either a Windows Service with a built in Web Server, or an IIS application running a Service application, neither
of which follows
the standard Service or Web App template.Personally I much prefer Web applications. Running inside
of IIS I get all
the benefits
of the IIS platform including service lifetime management (crash and restart), controlled shutdowns,
the whole security infrastructure including easy certificate support, hot-swapping
of code and
the the ability to publish directly to IIS from within Visual Studio with ease.Because
of these benefits we set out to move from
the self hosted service into an ASP.NET Web app instead.
The Missing Link for ASP.NET as a Service: Auto-LoadingI've had moments in
the past where I wanted to run a 'service like' application in ASP.NET because when you think about it, it's so much easier to control a Web application remotely. Services are locked into start/stop operations, but if you host inside
of a Web app you can write your own ticket and control it from anywhere. In fact nearly 10 years ago I built a background scheduling application that ran inside
of ASP.NET and it worked great and it's still running doing its job today.
The tricky part for running an app as a service inside
of IIS then and now, is how to get IIS and ASP.NET launched so your 'service' stays alive even after an Application Pool reset. 7 years ago I faked it by using a web monitor (my own West Wind Web Monitor app) I was running anyway to monitor my various web sites for uptime, and having
the monitor ping my 'service' every 20 seconds to effectively keep ASP.NET alive or fire it back up after a reload. I used a simple scheduler class that also includes some logic for 'self-reloading'. Hacky for sure, but it worked reliably.Luckily today it's much easier and more integrated to get IIS to launch ASP.NET as soon as an Application Pool is started by using
the Application Initialization Module.
The Application Initialization Module basically allows you to turn on Preloading on
the Application Pool and
the Site/IIS App, which essentially fires a request through
the IIS pipeline as soon as
the Application Pool has been launched. This means that effectively your ASP.NET app becomes active immediately, Application_Start is fired making sure your app stays up and running at all times. All
the other features like Application Pool recycling and auto-shutdown after idle time still work, but IIS will then always immediately re-launch
the application.Getting started with Application InitializationAs
of IIS 8 Application Initialization is part
of the IIS feature set. For IIS 7 and 7.5 there's a separate download available via Web Platform Installer. Using IIS 8 Application Initialization is an optional install component in Windows or
the Windows Server Role Manager:
This is an optional component so make sure you explicitly select it.IIS Configuration for Application InitializationInitialization needs to be applied on
the Application Pool as well as
the IIS Application level. As
of IIS 8 these settings can be made through
the IIS Administration console.Start with
the Application Pool:Here you need to set both
the Start Automatically which is always set, and
the StartMode which should be set to AlwaysRunning. Both have to be set -
the Start Automatically flag is set true by default and controls
the starting
of the application pool itself while Always Running flag is required in order to launch
the application. Without
the latter flag set
the site settings have no effect.Now on
the Site/Application level you can specify whether
the site should pre load:
Set
the Preload Enabled flag to true.At this point ASP.NET apps should auto-load. This is all that's needed to pre-load
the site if all you want is to get your site launched automatically.If you want a little more control over
the load process you can add a few more settings to your web.config file that allow you to show a static page while
the App is starting up. This can be useful if startup is really slow, so rather than displaying blank screen while
the user is fiddling their thumbs you can display a static HTML page instead: <system.webServer>
<applicationInitialization remapManagedRequestsTo="Startup.htm"
skipManagedModules="true">
<add initializationPage="ping.ashx" />
</applicationInitialization>
</system.webServer>This allows you to specify a page to execute in a dry run. IIS basically fakes request and pushes it directly into
the IIS pipeline without hitting
the network. You specify a page and IIS will fake a request to that page in this case ping.ashx which just returns a simple OK string - ie. a fast pipeline request. This request is run immediately after Application Pool restart, and while this request is running and your app is warming up, IIS can display an alternate static page - Startup.htm above. So instead
of showing users an empty loading page when clicking a link on your site you can optionally show some sort
of static status page that says, "we'll be right back". I'm not sure if that's such a brilliant idea since this can be pretty disruptive in some cases. Personally I think I prefer letting people wait, but at least get
the response they were supposed to get back rather than a random page. But it's there if you need it.Note that
the web.config stuff is optional. If you don't provide it IIS hits
the default site link (/) and even if there's no matching request at
the end of that request it'll still fire
the request through
the IIS pipeline. Ideally though you want to make sure that an ASP.NET endpoint is hit either with your default page, or by specify
the initializationPage to ensure ASP.NET actually gets hit since it's possible for IIS fire unmanaged requests only for static pages (depending how your pipeline is configured).What about AppDomain Restarts?In addition to full Worker Process recycles at
the IIS level, ASP.NET also has to deal with AppDomain shutdowns which can occur for a variety
of reasons:Files are updated in
the BIN folderWeb Deploy to your siteweb.config is changedHard application crashThese operations don't cause
the worker process to restart, but they do cause ASP.NET to unload
the current AppDomain and start up a new one. Because
the features above only apply to Application Pool restarts, AppDomain restarts could also cause your 'ASP.NET service' to stop processing in
the background.In order to keep
the app running on AppDomain recycles, you can resort to a simple ping in
the Application_End event:protected void Application_End()
{
var client = new WebClient();
var url = App.AdminConfiguration.MonitorHostUrl + "ping.aspx";
client.DownloadString(url);
Trace.WriteLine("Application Shut Down Ping: " + url);
}which fires any ASP.NET url to
the current site at
the very
end of the pipeline shutdown which in turn ensures that
the site immediately starts back up.Manual Configuration in ApplicationHost.configThe above UI corresponds to
the following ApplicationHost.config settings. If you're using IIS 7, there's no UI for these flags so you'll have to manually edit them.When you install
the Application Initialization component into IIS it should auto-configure
the module into ApplicationHost.config. Unfortunately for me, with Mr. Murphy in his best form for me,
the module registration did not occur and I had to manually add it.<globalModules>
<add name="ApplicationInitializationModule"
image="%windir%\System32\inetsrv\warmup.dll" />
</globalModules>Most likely you won't need ever need to add this, but if things are not working it's worth to check if
the module is actually registered.Next you need to configure
the ApplicationPool and
the Web site.
The following are
the two relevant entries in ApplicationHost.config.<system.applicationHost>
<applicationPools>
<add name="West Wind West Wind Web Connection"
autoStart="true"
startMode="AlwaysRunning"
managedRuntimeVersion="v4.0"
managedPipelineMode="Integrated">
<processModel identityType="LocalSystem"
setProfileEnvironment="true" />
</add>
</applicationPools>
<sites>
<site name="Default Web Site" id="1">
<application path="/MPress.Workflow.WebQueueMessageManager"
applicationPool="West Wind West Wind Web Connection"
preloadEnabled="true">
<virtualDirectory path="/"
physicalPath="C:\Clients\…" />
</application>
</site>
</sites>
</system.applicationHost>On
the Application Pool make sure to set
the autoStart and startMode flags to true and AlwaysRunning respectively. On
the site make sure to set
the preloadEnabled flag to true.And that's all you should need. You can still set
the web.config settings described above as well.ASP.NET as a Service?In
the particular application I'm working on currently, we have a queue manager that runs as standalone service that polls a database queue and picks out jobs and processes them on several threads.
The service can spin up any number
of threads and keep these threads alive in
the background while IIS is running doing its own thing. These threads are newly created threads, so they sit completely outside
of the IIS thread pool. In order for this service to work all it needs is a long running reference that keeps it alive for
the life time
of the application.In this particular app there are two components that run in
the background on their own threads: A scheduler that runs various scheduled tasks and handles things like picking up emails to send out outside
of IIS's scope and
the QueueManager. Here's what this looks like in global.asax:public class Global : System.Web.HttpApplication
{
private static ApplicationScheduler scheduler;
private static ServiceLauncher launcher;
protected void Application_Start(object sender, EventArgs e)
{
// Pings
the service and ensures it stays alive
scheduler = new ApplicationScheduler()
{
CheckFrequency = 600000
};
scheduler.Start();
launcher = new ServiceLauncher();
launcher.Start();
// register so shutdown is controlled
HostingEnvironment.RegisterObject(launcher);
}}By keeping these objects around as static instances that are set only once on startup, they survive
the lifetime
of the application.
The code in these classes is essentially unchanged from
the Windows Service code except that I could remove
the various overrides required for
the Windows Service interface (OnStart,OnStop,OnResume etc.). Otherwise
the behavior and operation is very similar.In this application ASP.NET serves two purposes: It acts as
the host for SignalR and provides
the administration interface which allows remote management
of the 'service'. I can start and stop
the service remotely by shutting down
the ApplicationScheduler very easily. I can also very easily feed stats from
the queue out directly via a couple
of Web requests or (as we do now) through
the SignalR service.Registering a Background Object with ASP.NETNotice also
the use
of the HostingEnvironment.RegisterObject(). This function registers an object with ASP.NET to let it know that it's a background task that should be notified if
the AppDomain shuts down. RegisterObject() requires an interface with a Stop() method that's fired and allows your code to respond to a shutdown request. Here's what
the IRegisteredObject::Stop() method looks like on
the launcher:public void Stop(bool immediate = false)
{
LogManager.Current.LogInfo("QueueManager Controller Stopped.");
Controller.StopProcessing();
Controller.Dispose();
Thread.Sleep(1500); // give background threads some time
HostingEnvironment.UnregisterObject(this);
}Implementing IRegisterObject should help with reliability on AppDomain shutdowns. Thanks to Justin Van Patten for pointing this out to me on Twitter.RegisterObject() is not required but I would highly recommend implementing it on whatever object controls your background processing to all clean shutdowns when
the AppDomain shuts down.Testing it outI'm still in
the testing phase with this particular service to see if there are any side effects. But so far it doesn't look like it. With about 50 lines
of code I was able to replace
the Windows service startup to Web start up - everything else just worked as is. An honorable mention goes to SignalR 2.0's oWin hosting, because with
the new oWin based hosting no code changes at all were required, merely a couple
of configuration file settings and an assembly directive needed, to point at
the SignalR startup class. Sweet!It also seems like SignalR is noticeably faster running inside
of IIS compared to self-host. Startup feels faster because
of the preload.Starting and Stopping
the 'Service'Because
the application is running as a Web Server, it's easy to have a Web interface for starting and stopping
the services running inside
of the service. For our queue manager
the SignalR service and front monitoring app has a play and stop button for toggling
the queue.If you want more administrative control and have it work more like a Windows Service you can also stop
the application pool explicitly from
the command line which would be equivalent to stopping and restarting a service.To start and stop from
the command line you can use
the IIS appCmd tool. To stop:> %windir%\system32\inetsrv\appcmd stop apppool /apppool.name:"Weblog"and to start> %windir%\system32\inetsrv\appcmd start apppool /apppool.name:"Weblog"Note that when you explicitly force
the AppPool to stop running either in
the UI (on
the ApplicationPools page use Start/Stop) or via command line tools,
the application pool will not auto-restart immediately. You have to manually start it back up.What's not to like?There are certainly a lot
of benefits to running a background service in IIS, but… ASP.NET applications do have more overhead in terms
of memory footprint and startup time is a little slower, but generally for server applications this is not a big deal. If
the application is stable
the service should fire up and stay running indefinitely. A lot
of times this kind
of service interface can simply be attached to an existing Web application, or if scalability requires be offloaded to its own Web server.Easier to work withBut
the ultimate benefit here is that it's much easier to work with a Web app as opposed to a service. While developing I can simply turn off
the auto-launch features and launch
the service on demand through IIS simply by hitting a page on
the site. If I want to shut down an IISRESET -stop will shut down
the service easily enough. I can then attach a debugger anywhere I want and this works like any other ASP.NET application. Yes you
end up on a background thread for debugging but Visual Studio handles that just fine and if you stay on a single thread this is no different than debugging any other code.SummaryUsing ASP.NET to run background service operations is probably not a super common scenario, but it probably should be something that is considered carefully when building services. Many applications have service like features and with
the auto-start functionality
of the Application Initialization module, it's easy to build this functionality into ASP.NET. Especially when combined with
the notification features
of SignalR it becomes very, very easy to create rich services that can also communicate their status easily to
the outside
world.Whether it's existing applications that need some background processing for scheduling related tasks, or whether you just create a separate site altogether just to host your service it's easy to do and you can leverage
the same tool chain you're already using for other Web projects. If you have lots
of service projects it's worth considering… give it some thought…© Rick Strahl, West Wind Technologies, 2005-2013Posted in ASP.NET SignalR IIS
Tweet
!function(d,s,id){var js,fjs=d.getElementsByTagName(s)[0];if(!d.getElementById(id)){js=d.createElement(s);js.id=id;js.src="//platform.twitter.com/widgets.js";fjs.parentNode.insertBefore(js,fjs);}}(document,"script","twitter-wjs");
(function() {
var po = document.createElement('script'); po.type = 'text/javascript'; po.async = true;
po.src = 'https://apis.google.com/js/plusone.js';
var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(po, s);
})();
