private static void CreateJobCollection()
{
if (JobCollectionAlreadyExists())
{
return;
}
var schedulerManagementClient = new SchedulerManagementClient(Credentials);
var eventJobCollection = new JobCollectionCreateParameters
{
Label = JobsCollectionLabel,
IntrinsicSettings = new JobCollectionIntrinsicSettings
{
Plan = JobCollectionPlan.Standard,
Quota = new JobCollectionQuota
{
MaxJobCount = 50,
MaxJobOccurrence = 5,
MaxRecurrence = new JobCollectionMaxRecurrence
{
Frequency = JobCollectionRecurrenceFrequency.Minute,
Interval = 5
}
}
}
};
var jobCollectionCreationResult = schedulerManagementClient.JobCollections.Create(JobsCloudServiceName, JobsCollectionName, eventJobCollection);
if (jobCollectionCreationResult.StatusCode != HttpStatusCode.OK)
{
Logger.Error(new JobSchedulerException(jobCollectionCreationResult));
}
}
static void Main(string[] args)
{
if (args.Length < 1)
{
throw new ArgumentNullException("publish settings informations");
}
SubscriptionCloudCredentials cred = GetCredentials(args[0]);
//WATM
TrafficManagerManagementClient watmClient = new TrafficManagerManagementClient(cred);
string atmDns = "adxsdk12345.trafficmanager.net";
DnsPrefixAvailabilityCheckResponse watmResp =
watmClient.Profiles.CheckDnsPrefixAvailability("adxsdk12345.trafficmanager.net");
Console.WriteLine("Invoke WATM->CheckDnsPrefixAvailability(\'{0}\'). Result: {1}", atmDns, watmResp.Result);
//Compute
ComputeManagementClient computeClient = new ComputeManagementClient(cred);
string hostServiceName = "adxsdk12345";
HostedServiceCheckNameAvailabilityResponse computeResp =
computeClient.HostedServices.CheckNameAvailability(hostServiceName);
Console.WriteLine("Invoke Compute->CheckNameAvailability(\'{0}\'). Result: {1}",
hostServiceName, computeResp.IsAvailable);
//Websites
WebSiteManagementClient websiteClient = new WebSiteManagementClient(cred);
string webSiteName = "adxsdk12345";
WebSiteIsHostnameAvailableResponse webSiteResp = websiteClient.WebSites.IsHostnameAvailable(webSiteName);
Console.WriteLine("Invoke WebSite->IsHostnameAvailable(\'{0}\'). Result: {1}",
webSiteName, webSiteResp.IsAvailable);
//Scheduler
SchedulerManagementClient schedulerClient = new SchedulerManagementClient(cred);
string schedulerCloudServiceName = "foobarrr";
string expectedSchedulerException = string.Format(
"ResourceNotFound: The cloud service with name {0} was not found.", schedulerCloudServiceName);
bool exceptionFromSchedulerServiceOccurred = false;
try
{
schedulerClient.JobCollections.CheckNameAvailability(schedulerCloudServiceName, "doesnotmatter");
}
catch (Exception ex)
{
if (ex.Message == expectedSchedulerException)
{
exceptionFromSchedulerServiceOccurred = true;
Console.WriteLine("Invoke Scheduler->CheckNameAvailability(\'{0}\'). Get back correct exception",
schedulerCloudServiceName, expectedSchedulerException);
}
}
if (!exceptionFromSchedulerServiceOccurred)
{
throw new Exception("we didn't get expected exception message from scheduler service");
}
Console.WriteLine("Smoke test is good");
}
public static IActionResult Run(
[HttpTrigger(AuthorizationLevel.Function, "put", Route = "createupdateschedulerjob/{name}")]
Microsoft.AspNetCore.Http.HttpRequest req,
String name,
ILogger log,
ExecutionContext context
)
{
try {
var config = new ConfigurationBuilder()
.SetBasePath(context.FunctionAppDirectory)
.AddEnvironmentVariables()
.Build();
var credentials = Methods.GetAzureCredentials();
SchedulerManagementClient schedulerManagementClient = new SchedulerManagementClient(
credentials
);
Schedule schedule;
using (var reader = new StreamReader(req.Body))
{
try
{
var body = reader.ReadToEnd();
log.LogInformation(body);
schedule = JsonConvert.DeserializeObject(
body,
(new Schedule()).GetType()
) as Schedule;
}
catch (Newtonsoft.Json.JsonException q)
{
return((ActionResult) new BadRequestObjectResult(q.Message));
}
}
var parsed = ResourceId.FromString(config["scheduler_job_collection_id"]);
schedulerManagementClient.SubscriptionId = parsed.SubscriptionId;
var definition = CreateJobDefinition(
config["queue_scheduler"],
schedule.message.ToBase64JsonString(),
schedule.recurrence
);
schedulerManagementClient.Jobs.CreateOrUpdate(
parsed.ResourceGroupName,
parsed.Name,
name,
definition
);
return((ActionResult) new OkResult());
}
catch (Exception e)
{
log.LogError(e.Message);
log.LogError(e.StackTrace);
log.LogError(e.Source);
throw e;
}
}
protected SchedulerManagementClient GetSchedulerManagementClient(RecordedDelegatingHandler handler)
{
var tokenCredential = new TokenCredentials(Guid.NewGuid().ToString(), "abc123");
handler.IsPassThrough = false;
var schedulerManagementClient = new SchedulerManagementClient(credentials: tokenCredential, handlers: handler);
schedulerManagementClient.SubscriptionId = "12345";
return(schedulerManagementClient);
}
/// <summary>
/// Creates new Scheduler Management Convenience Client
/// </summary>
/// <param name="subscription">Subscription containing websites to manipulate</param>
public SchedulerMgmntClient(WindowsAzureSubscription subscription)
{
currentSubscription = subscription;
csmClient = subscription.CreateClient <CloudServiceManagementClient>();
schedulerManagementClient = subscription.CreateClient <SchedulerManagementClient>();
//Get RP properties
IDictionary <string, string> dict = schedulerManagementClient.GetResourceProviderProperties().Properties;
//Get available regions
string val = string.Empty;
if (dict.TryGetValue(SupportedRegionsKey, out val))
{
AvailableRegions = new List <string>();
val.Split(',').ToList().ForEach(s => AvailableRegions.Add(s));
}
//Store global counts for max jobs and min recurrence for each plan
if (dict.TryGetValue(FreeMaxJobCountKey, out val))
{
FreeMaxJobCountValue = Convert.ToInt32(dict[FreeMaxJobCountKey]);
}
if (dict.TryGetValue(FreeMinRecurrenceKey, out val))
{
FreeMinRecurrenceValue = TimeSpan.Parse(dict[FreeMinRecurrenceKey]);
}
if (dict.TryGetValue(StandardMaxJobCountKey, out val))
{
StandardMaxJobCountValue = Convert.ToInt32(dict[StandardMaxJobCountKey]);
}
if (dict.TryGetValue(StandardMinRecurrenceKey, out val))
{
StandardMinRecurrenceValue = TimeSpan.Parse(dict[StandardMinRecurrenceKey]);
}
if (dict.TryGetValue(PremiumMaxJobCountKey, out val))
{
PremiumMaxJobCountValue = Convert.ToInt32(dict[PremiumMaxJobCountKey]);
}
if (dict.TryGetValue(PremiumMinRecurrenceKey, out val))
{
PremiumMinRecurrenceValue = TimeSpan.Parse(dict[PremiumMinRecurrenceKey]);
}
}
private static void CreateJobCollectionAndJobs(SchedulerManagementClient schedulerManagementClient)
{
var resourceGroup = ConfigurationManager.AppSettings["AzureResourceGroup"];
var location = ConfigurationManager.AppSettings["AzureLocation"];
var jobCollectionNamePrefix = "jc_";
var jobCollectionName = string.Format("{0}{1}", jobCollectionNamePrefix, Guid.NewGuid().ToString());
schedulerManagementClient.JobCollections.CreateOrUpdate(
resourceGroupName: resourceGroup,
jobCollectionName: jobCollectionName,
jobCollection: BuildJobCollecionDefinition(jobCollectionName, location));
CreateOrUpdateJob(schedulerManagementClient, resourceGroup, jobCollectionName, Guid.NewGuid().ToString(), RecurrenceFrequency.Week);
CreateOrUpdateJob(schedulerManagementClient, resourceGroup, jobCollectionName, Guid.NewGuid().ToString(), RecurrenceFrequency.Hour);
}
static void Main(string[] args)
{
// Set Environment - Choose between Azure public cloud, china cloud and US govt. cloud
_environment = AzureEnvironment.PublicEnvironments[EnvironmentName.AzureCloud];
// Get the credentials
var tokenCloudCreds = GetCredsFromServicePrincipal();
var tokenCreds = new TokenCredentials(tokenCloudCreds.Token);
// Use credentials to create Scheduler managment client.
SchedulerManagementClient schedulerManagementClient = new SchedulerManagementClient(_environment.GetEndpointAsUri(AzureEnvironment.Endpoint.ResourceManager), tokenCreds)
{
SubscriptionId = ConfigurationManager.AppSettings["AzureSubscriptionId"]
};
CreateJobCollectionAndJobs(schedulerManagementClient);
}
public SchedulerService(ServiceConfiguration serviceConfiguration)
: base(serviceConfiguration)
{
CloudServiceManagementClient = new CloudServiceManagementClient(CertificateCloudCredentials);
SchedulerManagementClient = new SchedulerManagementClient(CertificateCloudCredentials);
try
{
System.Diagnostics.Trace.TraceInformation("Registering Schedluer Resource");
SchedulerManagementClient.RegisterResourceProvider();
}
catch (Hyak.Common.CloudException)
{
// Probably it is registered before
// but TODO: do some logging in case it isn't the expected error
System.Diagnostics.Trace.TraceInformation("Schedluer Resource already registered");
}
}
private static void CreateOrUpdateJob(
SchedulerManagementClient schedulerManagementClient,
string resourceGroupName,
string jobCollectionName,
string jobName,
RecurrenceFrequency recurrenceRequency)
{
var headers = new Dictionary <string, string>();
var andomHour = new Random();
var randomMinute = new Random();
var randomSecond = new Random();
schedulerManagementClient.Jobs.CreateOrUpdate(
resourceGroupName,
jobCollectionName,
jobName,
new JobDefinition()
{
Properties = new JobProperties()
{
StartTime = DateTime.UtcNow,
Action = new JobAction()
{
Type = JobActionType.Http,
Request = new HttpRequest()
{
Uri = ConfigurationManager.AppSettings["HttpActionUrl"],
Method = "GET",
},
RetryPolicy = new RetryPolicy()
{
RetryType = RetryType.None,
}
},
Recurrence = new JobRecurrence()
{
Frequency = recurrenceRequency,
Interval = 1,
Count = 10000,
},
State = JobState.Enabled,
}
});
}
public static void QueryRegisteredSchedulerProperties(CertificateCloudCredentials credentials)
{
try
{
var schedulerServiceClient = new SchedulerManagementClient(credentials);
var result3 = schedulerServiceClient.GetResourceProviderProperties();
foreach (var prop in result3.Properties)
{
Console.WriteLine("QueryRegisteredSchedulerProperties :\n" + prop.Key + ": " + prop.Value);
}
Console.ReadLine();
}
catch (Exception e)
{
Console.WriteLine("QueryRegisteredSchedulerProperties Exception :\n" + e.Message);
throw;
}
}
public static void RegisterScheduleResourceProvider(CertificateCloudCredentials credentials)
{
var schedulerServiceClient = new SchedulerManagementClient(credentials);
try
{
var result2 = schedulerServiceClient.RegisterResourceProvider();
Console.WriteLine("RegisterScheduleResourceProvider :\n" + result2.RequestId);
Console.WriteLine("RegisterScheduleResourceProvider :\n" + result2.StatusCode);
Console.ReadLine();
}
catch (CloudException exc)
{
if (exc.Response.StatusCode != HttpStatusCode.Conflict)
{
Console.WriteLine("RegisterScheduleResourceProvider Exception :\n" + exc.Message);
throw;
}
}
}
public static void CreateJobCollections(string cloudServiceName, string jobCollectionName, CertificateCloudCredentials credentials)
{
try
{
var schedulerServiceClient = new SchedulerManagementClient(credentials);
// SchedulerOperationStatusResponse deletejob=schedulerServiceClient.JobCollections.Delete(cloudServiceName, jobCollectionName);
JobCollectionCheckNameAvailabilityResponse response = schedulerServiceClient.JobCollections.CheckNameAvailability(cloudServiceName, jobCollectionName);
if (response.IsAvailable == true)
{
var result4 = schedulerServiceClient.JobCollections.Create(cloudServiceName, jobCollectionName,
new JobCollectionCreateParameters()
{
Label = jobCollectionName,
IntrinsicSettings = new JobCollectionIntrinsicSettings()
{
Plan = JobCollectionPlan.Standard,
Quota = new JobCollectionQuota()
{
MaxJobCount = 100,
MaxJobOccurrence = 100,
MaxRecurrence = new JobCollectionMaxRecurrence()
{
Frequency = JobCollectionRecurrenceFrequency.Minute,
Interval = 1
}
}
}
});
Console.WriteLine("CreateJobCollections :\n" + result4.RequestId);
Console.WriteLine("CreateJobCollections :\n" + result4.StatusCode);
Console.ReadLine();
}
}
catch (Exception ex)
{
Console.WriteLine("CreateJobCollections Exception :\n" + ex.Message);
}
}
private static void CreateSchedulerJob(AzureDetails details)
{
// retrieve the windows azure managment certificate from current user
var store = new X509Store(StoreName.My, StoreLocation.CurrentUser);
store.Open(OpenFlags.ReadWrite);
var certificate = store.Certificates.Find(X509FindType.FindByThumbprint, "<THUMBPRINT of CERTIFICATE>", false)[0];
store.Close();
// create management credencials and cloud service management client
var credentials = new CertificateCloudCredentials("<Your subscription ID>", certificate);
var cloudServiceMgmCli = new CloudServiceManagementClient(credentials);
// create job collection
var schedulerMgmCli = new SchedulerManagementClient(credentials);
var jobCollectionIntrinsicSettings = new JobCollectionIntrinsicSettings()
{
Plan = JobCollectionPlan.Free,
Quota = new JobCollectionQuota()
{
MaxJobCount = 5,
MaxJobOccurrence = 1,
MaxRecurrence = new JobCollectionMaxRecurrence()
{
Frequency = JobCollectionRecurrenceFrequency.Hour,
Interval = 24
}
}
};
var jobCollectionCreateParameters = new JobCollectionCreateParameters()
{
IntrinsicSettings = jobCollectionIntrinsicSettings,
Label = "RunBackupJob"
};
var jobCollectionCreateResponse = schedulerMgmCli.JobCollections.Create(details.ResourceGroup, "RunBackupJob", jobCollectionCreateParameters);
//generate sas token
var storageAccount = CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting("AzureWebJobsStorage"));
//Set the expiry time and permissions for the container.
//In this case no start time is specified, so the shared access signature becomes valid immediately.
var sasConstraints = new SharedAccessAccountPolicy
{
SharedAccessExpiryTime = DateTimeOffset.UtcNow.AddYears(1),
Permissions = SharedAccessAccountPermissions.Add
| SharedAccessAccountPermissions.Create
| SharedAccessAccountPermissions.Delete
| SharedAccessAccountPermissions.ProcessMessages
| SharedAccessAccountPermissions.Read
| SharedAccessAccountPermissions.Write
};
var token = storageAccount.GetSharedAccessSignature(sasConstraints);
// create job
var schedulerClient = new SchedulerClient(details.ResourceGroup, "RunBackupJob", credentials);
var jobAction = new JobAction()
{
Type = JobActionType.StorageQueue,
QueueMessage = new JobQueueMessage
{
Message = details.PairName,
QueueName = "get-containers",
SasToken = sasConstraints.ToString(),
StorageAccountName = "queuefunction"
}
};
var jobRecurrence = new JobRecurrence()
{
Frequency = JobRecurrenceFrequency.Hour,
Interval = 24
};
var jobCreateOrUpdateParameters = new JobCreateOrUpdateParameters()
{
Action = jobAction,
Recurrence = jobRecurrence
};
var jobCreateResponse = schedulerClient.Jobs.CreateOrUpdate(details.ResourceGroup, jobCreateOrUpdateParameters);
}
public static IActionResult Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = null)]
HttpRequest req,
ILogger log,
ExecutionContext context
)
{
try
{
var config = new ConfigurationBuilder()
.SetBasePath(context.FunctionAppDirectory)
.AddEnvironmentVariables()
.Build();
var credentials = Methods.GetAzureCredentials();
SchedulerManagementClient schedulerManagementClient = new SchedulerManagementClient(
credentials
);
var parsed = ResourceId.FromString(config["scheduler_job_collection_id"]);
schedulerManagementClient.SubscriptionId = parsed.SubscriptionId;
var jobs = schedulerManagementClient.Jobs.List(parsed.ResourceGroupName, parsed.Name);
var alljobs = jobs.AsContinuousCollection(x => schedulerManagementClient.Jobs.ListNext(x));
var result = new List <Schedule>();
foreach (var job in alljobs)
{
var encodedMessage = job.Properties?.Action?.QueueMessage?.Message;
ScheduleMessage scheduleMessage = new ScheduleMessage();
try
{
if (!String.IsNullOrEmpty(encodedMessage))
{
var message = Methods.ConvertBase64String(encodedMessage);
scheduleMessage = JsonConvert.DeserializeObject(
message,
(new ScheduleMessage()).GetType()
) as ScheduleMessage;
}
else
{
scheduleMessage.BlankMessage();
}
}
catch (FormatException f)
{
log.LogInformation($"Could not decode scheduler job message: {f.Message}");
scheduleMessage.BlankMessage();
}
catch (Newtonsoft.Json.JsonException j)
{
log.LogInformation($"Could not deserialize scheduler job message: {j.Message}");
scheduleMessage.BlankMessage();
}
var schedule = new Schedule()
{
id = job.Id,
name = job.Name.Split('/')[1],
message = scheduleMessage
};
if (job.Properties.Recurrence == null)
{
schedule.recurrence = new Microsoft.Azure.Management.Scheduler.Models.JobRecurrence();
schedule.recurrence.Schedule = new Microsoft.Azure.Management.Scheduler.Models.JobRecurrenceSchedule();
}
else
{
schedule.recurrence = job.Properties.Recurrence;
}
result.Add(schedule);
}
return((ActionResult) new JsonResult(result));
}
catch (Exception e)
{
log.LogError(e.Message);
log.LogError(e.StackTrace);
throw e;
}
}
// retrieve the windows azure managment certificate from current user
public ApprenticeShipSchedular()
{
var store = new X509Store(StoreName.My, StoreLocation.CurrentUser);
store.Open(OpenFlags.ReadWrite);
var certificate = store.Certificates.Find(X509FindType.FindByThumbprint, "CA4716F85EC0962E2B69BB7D626CC16B924E550D", false)[0];
store.Close();
//
// create management credencials and cloud service management client
var credentials = new CertificateCloudCredentials("bd27a79c-de25-4097-a874-3bb35f2b926a", certificate);
var cloudServiceMgmCli = new CloudServiceManagementClient(credentials);
// create cloud service
var cloudServiceCreateParameters = new CloudServiceCreateParameters
{
Description = "sfaarmscheduler",
Email = "*****@*****.**",
GeoRegion = "West Europe",
Label = "sfaarmscheduler"
};
var cloudService = cloudServiceMgmCli.CloudServices.Create("sfaarmscheduler", cloudServiceCreateParameters);
// create job collection
var schedulerMgmCli = new SchedulerManagementClient(credentials);
var jobCollectionIntrinsicSettings = new JobCollectionIntrinsicSettings
{
//Add Credentials for X.509
Plan = JobCollectionPlan.Free,
Quota = new JobCollectionQuota
{
MaxJobCount = 5,
MaxJobOccurrence = 1,
MaxRecurrence = new JobCollectionMaxRecurrence
{
Frequency = JobCollectionRecurrenceFrequency.Hour,
Interval = 1
}
}
};
var jobCollectionCreateParameters = new JobCollectionCreateParameters
{
IntrinsicSettings = jobCollectionIntrinsicSettings,
Label = "sfajobcollection"
};
var jobCollectionCreateResponse =
schedulerMgmCli.JobCollections.Create("sfaarmscheduler", "sfajobcollection", jobCollectionCreateParameters);
var schedulerClient = new SchedulerClient("sfaarmscheduler", "sfajobcollection", credentials);
var jobAction = new JobAction
{
Type = JobActionType.StorageQueue,
QueueMessage = new JobQueueMessage()
{
Message = "test", QueueName = "vacancysummaryqueueitem", SasToken = "?sv=2017-04-17&ss=bfqt&srt=sco&sp=rwdlacup&se=2017-09-01T21:58:06Z&st=2017-09-01T13:58:06Z&spr=https&sig=r0u1A01ytcN213lsWO47Td7DUaU7lo3aQTPNTCrHRxU%3D", StorageAccountName = "sfabetastorage"
}
//Request = new JobHttpRequest
//{
// Uri = new Uri("http://blog.shaunxu.me"),
// Method = "GET"
//}
};
var jobRecurrence = new JobRecurrence
{
Frequency = JobRecurrenceFrequency.Hour,
Interval = 1
};
var jobCreateOrUpdateParameters = new JobCreateOrUpdateParameters
{
Action = jobAction,
Recurrence = jobRecurrence
};
var jobCreateResponse = schedulerClient.Jobs.CreateOrUpdate("poll_blog", jobCreateOrUpdateParameters);
var jobGetHistoryParameters = new JobGetHistoryParameters
{
Skip = 0,
Top = 100
};
var history = schedulerClient.Jobs.GetHistory("poll_blog", jobGetHistoryParameters);
foreach (var action in history)
{
Console.WriteLine("{0}\t{1}\t{2}\t{3}\t{4}", action.Status, action.Message, action.RetryCount,
action.RepeatCount, action.Timestamp);
}
}
// retrieve the windows azure managment certificate from current user
public Schedular()
{
var store = new X509Store(StoreName.My, StoreLocation.CurrentUser);
store.Open(OpenFlags.ReadWrite);
var certificate = store.Certificates.Find(X509FindType.FindByThumbprint, "<ThumbPrint>", false)[0];
store.Close();
//
// create management credencials and cloud service management client
var credentials = new CertificateCloudCredentials("8cb918af-59d0-4b24-893c-15661d048f16", certificate);
var cloudServiceMgmCli = new CloudServiceManagementClient(credentials);
// create cloud service
var cloudServiceCreateParameters = new CloudServiceCreateParameters()
{
Description = "schedulerdemo1",
Email = "microsoft.com",
GeoRegion = "Southeast Asia",
Label = "schedulerdemo1"
};
var cloudService = cloudServiceMgmCli.CloudServices.Create("schedulerdemo1", cloudServiceCreateParameters);
// create job collection
var schedulerMgmCli = new SchedulerManagementClient(credentials);
var jobCollectionIntrinsicSettings = new JobCollectionIntrinsicSettings()
{
Plan = JobCollectionPlan.Free,
Quota = new JobCollectionQuota()
{
MaxJobCount = 5,
MaxJobOccurrence = 1,
MaxRecurrence = new JobCollectionMaxRecurrence()
{
Frequency = JobCollectionRecurrenceFrequency.Hour,
Interval = 1
}
}
};
var jobCollectionCreateParameters = new JobCollectionCreateParameters()
{
IntrinsicSettings = jobCollectionIntrinsicSettings,
Label = "jc1"
};
var jobCollectionCreateResponse = schedulerMgmCli.JobCollections.Create("schedulerdemo1", "jc1", jobCollectionCreateParameters);
var schedulerClient = new SchedulerClient("schedulerdemo1", "jc1", credentials);
var jobAction = new JobAction()
{
Type = JobActionType.Http,
Request = new JobHttpRequest()
{
Uri = new Uri("http://blog.shaunxu.me"),
Method = "GET"
}
};
var jobRecurrence = new JobRecurrence()
{
Frequency = JobRecurrenceFrequency.Hour,
Interval = 1
};
var jobCreateOrUpdateParameters = new JobCreateOrUpdateParameters()
{
Action = jobAction,
Recurrence = jobRecurrence
};
var jobCreateResponse = schedulerClient.Jobs.CreateOrUpdate("poll_blog", jobCreateOrUpdateParameters);
var jobGetHistoryParameters = new JobGetHistoryParameters()
{
Skip = 0,
Top = 100
};
var history = schedulerClient.Jobs.GetHistory("poll_blog", jobGetHistoryParameters);
foreach (var action in history)
{
Console.WriteLine("{0}\t{1}\t{2}\t{3}\t{4}", action.Status, action.Message, action.RetryCount, action.RepeatCount, action.Timestamp);
}
}
/// <summary>
/// Creates new Scheduler Management Convenience Client
/// </summary>
/// <param name="subscription">Subscription containing websites to manipulate</param>
public SchedulerMgmntClient(WindowsAzureSubscription subscription)
{
csmClient = subscription.CreateClient <CloudServiceManagementClient>();
schedulerManagementClient = subscription.CreateClient <SchedulerManagementClient>();
}
