Quartz.Net

Quartz.Net scheduler exposed via a Web Service

Tarun Arora [Microsoft MVP] — Sun, 20 Jan 2013 14:24:00 GMT

Originally posted on: http://geekswithblogs.net/TarunArora/archive/2013/01/20/quartz.net-scheduler-exposed-via-a-web-service.aspx

I had been given a business requirement to provide a self service Website for job scheduling. Having worked with Quartz.Net, it seemed the perfect backend engine to schedule and process jobs. I decided to expose the functionality of the Quartz.Net via a few web methods using Web services to allow for it to be consumed in Excel, SharePoint, a Web or a desktop app. In this blog post I’ll show you how to expose Quartz.Net via a Web Service.

If you are new to Quartz.Net I would recommend going through,

01 - A brief introduction to Quartz.net

02 - Walkthrough of Installing & Testing Quartz.Net as a Windows Service

03 - Writing & Scheduling your First Hello World job with Quartz.Net

04 - How to Configuring Logging for Quartz.Net windows service

05 -Config Gotyas when setting up Quartz.Net on the server

01 – Architecture

- The Scheduler Web Service (Scheduler.asmx) is hosted on a Web Server.

- I currently have 3 App Servers which are running Quartz.Net as a windows service. The names of these app servers are ‘Alpha’, ‘Beta’ and ‘Gamma’. I have added a firewall exception for port 555 for Quartz.Net to listen on port 555.

- Tags: Interesting! Now you would ask, what are tags? Tags are basically my way of identifying which type of scheduled jobs is my quartz app server capable of running. For instance Alpha is only equipped to schedule PowerShell specific jobs, while Beta can schedule VBA jobs and Gamma can schedule any job that requires the cmd process. You can scale this out to include .Net, Python or just different versions of a process.

- XML: The xml config you see flowing from the user to the web server is the job description i.e. the request for scheduling Job X while specifying the schedule, priority, etc.

02 – Business Logic

Please see the business Logic below for the methods you have seen in the web service signature above.

using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Configuration;
using System.Linq;
using Quartz;
using Quartz.Impl;
using Quartz.Impl.Matchers;
using Rte.Model.Entities;

namespace Scheduler.Business
{
    public class Scheduler
    {
        public readonly IScheduler Instance;
        public string Address { get; private set; }
        public string JobName { get; set; }
        public string JobGroup { get; set; }
        public int Priority { get; set; }
        public string CronExpression { get; set; }

        private readonly ISchedulerFactory _schedulerFactory;


        public Scheduler(string server, int port, string scheduler)
        {
            Address = string.Format("tcp://{0}:{1}/{2}", server, port, scheduler);
            _schedulerFactory = new StdSchedulerFactory(GetProperties(Address));

            try
            {
                Instance = _schedulerFactory.GetScheduler();

                if (!Instance.IsStarted)
                    Instance.Start();
            }
            catch (SchedulerException ex)
            {
                throw new Exception(string.Format("Failed: {0}", ex.Message));
            }
        }

        private static NameValueCollection GetProperties(string address)
        {
            var properties = new NameValueCollection();
            properties["quartz.scheduler.instanceName"] = "ServerScheduler";
            properties["quartz.scheduler.proxy"] = "true";
            properties["quartz.threadPool.threadCount"] = "0";
            properties["quartz.scheduler.proxy.address"] = address;
            return properties;
        }

        public IScheduler GetScheduler()
        {
            return Instance;
        }

        public List<GroupStatus> GetGroups()
        {
            var results = new List<GroupStatus>();
            foreach (var gp in Instance.GetJobGroupNames())
            {
                results.Add(new GroupStatus()
                    {
                        Group = gp,
                        IsJobGroupPaused = Instance.IsJobGroupPaused(gp),
                        IsTriggerGroupPaused = Instance.IsTriggerGroupPaused(gp)
                    });
            }
            return results;
        }

        public JobSchedule GetSchedule()
        {
            var jobKey = new JobKey(JobName, JobGroup);

            var trigger = Instance.GetTriggersOfJob(jobKey).FirstOrDefault();

            var js = new JobSchedule();

            if (trigger != null)
            {
                js.Name = trigger.Key.Name;
                js.Group = trigger.Key.Group;
                js.Description = trigger.Description;
                js.Priority = trigger.Priority;
                js.TriggerType = trigger.GetType().Name;
                js.TriggerState = Instance.GetTriggerState(trigger.Key).ToString();

                DateTimeOffset? startTime = trigger.StartTimeUtc;
                js.StartTime = TimeZone.CurrentTimeZone.ToLocalTime(startTime.Value.DateTime);

                var nextFireTime = trigger.GetNextFireTimeUtc();
                if (nextFireTime.HasValue)
                {
                    js.NextFire = TimeZone.CurrentTimeZone.ToLocalTime(nextFireTime.Value.DateTime);
                }

                var previousFireTime = trigger.GetPreviousFireTimeUtc();
                if (previousFireTime.HasValue)
                {
                    js.LastFire = TimeZone.CurrentTimeZone.ToLocalTime(previousFireTime.Value.DateTime);
                }
            }

            return js;
        }

