/// <summary>
        /// This will take the basic data provided about the account, upload the necessary information to the account, and schedule a job.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnStart_Click(object sender, RoutedEventArgs e)
        {
            BatchCredentials credentials = new BatchCredentials(txtBAccountName.Text, txtBAccountKey.Text);
            IBatchClient     bClient     = BatchClient.Connect(SampleConstants.BatchSvcEndpoint, credentials);

            // Setting a retry policy adds robustness against an individual call timing out.  When using a policy, by default all recoverable failures are retried.
            bClient.CustomBehaviors.Add(new SetRetryPolicy(new ExponentialRetry(TimeSpan.FromSeconds(5), 5)));

            // Create a unique workitem name; don't forget to delete these when you're done
            string workItemName = SampleConstants.WorkItemNamePrefix + Guid.NewGuid().ToString();

            // Identify the pre-existing pool of VMs that will run the tasks. An Autopool specification
            // is fine but there is the delay associated with the creation of the pool along with waiting
            // for the VMs to reach Idle state before tasks are running. You can use Batch Explorer to
            // pre-create the pool and then resize it to the desired size and number of VMs.
            JobExecutionEnvironment jee = new JobExecutionEnvironment()
            {
                PoolName = PoolName
            };

            // Next, create the JobManager instance describing the environment settings and resources it
            // needs to run
            JobManager jobMgr = new JobManager()
            {
                Name        = "JM1",
                CommandLine = SampleConstants.JobManager,

                // NOTE: We do not in general recommend that customers put their secrets on the command line or as environmental variables, as
                //       these are not a secure locations.  This was done for the simplicity of the sample.
                EnvironmentSettings = new List <IEnvironmentSetting>()
                {
                    { new EnvironmentSetting(SampleConstants.EnvWorkItemName, workItemName) },
                    { new EnvironmentSetting(SampleConstants.EnvBatchAccountKeyName, txtBAccountKey.Text) }
                },

                // In many cases you will want KillJobOnCompletion to be set to 'TRUE' - this allows the previous job to finish before
                // a recurrence is scheduled.  As an alternative, you can set this to 'FALSE' and use MaxWallClockTime as shown below,
                // which will instead ensure that every recurrence happens.
                KillJobOnCompletion = true
            };

            // Create a list of resource files that are needed to run JobManager.exe. A shared access signature key specifying
            // readonly access is used so the JobManager program will have access to the resource files when it is started
            // on a VM.
            var sasPrefix = Helpers.ConstructContainerSas(
                txtSAccountName.Text,
                txtSAccountKey.Text,
                "core.windows.net",
                txtSContainerName.Text);

            jobMgr.ResourceFiles = Helpers.GetResourceFiles(sasPrefix, SampleConstants.JobManagerFiles);

            // Create the job specification, identifying that this job has a job manager associated with it
            JobSpecification jobSpec = new JobSpecification()
            {
                JobManager = jobMgr
            };

            // Set up the desired recurrence or start time schedule.
            WorkItemSchedule wiSchedule = new WorkItemSchedule();

            if (rdoOnce.IsChecked == true)
            {
                // Set information if the task is to be run once.
                DateTime runOnce = (DateTime)(dpkDate.SelectedDate);
                runOnce = runOnce.AddHours(cbxHourO.SelectedIndex);
                runOnce = runOnce.AddMinutes(cbxMinuteO.SelectedIndex);
                wiSchedule.DoNotRunUntil = runOnce;
            }
            else
            {
                // Set information if the task is to be recurring.
                TimeSpan recurring = new TimeSpan(cbxHourR.SelectedIndex, cbxMinuteR.SelectedIndex, 0);
                wiSchedule.RecurrenceInterval = recurring;
                TimeSpan countback = new TimeSpan(0, 0, 30);
                jobSpec.JobConstraints = new JobConstraints(recurring.Subtract(countback), null);
            }

            // Upload files and create workitem.
            UploadFiles();

            using (IWorkItemManager wiMgr = bClient.OpenWorkItemManager())
            {
                ICloudWorkItem workItem = wiMgr.CreateWorkItem(workItemName);
                workItem.JobExecutionEnvironment = jee;
                workItem.Schedule         = wiSchedule;
                workItem.JobSpecification = jobSpec;

                try
                {
                    workItem.Commit();
                }
                catch (Exception ex)
                {
                    MessageBox.Show(ex.ToString());
                }
            }
            // Remember to clean up your workitems and jobs
        }
        /// <summary>
        /// This will take the basic data provided about the account, upload the necessary information to the account, and schedule a job.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnStart_Click(object sender, RoutedEventArgs e)
        {
            BatchCredentials credentials = new BatchCredentials(txtBAccountName.Text, txtBAccountKey.Text);
            IBatchClient bClient = BatchClient.Connect(SampleConstants.BatchSvcEndpoint, credentials);

            // Setting a retry policy adds robustness against an individual call timing out.  When using a policy, by default all recoverable failures are retried.
            bClient.CustomBehaviors.Add(new SetRetryPolicy(new ExponentialRetry(TimeSpan.FromSeconds(5), 5)));

            // Create a unique workitem name; don't forget to delete these when you're done
            string workItemName = SampleConstants.WorkItemNamePrefix + Guid.NewGuid().ToString();

            // Identify the pre-existing pool of VMs that will run the tasks. An Autopool specification
            // is fine but there is the delay associated with the creation of the pool along with waiting
            // for the VMs to reach Idle state before tasks are running. You can use Batch Explorer to
            // pre-create the pool and then resize it to the desired size and number of VMs.
            JobExecutionEnvironment jee = new JobExecutionEnvironment()
            {
                PoolName = PoolName
            };

            // Next, create the JobManager instance describing the environment settings and resources it
            // needs to run
            JobManager jobMgr = new JobManager()
            {
                Name = "JM1",
                CommandLine = SampleConstants.JobManager,

                // NOTE: We do not in general recommend that customers put their secrets on the command line or as environmental variables, as 
                //       these are not a secure locations.  This was done for the simplicity of the sample.
                EnvironmentSettings = new List<IEnvironmentSetting>() {
                    { new EnvironmentSetting( SampleConstants.EnvWorkItemName, workItemName ) },
                    { new EnvironmentSetting( SampleConstants.EnvBatchAccountKeyName, txtBAccountKey.Text) }
                },

                // In many cases you will want KillJobOnCompletion to be set to 'TRUE' - this allows the previous job to finish before
                // a recurrence is scheduled.  As an alternative, you can set this to 'FALSE' and use MaxWallClockTime as shown below,
                // which will instead ensure that every recurrence happens.
                KillJobOnCompletion = true
            };

            // Create a list of resource files that are needed to run JobManager.exe. A shared access signature key specifying
            // readonly access is used so the JobManager program will have access to the resource files when it is started
            // on a VM.
            var sasPrefix = Helpers.ConstructContainerSas(
                txtSAccountName.Text,
                txtSAccountKey.Text,
                "core.windows.net",
                txtSContainerName.Text);

            jobMgr.ResourceFiles = Helpers.GetResourceFiles(sasPrefix, SampleConstants.JobManagerFiles);

            // Create the job specification, identifying that this job has a job manager associated with it
            JobSpecification jobSpec = new JobSpecification()
            {
                JobManager = jobMgr
            };

            // Set up the desired recurrence or start time schedule.
            WorkItemSchedule wiSchedule = new WorkItemSchedule();

            if (rdoOnce.IsChecked == true)
            {
                // Set information if the task is to be run once.
                if (dpkDate.SelectedDate != null)
                {
                    DateTime runOnce = (DateTime)(dpkDate.SelectedDate);
                    runOnce = runOnce.AddHours(cbxHourO.SelectedIndex);
                    runOnce = runOnce.AddMinutes(cbxMinuteO.SelectedIndex);
                    wiSchedule.DoNotRunUntil = runOnce;
                }
            }
            else
            {
                // Set information if the task is to be recurring.
                TimeSpan recurring = new TimeSpan(cbxHourR.SelectedIndex, cbxMinuteR.SelectedIndex, 0);
                wiSchedule.RecurrenceInterval = recurring;
                TimeSpan countback = new TimeSpan(0, 0, 30);
                jobSpec.JobConstraints = new JobConstraints(recurring.Subtract(countback), null);
            }

            // Upload files and create workitem.
            UploadFiles();

            using (IWorkItemManager wiMgr = bClient.OpenWorkItemManager())
            {
                ICloudWorkItem workItem = wiMgr.CreateWorkItem(workItemName);
                workItem.JobExecutionEnvironment = jee;
                workItem.Schedule = wiSchedule;
                workItem.JobSpecification = jobSpec;

                try
                {
                    workItem.Commit();
                }
                catch (Exception ex)
                {
                    MessageBox.Show(ex.ToString());
                }
            }
            // Remember to clean up your workitems and jobs
        }
        /// <summary>
        /// Creates a work item with the specified work item options.
        /// </summary>
        /// <param name="options">The options describing the work item to create.</param>
        /// <returns></returns>
        public async Task CreateWorkItemAsync(CreateWorkItemOptions options)
        {
            try
            {
                using (IWorkItemManager workItemManager = this.Client.OpenWorkItemManager())
                {
                    ICloudWorkItem unboundWorkItem = workItemManager.CreateWorkItem(options.WorkItemName);

                    IJobExecutionEnvironment jobExecutionEnvironment = new JobExecutionEnvironment();
                    if (options.UseAutoPool.HasValue && options.UseAutoPool.Value)
                    {
                            IAutoPoolSpecification autoPoolSpecification = new AutoPoolSpecification()
                            {
                                AutoPoolNamePrefix = options.AutoPoolPrefix,
                                KeepAlive = options.KeepAlive,
                                PoolLifeTimeOption = options.LifeTimeOption.Equals("Job", StringComparison.OrdinalIgnoreCase) ? PoolLifeTimeOption.Job : PoolLifeTimeOption.WorkItem
                            };

                            jobExecutionEnvironment.AutoPoolSpecification = autoPoolSpecification;
                    }
                    else
                    {
                        jobExecutionEnvironment.PoolName = options.PoolName;
                    }

                    unboundWorkItem.JobExecutionEnvironment = jobExecutionEnvironment;
                    unboundWorkItem.JobSpecification = new JobSpecification()
                    {
                        Priority = options.Priority
                    };

                    // TODO: These are read only
                    unboundWorkItem.JobSpecification.JobConstraints = new JobConstraints(options.MaxWallClockTime, options.MaxRetryCount);

                    if (options.CreateSchedule.HasValue && options.CreateSchedule.Value == true)
                    {
                        IWorkItemSchedule schedule = new WorkItemSchedule()
                        {
                            DoNotRunAfter = options.DoNotRunAfter,
                            DoNotRunUntil = options.DoNotRunUntil,
                            RecurrenceInterval = options.RecurrenceInterval,
                            StartWindow = options.StartWindow
                        };

                        unboundWorkItem.Schedule = schedule;
                    }

                    if (options.CreateJobManager.HasValue && options.CreateJobManager.Value == true)
                    {
                        IJobManager jobManager = new JobManager()
                        {
                            CommandLine = options.CommandLine,
                            KillJobOnCompletion = options.KillOnCompletion,
                            Name = options.JobManagerName
                        };

                        jobManager.TaskConstraints = new TaskConstraints(options.MaxTaskWallClockTime, options.RetentionTime, options.MaxTaskRetryCount);

                        unboundWorkItem.JobSpecification.JobManager = jobManager;
                    }

                    await unboundWorkItem.CommitAsync();
                }
            }
            catch
            {
                throw;
            }
        }
