Пример #1
0
        public override void Load()
        {
            WatchFolderDetails wfd = details as WatchFolderDetails;

            string infile = ConfigUtils.CleanPath(wfd.Path + @"\" + wfd.FileName);
            if (File.Exists(infile))
            {
                JobDetails jobDetail = new JobDetails();

                jobDetail.AdapterType = this.GetType().ToString();
                jobDetail.ReferencePath = infile;

                ExecutionEngine.InstanceOf().QueueExecuteJob(jobDetail);
            }
            else
                log.WarnFormat("Failed to find file to load {0}\\{1}", wfd.Path, wfd.FileName);
        }
Пример #2
0
        public Object RunJobXml(NbIdentity identity, object _arg)
        {
            try
            {
                string arg = _arg.ToString();
                if (arg.ToString().IndexOf('|') == -1)
                    return false;

                string jobName = arg.ToString().Substring(0, arg.IndexOf('|'));
                string jobSpecXml = arg.ToString().Substring(arg.IndexOf('|') + 1);
                jobSpecXml = jobName.StartsWith("ADHOC_") ? ConfigUtils.MetaTagReplacer(jobSpecXml) : jobSpecXml;
                userWatchedJobLogs[String.Format("{0}|{1}", identity.Machinename, identity.Username)] = jobName;

                log.InfoFormat("Running job {0}.  Requested by {1}\\{2} on {3}", jobName, identity.AppDomain, identity.Username, identity.Machinename);
                JobDetails jd = new JobDetails(jobName, jobSpecXml);
                jd.AdapterType = "Bits.FileManagerNS.Adapters.JobAdapter";
                ExecutionEngine.InstanceOf().QueueExecuteJob(jd);
            }
            catch (Exception Exception)
            {
                log.Warn(Exception);
                return false;
            }
            return true;
        }
Пример #3
0
 public Object GetStartUpJobsInstant(NbIdentity identity, object arg)
 {
     ArrayList listStartUpJobs = new ArrayList();
     try
     {
         XmlDocument doc = new XmlDocument();
         doc = LoadBitsShellXmlConfigFile();
         XmlNode nodeConfiguration = doc.SelectSingleNode("configuration");
         foreach (XmlNode node in nodeConfiguration.ChildNodes)
         {
             if (node.Name.Contains("StartupJobs"))
             {
                 foreach (XmlNode nodeStartUpJob in node.ChildNodes)
                 {
                     if (nodeStartUpJob.Attributes != null && nodeStartUpJob.Attributes["spec"].Value != null)
                     {
                         JobDetails jd = new JobDetails();
                         jd.Name = nodeStartUpJob.Attributes["spec"].Value.ToString().Replace(".xml", "");
                         jd.ReferencePath = nodeStartUpJob.Attributes["spec"].Value;
                         jd.isEditable = true;
                         listStartUpJobs.Add(jd);
                     }
                 }
             }
         }
     }
     catch (Exception exception)
     {
         log.Warn(exception);
     }
     return listStartUpJobs;
 }
Пример #4
0
        internal ArrayList GetStartupJobs(bool ifOnlyUserDefined)
        {
            ArrayList _startupJobs = new ArrayList();

            try
            {

                if (File.Exists(globalConfig.UserDefinedStartupJobsFilepath))
                {
                    using (StreamReader sr = new StreamReader(globalConfig.UserDefinedStartupJobsFilepath))
                    {
                        string record = string.Empty;
                        while ((record = sr.ReadLine()) != null)
                        {
                            JobDetails jd = new JobDetails();
                            jd.Name = record;
                            jd.ReferencePath = record + ".xml";
                            jd.isEditable = true;

                            if (!_startupJobs.Contains(jd))
                                _startupJobs.Add(jd);
                        }
                    }
                }

                foreach (JobDetails j in (ArrayList)ConfigurationManager.GetSection("StartupJobs"))
                {
                    if (!_startupJobs.Contains(j))
                        _startupJobs.Add(j);
                }
            }
            catch (Exception ex)
            {
                log.Error(ex);
            }

            return _startupJobs;
        }
Пример #5
0
 private void WriteStartupJobs(JobDetails jd, bool isSelected)
 {
     lock (s_lock)
     {
         ArrayList startupJobs = (ArrayList)ConfigurationManager.GetSection("StartupJobs");
         try
         {
             if (isSelected)
             {
                 using (StreamWriter sw = new StreamWriter(globalConfig.UserDefinedStartupJobsFilepath, true))
                 {
                     sw.WriteLine(jd.Name);
                     log.InfoFormat("Wrote {0} to user defined statrtup job file", jd.Name);
                 }
             }
             else
             {
                 if (File.Exists(globalConfig.UserDefinedStartupJobsFilepath))
                 {
                     ArrayList tar = new ArrayList();
                     using (StreamReader sr = new StreamReader(globalConfig.UserDefinedStartupJobsFilepath))
                     {
                         string record = string.Empty;
                         while ((record = sr.ReadLine()) != null)
                         {
                             JobDetails _jd = new JobDetails();
                             _jd.Name = record;
                             _jd.ReferencePath = record;
                             tar.Add(_jd);
                         }
                     }
                     File.Delete(globalConfig.UserDefinedStartupJobsFilepath);
                     using (StreamWriter sw = new StreamWriter(globalConfig.UserDefinedStartupJobsFilepath))
                     {
                         foreach (JobDetails _jd in tar)
                         {
                             if (!_jd.Equals(jd))
                                 sw.WriteLine(_jd.Name);
                         }
                     }
                 }
             }
         }
         catch (Exception ex)
         {
             log.Error(ex);
         }
     }
 }
Пример #6
0
        public Object ToggleStartupJob(object arg)
        {
            try
            {
                string[] keys = arg.ToString().Split('|');

                JobDetails jd = new JobDetails();
                jd.Name = keys[0];

                bool isSelected = Convert.ToBoolean(keys[1]);

                WriteStartupJobs(jd, isSelected);
            }
            catch (Exception ex)
            {
                log.Error(ex);
                return false;
            }
            return true;
        }
Пример #7
0
        /// <summary>
        /// Called internally, except for JobLauncher module
        /// </summary>
        /// <param name="oJobDetail"></param>
        /// <returns></returns>
        public ErrorCode ExecuteJobNew(JobDetails jobDetail, ref IJobWrapper ijobWrapper)
        {
            if (jobDetail.Xml.Equals(String.Empty))
            {
                jobDetail.Xml = globalConfig.Hierarchy.GetValueAtLevel("app\\BITS_JOB_SPEC", jobDetail.Name.Replace("_Job", ""), "");
                if (jobDetail.Xml.Equals(String.Empty))
                {
                    log.ErrorFormat("No job spec found for {0}.  Skipping request to build job.", jobDetail.Name);
                    return ErrorCode.JOB_SPEC_NOT_FOUND;
                }
            }

            if (jobWrappers.ContainsKey(jobDetail.Name) && jobDetail.Name.Contains("ADHOC") == false)
            {
                return ErrorCode.JOB_CODE_NOT_UNIQUE;
            }

            // Set up job spec for "Run Once."  This means that the start time will be set to *IMMEDIATELY*, the 
            // weekly schedule will be set to SMTWTFS. 
            if (jobDetail.RunOnce)
            {
                XmlDocument xdocAdhoc = Job.SetRunOnceAttributes(jobDetail.Xml, true);
                jobDetail.Xml = xdocAdhoc.InnerXml;
            }

        #endregion

            // Obtain a new PropertyBag for the job's metatags (ie the job's Dynamic Parameters).  In this PropertyBag, 
            // the parameters that were identified as Environmental will have been set.  Those that are not Environmental,
            // (ie Runtime) will have a value of null;
            PropertyBag jobMetaTags = MetaTagReplacer.GetJobParametersPB(jobDetail.Name, jobDetail.Xml);
            MetaTagReplacer.SetParametersValuesPB(ref jobMetaTags, ConfigUtils.MetatagMode.Environment, null, null);

            // Use the Dynamic Parameters PropertyBag to define the job spec at Enable-time.  Only Environment parameters
            // will be determined at this time.
            jobDetail.Xml = MetaTagReplacer.InlineMetatagSubstitution(jobDetail.Xml, jobMetaTags);

            // Create the job.  This step instantiates the job's modules and sets up the job's dependencies 
            Job job = (Job)JobImpl.BuildJobFromXml(jobDetail);
            if (job == null)
            {
                log.ErrorFormat("Unable to build job from job spec for {0}.  Skipping request to build job.", jobDetail.Name);
                return ErrorCode.UNABLE_TO_BUILD_JOB_FROM_SPEC;
            }

            job.Config.RunInstance = globalConfig.RunInstance;
            job.Config.SuppressEmail = globalConfig.SuppressEmail;
            job.JobState.CurrentParameters.CurrentParameters = jobMetaTags;

            foreach (JobDetailsData jdd in jobDetail.Data)
            {
                ((IModule)job.Modules[jdd.ModuleName]).OutputData.Add(jdd.DataName, jdd.Data);
            }

            // Create JobWrapper
            JobExeWrapper jobWrapper = null;
            if (jobWrappers.ContainsKey(job.JobName))
            {
                jobWrapper = jobWrappers[job.JobName];
                job.Key = DateTime.Now;
                jobWrapper.Job = job;
                jobWrapper.ResetState();
            }
            else
            {
                job.Key = Convert.ToDateTime(DateTime.Now.ToString("yyyy-MM-dd"));
                jobWrapper = new JobExeWrapper(job);
            }
            ijobWrapper = jobWrapper;

            // Job will be enabled after this...
            lock (jobWrappers)
            {
                jobWrappers[job.JobName] = jobWrapper;
            }

            return ProcessJob(jobWrapper);
        }
Пример #8
0
        /// <summary>
        /// Main entry point from WCF for Geneva jobs
        /// </summary>
        /// <param name="xml"></param>
        /// <returns></returns>
        public int RunJobFromClient(string jobName, string _ps, string _pe, string _k, string _pk)
        {
            JobDetails jobDetail = new JobDetails(jobName,
                GetJobSpecFromDb(null, jobName).ToString());
            jobDetail.RunOnce = true;

            IJobWrapper jobWrapper = null;

            jobDetail.Xml = jobDetail.Xml.Replace("PeriodStartDate=*START_TODAY*",
                String.Format("PeriodStartDate={0}", ReformatGenevaDate(_ps).ToString("yyyy-MM-dd HH:mm:ss")));
            jobDetail.Xml = jobDetail.Xml.Replace("PeriodEndDate=*END_TODAY*",
                String.Format("PeriodEndDate={0}", ReformatGenevaDate(_pe).ToString("yyyy-MM-dd HH:mm:ss")));
            jobDetail.Xml = jobDetail.Xml.Replace("KnowledgeDate=*END_TODAY*",
                String.Format("KnowledgeDate={0}", ReformatGenevaDate(_k).ToString("yyyy-MM-dd HH:mm:ss")));
            jobDetail.Xml = jobDetail.Xml.Replace("PriorKnowledgeDate=*START_TODAY*",
                String.Format("PriorKnowledgeDate={0}", ReformatGenevaDate(_pk).ToString("yyyy-MM-dd HH:mm:ss")));

            ExecuteJobNew(jobDetail, ref jobWrapper);

            while (!((State)jobWrapper.JobGlobalState).ExecutionState.Equals(StateEnums.ExecutionState.Complete))
            {
                Thread.Sleep(1000);
            }

            switch (((State)jobWrapper.JobGlobalState).CurrentStatus)
            {
                case StateEnums.Status.Success:
                    return 1;
                default:
                    return 0;
            }
        }
Пример #9
0
        /// <summary>
        /// Main entry point from WCF
        /// </summary>
        /// <param name="xml"></param>
        /// <returns></returns>
        public Object SubmitGenevaXml(string wfmActivityName, string xml)
        {
            JobDetails jobDetail = new JobDetails("Util_GenevaXmlLoader",
                GetJobSpecFromDb(null, "Util_GenevaXmlLoader").ToString());

            XmlDocument xd = new XmlDocument();
            xd.LoadXml(xml);
            jobDetail.Data.Add(new JobDetailsData("Scheduler", "ActivityName", wfmActivityName));
            jobDetail.Data.Add(new JobDetailsData("Scheduler", "Upload", xd));
            jobDetail.RunOnce = true;

            return RunJobXml(new NbIdentity("FOUNTAINHEAD", "WCF", "Unknown"), null, jobDetail);
        }
Пример #10
0
        /// <summary>
        /// Main entry point from WCF
        /// </summary>
        /// <param name="xml"></param>
        /// <returns></returns>
        public int RunJobFromClient(string jobName, string fileName)
        {
            JobDetails jobDetail = new JobDetails(jobName,
                GetJobSpecFromDb(null, jobName).ToString());
            jobDetail.RunOnce = true;

            IJobWrapper jobWrapper = null;

            if (String.IsNullOrEmpty(fileName))
                ExecuteJobNew(jobDetail, ref jobWrapper);
            else
                flatFileLoader.FileReceived(fileName, ref jobWrapper);

            Thread.Sleep(5000);  // wait for job to be queued
            while (!((State)jobWrapper.JobGlobalState).ExecutionState.Equals(StateEnums.ExecutionState.Complete))
            {
                Thread.Sleep(1000);
            }

            switch (((State)jobWrapper.JobGlobalState).CurrentStatus)
            {
                case StateEnums.Status.Success:
                    return 1;
                default:
                    return 0;
            }
        }
Пример #11
0
        public static Job BuildJobFromXml(JobDetails detail)
        {
            Job job = null;

            try
            {
                XmlDocument doc = new XmlDocument();
                doc.LoadXml(detail.Xml);

                XmlNode jobNode = doc.SelectSingleNode("Job");

                if (jobNode.Attributes["isHistoricalMode"] != null)
                    detail.IsHistoricalMode = Convert.ToBoolean(jobNode.Attributes["isHistoricalMode"].Value);

                if (jobNode.Attributes["ifWaitingForFirstTrigger"] != null)
                    detail.IfWaitingForFirstTrigger = Convert.ToBoolean(jobNode.Attributes["ifWaitingForFirstTrigger"].Value);

                if (jobNode.Attributes["skipTodayIfPassed"] != null)
                    detail.SkipTodayIfPassed = Convert.ToBoolean(jobNode.Attributes["skipTodayIfPassed"].Value);

                if (jobNode.Attributes["runOnce"] != null)
                    detail.RunOnce = Convert.ToBoolean(jobNode.Attributes["runOnce"].Value);

                if (jobNode.Attributes["limitTrigger"] != null)
                {
                    detail.UserLimit = Convert.ToInt32(jobNode.Attributes["limitTrigger"].Value);
                }

                if (jobNode.Attributes["inDate"] != null || jobNode.Attributes["runDate"] != null)
                {
                    if (jobNode.Attributes["inDate"] != null)
                        detail.InDate = Convert.ToString(jobNode.Attributes["inDate"].Value);
                    else if (jobNode.Attributes["runDate"] != null)
                        detail.InDate = Convert.ToString(jobNode.Attributes["runDate"].Value);
                }

                if (jobNode.Attributes["MaxRetries"] != null)
                    detail.MaxRetries = Convert.ToInt32(jobNode.Attributes["MaxRetries"].Value);
                if (jobNode.Attributes["DelayBetweenRetries"] != null)
                    detail.DelayBetweenRetries = Convert.ToInt32(jobNode.Attributes["DelayBetweenRetries"].Value);
                if (jobNode.Attributes["RetryFromTop"] != null)
                    detail.RetryFromTop = Convert.ToBoolean(jobNode.Attributes["RetryFromTop"].Value);

                job = new Job(
                    jobNode.Attributes["name"].Value.ToString().Trim(),
                    jobNode.Attributes["dependencyTraversalMode"].Value.ToString().Trim(),
                    detail,
                    ConfigUtils.GlobalConfig);

                IModule root = BuildModule(job.JobName, "NullModule");

                job.Modules.Add(root.Name.Trim(), root);

                XmlNodeList modules = doc.SelectNodes("Job/Module");
                foreach (XmlNode moduleNode in modules)
                {
                    string moduleTypeName = moduleNode.Attributes["moduleType"].Value.ToString();

                    PropertyBag moduleOriginalPropertyValues = new PropertyBag();
                    IModule module = BuildModule(moduleNode, moduleTypeName, moduleOriginalPropertyValues);
                    job.OrderedModuleList.Add(module.Name);

                    if (job.Modules.ContainsKey(module.Name))
                        job.Modules.Remove(module.Name);
                    job.Modules.Add(module.Name, module);
                    job.JobState.CurrentParameters.SetOriginalModulePropertyValuesPB(module.Name, moduleOriginalPropertyValues);
                    job.JobState.CurrentStatusCollection.Add(module.Name, new DependencyStatus());

                    log.DebugFormat("Job {0}: Instantiated module {1}", job.JobName, moduleNode.Attributes["name"].Value.ToString());
                }

                DependencyEngine dsb = new DependencyEngine();
                dsb.Build(ref job);
            }
            catch (Exception ex)
            {
                log.Error(ex);
            }
            return job;
        }
Пример #12
0
        //public Job(Job oJob, bool isNew)
        //{
        //    key = isNew ? DateTime.Now : oJob.key;
        //    jobName = oJob.jobName;
        //    dependencyTraversalMode = oJob.dependencyTraversalMode;
        //    config = oJob.config;
        //    arrModules = oJob.arrModules;
        //    modules = oJob.modules;
        //    dependencies = oJob.dependencies;
        //    limiter = oJob.limiter;

        //    jobStats = new JobStats(this);
        //    jobDetails = oJob.jobDetails;

        //    jobState = new State(oJob.JobState);
        //    jobState.CurrentJobCode = key;
        //    jobState.CurrentJobHash = KeyHash;
        //    jobState.JobName = jobName;
        //}

        public Job(string _jobName, string _dependencyTraversalMode, JobDetails _jobDetails, GlobalConfigDetails _config)
        {
            config = _config;

            jobName = _jobName;
            jobStats = new JobStats(this);
            jobState = new State(_jobName);
            jobDetails = _jobDetails;
            dependencyTraversalMode = _dependencyTraversalMode;
        }
Пример #13
0
        public Job(Job oJob)
        {
            key = oJob.key;
            jobName = oJob.jobName;
            dependencyTraversalMode = oJob.dependencyTraversalMode;

            jobStats = new JobStats(this);
            jobDetails = oJob.jobDetails;
            jobState = new State(oJob.JobState);

            config = oJob.config;
            arrModules = oJob.arrModules;
            modules = oJob.modules;
            dependencies = oJob.dependencies;
            limiter = oJob.limiter;
        }
Пример #14
0
        /// <summary>
        /// This method was introduced in order to run jobs synchronously for Unit Testing purposes.
        /// It should only be called from the test harness.
        /// </summary>
        /// <param name="identity"></param>
        /// <param name="_arg"></param>
        /// <returns></returns>
        public ErrorCode RunJobXmlSynchronously(NbIdentity identity, object _arg)
        {
            try
            {
                string arg = _arg.ToString();
                if (arg.ToString().IndexOf('|') == -1)
                    return ErrorCode.UNABLE_TO_BUILD_JOB_FROM_SPEC;

                string jobName = arg.ToString().Substring(0, arg.IndexOf('|'));
                string jobSpecXml = arg.ToString().Substring(arg.IndexOf('|') + 1);
                jobSpecXml = jobName.StartsWith("ADHOC_") ? ConfigUtils.MetaTagReplacer(jobSpecXml) : jobSpecXml;
                userWatchedJobLogs[String.Format("{0}|{1}", identity.Machinename, identity.Username)] = jobName;

                log.InfoFormat("Running job {0}.  Requested by {1}\\{2} on {3}", jobName, identity.AppDomain, identity.Username, identity.Machinename);
                JobDetails jd = new JobDetails(jobName, jobSpecXml);
                jd.AdapterType = "Bits.FileManagerNS.Adapters.JobAdapter";
                return ExecutionEngine.InstanceOf().ExecuteJob(jd);
            }
            catch (Exception Exception)
            {
                log.Warn(Exception);
                return ErrorCode.MODULE_FAILED;
            }
        }
Пример #15
0
	    /// <summary>
        /// Top level of job execution
        /// </summary>
        /// <param name="identity"></param>
        /// <param name="_arg"></param>
        /// <returns></returns>
		public Object RunJobXml(NbIdentity identity, object arg, JobDetails jobDetail)
		{
			try
			{
			    if (jobDetail == null)
			    {
                    try
                    {
                        //form the job from the input
                        var jobName = arg.ToString().Substring(0, arg.ToString().IndexOf('|'));
                        var jobSpecXml = arg.ToString().Substring(arg.ToString().IndexOf('|') + 1);
                    
                        //VJ No longer needed?
                        //jobSpecXml = jobName.StartsWith("ADHOC_") ?
                        //   ConfigUtils.MetaTagReplacer(jobSpecXml, ConfigUtils.MetatagMode.Environment) :
                        //    jobSpecXml;
                        jobDetail = new JobDetails(jobName, jobSpecXml);
                        jobDetail.AdapterType = "Bits.FileManagerNS.Adapters.JobAdapter";

                        //gui support
                        userWatchedJobLogs[String.Format("{0}|{1}", identity.Machinename, identity.Username)] = jobName;
                    }
                    catch
                    {
                        throw new ApplicationException(String.Format("Malformed request to RunJobXml [{0}]", arg));
                    }
			    }

                log.InfoFormat("Running job {0}.  Requested by {1}\\{2} on {3}", jobDetail.Name, identity.AppDomain, identity.Username, identity.Machinename);
                ExecutionEngine.InstanceOf().QueueExecuteJob(jobDetail);
			}
			catch (Exception ex)
			{
				log.Error(ex);
				return false;
			}
			return true;
		}
Пример #16
0
 public void QueueExecuteJob(JobDetails jobDetail)
 {
     ThreadPool.QueueUserWorkItem(new WaitCallback(Execute), jobDetail);
 }
Пример #17
0
        public override StateEnums.Status Execute(Object o, Hashtable inputData)
        {
            StateEnums.Status retval = StateEnums.Status.Success;
            int activityIdStarting = UpdateProcessStatus(Enums.ProcessStatus.Starting, "", (State)o );

            if (IfResetOnEachRun)
                ResetOutput();

            PassAlongOutputs(inputData);

            log.InfoFormat(((State)o).CurrentJobHash, "RunJobName: {0}  RunOnce: {1} ", runJobName, runOnce);

            try
            {
                Thread.Sleep(delayInterval);
                if (!runJobName.Equals(String.Empty))
                {
                    DateTime runDate = ((State)this.ExecutionEngine.GetJobState(this.job.JobName)).CurrentParameters.ProcessInputDates.InDate;

                    JobDetails jobDetails = new JobDetails();
                    jobDetails.Name = runJobName;
                    jobDetails.Xml = executionEngine.GlobalConfig.Hierarchy.GetValueAtLevel("app\\BITS_JOB_SPEC", runJobName, "");
                    log.InfoFormat(((State)o).CurrentJobHash, "Job Xml 1: {0}", jobDetails.Xml);
                    jobDetails.Xml = MetaTagReplacer.InlineMetatagSubstitution(jobDetails.Xml, runDate);
                    log.InfoFormat(((State)o).CurrentJobHash, "Job Xml 2: {0}", jobDetails.Xml);

                    if (runOnce)
                    {
                        XmlDocument xdoc = new XmlDocument();
                        xdoc.LoadXml(jobDetails.Xml);
                        xdoc = Job.SetRunOnceAttributes(xdoc, true);
                        jobDetails.RunOnce = true;
                        jobDetails.Xml = xdoc.InnerText;
                    }

                    log.InfoFormat(((State)o).CurrentJobHash, "RunDate: {0}  RunOnce: {1}  WaitForCompletion: {2}", runDate, jobDetails.RunOnce, waitForCompletion);
                    log.InfoFormat(((State)o).CurrentJobHash, "Job Xml 3: {0}", jobDetails.Xml);

                    if (waitForCompletion)
                        ExecutionEngine.InstanceOf().ExecuteJob(jobDetails);
                    else
                        ExecutionEngine.InstanceOf().QueueExecuteJob(jobDetails);
                }
            }
            catch (Exception ex)
            {
                log.Error(((State)o).CurrentJobHash, ex);
                retval = StateEnums.Status.Error;
            }

            int activityIdEnding = UpdateProcessStatus(Enums.ProcessStatus.Success, "", (State)o );

            log.InfoFormat(((State)o).CurrentJobHash, "JobLauncher executed job {0}.", runJobName);
            
            return retval;
        }