        public List<JobSchedule> GetSchedules()
        {
            var jcs = new List<JobSchedule>();

            foreach (var group in Instance.GetJobGroupNames())
            {
                var groupMatcher = GroupMatcher<JobKey>.GroupContains(group);
                var jobKeys = Instance.GetJobKeys(groupMatcher);

                foreach (var jobKey in jobKeys)
                {
                    var triggers = Instance.GetTriggersOfJob(jobKey);
                    foreach (var trigger in triggers)
                    {
                        var js = new JobSchedule();
                        js.Name = jobKey.Name;
                        js.Group = jobKey.Group;
                        js.TriggerType = trigger.GetType().Name;
                        js.TriggerState = Instance.GetTriggerState(trigger.Key).ToString();
                        js.Priority = trigger.Priority;

                        DateTimeOffset? startTime = trigger.StartTimeUtc;
                        js.StartTime = TimeZone.CurrentTimeZone.ToLocalTime(startTime.Value.DateTime);

                        DateTimeOffset? nextFireTime = trigger.GetNextFireTimeUtc();
                        if (nextFireTime.HasValue)
                        {
                            js.NextFire = TimeZone.CurrentTimeZone.ToLocalTime(nextFireTime.Value.DateTime);
                        }

                        DateTimeOffset? previousFireTime = trigger.GetPreviousFireTimeUtc();
                        if (previousFireTime.HasValue)
                        {
                            js.LastFire = TimeZone.CurrentTimeZone.ToLocalTime(previousFireTime.Value.DateTime);
                        }

                        jcs.Add(js);
                    }
                }
            }
            return jcs;
        }

        public List<JobSchedule> GetSchedules(string groupName)
        {
            var jcs = new List<JobSchedule>();

            var groupMatcher = GroupMatcher<JobKey>.GroupContains(groupName);
            var jobKeys = Instance.GetJobKeys(groupMatcher);

            foreach (var jobKey in jobKeys)
            {
                var triggers = Instance.GetTriggersOfJob(jobKey);
                foreach (var trigger in triggers)
                {
                    var js = new JobSchedule();
                    js.Name = jobKey.Name;
                    js.Description = trigger.Description;
                    js.Group = jobKey.Group;
                    js.TriggerType = trigger.GetType().Name;
                    js.TriggerState = Instance.GetTriggerState(trigger.Key).ToString();
                    js.Priority = trigger.Priority;

                    DateTimeOffset? startTime = trigger.StartTimeUtc;
                    js.StartTime = TimeZone.CurrentTimeZone.ToLocalTime(startTime.Value.DateTime);

                    DateTimeOffset? nextFireTime = trigger.GetNextFireTimeUtc();
                    if (nextFireTime.HasValue)
                    {
                        js.NextFire = TimeZone.CurrentTimeZone.ToLocalTime(nextFireTime.Value.DateTime);
                    }

                    DateTimeOffset? previousFireTime = trigger.GetPreviousFireTimeUtc();
                    if (previousFireTime.HasValue)
                    {
                        js.LastFire = TimeZone.CurrentTimeZone.ToLocalTime(previousFireTime.Value.DateTime);
                    }

                    jcs.Add(js);
                }
            }
            return jcs;
        }

        public string GetMetaData()
        {
            var metaData = Instance.GetMetaData();

            return string.Format(
                "{0}Name: '{1}'{0}Version: '{2}'{0}ThreadPoolSize: '{3}'{0}IsRemote: '{4}'{0}JobStoreName: '{5}'

                 {0}SupportsPersistance: '{6}'{0}IsClustered: '{7}'",
                Environment.NewLine, metaData.SchedulerName, metaData.Version, metaData.ThreadPoolSize,
                metaData.SchedulerRemote, metaData.JobStoreType.Name, metaData.JobStoreSupportsPersistence,
                metaData.JobStoreClustered);
        }

        public bool UnscheduleJob()
        {
            var jobKey = new JobKey(JobName, JobGroup);

            if (Instance.CheckExists(jobKey))
            {
                return Instance.UnscheduleJob(new TriggerKey(JobName, JobGroup));
            }
            return false;
        }

        public bool UnscheduleAll()
        {
            foreach (var group in Instance.GetTriggerGroupNames())
            {
                var groupMatcher = GroupMatcher<JobKey>.GroupContains(group);
                var jobKeys = Instance.GetJobKeys(groupMatcher);

                foreach (var triggers in jobKeys.Select(jobKey => Instance.GetTriggersOfJob(jobKey)))
                {
                    return Instance.UnscheduleJobs(triggers.Select(t => t.Key).ToList());
                }
            }
            return false;
        }

        public void DeleteAll()
        {
            Instance.Clear();
        }

        public void RescheduleJob()
        {
            // Build new trigger
            var trigger = (ICronTrigger)TriggerBuilder.Create()
                .WithIdentity(JobName, JobGroup)
                .WithCronSchedule(CronExpression)
                .WithPriority(Priority)
                //.StartAt(StartAt.ToUniversalTime())
                .Build();

            Instance.RescheduleJob(new TriggerKey(JobName, JobGroup), trigger);
        }
    }
}

I hope this is useful for you…