Ejemplo n.º 4
0
        /// <summary>
        /// Creates a work item with the specified work item options.
        /// </summary>
        /// <param name="options">The options describing the work item to create.</param>
        /// <returns></returns>
        public async Task CreateWorkItemAsync(CreateWorkItemOptions options)
        {
            try
            {
                using (IWorkItemManager workItemManager = this.Client.OpenWorkItemManager())
                {
                    ICloudWorkItem unboundWorkItem = workItemManager.CreateWorkItem(options.WorkItemName);

                    IJobExecutionEnvironment jobExecutionEnvironment = new JobExecutionEnvironment();
                    if (options.UseAutoPool.HasValue && options.UseAutoPool.Value)
                    {
                        IAutoPoolSpecification autoPoolSpecification = new AutoPoolSpecification()
                        {
                            AutoPoolNamePrefix = options.AutoPoolPrefix,
                            KeepAlive          = options.KeepAlive,
                            PoolLifeTimeOption = options.LifeTimeOption.Equals("Job", StringComparison.OrdinalIgnoreCase) ? PoolLifeTimeOption.Job : PoolLifeTimeOption.WorkItem
                        };

                        jobExecutionEnvironment.AutoPoolSpecification = autoPoolSpecification;
                    }
                    else
                    {
                        jobExecutionEnvironment.PoolName = options.PoolName;
                    }

                    unboundWorkItem.JobExecutionEnvironment = jobExecutionEnvironment;
                    unboundWorkItem.JobSpecification        = new JobSpecification()
                    {
                        Priority = options.Priority
                    };

                    // TODO: These are read only
                    unboundWorkItem.JobSpecification.JobConstraints = new JobConstraints(options.MaxWallClockTime, options.MaxRetryCount);

                    if (options.CreateSchedule.HasValue && options.CreateSchedule.Value == true)
                    {
                        IWorkItemSchedule schedule = new WorkItemSchedule()
                        {
                            DoNotRunAfter      = options.DoNotRunAfter,
                            DoNotRunUntil      = options.DoNotRunUntil,
                            RecurrenceInterval = options.RecurrenceInterval,
                            StartWindow        = options.StartWindow
                        };

                        unboundWorkItem.Schedule = schedule;
                    }

                    if (options.CreateJobManager.HasValue && options.CreateJobManager.Value == true)
                    {
                        IJobManager jobManager = new JobManager()
                        {
                            CommandLine         = options.CommandLine,
                            KillJobOnCompletion = options.KillOnCompletion,
                            Name = options.JobManagerName
                        };

                        jobManager.TaskConstraints = new TaskConstraints(options.MaxTaskWallClockTime, options.RetentionTime, options.MaxTaskRetryCount);

                        unboundWorkItem.JobSpecification.JobManager = jobManager;
                    }

                    await unboundWorkItem.CommitAsync();
                }
            }
            catch
            {
                throw;
            }
        }