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);
})();