This was sixth in the series of posts on enterprise scheduling using Quartz.net, in the next post I’ll be covering how to build a sample MVC website to look at the jobs scheduled via Quartz.Net scheduling windows service. All Quartz.Net specific blog posts are listed here. Thank you for taking the time out and reading this blog post. If you enjoyed the post, remember to subscribe to http://feeds.feedburner.com/TarunArora. Stay tuned!

Quartz.Net Windows Service on Server Important Configuration Steps To Remember

Tarun Arora [Microsoft MVP] — Sat, 19 Jan 2013 15:51:00 GMT

Originally posted on: http://geekswithblogs.net/TarunArora/archive/2013/01/19/quartz.net-windows-service-on-server-important-configuration-steps-to-remember.aspx

Are you running Quartz.Net as a windows service on a remote server and trying to connect to it from a client to schedule jobs? Then I would highly recommend reading the below listed configuration steps to save your self from endless hours of debugging.

01 – How to ensure that the Quartz.NET service is executing jobs on the server and not locally?
02 – Fixing “Scheduler with the name xxx already exists.” issue

If you are new to Quartz.Net I would recommend going through,

01 - A brief introduction to Quartz.net

02 - Walkthrough of Installing & Testing Quartz.Net as a Windows Service

03 - Writing & Scheduling your First Hello World job with Quartz.Net

04 - How to Configuring Logging for Quartz.Net windows service

01 - How to ensure that the Quartz.NET service is executing jobs on the server and not locally?

To ensure that Quartz.Net schedules the job on the *remote server* and not on the local instance you need to set the thread count to 0 along with other properties shown below at the time of instantiating a new instance of the scheduler service,

// address = string.Format("tcp://{0}:{1}/{2}", server, port, scheduler)
private static NameValueCollection GetProperties(string address) 
{
     var properties = new NameValueCollection();
     properties["quartz.scheduler.instanceName"] = "ServerScheduler";
     properties["quartz.scheduler.proxy"] = "true";
     properties["quartz.threadPool.threadCount"] = "0";
     properties["quartz.scheduler.proxy.address"] = address;
     return properties;
}

Figure 1 – Quartz.Net config, contains useful details, does not need to be changed

Value of the properties that need to be passed while instantiating a new instance of Quartz service,

Address: The address needs to be passed in the format tcp://NameOfSeverWhereQuartzIsInstalled:555/QuartzScheduler

Instance Name: You can find the instance name from the Quartz.Net config file on the server. See in the config above, the instance name is ‘ServerScheduler’

Proxy: Set the proxy to true

ThreadCount: If you don’t specify the threadcount to 0, quartz.net will spin a local instance of the service to schedule your job. This means, your job would be scheduled but not on the server that you intended for it to be scheduled. The down side is, as soon as the local process terminates, the schedule will be lost.

The values you specify for the properties before instantiating the Quartz scheduler will have precedence over the values in the config file.

How to validate that the Quartz.Net scheduler service is scheduling remotely and not locally?

You can use the GetMetaData() method on the instance of Scheduler to get information such as the version of quartz.net, threadpool size, jobStoreType, jobStorePersistanceType, etc. This important method also returns the property ‘IsRemote’. If you have correctly configured the scheduler and correctly instanciated it, the value of this property should be ‘True’

02 – Fixing “Scheduler with the name xxx already exists.” issue

This would typically happen if you try to instantiate a new instance of the scheduler when you already have one active instance loaded in the process. The easiest way to avoid this is by implementing Scheduler instantiation using the singleton pattern. See the sample code for instantiating Quartz.Net using the Singleton pattern.

Scheduler is a singleton implementation. The class is instantiated only when the server name, port number and scheduler name input parameters are passed. Using this allows you to invoke the StdSchedulerFactory method and search if there is already an instance of scheduler instantiated using these properties. If so, return that instance other wise create a new instance and remember it.

public class Scheduler
{
    public readonly IScheduler Instance;
    public string Address { get; private set; }
    public string JobName { get; set; }
    public string JobGroup { get; set; }
    public int Priority { get; set; }
    public string CronExpression { get; set; }

    private readonly ISchedulerFactory _schedulerFactory;


    public Scheduler(string server, int port, string scheduler)
    {
        Address = string.Format("tcp://{0}:{1}/{2}", server, port, scheduler);
        _schedulerFactory = new StdSchedulerFactory(GetProperties(Address));

        try
        {
            Instance = _schedulerFactory.GetScheduler();

            if (!Instance.IsStarted)
                Instance.Start();
        }
        catch (SchedulerException ex)
        {
            throw new Exception(string.Format("Failed: {0}", ex.Message));
        }
    }

    private static NameValueCollection GetProperties(string address) 
    {
        var properties = new NameValueCollection();
        properties["quartz.scheduler.instanceName"] = "ServerScheduler";
        properties["quartz.scheduler.proxy"] = "true";
        properties["quartz.threadPool.threadCount"] = "0";
        properties["quartz.scheduler.proxy.address"] = address;
        return properties;
    }

    public IScheduler GetScheduler()
    {
        return Instance;
    }
}

If you wanted to call Scheduler then you should be using something like the code sample below…

Simply calling the Scheduler class with the name of the server where Quartz is installed, the port on which the quartz service is listening and the name of the scheduler.

