Error in a winservice : "ThreadPool type 'Quartz.Simpl.DefaultThreadPool' props could not be configured."

[NicoGrif]

Hello, I am creating a WinService in C# 4.6.2 and I am using Quartz.Net in version 3.7 to set up batch processing on a server. However, when I start the service I get the following error:

ThreadPool type 'Quartz.Simpl.DefaultThreadPool' props could not be configured. - StackTrace : à Quartz.Impl.StdSchedulerFactory.

I followed the site documentation and used information from this site: https://mjc.si/2019/08/25/use-quartz-net-library-for-running-tasks-in-a-windows-service/

Here is my code:

Service :

      public ServiceBackupSage()
       {
           InitializeComponent();

           m_ServiceLog = new EventLog();

           string sourceNameService = Properties.Settings.Default.SourceName;
           string logNameService = Properties.Settings.Default.LogName;

           if (!System.Diagnostics.EventLog.SourceExists(sourceNameService))
           {
               System.Diagnostics.EventLog.CreateEventSource(sourceNameService, logNameService);
           }
           // configure the event log instance to use this source name
           m_ServiceLog.Source = sourceNameService;
           m_ServiceLog.Log = logNameService;
       }


       protected override async void OnStart(string[] args)
       {
           try
           {
               m_ServiceLog.WriteEntry(string.Format(CultureInfo.CurrentCulture, "Le service backup sage s'est lancé à {0}.", DateTime.Now), EventLogEntryType.Information);

               var properties = new NameValueCollection();

               properties.Add("quartz.scheduler.instanceName", "SchedulerSage");
               properties.Add("quartz.threadPool.type", "Quartz.Simpl.SimpleThreadPool, Quartz");
               properties.Add("quartz.threadPool.threadCount", "0");
               //properties.Add("quartz.threadPool.threadPriority", "Normal");
               properties.Add("quartz.threadPool.maxConcurrency", "1");

               m_SchedulerFactory = new StdSchedulerFactory(properties);

               // get a scheduler
               m_Scheduler = await m_SchedulerFactory.GetScheduler();

               m_ServiceLog.WriteEntry(string.Format(CultureInfo.CurrentCulture, "m_SchedulerFactory.GetScheduler OK {0}.", DateTime.Now), EventLogEntryType.Information);

               await m_Scheduler.Start();
               m_ServiceLog.WriteEntry(string.Format(CultureInfo.CurrentCulture, "Start Scheduler OK {0}.", DateTime.Now), EventLogEntryType.Information);


               //// define the job and tie it to our UserSyncJob class using configurations from app.config as a job data.
               var job = JobBuilder.Create<BackupSageJob>()
                                   .WithIdentity("BackupSageJob", "DefaultGroup")
                                   .UsingJobData("IPServer", Properties.Settings.Default.IPServeur)
                                   .UsingJobData("Login", Properties.Settings.Default.Login)
                                   .UsingJobData("Port", Properties.Settings.Default.Port)
                                   .UsingJobData("Password", Properties.Settings.Default.Password)
                                   .Build();
               m_ServiceLog.WriteEntry(string.Format(CultureInfo.CurrentCulture, "Création du Job Quartz OK {0}.", DateTime.Now), EventLogEntryType.Information);


               ITrigger trigger = TriggerBuilder.Create()
                       .WithIdentity("BackupSageTrigger", "DefaultGroup")
                       .StartNow()
                       .WithCronSchedule(Properties.Settings.Default.CronSchedule)
                       .Build();
               m_ServiceLog.WriteEntry(string.Format(CultureInfo.CurrentCulture, "Création du trigger Quartz OK {0}.", DateTime.Now), EventLogEntryType.Information);

               // Tell Quartz to schedule the job using our trigger
               await m_Scheduler.ScheduleJob(job, trigger);
               m_ServiceLog.WriteEntry(string.Format(CultureInfo.CurrentCulture, "Schedule Job lancé {0}.", DateTime.Now), EventLogEntryType.Information);

               // some sleep to show what's happening
               await Task.Delay(TimeSpan.FromSeconds(5));




           }
           catch (Exception ex)
           {
               m_ServiceLog.WriteEntry(string.Format(CultureInfo.CurrentCulture, "Service backup sage - Erreur survenue à '{0}' : {1} - StackTrace : {2}",
                                               DateTime.Now.ToString("HH:mm:ss"),
                                               ex.Message.ToString(),
                                               ex.StackTrace.ToString()), EventLogEntryType.Error);

               throw ex;

           }


       }

       protected override async void OnStop()
       {
           try
           {
               await m_Scheduler.Shutdown();

               // Log d'arrêt du service
               m_ServiceLog.WriteEntry(string.Format(CultureInfo.CurrentCulture,
                   "Le service backup sage  s'est arreté à '{0}'.",
                   DateTime.Now.ToString("HH:mm:ss")), EventLogEntryType.Information);

               // Fermeture du journal d'évènement
               m_ServiceLog.Close();
           }
           catch (Exception ex)
           {
               throw ex;
           }

Class BackupSageJob :

    public class BackupSageJob : IJob
    {
        #region Membres

        /// <summary>
        /// Indique si le traitement est en cours
        /// </summary>
        private static bool m_IsRunning;

        /// <summary>
        /// Journal d'évènement du service
        /// </summary>
        private EventLog m_ServiceLog;

        #endregion Membres       

        public BackupSageJob()
        {
            string sourceNameService = Properties.Settings.Default.SourceName;
            string logNameService = Properties.Settings.Default.LogName;

            // Instanciation du journal d'évènement
            m_ServiceLog = new EventLog(logNameService);
            m_ServiceLog.Source = sourceNameService;
        }


        public Task Execute(IJobExecutionContext context)
        {
            try
            {
                // Log de démarrage
                m_ServiceLog.WriteEntry(string.Format(CultureInfo.InvariantCulture, "Lancement de la tache du backup des bases Sage {0}:{1}", DateTime.Now.Hour.ToString("00"), 
                                                                                                                                                DateTime.Now.Minute.ToString("00")), 
                                                                                                                                                EventLogEntryType.Information);

                //Load Job configuration
                var key = context.JobDetail.Key;
                var dataMap = context.JobDetail.JobDataMap;

                var ipftp = dataMap.GetString("IPServer");
                var login = dataMap.GetString("Login");
                var port = dataMap.GetString("Port");
                var password = dataMap.GetString("Password");

                Task taskBackup = new Task(() => BackupSageService.LaunchBackup(ipftp, login, password));

                taskBackup.Start();


                // Log de succès
                m_ServiceLog.WriteEntry(string.Format(CultureInfo.InvariantCulture,
                    "Fin de la tache de la tache du backup des bases Sage  {0}:{1}",
                    DateTime.Now.Hour.ToString("00"), DateTime.Now.Minute.ToString("00")),
                    EventLogEntryType.Information);

                return taskBackup;
            }
            catch (Exception e)
            {
                m_ServiceLog.WriteEntry(string.Format(CultureInfo.InvariantCulture,
                                                    "Erreur de la tache de la tache du backup des bases Sage  {0}:{1}\n{2}",
                                                    DateTime.Now.Hour.ToString("00"),
                                                    DateTime.Now.Minute.ToString("00"),
                                                    EventLogEntryType.Error,
                                                    e.Message));

                return Task.CompletedTask;
            }
        }
    }

I tried to set the config in properties and it doesn't work.

                // set thread pool info
                properties["quartz.threadPool.type"] = "Quartz.Simpl.SimpleThreadPool, Quartz";
                properties["quartz.threadPool.threadCount"] = "5";
                properties["quartz.threadPool.threadPriority"] = "Normal";


                m_SchedulerFactory = new StdSchedulerFactory(properties);

ThreadPool type 'Quartz.Simpl.DefaultThreadPool'

I no longer know what to do to make Quartz.net 3.x work in a WinService.
If you have a solution, I'm interested :)

[lahma]

Please consider using the scheduler builder API instead of magic strings, might help you to pinpoint the issue.

quartznet/src/Quartz.Examples/13_ClusteringJobsExecution/ClusteringJobsExecutionExample.cs

Lines 69 to 81 in a0e5bc1

	IScheduler sched = await SchedulerBuilder.Create()
	.WithId("instance_one")
	.WithName("TestScheduler")
	.UseDefaultThreadPool(x => x.MaxConcurrency = 5)
	.WithMisfireThreshold(TimeSpan.FromSeconds(60))
	.UsePersistentStore(x =>
	{
	x.UseProperties = true;
	x.UseClustering();
	x.UseSqlServer(TestConstants.SqlServerConnectionString);
	x.UseNewtonsoftJsonSerializer();
	})
	.BuildScheduler();

[NicoGrif]

Thanks for the idea. I will make the modifications in my code and report the errors via the event log

[NicoGrif]

I modified my code using the "SchedulerBuilder"
and when I start the WinService, I get the same error message.

ThreadPool type 'Quartz.Simpl.DefaultThreadPool' props could not be configured.

                var properties = new NameValueCollection();

                //properties.Add("quartz.scheduler.instanceName", "SchedulerSage");

                // set thread pool info
                properties["quartz.threadPool.type"] = "Quartz.Simpl.SimpleThreadPool, Quartz";
                properties["quartz.threadPool.threadCount"] = "5";
                properties["quartz.threadPool.threadPriority"] = "Normal";



                IScheduler m_Scheduler = await SchedulerBuilder.Create(properties)
                                                .WithId("SchedulerBuilderId")
                                                .WithName("SchedulerBuilderName")
                                                .UseDefaultThreadPool(x => x.MaxConcurrency = 5)
                                                .BuildScheduler();


                //m_SchedulerFactory = new StdSchedulerFactory(properties);

[lahma]

Don't use the properties, use the UseDefaultScheduler() to pass configuration.