public SchedulerMetaData GetMetaData()
{
        var scheduler = new Scheduler("ServerName", Convert.ToInt32("PortNumber"), "Scheduler"));
        return scheduler.GetMetaData();
}

I hope this helps!

This was fifth in the series of posts on enterprise scheduling using Quartz.net, in the next post I’ll be covering how to expose the functionality of the Quartz.Net scheduling service via WebService. All Quartz.Net specific blog posts are listed here. Thank you for taking the time out and reading this blog post. If you enjoyed the post, remember to subscribe to http://feeds.feedburner.com/TarunArora. Stay tuned!

Quartz.Net Windows Service Configure Logging

Tarun Arora — Sat, 17 Nov 2012 15:05:00 GMT

Originally posted on: http://geekswithblogs.net/TarunArora/archive/2012/11/17/quartz.net-windows-service-configure-logging.aspx

In this blog post I’ll be covering,

Logging for Quartz.Net Windows Service
- 01 – Why doesn’t Quartz.Net Windows Service log by default
- 02 – Configuring Quartz.Net windows service for logging to eventlog, file, console, etc
- 03 – Results: Logging in action

If you are new to Quartz.Net I would recommend going through,

A brief Introduction to Quartz.net

Walkthrough of Installing & Testing Quartz.Net as a Windows Service

Writing & Scheduling your First HelloWorld job with Quartz.Net

01 – Why doesn’t Quartz.Net Windows Service log by default

If you are trying to figure out why…

The Quartz.Net windows service isn’t logging
The Quartz.Net windows service isn’t writing anything to the event log
The Quartz.Net windows service isn’t writing anything to a file
How do I configure Quartz.Net windows service to use log4Net
How do I change the level of logging for Quartz.Net

Look no further, This blog post should help you answer these questions.

Quartz.NET uses the Common.Logging framework for all of its logging needs. If you navigate to the directory where Quartz.Net Windows Service is installed (I have the service installed in C:\Program Files (x86)\Quartz.net, you can find out the location by looking at the properties of the service) and open ‘Quartz.Server.exe.config’ you’ll see that the Quartz.Net is already set up for logging to ConsoleAppender and EventLogAppender, but only ‘ConsoleAppender’ is set up as active. So, unless you have the console associated to the Quartz.Net service you won’t be able to see any logging.

<log4net>
    <appender name="ConsoleAppender" type="log4net.Appender.ConsoleAppender">
        <layout type="log4net.Layout.PatternLayout">
            <conversionPattern value="%d [%t] %-5p %l - %m%n" />
        </layout>
    </appender>
    <appender name="EventLogAppender" type="log4net.Appender.EventLogAppender">
        <layout type="log4net.Layout.PatternLayout">
            <conversionPattern value="%d [%t] %-5p %l - %m%n" />
        </layout>
    </appender>
    <root>
        <level value="INFO" />
        <appender-ref ref="ConsoleAppender" />
  <!-- uncomment to enable event log appending -->
        <!-- <appender-ref ref="EventLogAppender" /> -->
    </root>
</log4net>

Problem: In the configuration above Quartz.Net Windows Service only has ConsoleAppender active. So, no logging will be done to EventLog. More over the RollingFileAppender isn’t setup at all. So, Quartz.Net will not log to an application trace log file.

02 – Configuring Quartz.Net windows service for logging to eventlog, file, console, etc

Let’s change this behaviour by changing the config file… In the below config file,

I have added the RollingFileAppender. This will configure Quartz.Net service to write to a log file. (<appender name="GeneralLog" type="log4net.Appender.RollingFileAppender">)
I have specified the location for the log file (<arg key="configFile" value="Trace/application.log.txt"/>)
I have enabled the EventLogAppender and RollingFileAppender to be written to by Quartz. Net windows service
Changed the default level of logging from ‘Info’ to ‘All’. This means all activity performed by Quartz.Net Windows service will be logged. You might want to tune this back to ‘Debug’ or ‘Info’ later as logging ‘All’ will produce too much data to the logs. (<level value="ALL"/>)
Since I have changed the logging level to ‘All’, I have added applicationSetting to remove logging log4Net internal debugging. (<add key="log4net.Internal.Debug" value="false"/>)

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <configSections>
        <section name="quartz" type="System.Configuration.NameValueSectionHandler,

                                     System, Version=1.0.5000.0,Culture=neutral,

                                     PublicKeyToken=b77a5c561934e089" />
            <section name="log4net" type="log4net.Config.Log4NetConfigurationSectionHandler, log4net" />
        <sectionGroup name="common">
            <section name="logging" type="Common.Logging.ConfigurationSectionHandler, Common.Logging" />
        </sectionGroup>
    </configSections>

    <common>
        <logging>
            <factoryAdapter type="Common.Logging.Log4Net.Log4NetLoggerFactoryAdapter, Common.Logging.Log4net">
                <arg key="configType" value="INLINE" />                
                <arg key="configFile" value="Trace/application.log.txt"/>
                <arg key="level" value="ALL" />
            </factoryAdapter>
        </logging>
    </common>
    <appSettings>
      <add key="log4net.Internal.Debug" value="false"/>
    </appSettings>
    <log4net>
        <appender name="ConsoleAppender" type="log4net.Appender.ConsoleAppender">
            <layout type="log4net.Layout.PatternLayout">
                <conversionPattern value="%d [%t] %-5p %l - %m%n" />
            </layout>
        </appender>
        <appender name="EventLogAppender" type="log4net.Appender.EventLogAppender">
            <layout type="log4net.Layout.PatternLayout">
                <conversionPattern value="%d [%t] %-5p %l - %m%n" />
            </layout>
        </appender>
        <appender name="GeneralLog" type="log4net.Appender.RollingFileAppender">
            <file value="Trace/application.log.txt"/>
            <appendToFile value="true"/>
            <maximumFileSize value="1024KB"/>
            <rollingStyle value="Size"/>
            <layout type="log4net.Layout.PatternLayout">
              <conversionPattern value="%d{HH:mm:ss} [%t] %-5p %c - %m%n"/>
            </layout>
          </appender>
        <root>
            <level value="ALL" />
            <appender-ref ref="ConsoleAppender" />
            <appender-ref ref="EventLogAppender" />
            <appender-ref ref="GeneralLog"/>
        </root>
    </log4net>
</configuration>

Note – Please ensure you restart the Quartz.Net Windows service for the config changes to be picked up by the service

03 – Results: Logging in action

Once you start the Quartz.Net Windows Service up, the logging should be initiated to write all activities in the Console, EventLog and File… See screen shots below…

Figure – Quartz.Net Windows Service logging all activity to the event log

Figure – Quartz.Net Windows Service logging all activity to the application log file

Where is the output from log4Net ConsoleAppender?

As a default behaviour, the console isn't available in windows services, web services, windows forms. The output will simply be dismissed. Unless you are running the process interactively. Which you can do by firing up Quartz.Server.exe –i to see the output

This was fourth in the series of posts on enterprise scheduling using Quartz.net, in the next post I’ll be covering troubleshooting why a scheduled task hasn’t fired on Quartz.net windows service. All Quartz.Net specific blog posts can listed here. Thank you for taking the time out and reading this blog post. If you enjoyed the post, remember to subscribe to http://feeds.feedburner.com/TarunArora. Stay tuned!

Quartz.Net Writing your first Hello World Job

Tarun Arora — Sat, 17 Nov 2012 01:07:00 GMT

Originally posted on: http://geekswithblogs.net/TarunArora/archive/2012/11/17/quartz.net-writing-your-first-hello-world-job.aspx

In this blog post I’ll be covering,

01: A few things to consider before you should schedule a Job using Quartz.Net
02: Setting up your solution to use Quartz.Net API
03: Quartz.Net configuration
04: Writing & scheduling a hello world job with Quartz.Net
05: Download Quartz.Net sample project and instructions

If you are new to Quartz.Net I would recommend going through,

A brief introduction to Quartz.net

Walkthrough of Installing & Testing Quartz.Net as a Windows Service

How to Configuring Logging for Quartz.Net windows service

01 – A few things to consider before you should schedule a Job using Quartz.Net

To schedule a job to run on Quartz.Net windows service at the very minimum you need the 3 items listed below,

- An instance of the scheduler service

- A trigger

- And last but not the least a job

But a few additional things that you should think about are… For example, if I wanted to schedule a script to run on the server, I should be jotting down answers to the below questions,

a. Considering there are multiple machines set up with Quartz.Net windows service, how can I choose the instance of Quartz.Net where I want my script to be run

b. What will trigger the execution of the job

c. How often do I want the job to run

d. Do I want the job to run right away or start after a delay or may be have the job start at a specific time

e. What will happen to my job if Quartz.Net windows service is reset

f. Do I want multiple instances of this job to run concurrently

g. Can I pass parameters to the job being executed by Quartz.Net windows service

02 – Setting up your solution to use Quartz.Net API

1. Create a new C# Console Application project and call it “HelloWorldQuartzDotNet” and add a reference to Quartz.Net.dll. I use the NuGet Package Manager to add the reference. This can be done by right clicking references and choosing Manage NuGet packages, from the Nuget Package Manager choose Online from the left panel and in the search box on the right search for Quartz.Net. Click Install on the package “Quartz” (Screen shot below).

Figure – Adding Quartz.Net reference to my project via Nuget Package Manager

Figure – Searching for Quartz.Net reference in Nuget Package Manager

Figure – Quartz reference added to my project via Nuget Package Manager

2. Right click the project and choose Add New Item. Add a new Interface and call it ‘IScheduledJob.cs’. Mark the Interface public and add the signature for Run. Your interface should look like below.

namespace HelloWorldQuartzDotNet
{
    public interface IScheduledJob
    {
        void Run();
    }
}

3. Right click the project and choose Add new Item. Add a class and call it ‘Scheduled Job’. Use this class to implement the interface ‘IscheduledJob.cs’. Look at the pseudo code in the implementation of the Run method.

using System;

namespace HelloWorldQuartzDotNet
{
    class ScheduledJob : IScheduledJob
    {
        public void Run()
        {

            // Get an instance of the Quartz.Net scheduler

            // Define the Job to be scheduled

            // Associate a trigger with the Job

            // Assign the Job to the scheduler

            throw new NotImplementedException();
        }
    }
}

I’ll get into the implementation in more detail, but let’s look at the minimal configuration a sample configuration file for Quartz.Net service to work.

03 – HelloWorldQuartzDotNet configuration file

In the App.Config file copy the below configuration

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <configSections>
    <section name="quartz" 
             type="System.Configuration.NameValueSectionHandler, 
             System, Version=1.0.5000.0,Culture=neutral, 
             PublicKeyToken=b77a5c561934e089" />
  </configSections>
  <quartz>
    <add key="quartz.scheduler.instanceName" value="ServerScheduler" />
    <add key="quartz.threadPool.type" value="Quartz.Simpl.SimpleThreadPool, Quartz" />
    <add key="quartz.threadPool.threadCount" value="10" />
    <add key="quartz.threadPool.threadPriority" value="2" />
    <add key="quartz.jobStore.misfireThreshold" value="60000" />
    <add key="quartz.jobStore.type" value="Quartz.Simpl.RAMJobStore, Quartz" />
  </quartz>
</configuration>

As you can see in the configuration above, I have included the instance name of the quartz scheduler, the thread pool type, count and priority, the job store type has been defined as RAM. You have the option of configuring that to ADO.NET JOB store. More details here.

04 – Writing & scheduling a hello world job with Quartz.Net Windows Service

Once fully implemented the ScheduleJob.cs class should look like below. I’ll walk you through the details of the implementation…

- GetScheduler() uses the name of the quartz.net and listens on localhost port 555 to try and connect to the quartz .net windows service.

- Run() an attempt is made to start the scheduler in case it is in standby mode

- I have defined a job “WriteHelloToLog” (that’s the name of the job), this job belongs to the group “IT”. Think of group as a logical grouping feature. It helps you bucket jobs into groups. Quartz.Net gives you the ability to pause or delete all jobs in a group (We’ll look at that in some of the future posts). I have requested for recovery of this job in case the quartz.net service fails over to the other node in the cluster. The jobType is “HelloWorldJob”. This is the class that would be called to execute the job. More details on this below…

- schd.CheckExists will check to ensure that the job WriteHelloToLog doesn’t already exist. If it does, I’ll delete the job and allow you to recreate the same job. I have added this code just as a precaution to avoid you running into the exception “Quartz.ObjectAlreadyExistsException: Unable to store Job with name: 'WriteHelloWorldToLog' and group: 'IT', because one already exists with this identification.”

- I have defined a trigger for my job. I have called the trigger “WriteHelloToLog”. The Trigger works on the cron schedule “0 0/1 * 1/1 * ? *” which means fire the job once every minute. I would recommend that you look at www.cronmaker.com a free and great website to build and parse cron expressions. The trigger has a priority 1. So, if two jobs are run at the same time, this trigger will have high priority and will be run first.

- Use the Job and Trigger to schedule the job. This method returns a datetime offeset. It is possible to see the next fire time for the job from this variable.

using System.Collections.Specialized;
using Quartz;
using System;
using Quartz.Impl;

namespace HelloWorldQuartzDotNet
{
    class ScheduledJob : IScheduledJob
    {
        public void Run()
        {
            // Get an instance of the Quartz.Net scheduler
            var schd = GetScheduler();

            // Start the scheduler if its in standby
            if (!schd.IsStarted)
                schd.Start();

            // Define the Job to be scheduled
            var job = JobBuilder.Create<HelloWorldJob>()
                .WithIdentity("WriteHelloToLog", "IT")
                .RequestRecovery()
                .Build();

            // Associate a trigger with the Job
            var trigger = (ICronTrigger)TriggerBuilder.Create()
                .WithIdentity("WriteHelloToLog", "IT")
                .WithCronSchedule("0 0/1 * 1/1 * ? *") // visit http://www.cronmaker.com/ Queues the job every minute
                .StartAt(DateTime.UtcNow)
                .WithPriority(1)
                .Build();

            // Validate that the job doesn't already exists
            if (schd.CheckExists(new JobKey("WriteHelloToLog", "IT")))
            {
                schd.DeleteJob(new JobKey("WriteHelloToLog", "IT"));
            }

            var schedule = schd.ScheduleJob(job, trigger);
            Console.WriteLine("Job '{0}' scheduled for '{1}'", "WriteHelloToLog", schedule.ToString("r"));
        }

        // Get an instance of the Quartz.Net scheduler
        private static IScheduler GetScheduler()
        {
            try
            {
                var properties = new NameValueCollection();
                properties["quartz.scheduler.instanceName"] = "ServerScheduler";

                // set remoting expoter
                properties["quartz.scheduler.proxy"] = "true";
                properties["quartz.scheduler.proxy.address"] = string.Format("tcp://{0}:{1}/{2}", "localhost", "555",
                                                                             "QuartzScheduler");

                // Get a reference to the scheduler
                var sf = new StdSchedulerFactory(properties);

                return sf.GetScheduler();

            }
            catch (Exception ex)
            {
                Console.WriteLine("Scheduler not available: '{0}'", ex.Message);
                throw;
            }
        }
    }
}

The above highlighted values have been taken from the Quartz.config file, this file is available in the Quartz.net server installation directory.

Implementation of my HelloWorldJob Class below.

The HelloWorldJob class gets called to execute the job “WriteHelloToLog” using the once every minute trigger set up for this job. The HelloWorldJob is a class that implements the interface IJob. I’ll walk you through the details of the implementation…

- If you don’t include an empty constructor in the HelloWorldJob class then Quartz.Net windows service will not be able to create an instance of this class to execute your job. I learned this the hard way #JustSaying

- context is passed to the method execute by the quartz.net scheduler service. This has everything you need to pull out the job, trigger specific information. For example. I have pulled out the value of the jobKey name, the fire time and next fire time.

using Common.Logging;
using Quartz;
using System;

namespace HelloWorldQuartzDotNet
{
    class HelloWorldJob : IJob
    {

        private static readonly ILog Log = LogManager.GetLogger(typeof(HelloWorldJob));

        /// <summary> 
        /// Empty constructor for job initilization
        /// <para>
        /// Quartz requires a public empty constructor so that the
        /// scheduler can instantiate the class whenever it needs.
        /// </para>
        /// </summary>
        public HelloWorldJob()
        {
            
        }

        public void Execute(IJobExecutionContext context)        
        {
            try
            {
                Log.DebugFormat("{0}****{0}Job {1} fired @ {2} next scheduled for {3}{0}***{0}", 
                                                                        Environment.NewLine,
                                                                        context.JobDetail.Key,
                                                                        context.FireTimeUtc.Value.ToString("r"), 
                                                                        context.NextFireTimeUtc.Value.ToString("r"));


                Log.DebugFormat("{0}***{0}Hello World!{0}***{0}", Environment.NewLine);
            }
            catch (Exception ex)
            {
                Log.DebugFormat("{0}***{0}Failed: {1}{0}***{0}", Environment.NewLine, ex.Message);
            }
        }
    }
}

I’ll add a call to call the scheduler in the Main method in Program.cs

using System;
using System.Threading;

namespace HelloWorldQuartzDotNet
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
               // Infinite loop, so that the console doesn't close on you
                while (true)
                {
                    var sj = new ScheduledJob();
                    sj.Run();

                    Console.WriteLine(@"{0}Check Quartz.net\Trace\application.log.txt for Job updates{0}",
                                        Environment.NewLine);

                    Console.WriteLine("{0}Press Ctrl^C to close the window. The job will continue " +
                                        "to run via Quartz.Net windows service, " +
                                        "see job activity in the Quartz.Net Trace file...{0}",
                                        Environment.NewLine);

                    Thread.Sleep(10000 * 100000);    
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("Failed: {0}", ex.Message);
                Console.ReadKey();
            }
        }
    }
}

I am going to hit F5 to fire up “HelloWorldQuartzDotNet” project… Let’s see the Quartz.Net job scheduling in action…

Figure – The program has run as expected. The program has successfully scheduled the “WriteHelloWorldToLog” job to the Quartz.Net Scheduler. As you can see the job has been scheduled to start at ‘Sat, 17 Nov 2012 13:19:00 GMT’

Let’s open up the C:\Program Files (x86)\Quartz.Net\Trace\Application.log.txt file to see Quartz.Net scheduler activity…

Note – If you can’t see the log file, then you don’t have logging for Quartz.Net enabled, follow the instructions here

Figure – The Quartz. Net application log file has the execution details of my “WriteHelloWorldToLog” job.

05 – Download Quartz.Net sample project and instructions

I have packaged the sample that I created for this blogpost and uploaded it to my skydrive. You can download the sample quartz.net helloworld solution from here.

Once you have downloaded and unpackaged the solution follow the steps below to get it to work,

1. Build the solution and resolve any compilation errors. You might run into compilation issues if you don’t have .net 4 installed on your machine. Ensure that Quartz.dll, Common.Logging.dll, Common.Logging.log4Net.dll and log4Net.dll are correctly available under references.

2. Once successfully compiled, go to the bin folder, copy “HelloWorldQuartzDotNet.exe” and paste it to the Quartz.Net windows service directory. In the example above, the Quartz.Net windows service directory is “C:\Program Files (x86)\Quartz.Net”

3. Stop the Quartz.Net service from Services.msc and start the service again.

4. Hit F5 on the “HelloWorldQuartzDotNet” project in Visual Studio.

And… that’s it…

This was third in the series of posts on enterprise scheduling using Quartz.net, in the next post I’ll be covering how to configure logging for the Quartz.net windows service. All Quartz.Net specific blog posts can listed here. Thank you for taking the time out and reading this blog post. If you enjoyed the post, remember to subscribe to http://feeds.feedburner.com/TarunArora. Stay tuned!

Install Quartz.Net as a windows service and Test installation

Tarun Arora — Fri, 16 Nov 2012 20:02:00 GMT

Originally posted on: http://geekswithblogs.net/TarunArora/archive/2012/11/16/install-quartz.net-as-a-windows-service-and-test-installation.aspx

In this blog post I’ll be covering,

01: Where to download Quartz.net from
02: How to install Quartz.net as a Windows service
03: Test the Quartz.net Installation

If you are new to Quartz.Net I would recommend going through,

A brief Introduction to Quartz.net

Writing & Scheduling your First HelloWorld job with Quartz.Net

How to Configuring Logging for Quartz.Net windows service

01 – Where to download Quartz.net?

http://sourceforge.net/projects/quartznet/files/quartznet/

Currently version Quartz.Net 2.0.1 is the recommended download version.

02 – How to install Quartz.net as a Windows service

Go to the download location and unzip the Quartz.net package
Navigate to the folder Quartz.Net \ Server \ bin – This is where you will find different .net version installers of the quartz.net packages. For example in the screen shot above, you can see the Quartz.net .net 3.5 and .net 4 packages.
Open up the Quartz.net .net 4.0 folder, this folder contains the files you need to install Quartz.net as a windows service
Copy the contents of the folder Downloads\Quartz.NET-2.0.1\server\bin\4.0 to the folder %program files%\Quartz.net

5. Open up a new CMD as an administrator and run the below command to install Quartz.net as a windows service

/> Quartz.Server.exe install

6. How do I know that Quartz.Net service has installed as a Windows service?

Go to run prompt and type ‘services.msc’ you should now see all the windows services installed on your machine. Navigate down to look for Quartz.Net. The service installs itself as an automatic startup Type and log on as ‘Local System’. You can easily change this to your prefer account that you would like to run the service as.

If you wanted to name the Quartz service something else then that’s also possible…

Can I change the default display name of the quartz.net windows service?

Yes, you can! Navigate to C:\Program Files (x86)\Quartz.Net\ and open up the config file ‘quartz.config’

- You can change the instance name

- You can change the default thread count of 10

- The port that the service listens to (by default this is port 555)

A blog post on more configuration details can be found here.

03 – Test Quartz.Net windows service installation

So, I have installed Quartz.Net as a windows service, how do I test whether my installation has been successful.

Open up cmd as an administrator and run the below command,

C:\Program Files (x86)\Quartz.Net> Quartz.Server.exe –i

Since by default the Quartz.net windows service writes INFO level diagnostics (this can be changed from Quartz.Server.exe.config) you should see the service information show up on the console. For instance in the example above I can see that the service is running in a NON CLUSTERED mode, its currently not started and is currently in standby mode with 0 number of jobs executed so far…

This was second in the series of posts on enterprise scheduling using Quartz.net, in the next post I’ll be covering how to run your first scheduled task using Quartz.net windows service. All Quartz.Net specific blog posts can listed here. Thank you for taking the time out and reading this blog post. If you enjoyed the post, remember to subscribe to http://feeds.feedburner.com/TarunArora. Stay tuned!

Walkthrough: Scheduling jobs using Quartz.net – Part 1: What is Quartz.Net?

Tarun Arora — Tue, 10 Apr 2012 20:50:00 GMT

Originally posted on: http://geekswithblogs.net/TarunArora/archive/2012/04/10/walkthrough-scheduling-jobs-using-quartz.net-ndash-part-1-what-is.aspx

Quartz.NET is a full-featured, open source enterprise job scheduling system written in .NET platform that can be used from smallest apps to large scale enterprise systems.

Suggested Further Reading

Walkthrough of Installing & Testing Quartz.Net as a Windows Service

How to Configuring Logging for Quartz.Net windows service

Writing & Scheduling your First Hello World job with Quartz.Net

What is the problem that we trying to address?

I want to schedule the execution of a task but only when something happens. Let’s call that something a trigger, so... if the trigger is met => execute the task. Sounds simple, why not use windows task scheduler for this?

Well, windows task scheduler is great for tasks where the trigger can be easily defined. With windows task scheduler will you be able to schedule a task to run on every working day according to the UK calendar (exclude all weekends & bank holidays) without either writing the logic for day check in the task or a wrapper script calling into the task.

The task should just contain the execution logic and should not have anything to do with the schedule for execution; Quartz.net allows you to achieve this and lots more. A quartz.net trigger gives you the flexibility for task invocation based on the following triggers,

1. at a certain time of day (to the millisecond)
2. on certain days of the week
3. on certain days of the month
4. on certain days of the year
5. not on certain days listed within a registered Calendar (such as business holidays)
6. repeated a specific number of times
7. repeated until a specific time/date
8. repeated indefinitely
9. repeated with a delay interval

Did 8 – repeat indefinitely just ring a bell? I’ll be covering that in the future post.

Using Quartz.net as a windows service

You can have Quartz.net run as a standalone instance within its own .NET virtual machine instance via .NET Remoting. Let’s take a look at typical application architecture. In the figure below, I have the application tier set up on Machine 1, database set up on Machine 2 and Quartz.net set up on Machine 3 which is normally the architecture for most (if not all) enterprise applications.

Figure 1 - Typical Application architecture while using Quartz.net as a windows service

What other options do I have if I don’t want to use Quartz.net?

Quartz.net is just one of the many job scheduling services. Have a look at this comprehensive list of free and paid enterprise job scheduling software along with their feature comparison. http://en.wikipedia.org/wiki/List_of_job_scheduler_software

This was first in the series of posts on enterprise scheduling using Quartz.net, in the next post I’ll be covering how to Install Quartz.net as a windows service. All Quartz.Net specific blog posts can listed here. Thank you for taking the time out and reading this blog post. If you enjoyed the post, remember to subscribe to http://feeds.feedburner.com/TarunArora. Stay tuned!