public virtual PSJob GetJob(string resourceGroupName, string jobName, string propertiesToExpand)
{
JobGetParameters parameters = new JobGetParameters(propertiesToExpand);
var response = StreamAnalyticsManagementClient.StreamingJobs.Get(
resourceGroupName, jobName, parameters);
return(new PSJob(response.Job)
{
ResourceGroupName = resourceGroupName
});
}
static void Main(string[] args)
{
string resourceGroupName = "<YOUR AZURE RESOURCE GROUP NAME>";
string streamAnalyticsJobName = "<YOUR STREAM ANALYTICS JOB NAME>";
// Get authentication token
TokenCloudCredentials aadTokenCredentials =
new TokenCloudCredentials(
ConfigurationManager.AppSettings["SubscriptionId"],
GetAuthorizationHeader());
Uri resourceManagerUri = new Uri(ConfigurationManager.AppSettings["ResourceManagerEndpoint"]);
// Create Stream Analytics and Insights management client
StreamAnalyticsManagementClient streamAnalyticsClient = new
StreamAnalyticsManagementClient(aadTokenCredentials, resourceManagerUri);
InsightsManagementClient insightsClient = new
InsightsManagementClient(aadTokenCredentials, resourceManagerUri);
// Get an existing Stream Analytics job
JobGetParameters jobGetParameters = new JobGetParameters()
{
PropertiesToExpand = "inputs,transformation,outputs"
};
JobGetResponse jobGetResponse = streamAnalyticsClient.StreamingJobs.Get(resourceGroupName, streamAnalyticsJobName, jobGetParameters);
// Enable monitoring
ServiceDiagnosticSettingsPutParameters insightPutParameters = new ServiceDiagnosticSettingsPutParameters()
{
Properties = new ServiceDiagnosticSettings()
{
StorageAccountName = "<YOUR STORAGE ACCOUNT NAME>"
}
};
InsightsClient.ServiceDiagnosticSettingsOperations.Put(jobGetResponse.Job.Id, insightPutParameters);
}
public void Test_InputOperations_IoTHub()
{
BasicDelegatingHandler handler = new BasicDelegatingHandler();
using (var undoContext = UndoContext.Current)
{
undoContext.Start();
string resourceGroupName = TestUtilities.GenerateName("StreamAnalytics");
string resourceName = TestUtilities.GenerateName("MyStreamingJobSubmittedBySDK");
string serviceLocation = TestHelper.GetDefaultLocation();
var resourceClient = TestHelper.GetResourceClient(handler);
var client = TestHelper.GetStreamAnalyticsManagementClient(handler);
try
{
ResourceGroup resourceGroup = new ResourceGroup()
{
Location = serviceLocation
};
resourceClient.ResourceGroups.CreateOrUpdate(resourceGroupName, resourceGroup);
// Construct the JobCreateProperties
JobCreateOrUpdateParameters jobCreateOrUpdateParameters =
new JobCreateOrUpdateParameters(TestHelper.GetDefaultJob(resourceName, serviceLocation));
// Create a streaming job
JobCreateOrUpdateResponse jobCreateOrUpdateResponse = client.StreamingJobs.CreateOrUpdate(resourceGroupName, jobCreateOrUpdateParameters);
Assert.Equal(HttpStatusCode.OK, jobCreateOrUpdateResponse.StatusCode);
// Get a streaming job to check
JobGetParameters jobGetParameters = new JobGetParameters(string.Empty);
JobGetResponse jobGetResponse = client.StreamingJobs.Get(resourceGroupName, resourceName, jobGetParameters);
Assert.Equal(HttpStatusCode.OK, jobGetResponse.StatusCode);
Assert.Equal(serviceLocation, jobGetResponse.Job.Location);
Assert.Equal(resourceName, jobGetResponse.Job.Name);
// Construct the Input
string sharedAccessPolicyName = "owner";
InputProperties inputProperties = new StreamInputProperties()
{
Serialization = new CsvSerialization()
{
Properties = new CsvSerializationProperties()
{
FieldDelimiter = ",",
Encoding = "UTF8"
}
},
DataSource = new IoTHubStreamInputDataSource()
{
Properties = new IoTHubStreamInputDataSourceProperties()
{
IotHubNamespace = TestHelper.IoTHubNamespace,
SharedAccessPolicyName = sharedAccessPolicyName,
SharedAccessPolicyKey = TestHelper.IotHubSharedAccessPolicyKey
}
}
};
string inputName = TestUtilities.GenerateName("inputtest");
Input input1 = new Input(inputName)
{
Properties = inputProperties
};
// Add an input
InputCreateOrUpdateParameters inputCreateOrUpdateParameters = new InputCreateOrUpdateParameters();
inputCreateOrUpdateParameters.Input = input1;
InputCreateOrUpdateResponse inputCreateOrUpdateResponse = client.Inputs.CreateOrUpdate(resourceGroupName, resourceName, inputCreateOrUpdateParameters);
Assert.Equal(HttpStatusCode.OK, inputCreateOrUpdateResponse.StatusCode);
Assert.Equal(inputName, inputCreateOrUpdateResponse.Input.Name);
Assert.Equal("Stream", inputCreateOrUpdateResponse.Input.Properties.Type);
Assert.True(inputCreateOrUpdateResponse.Input.Properties.Serialization is CsvSerialization);
CsvSerialization csvSerializationInResponse1 = (CsvSerialization)inputCreateOrUpdateResponse.Input.Properties.Serialization;
Assert.Equal(",", csvSerializationInResponse1.Properties.FieldDelimiter);
Assert.True(inputCreateOrUpdateResponse.Input.Properties is StreamInputProperties);
StreamInputProperties streamInputPropertiesInResponse = (StreamInputProperties)inputCreateOrUpdateResponse.Input.Properties;
Assert.True(streamInputPropertiesInResponse.DataSource is IoTHubStreamInputDataSource);
IoTHubStreamInputDataSource iotHubInputDataSourceInResponse1 = (IoTHubStreamInputDataSource)streamInputPropertiesInResponse.DataSource;
Assert.Equal(sharedAccessPolicyName, iotHubInputDataSourceInResponse1.Properties.SharedAccessPolicyName);
Assert.NotNull(streamInputPropertiesInResponse.Etag);
// Get the input
InputGetResponse inputGetResponse = client.Inputs.Get(resourceGroupName, resourceName, inputName);
Assert.Equal(HttpStatusCode.OK, inputGetResponse.StatusCode);
Assert.Equal(inputName, inputGetResponse.Input.Name);
Assert.True(inputGetResponse.Input.Properties is StreamInputProperties);
StreamInputProperties streamInputPropertiesInResponse2 = (StreamInputProperties)inputGetResponse.Input.Properties;
Assert.True(streamInputPropertiesInResponse2.DataSource is IoTHubStreamInputDataSource);
IoTHubStreamInputDataSource iotHubInputDataSourceInResponse2 = (IoTHubStreamInputDataSource)streamInputPropertiesInResponse2.DataSource;
Assert.Equal(sharedAccessPolicyName, iotHubInputDataSourceInResponse2.Properties.SharedAccessPolicyName);
Assert.Equal(inputCreateOrUpdateResponse.Input.Properties.Etag, inputGetResponse.Input.Properties.Etag);
// Test input connectivity
ResourceTestConnectionResponse response = client.Inputs.TestConnection(resourceGroupName, resourceName, inputName);
Assert.Equal(OperationStatus.Succeeded, response.Status);
Assert.Equal(ResourceTestStatus.TestSucceeded, response.ResourceTestStatus);
// Update the input
string newSharedPolicyName = TestUtilities.GenerateName("owner");
inputProperties = new StreamInputProperties()
{
Serialization = new CsvSerialization()
{
Properties = new CsvSerializationProperties()
{
FieldDelimiter = "|",
Encoding = "UTF8"
}
},
DataSource = new IoTHubStreamInputDataSource()
{
Properties = new IoTHubStreamInputDataSourceProperties()
{
IotHubNamespace = TestHelper.IoTHubNamespace,
SharedAccessPolicyName = newSharedPolicyName,
SharedAccessPolicyKey = TestHelper.IotHubSharedAccessPolicyKey
}
}
};
inputProperties.Etag = inputCreateOrUpdateResponse.Input.Properties.Etag;
InputPatchParameters inputPatchParameters = new InputPatchParameters(inputProperties);
InputPatchResponse inputPatchResponse = client.Inputs.Patch(resourceGroupName, resourceName, inputName, inputPatchParameters);
Assert.Equal(HttpStatusCode.OK, inputPatchResponse.StatusCode);
Assert.True(inputPatchResponse.Properties.Serialization is CsvSerialization);
CsvSerialization csvSerializationInResponse2 = (CsvSerialization)inputPatchResponse.Properties.Serialization;
Assert.Equal("|", csvSerializationInResponse2.Properties.FieldDelimiter);
Assert.True(inputPatchResponse.Properties is StreamInputProperties);
StreamInputProperties streamInputPropertiesInResponse3 = (StreamInputProperties)inputPatchResponse.Properties;
Assert.True(streamInputPropertiesInResponse3.DataSource is IoTHubStreamInputDataSource);
IoTHubStreamInputDataSource iotHubInputDataSourceInResponse3 = (IoTHubStreamInputDataSource)streamInputPropertiesInResponse3.DataSource;
Assert.Equal(newSharedPolicyName, iotHubInputDataSourceInResponse3.Properties.SharedAccessPolicyName);
Assert.NotNull(inputPatchResponse.Properties.Etag);
Assert.NotEqual(streamInputPropertiesInResponse.Etag, inputPatchResponse.Properties.Etag);
// Delete the input
AzureOperationResponse deleteInputOperationResponse = client.Inputs.Delete(resourceGroupName, resourceName, inputName);
Assert.Equal(HttpStatusCode.OK, deleteInputOperationResponse.StatusCode);
// Check that there are 0 inputs in the job
jobGetParameters = new JobGetParameters("inputs");
jobGetResponse = client.StreamingJobs.Get(resourceGroupName, resourceName, jobGetParameters);
Assert.Equal(HttpStatusCode.OK, jobGetResponse.StatusCode);
Assert.Equal(0, jobGetResponse.Job.Properties.Inputs.Count);
}
finally
{
client.StreamingJobs.Delete(resourceGroupName, resourceName);
resourceClient.ResourceGroups.Delete(resourceGroupName);
}
}
}
public void Test_InputOperations_ReferenceBlob()
{
BasicDelegatingHandler handler = new BasicDelegatingHandler();
using (var undoContext = UndoContext.Current)
{
undoContext.Start();
string resourceGroupName = TestUtilities.GenerateName("StreamAnalytics");
string resourceName = TestUtilities.GenerateName("MyStreamingJobSubmittedBySDK");
string serviceLocation = TestHelper.GetDefaultLocation();
var resourceClient = TestHelper.GetResourceClient(handler);
var client = TestHelper.GetStreamAnalyticsManagementClient(handler);
try
{
ResourceGroup resourceGroup = new ResourceGroup()
{
Location = serviceLocation
};
resourceClient.ResourceGroups.CreateOrUpdate(resourceGroupName, resourceGroup);
// Construct the JobCreateProperties
JobCreateOrUpdateParameters jobCreateOrUpdateParameters =
new JobCreateOrUpdateParameters(TestHelper.GetDefaultJob(resourceName, serviceLocation));
// Create a streaming job
JobCreateOrUpdateResponse jobCreateOrUpdateResponse = client.StreamingJobs.CreateOrUpdate(resourceGroupName, jobCreateOrUpdateParameters);
Assert.Equal(HttpStatusCode.OK, jobCreateOrUpdateResponse.StatusCode);
// Get a streaming job to check
JobGetParameters jobGetParameters = new JobGetParameters(string.Empty);
JobGetResponse jobGetResponse = client.StreamingJobs.Get(resourceGroupName, resourceName, jobGetParameters);
Assert.Equal(HttpStatusCode.OK, jobGetResponse.StatusCode);
Assert.Equal(serviceLocation, jobGetResponse.Job.Location);
Assert.Equal(resourceName, jobGetResponse.Job.Name);
// Construct the Input
StorageAccount storageAccount = new StorageAccount();
storageAccount.AccountName = TestHelper.AccountName;
storageAccount.AccountKey = TestHelper.AccountKey;
InputProperties inputProperties = new ReferenceInputProperties()
{
Serialization = new CsvSerialization()
{
Properties = new CsvSerializationProperties()
{
FieldDelimiter = ",",
Encoding = "UTF8"
}
},
DataSource = new BlobReferenceInputDataSource()
{
Properties = new BlobReferenceInputDataSourceProperties()
{
StorageAccounts = new[] { storageAccount },
Container = "state",
PathPattern = "{date}",
DateFormat = "yyyy/MM/dd"
}
}
};
string inputName = TestUtilities.GenerateName("inputtest");
Input input1 = new Input(inputName)
{
Properties = inputProperties
};
// Add an input
InputCreateOrUpdateParameters inputCreateOrUpdateParameters = new InputCreateOrUpdateParameters();
inputCreateOrUpdateParameters.Input = input1;
InputCreateOrUpdateResponse inputCreateOrUpdateResponse = client.Inputs.CreateOrUpdate(resourceGroupName, resourceName, inputCreateOrUpdateParameters);
Assert.Equal(HttpStatusCode.OK, inputCreateOrUpdateResponse.StatusCode);
Assert.Equal(inputName, inputCreateOrUpdateResponse.Input.Name);
Assert.Equal("Reference", inputCreateOrUpdateResponse.Input.Properties.Type);
Assert.True(inputCreateOrUpdateResponse.Input.Properties is ReferenceInputProperties);
ReferenceInputProperties referenceInputPropertiesInResponse1 = (ReferenceInputProperties)inputCreateOrUpdateResponse.Input.Properties;
Assert.True(referenceInputPropertiesInResponse1.DataSource is BlobReferenceInputDataSource);
BlobReferenceInputDataSource blobReferenceInputDataSourceInResponse1 = (BlobReferenceInputDataSource)referenceInputPropertiesInResponse1.DataSource;
Assert.Equal("{date}", blobReferenceInputDataSourceInResponse1.Properties.PathPattern);
Assert.Equal("yyyy/MM/dd", blobReferenceInputDataSourceInResponse1.Properties.DateFormat);
Assert.NotNull(inputCreateOrUpdateResponse.Input.Properties.Etag);
// Get the input
InputGetResponse inputGetResponse = client.Inputs.Get(resourceGroupName, resourceName, inputName);
Assert.Equal(HttpStatusCode.OK, inputGetResponse.StatusCode);
Assert.Equal(inputName, inputGetResponse.Input.Name);
Assert.True(inputGetResponse.Input.Properties is ReferenceInputProperties);
ReferenceInputProperties referenceInputPropertiesInResponse2 = (ReferenceInputProperties)inputGetResponse.Input.Properties;
Assert.True(referenceInputPropertiesInResponse2.DataSource is BlobReferenceInputDataSource);
BlobReferenceInputDataSource blobReferenceInputDataSourceInResponse2 = (BlobReferenceInputDataSource)referenceInputPropertiesInResponse2.DataSource;
Assert.Equal("{date}", blobReferenceInputDataSourceInResponse2.Properties.PathPattern);
Assert.Equal("yyyy/MM/dd", blobReferenceInputDataSourceInResponse2.Properties.DateFormat);
Assert.Equal(inputCreateOrUpdateResponse.Input.Properties.Etag, inputGetResponse.Input.Properties.Etag);
// List inputs
InputListResponse inputListResponse = client.Inputs.ListInputInJob(resourceGroupName, resourceName, new InputListParameters());
Assert.Equal(HttpStatusCode.OK, inputListResponse.StatusCode);
Assert.Equal(1, inputListResponse.Value.Count);
// Test input connectivity
ResourceTestConnectionResponse response = client.Inputs.TestConnection(resourceGroupName, resourceName, inputName);
Assert.Equal(OperationStatus.Succeeded, response.Status);
Assert.Equal(ResourceTestStatus.TestSucceeded, response.ResourceTestStatus);
// Update the input
BlobReferenceInputDataSource blobReferenceInputDataSource = new BlobReferenceInputDataSource()
{
Properties = new BlobReferenceInputDataSourceProperties()
{
StorageAccounts = new[] { storageAccount },
Container = "state",
PathPattern = "test.csv",
DateFormat = "yyyy/MM/dd"
}
};
((ReferenceInputProperties)inputProperties).DataSource = blobReferenceInputDataSource;
inputProperties.Etag = inputCreateOrUpdateResponse.Input.Properties.Etag;
InputPatchParameters inputPatchParameters = new InputPatchParameters(inputProperties);
InputPatchResponse inputPatchResponse = client.Inputs.Patch(resourceGroupName, resourceName, inputName, inputPatchParameters);
Assert.Equal(HttpStatusCode.OK, inputPatchResponse.StatusCode);
Assert.True(inputPatchResponse.Properties is ReferenceInputProperties);
ReferenceInputProperties referenceInputPropertiesInResponse3 = (ReferenceInputProperties)inputPatchResponse.Properties;
Assert.True(referenceInputPropertiesInResponse3.DataSource is BlobReferenceInputDataSource);
BlobReferenceInputDataSource blobReferenceInputDataSourceInResponse3 = (BlobReferenceInputDataSource)referenceInputPropertiesInResponse3.DataSource;
Assert.Equal("test.csv", blobReferenceInputDataSourceInResponse3.Properties.PathPattern);
Assert.Equal("yyyy/MM/dd", blobReferenceInputDataSourceInResponse3.Properties.DateFormat);
Assert.NotNull(inputPatchResponse.Properties.Etag);
Assert.NotEqual(inputCreateOrUpdateResponse.Input.Properties.Etag, inputPatchResponse.Properties.Etag);
// Delete the inputs
AzureOperationResponse deleteInputOperationResponse = client.Inputs.Delete(resourceGroupName, resourceName, inputName);
Assert.Equal(HttpStatusCode.OK, deleteInputOperationResponse.StatusCode);
// Check that there are 0 inputs in the job
jobGetParameters = new JobGetParameters("inputs");
jobGetResponse = client.StreamingJobs.Get(resourceGroupName, resourceName, jobGetParameters);
Assert.Equal(HttpStatusCode.OK, jobGetResponse.StatusCode);
Assert.Equal(0, jobGetResponse.Job.Properties.Inputs.Count);
}
finally
{
client.StreamingJobs.Delete(resourceGroupName, resourceName);
resourceClient.ResourceGroups.Delete(resourceGroupName);
}
}
}
public void Test_OutputOperations_EventHub()
{
BasicDelegatingHandler handler = new BasicDelegatingHandler();
using (var undoContext = UndoContext.Current)
{
undoContext.Start();
string resourceGroupName = TestUtilities.GenerateName("StreamAnalytics");
string resourceName = TestUtilities.GenerateName("MyStreamingJobSubmittedBySDK");
string serviceLocation = TestHelper.GetDefaultLocation();
var resourceClient = TestHelper.GetResourceClient(handler);
var client = TestHelper.GetStreamAnalyticsManagementClient(handler);
try
{
ResourceGroup resourceGroup = new ResourceGroup()
{
Location = serviceLocation
};
resourceClient.ResourceGroups.CreateOrUpdate(resourceGroupName, resourceGroup);
Job job = new Job();
job.Name = resourceName;
job.Location = serviceLocation;
// Construct the general properties for JobProperties
JobProperties jobProperties = new JobProperties();
jobProperties.Sku = new Sku()
{
Name = "standard"
};
jobProperties.EventsOutOfOrderPolicy = EventsOutOfOrderPolicy.Drop;
jobProperties.EventsOutOfOrderMaxDelayInSeconds = 0;
job.Properties = jobProperties;
// Construct the JobCreateProperties
JobCreateOrUpdateParameters jobCreateOrUpdateParameters = new JobCreateOrUpdateParameters();
jobCreateOrUpdateParameters.Job = job;
// Create a streaming job
JobCreateOrUpdateResponse jobCreateOrUpdateResponse = client.StreamingJobs.CreateOrUpdate(resourceGroupName, jobCreateOrUpdateParameters);
Assert.Equal(HttpStatusCode.OK, jobCreateOrUpdateResponse.StatusCode);
// Get a streaming job to check
JobGetParameters jobGetParameters = new JobGetParameters(string.Empty);
JobGetResponse jobGetResponse = client.StreamingJobs.Get(resourceGroupName, resourceName, jobGetParameters);
Assert.Equal(HttpStatusCode.OK, jobGetResponse.StatusCode);
Assert.Equal(serviceLocation, jobGetResponse.Job.Location);
Assert.Equal(resourceName, jobGetResponse.Job.Name);
// Construct the Output
OutputProperties outputProperties = new OutputProperties();
string outputName = TestUtilities.GenerateName("outputtest");
string partitionKey = "partitionKey";
EventHubOutputDataSource eventHubOutputDataSource = new EventHubOutputDataSource()
{
Properties = new EventHubOutputDataSourceProperties()
{
ServiceBusNamespace = "sdktest",
EventHubName = "sdkeventhub",
SharedAccessPolicyName = TestHelper.SharedAccessPolicyName,
SharedAccessPolicyKey = TestHelper.SharedAccessPolicyKey,
PartitionKey = partitionKey
}
};
JsonSerialization jsonSerialization = new JsonSerialization()
{
Properties = new JsonSerializationProperties()
{
Encoding = "UTF8",
Format = Format.LineSeparated
}
};
outputProperties.DataSource = eventHubOutputDataSource;
outputProperties.Serialization = jsonSerialization;
Output output1 = new Output(outputName)
{
Properties = outputProperties
};
// Add an output
OutputCreateOrUpdateParameters outputCreateOrUpdateParameters = new OutputCreateOrUpdateParameters();
outputCreateOrUpdateParameters.Output = output1;
OutputCreateOrUpdateResponse outputCreateOrUpdateResponse = client.Outputs.CreateOrUpdate(resourceGroupName, resourceName, outputCreateOrUpdateParameters);
Assert.Equal(HttpStatusCode.OK, outputCreateOrUpdateResponse.StatusCode);
Assert.Equal(outputName, outputCreateOrUpdateResponse.Output.Name);
Assert.True(outputCreateOrUpdateResponse.Output.Properties.Serialization is JsonSerialization);
JsonSerialization jsonSerializationInResponse1 = (JsonSerialization)outputCreateOrUpdateResponse.Output.Properties.Serialization;
Assert.Equal(Format.LineSeparated, jsonSerializationInResponse1.Properties.Format);
Assert.True(outputCreateOrUpdateResponse.Output.Properties.DataSource is EventHubOutputDataSource);
EventHubOutputDataSource eventHubOutputDataSourceInResponse1 = (EventHubOutputDataSource)outputCreateOrUpdateResponse.Output.Properties.DataSource;
Assert.Equal(partitionKey, eventHubOutputDataSourceInResponse1.Properties.PartitionKey);
Assert.NotNull(outputCreateOrUpdateResponse.Output.Properties.Etag);
// Get the output
OutputGetResponse outputGetResponse = client.Outputs.Get(resourceGroupName, resourceName, outputName);
Assert.Equal(HttpStatusCode.OK, outputGetResponse.StatusCode);
Assert.Equal(outputName, outputGetResponse.Output.Name);
Assert.True(outputGetResponse.Output.Properties.Serialization is JsonSerialization);
JsonSerialization jsonSerializationInResponse2 = (JsonSerialization)outputGetResponse.Output.Properties.Serialization;
Assert.Equal(Format.LineSeparated, jsonSerializationInResponse2.Properties.Format);
Assert.True(outputGetResponse.Output.Properties.DataSource is EventHubOutputDataSource);
EventHubOutputDataSource eventHubOutputDataSourceInResponse2 = (EventHubOutputDataSource)outputGetResponse.Output.Properties.DataSource;
Assert.Equal(partitionKey, eventHubOutputDataSourceInResponse2.Properties.PartitionKey);
// Test output connectivity
DataSourceTestConnectionResponse response = client.Outputs.TestConnection(resourceGroupName, resourceName, outputName);
Assert.Equal(OperationStatus.Succeeded, response.Status);
Assert.Equal(DataSourceTestStatus.TestSucceeded, response.DataSourceTestStatus);
// Update the output
jsonSerialization = new JsonSerialization()
{
Properties = new JsonSerializationProperties()
{
Encoding = "UTF8",
Format = Format.Array
}
};
string newPartitionKey = TestUtilities.GenerateName("NewPartitionKey");
eventHubOutputDataSource.Properties.PartitionKey = newPartitionKey;
outputProperties.DataSource = eventHubOutputDataSource;
outputProperties.Serialization = jsonSerialization;
outputProperties.Etag = outputCreateOrUpdateResponse.Output.Properties.Etag;
OutputPatchParameters outputPatchParameters = new OutputPatchParameters(outputProperties);
OutputPatchResponse outputPatchResponse = client.Outputs.Patch(resourceGroupName, resourceName, outputName, outputPatchParameters);
Assert.Equal(HttpStatusCode.OK, outputPatchResponse.StatusCode);
Assert.True(outputPatchResponse.Properties.Serialization is JsonSerialization);
JsonSerialization jsonSerializationInResponse3 = (JsonSerialization)outputPatchResponse.Properties.Serialization;
Assert.Equal(Format.Array, jsonSerializationInResponse3.Properties.Format);
Assert.True(outputPatchResponse.Properties.DataSource is EventHubOutputDataSource);
EventHubOutputDataSource eventHubOutputDataSourceInResponse3 = (EventHubOutputDataSource)outputPatchResponse.Properties.DataSource;
Assert.Equal(newPartitionKey, eventHubOutputDataSourceInResponse3.Properties.PartitionKey);
Assert.NotNull(outputPatchResponse.Properties.Etag);
Assert.NotEqual(outputCreateOrUpdateResponse.Output.Properties.Etag, outputPatchResponse.Properties.Etag);
// Delete the output
AzureOperationResponse deleteInputOperationResponse = client.Outputs.Delete(resourceGroupName, resourceName, outputName);
Assert.Equal(HttpStatusCode.OK, deleteInputOperationResponse.StatusCode);
// Check that there are 0 outputs in the job
jobGetParameters = new JobGetParameters("outputs");
jobGetResponse = client.StreamingJobs.Get(resourceGroupName, resourceName, jobGetParameters);
Assert.Equal(HttpStatusCode.OK, jobGetResponse.StatusCode);
Assert.Equal(0, jobGetResponse.Job.Properties.Outputs.Count);
}
finally
{
client.StreamingJobs.Delete(resourceGroupName, resourceName);
resourceClient.ResourceGroups.Delete(resourceGroupName);
}
}
}
public void Test_OutputOperations_E2E()
{
BasicDelegatingHandler handler = new BasicDelegatingHandler();
using (var undoContext = UndoContext.Current)
{
undoContext.Start();
string resourceGroupName = TestUtilities.GenerateName("StreamAnalytics");
string resourceName = TestUtilities.GenerateName("MyStreamingJobSubmittedBySDK");
string serviceLocation = TestHelper.GetDefaultLocation();
var resourceClient = TestHelper.GetResourceClient(handler);
var client = TestHelper.GetStreamAnalyticsManagementClient(handler);
try
{
ResourceGroup resourceGroup = new ResourceGroup()
{
Location = serviceLocation
};
resourceClient.ResourceGroups.CreateOrUpdate(resourceGroupName, resourceGroup);
Job job = new Job();
job.Name = resourceName;
job.Location = serviceLocation;
// Construct the general properties for JobProperties
JobProperties jobProperties = new JobProperties();
jobProperties.Sku = new Sku()
{
Name = "standard"
};
jobProperties.EventsOutOfOrderPolicy = EventsOutOfOrderPolicy.Drop;
jobProperties.EventsOutOfOrderMaxDelayInSeconds = 0;
job.Properties = jobProperties;
// Construct the JobCreateProperties
JobCreateOrUpdateParameters jobCreateOrUpdateParameters = new JobCreateOrUpdateParameters();
jobCreateOrUpdateParameters.Job = job;
// Create a streaming job
JobCreateOrUpdateResponse jobCreateOrUpdateResponse = client.StreamingJobs.CreateOrUpdate(resourceGroupName, jobCreateOrUpdateParameters);
Assert.Equal(HttpStatusCode.OK, jobCreateOrUpdateResponse.StatusCode);
// Get a streaming job to check
JobGetParameters jobGetParameters = new JobGetParameters(string.Empty);
JobGetResponse jobGetResponse = client.StreamingJobs.Get(resourceGroupName, resourceName, jobGetParameters);
Assert.Equal(HttpStatusCode.OK, jobGetResponse.StatusCode);
Assert.Equal(serviceLocation, jobGetResponse.Job.Location);
Assert.Equal(resourceName, jobGetResponse.Job.Name);
// Construct the Output
OutputProperties outputProperties = new OutputProperties();
string outputName = TestUtilities.GenerateName("outputtest");
string tableName = "StateInfo";
SqlAzureOutputDataSource sqlAzureOutputDataSource = new SqlAzureOutputDataSource()
{
Properties = new SqlAzureOutputDataSourceProperties()
{
Server = TestHelper.Server,
Database = TestHelper.Database,
User = TestHelper.User,
Password = TestHelper.Password,
Table = tableName
}
};
outputProperties.DataSource = sqlAzureOutputDataSource;
Output output1 = new Output(outputName)
{
Properties = outputProperties
};
// Add an output
OutputCreateOrUpdateParameters outputCreateOrUpdateParameters = new OutputCreateOrUpdateParameters();
outputCreateOrUpdateParameters.Output = output1;
OutputCreateOrUpdateResponse outputCreateOrUpdateResponse = client.Outputs.CreateOrUpdate(resourceGroupName, resourceName, outputCreateOrUpdateParameters);
Assert.Equal(HttpStatusCode.OK, outputCreateOrUpdateResponse.StatusCode);
Assert.Equal(outputName, outputCreateOrUpdateResponse.Output.Name);
Assert.True(outputCreateOrUpdateResponse.Output.Properties.DataSource is SqlAzureOutputDataSource);
SqlAzureOutputDataSource sqlAzureOutputDataSourceInResponse1 = (SqlAzureOutputDataSource)outputCreateOrUpdateResponse.Output.Properties.DataSource;
Assert.Equal(tableName, sqlAzureOutputDataSourceInResponse1.Properties.Table);
Assert.NotNull(outputCreateOrUpdateResponse.Output.Properties.Etag);
// Get the output
OutputGetResponse outputGetResponse = client.Outputs.Get(resourceGroupName, resourceName, outputName);
Assert.Equal(HttpStatusCode.OK, outputGetResponse.StatusCode);
Assert.Equal(outputName, outputGetResponse.Output.Name);
Assert.True(outputGetResponse.Output.Properties.DataSource is SqlAzureOutputDataSource);
SqlAzureOutputDataSource sqlAzureOutputDataSourceInResponse2 = (SqlAzureOutputDataSource)outputGetResponse.Output.Properties.DataSource;
Assert.Equal(tableName, sqlAzureOutputDataSourceInResponse2.Properties.Table);
// List outputs
OutputListResponse outputListResponse = client.Outputs.ListOutputInJob(resourceGroupName, resourceName, new OutputListParameters());
Assert.Equal(HttpStatusCode.OK, outputListResponse.StatusCode);
Assert.Equal(1, outputListResponse.Value.Count);
// Check that there is 1 output in the job
jobGetParameters = new JobGetParameters("outputs");
jobGetResponse = client.StreamingJobs.Get(resourceGroupName, resourceName, jobGetParameters);
Assert.Equal(HttpStatusCode.OK, jobGetResponse.StatusCode);
Assert.Equal(1, jobGetResponse.Job.Properties.Outputs.Count);
// Test output connectivity
DataSourceTestConnectionResponse response = client.Outputs.TestConnection(resourceGroupName, resourceName, outputName);
Assert.Equal(OperationStatus.Succeeded, response.Status);
Assert.Equal(DataSourceTestStatus.TestSucceeded, response.DataSourceTestStatus);
// Update the output
string newTableName = TestUtilities.GenerateName("NewTableName");
sqlAzureOutputDataSource.Properties.Table = newTableName;
outputProperties.DataSource = sqlAzureOutputDataSource;
outputProperties.Etag = outputCreateOrUpdateResponse.Output.Properties.Etag;
OutputPatchParameters outputPatchParameters = new OutputPatchParameters(outputProperties);
OutputPatchResponse outputPatchResponse = client.Outputs.Patch(resourceGroupName, resourceName, outputName, outputPatchParameters);
Assert.Equal(HttpStatusCode.OK, outputPatchResponse.StatusCode);
Assert.True(outputPatchResponse.Properties.DataSource is SqlAzureOutputDataSource);
SqlAzureOutputDataSource sqlAzureOutputDataSourceInResponse3 = (SqlAzureOutputDataSource)outputPatchResponse.Properties.DataSource;
Assert.Equal(newTableName, sqlAzureOutputDataSourceInResponse3.Properties.Table);
Assert.NotNull(outputPatchResponse.Properties.Etag);
Assert.NotEqual(outputCreateOrUpdateResponse.Output.Properties.Etag, outputPatchResponse.Properties.Etag);
// Add second output
string outputName2 = TestUtilities.GenerateName("outputtest");
Output output2 = new Output(outputName2)
{
Properties = outputProperties
};
outputCreateOrUpdateParameters.Output = output2;
outputCreateOrUpdateResponse = client.Outputs.CreateOrUpdate(resourceGroupName, resourceName, outputCreateOrUpdateParameters);
// List outputs
outputListResponse = client.Outputs.ListOutputInJob(resourceGroupName, resourceName, new OutputListParameters());
Assert.Equal(HttpStatusCode.OK, outputListResponse.StatusCode);
Assert.Equal(2, outputListResponse.Value.Count);
// Check that there are 2 outputs in the job
jobGetParameters = new JobGetParameters("outputs");
jobGetResponse = client.StreamingJobs.Get(resourceGroupName, resourceName, jobGetParameters);
Assert.Equal(HttpStatusCode.OK, jobGetResponse.StatusCode);
Assert.Equal(2, jobGetResponse.Job.Properties.Outputs.Count);
// Delete the outputs
AzureOperationResponse deleteInputOperationResponse = client.Outputs.Delete(resourceGroupName, resourceName, outputName);
Assert.Equal(HttpStatusCode.OK, deleteInputOperationResponse.StatusCode);
deleteInputOperationResponse = client.Outputs.Delete(resourceGroupName, resourceName, outputName2);
Assert.Equal(HttpStatusCode.OK, deleteInputOperationResponse.StatusCode);
// Check that there are 0 outputs in the job
jobGetParameters = new JobGetParameters("outputs");
jobGetResponse = client.StreamingJobs.Get(resourceGroupName, resourceName, jobGetParameters);
Assert.Equal(HttpStatusCode.OK, jobGetResponse.StatusCode);
Assert.Equal(0, jobGetResponse.Job.Properties.Outputs.Count);
}
finally
{
client.StreamingJobs.Delete(resourceGroupName, resourceName);
resourceClient.ResourceGroups.Delete(resourceGroupName);
}
}
}
public void Test_FunctionOperations_Full_Scalar_AzureMLWebService()
{
BasicDelegatingHandler handler = new BasicDelegatingHandler();
using (var undoContext = UndoContext.Current)
{
undoContext.Start();
string resourceGroupName = TestUtilities.GenerateName("StreamAnalytics");
string resourceName = TestUtilities.GenerateName("MyStreamingJobSubmittedBySDK");
string serviceLocation = TestHelper.GetDefaultLocation();
var resourceClient = TestHelper.GetResourceClient(handler);
var client = TestHelper.GetStreamAnalyticsManagementClient(handler);
try
{
ResourceGroup resourceGroup = new ResourceGroup()
{
Location = serviceLocation
};
resourceClient.ResourceGroups.CreateOrUpdate(resourceGroupName, resourceGroup);
// Construct the JobCreateProperties
JobCreateOrUpdateParameters jobCreateOrUpdateParameters =
new JobCreateOrUpdateParameters(TestHelper.GetDefaultJob(resourceName, serviceLocation));
// Create a streaming job
JobCreateOrUpdateResponse jobCreateOrUpdateResponse = client.StreamingJobs.CreateOrUpdate(resourceGroupName, jobCreateOrUpdateParameters);
Assert.Equal(HttpStatusCode.OK, jobCreateOrUpdateResponse.StatusCode);
// Get a streaming job to check
JobGetParameters jobGetParameters = new JobGetParameters(string.Empty);
JobGetResponse jobGetResponse = client.StreamingJobs.Get(resourceGroupName, resourceName, jobGetParameters);
Assert.Equal(HttpStatusCode.OK, jobGetResponse.StatusCode);
Assert.Equal(serviceLocation, jobGetResponse.Job.Location);
Assert.Equal(resourceName, jobGetResponse.Job.Name);
// Retrieve default definition of the function
string functionName = TestUtilities.GenerateName("functiontest");
var retrieveDefaultDefinitionParameters = new AzureMachineLearningWebServiceFunctionRetrieveDefaultDefinitionParameters
()
{
BindingRetrievalProperties = new AzureMachineLearningWebServiceFunctionBindingRetrievalProperties()
{
ExecuteEndpoint = TestHelper.ExecuteEndpoint,
UdfType = "Scalar"
}
};
FunctionRetrieveDefaultDefinitionResponse retrieveDefaultDefinitionResponse =
client.Functions.RetrieveDefaultDefinition(resourceGroupName, resourceName, functionName,
retrieveDefaultDefinitionParameters);
Assert.Equal(functionName, retrieveDefaultDefinitionResponse.Function.Name);
// Add the function
ScalarFunctionProperties scalarFunctionProperties =
(ScalarFunctionProperties)retrieveDefaultDefinitionResponse.Function.Properties;
AzureMachineLearningWebServiceFunctionBinding azureMachineLearningWebServiceFunctionBinding =
(AzureMachineLearningWebServiceFunctionBinding)scalarFunctionProperties.Properties.Binding;
Assert.Equal(TestHelper.ExecuteEndpoint, azureMachineLearningWebServiceFunctionBinding.Properties.Endpoint);
Assert.Equal(1000, azureMachineLearningWebServiceFunctionBinding.Properties.BatchSize);
Assert.Null(azureMachineLearningWebServiceFunctionBinding.Properties.ApiKey);
azureMachineLearningWebServiceFunctionBinding.Properties.ApiKey = TestHelper.ApiKey;
FunctionCreateOrUpdateParameters functionCreateOrUpdateParameters =
new FunctionCreateOrUpdateParameters {
Function = retrieveDefaultDefinitionResponse.Function
};
FunctionCreateOrUpdateResponse functionCreateOrUpdateResponse = client.Functions.CreateOrUpdate(resourceGroupName, resourceName, functionCreateOrUpdateParameters);
Assert.Equal(HttpStatusCode.OK, functionCreateOrUpdateResponse.StatusCode);
Assert.Equal(functionName, functionCreateOrUpdateResponse.Function.Name);
scalarFunctionProperties =
(ScalarFunctionProperties)functionCreateOrUpdateResponse.Function.Properties;
azureMachineLearningWebServiceFunctionBinding =
(AzureMachineLearningWebServiceFunctionBinding)scalarFunctionProperties.Properties.Binding;
Assert.Equal(TestHelper.ExecuteEndpoint, azureMachineLearningWebServiceFunctionBinding.Properties.Endpoint);
Assert.Equal(1000, azureMachineLearningWebServiceFunctionBinding.Properties.BatchSize);
Assert.Null(azureMachineLearningWebServiceFunctionBinding.Properties.ApiKey);
Assert.NotNull(functionCreateOrUpdateResponse.Function.Properties.Etag);
// Get the function
FunctionGetResponse functionGetResponse = client.Functions.Get(resourceGroupName, resourceName, functionName);
Assert.Equal(HttpStatusCode.OK, functionGetResponse.StatusCode);
Assert.Equal(functionName, functionGetResponse.Function.Name);
scalarFunctionProperties =
(ScalarFunctionProperties)functionGetResponse.Function.Properties;
azureMachineLearningWebServiceFunctionBinding =
(AzureMachineLearningWebServiceFunctionBinding)scalarFunctionProperties.Properties.Binding;
Assert.Equal(TestHelper.ExecuteEndpoint, azureMachineLearningWebServiceFunctionBinding.Properties.Endpoint);
Assert.Equal(1000, azureMachineLearningWebServiceFunctionBinding.Properties.BatchSize);
Assert.Null(azureMachineLearningWebServiceFunctionBinding.Properties.ApiKey);
Assert.Equal(functionCreateOrUpdateResponse.Function.Properties.Etag, functionGetResponse.Function.Properties.Etag);
// List functions
FunctionListResponse functionListResponse = client.Functions.ListFunctionsInJob(resourceGroupName, resourceName);
Assert.Equal(HttpStatusCode.OK, functionListResponse.StatusCode);
Assert.Equal(1, functionListResponse.Value.Count);
// Check that there is 1 function in the job
jobGetParameters = new JobGetParameters("functions");
jobGetResponse = client.StreamingJobs.Get(resourceGroupName, resourceName, jobGetParameters);
Assert.Equal(HttpStatusCode.OK, jobGetResponse.StatusCode);
Assert.Equal(1, jobGetResponse.Job.Properties.Functions.Count);
// Test function connectivity
ResourceTestConnectionResponse response = client.Functions.TestConnection(resourceGroupName, resourceName, functionName);
Assert.Equal(OperationStatus.Succeeded, response.Status);
Assert.Equal(ResourceTestStatus.TestSucceeded, response.ResourceTestStatus);
// Update the function
ScalarFunctionProperties scalarFunctionPropertiesForPatch = new ScalarFunctionProperties()
{
Properties = new ScalarFunctionConfiguration()
{
Binding = new AzureMachineLearningWebServiceFunctionBinding()
{
Properties = new AzureMachineLearningWebServiceFunctionBindingProperties()
{
BatchSize = 256
}
}
}
};
FunctionPatchParameters functionPatchParameters = new FunctionPatchParameters(scalarFunctionPropertiesForPatch);
FunctionPatchResponse functionPatchResponse = client.Functions.Patch(resourceGroupName, resourceName, functionName, functionPatchParameters);
Assert.Equal(HttpStatusCode.OK, functionPatchResponse.StatusCode);
scalarFunctionProperties =
(ScalarFunctionProperties)functionPatchResponse.Properties;
azureMachineLearningWebServiceFunctionBinding =
(AzureMachineLearningWebServiceFunctionBinding)scalarFunctionProperties.Properties.Binding;
Assert.Equal(TestHelper.ExecuteEndpoint, azureMachineLearningWebServiceFunctionBinding.Properties.Endpoint);
Assert.Equal(256, azureMachineLearningWebServiceFunctionBinding.Properties.BatchSize);
Assert.Null(azureMachineLearningWebServiceFunctionBinding.Properties.ApiKey);
Assert.NotNull(functionPatchResponse.Properties.Etag);
Assert.NotEqual(functionCreateOrUpdateResponse.Function.Properties.Etag, functionPatchResponse.Properties.Etag);
// Add second function
string functionName2 = TestUtilities.GenerateName("functiontest");
Function function2 = new Function(functionName2)
{
Properties = retrieveDefaultDefinitionResponse.Function.Properties
};
functionCreateOrUpdateParameters.Function = function2;
functionCreateOrUpdateResponse = client.Functions.CreateOrUpdate(resourceGroupName, resourceName, functionCreateOrUpdateParameters);
// List functions
functionListResponse = client.Functions.ListFunctionsInJob(resourceGroupName, resourceName);
Assert.Equal(HttpStatusCode.OK, functionListResponse.StatusCode);
Assert.Equal(2, functionListResponse.Value.Count);
// Check that there are 2 functions in the job
jobGetParameters = new JobGetParameters("functions");
jobGetResponse = client.StreamingJobs.Get(resourceGroupName, resourceName, jobGetParameters);
Assert.Equal(HttpStatusCode.OK, jobGetResponse.StatusCode);
Assert.Equal(2, jobGetResponse.Job.Properties.Functions.Count);
// Delete the functions
AzureOperationResponse deleteFunctionOperationResponse = client.Functions.Delete(resourceGroupName, resourceName, functionName);
Assert.Equal(HttpStatusCode.OK, deleteFunctionOperationResponse.StatusCode);
deleteFunctionOperationResponse = client.Functions.Delete(resourceGroupName, resourceName, functionName2);
Assert.Equal(HttpStatusCode.OK, deleteFunctionOperationResponse.StatusCode);
// Check that there are 0 functions in the job
jobGetParameters = new JobGetParameters("functions");
jobGetResponse = client.StreamingJobs.Get(resourceGroupName, resourceName, jobGetParameters);
Assert.Equal(HttpStatusCode.OK, jobGetResponse.StatusCode);
Assert.Equal(0, jobGetResponse.Job.Properties.Functions.Count);
}
finally
{
client.StreamingJobs.Delete(resourceGroupName, resourceName);
resourceClient.ResourceGroups.Delete(resourceGroupName);
}
}
}
public void Test_FunctionOperations_RetrieveDefaultDefinitionWithRawJsonContent()
{
BasicDelegatingHandler handler = new BasicDelegatingHandler();
using (var undoContext = UndoContext.Current)
{
undoContext.Start();
string resourceGroupName = TestUtilities.GenerateName("StreamAnalytics");
string resourceName = TestUtilities.GenerateName("MyStreamingJobSubmittedBySDK");
string serviceLocation = TestHelper.GetDefaultLocation();
var resourceClient = TestHelper.GetResourceClient(handler);
var client = TestHelper.GetStreamAnalyticsManagementClient(handler);
try
{
ResourceGroup resourceGroup = new ResourceGroup()
{
Location = serviceLocation
};
resourceClient.ResourceGroups.CreateOrUpdate(resourceGroupName, resourceGroup);
// Construct the JobCreateProperties
JobCreateOrUpdateParameters jobCreateOrUpdateParameters =
new JobCreateOrUpdateParameters(TestHelper.GetDefaultJob(resourceName, serviceLocation));
// Create a streaming job
JobCreateOrUpdateResponse jobCreateOrUpdateResponse = client.StreamingJobs.CreateOrUpdate(resourceGroupName, jobCreateOrUpdateParameters);
Assert.Equal(HttpStatusCode.OK, jobCreateOrUpdateResponse.StatusCode);
// Get a streaming job to check
JobGetParameters jobGetParameters = new JobGetParameters(string.Empty);
JobGetResponse jobGetResponse = client.StreamingJobs.Get(resourceGroupName, resourceName, jobGetParameters);
Assert.Equal(HttpStatusCode.OK, jobGetResponse.StatusCode);
Assert.Equal(serviceLocation, jobGetResponse.Job.Location);
Assert.Equal(resourceName, jobGetResponse.Job.Name);
// Retrieve default definition of the function
string functionName = TestUtilities.GenerateName("functiontest");
string content = File.ReadAllText(@"Resources\RetrieveDefaultFunctionDefinitionRequest.json");
var retrieveDefaultDefinitionParameters = new FunctionRetrieveDefaultDefinitionWithRawJsonContentParameters
()
{
Content = content
};
FunctionRetrieveDefaultDefinitionResponse retrieveDefaultDefinitionResponse =
client.Functions.RetrieveDefaultDefinitionWithRawJsonContent(resourceGroupName, resourceName, functionName,
retrieveDefaultDefinitionParameters);
Assert.Equal(functionName, retrieveDefaultDefinitionResponse.Function.Name);
ScalarFunctionProperties scalarFunctionProperties =
(ScalarFunctionProperties)retrieveDefaultDefinitionResponse.Function.Properties;
AzureMachineLearningWebServiceFunctionBinding azureMachineLearningWebServiceFunctionBinding =
(AzureMachineLearningWebServiceFunctionBinding)scalarFunctionProperties.Properties.Binding;
Assert.Equal(TestHelper.ExecuteEndpoint, azureMachineLearningWebServiceFunctionBinding.Properties.Endpoint);
Assert.Equal(1000, azureMachineLearningWebServiceFunctionBinding.Properties.BatchSize);
Assert.Null(azureMachineLearningWebServiceFunctionBinding.Properties.ApiKey);
azureMachineLearningWebServiceFunctionBinding.Properties.ApiKey = TestHelper.ApiKey;
}
finally
{
client.StreamingJobs.Delete(resourceGroupName, resourceName);
resourceClient.ResourceGroups.Delete(resourceGroupName);
}
}
}
public void Test_TransformationOperations_E2E()
{
BasicDelegatingHandler handler = new BasicDelegatingHandler();
using (var undoContext = UndoContext.Current)
{
undoContext.Start();
string resourceGroupName = TestUtilities.GenerateName("StreamAnalytics");
string resourceName = TestUtilities.GenerateName("MyStreamingJobSubmittedBySDK");
string serviceLocation = TestHelper.GetDefaultLocation();
var resourceClient = TestHelper.GetResourceClient(handler);
var client = TestHelper.GetStreamAnalyticsManagementClient(handler);
try
{
ResourceGroup resourceGroup = new ResourceGroup()
{
Location = serviceLocation
};
resourceClient.ResourceGroups.CreateOrUpdate(resourceGroupName, resourceGroup);
Job job = new Job();
job.Name = resourceName;
job.Location = serviceLocation;
// Construct the general properties for JobProperties
JobProperties jobProperties = new JobProperties();
jobProperties.Sku = new Sku()
{
Name = "standard"
};
jobProperties.EventsOutOfOrderPolicy = EventsOutOfOrderPolicy.Drop;
jobProperties.EventsOutOfOrderMaxDelayInSeconds = 0;
job.Properties = jobProperties;
// Construct the JobCreateProperties
JobCreateOrUpdateParameters jobCreateOrUpdateParameters = new JobCreateOrUpdateParameters();
jobCreateOrUpdateParameters.Job = job;
// Create a streaming job
JobCreateOrUpdateResponse jobCreateOrUpdateResponse = client.StreamingJobs.CreateOrUpdate(resourceGroupName, jobCreateOrUpdateParameters);
Assert.Equal(HttpStatusCode.OK, jobCreateOrUpdateResponse.StatusCode);
// Get a streaming job to check
JobGetParameters jobGetParameters = new JobGetParameters(string.Empty);
JobGetResponse jobGetResponse = client.StreamingJobs.Get(resourceGroupName, resourceName, jobGetParameters);
Assert.Equal(HttpStatusCode.OK, jobGetResponse.StatusCode);
Assert.Equal(serviceLocation, jobGetResponse.Job.Location);
Assert.Equal(resourceName, jobGetResponse.Job.Name);
// Construct the Transformation
string transformationName = TestUtilities.GenerateName("transformationtest");
int numberOfStreamingUnits = 1;
Transformation transformation = new Transformation()
{
Name = transformationName,
Properties = new TransformationProperties()
{
Query = "Select Id, Name from inputtest",
StreamingUnits = numberOfStreamingUnits
}
};
// Add an Transformation
TransformationCreateOrUpdateParameters transformationCreateOrUpdateParameters = new TransformationCreateOrUpdateParameters();
transformationCreateOrUpdateParameters.Transformation = transformation;
TransformationCreateOrUpdateResponse transformationCreateOrUpdateResponse = client.Transformations.CreateOrUpdate(resourceGroupName, resourceName, transformationCreateOrUpdateParameters);
Assert.Equal(HttpStatusCode.OK, transformationCreateOrUpdateResponse.StatusCode);
Assert.Equal(numberOfStreamingUnits, transformationCreateOrUpdateResponse.Transformation.Properties.StreamingUnits);
Assert.NotNull(transformationCreateOrUpdateResponse.Transformation.Properties.Etag);
// Update the Transformation
transformation.Properties.StreamingUnits = 3;
transformation.Properties.Etag = transformationCreateOrUpdateResponse.Transformation.Properties.Etag;
TransformationPatchParameters transformationPatchParameters = new TransformationPatchParameters(transformation.Properties);
TransformationPatchResponse transformationPatchResponse = client.Transformations.Patch(resourceGroupName, resourceName, transformationName, transformationPatchParameters);
Assert.Equal(HttpStatusCode.OK, transformationPatchResponse.StatusCode);
Assert.Equal(3, transformationPatchResponse.Properties.StreamingUnits);
Assert.NotNull(transformationPatchResponse.Properties.Etag);
Assert.NotEqual(transformationCreateOrUpdateResponse.Transformation.Properties.Etag, transformationPatchResponse.Properties.Etag);
}
finally
{
client.StreamingJobs.Delete(resourceGroupName, resourceName);
resourceClient.ResourceGroups.Delete(resourceGroupName);
}
}
}
public void Test_JobOperations_E2E()
{
BasicDelegatingHandler handler = new BasicDelegatingHandler();
using (var undoContext = UndoContext.Current)
{
undoContext.Start();
string resourceGroupName = TestUtilities.GenerateName("StreamAnalytics");
string resourceName = TestUtilities.GenerateName("MyStreamingJobSubmittedBySDK");
string serviceLocation = TestHelper.GetDefaultLocation();
var resourceClient = TestHelper.GetResourceClient(handler);
var client = TestHelper.GetStreamAnalyticsManagementClient(handler);
try
{
ResourceGroup resourceGroup = new ResourceGroup()
{
Location = serviceLocation
};
resourceClient.ResourceGroups.CreateOrUpdate(resourceGroupName, resourceGroup);
Job job = new Job();
job.Name = resourceName;
job.Location = serviceLocation;
// Construct the general properties for JobProperties
JobProperties jobProperties = new JobProperties();
jobProperties.Sku = new Sku()
{
Name = "standard"
};
jobProperties.EventsOutOfOrderPolicy = EventsOutOfOrderPolicy.Drop;
jobProperties.EventsOutOfOrderMaxDelayInSeconds = 0;
// Construct the Input
StorageAccount storageAccount = new StorageAccount
{
AccountName = TestHelper.AccountName,
AccountKey = TestHelper.AccountKey
};
InputProperties inputProperties = new StreamInputProperties()
{
Serialization = new CsvSerialization()
{
Properties = new CsvSerializationProperties()
{
FieldDelimiter = ",",
Encoding = "UTF8"
}
},
DataSource = new BlobStreamInputDataSource()
{
Properties = new BlobStreamInputDataSourceProperties()
{
StorageAccounts = new[] { storageAccount },
Container = "state",
PathPattern = ""
}
}
};
Input input1 = new Input("inputtest")
{
Properties = inputProperties
};
jobProperties.Inputs = new[] { input1 };
// Construct the Output
OutputProperties outputProperties = new OutputProperties();
SqlAzureOutputDataSource sqlAzureOutputDataSource = new SqlAzureOutputDataSource()
{
Properties = new SqlAzureOutputDataSourceProperties()
{
Server = TestHelper.Server,
Database = TestHelper.Database,
User = TestHelper.User,
Password = TestHelper.Password,
Table = "StateInfo"
}
};
outputProperties.DataSource = sqlAzureOutputDataSource;
Output output1 = new Output("outputtest")
{
Properties = outputProperties
};
jobProperties.Outputs = new Output[] { output1 };
// Construct the transformation
Transformation transformation = new Transformation()
{
Name = "transformationtest",
Properties = new TransformationProperties()
{
Query = "Select Id, Name from inputtest",
StreamingUnits = 1
}
};
jobProperties.Transformation = transformation;
job.Properties = jobProperties;
// Construct the JobCreateProperties
JobCreateOrUpdateParameters jobCreateOrUpdateParameters = new JobCreateOrUpdateParameters();
jobCreateOrUpdateParameters.Job = job;
// Create a streaming job
JobCreateOrUpdateResponse jobCreateOrUpdateResponse = client.StreamingJobs.CreateOrUpdate(resourceGroupName, jobCreateOrUpdateParameters);
Assert.Equal(HttpStatusCode.OK, jobCreateOrUpdateResponse.StatusCode);
Assert.NotNull(jobCreateOrUpdateResponse.Job.Properties.Etag);
// Get a streaming job to check
JobGetParameters jobGetParameters = new JobGetParameters("inputs,transformation,outputs");
JobGetResponse jobGetResponse = client.StreamingJobs.Get(resourceGroupName, resourceName, jobGetParameters);
Assert.Equal(HttpStatusCode.OK, jobGetResponse.StatusCode);
Assert.Equal(serviceLocation, jobGetResponse.Job.Location);
Assert.Equal(resourceName, jobGetResponse.Job.Name);
Assert.True(jobGetResponse.Job.Properties.Inputs[0].Properties is StreamInputProperties);
StreamInputProperties streamInputProperties = jobGetResponse.Job.Properties.Inputs[0].Properties as StreamInputProperties;
Assert.Equal("Stream", jobGetResponse.Job.Properties.Inputs[0].Properties.Type);
Assert.Equal("Microsoft.Storage/Blob", streamInputProperties.DataSource.Type);
Assert.Equal("Csv", streamInputProperties.Serialization.Type);
Assert.Equal(EventsOutOfOrderPolicy.Drop, jobGetResponse.Job.Properties.EventsOutOfOrderPolicy);
Assert.NotNull(jobGetResponse.Job.Properties.Etag);
Assert.Equal(jobCreateOrUpdateResponse.Job.Properties.Etag, jobGetResponse.Job.Properties.Etag);
// Patch the streaming job
JobPatchParameters jobPatchParameters = new JobPatchParameters()
{
JobPatchRequest = new JobPatchRequest()
{
Properties = new JobProperties()
{
EventsOutOfOrderPolicy = EventsOutOfOrderPolicy.Adjust
}
}
};
var jobPatchResponse = client.StreamingJobs.Patch(resourceGroupName, resourceName, jobPatchParameters);
jobGetResponse = client.StreamingJobs.Get(resourceGroupName, resourceName, jobGetParameters);
Assert.Equal(HttpStatusCode.OK, jobPatchResponse.StatusCode);
Assert.Equal(HttpStatusCode.OK, jobGetResponse.StatusCode);
Assert.Equal(EventsOutOfOrderPolicy.Adjust, jobPatchResponse.Job.Properties.EventsOutOfOrderPolicy);
Assert.Equal(EventsOutOfOrderPolicy.Adjust, jobGetResponse.Job.Properties.EventsOutOfOrderPolicy);
JobListParameters parameters = new JobListParameters(string.Empty);
JobListResponse response = client.StreamingJobs.ListJobsInResourceGroup(resourceGroupName, parameters);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
// Start a streaming job
JobStartParameters jobStartParameters = new JobStartParameters()
{
OutputStartMode = OutputStartMode.LastOutputEventTime
};
CloudException cloudException = Assert.Throws <CloudException>(() => client.StreamingJobs.Start(resourceGroupName, resourceName, jobStartParameters));
Assert.Equal("LastOutputEventTime must be available when OutputStartMode is set to LastOutputEventTime. Please make sure at least one output event has been processed. ", cloudException.Error.Message);
jobStartParameters.OutputStartMode = OutputStartMode.CustomTime;
jobStartParameters.OutputStartTime = DateTime.Now;
AzureOperationResponse jobStartOperationResponse = client.StreamingJobs.Start(resourceGroupName, resourceName, jobStartParameters);
Assert.Equal(HttpStatusCode.OK, jobStartOperationResponse.StatusCode);
// Get a streaming job to check
jobGetResponse = client.StreamingJobs.Get(resourceGroupName, resourceName, jobGetParameters);
Assert.Equal(HttpStatusCode.OK, jobGetResponse.StatusCode);
Assert.True(IsRunning(jobGetResponse.Job.Properties.JobState));
// Check diagnostics
InputListResponse inputListResponse = client.Inputs.ListInputInJob(resourceGroupName, resourceName,
new InputListParameters("*"));
Assert.Equal(HttpStatusCode.OK, inputListResponse.StatusCode);
Assert.NotEqual(0, inputListResponse.Value.Count);
Assert.NotNull(inputListResponse.Value[0].Properties.Diagnostics);
Assert.NotEqual(0, inputListResponse.Value[0].Properties.Diagnostics.Conditions.Count);
Assert.NotNull(inputListResponse.Value[0].Properties.Diagnostics.Conditions[0].Code);
Assert.NotNull(inputListResponse.Value[0].Properties.Diagnostics.Conditions[0].Message);
// Stop a streaming job
AzureOperationResponse jobStopOperationResponse = client.StreamingJobs.Stop(resourceGroupName, resourceName);
Assert.Equal(HttpStatusCode.OK, jobStopOperationResponse.StatusCode);
// Get a streaming job to check
jobGetResponse = client.StreamingJobs.Get(resourceGroupName, resourceName, jobGetParameters);
Assert.Equal(HttpStatusCode.OK, jobGetResponse.StatusCode);
Assert.Equal(JobRunningState.Stopped, jobGetResponse.Job.Properties.JobState);
// Delete a streaming job
AzureOperationResponse jobDeleteOperationResponse = client.StreamingJobs.Delete(resourceGroupName, resourceName);
Assert.Equal(HttpStatusCode.OK, jobDeleteOperationResponse.StatusCode);
}
finally
{
client.StreamingJobs.Delete(resourceGroupName, resourceName);
resourceClient.ResourceGroups.Delete(resourceGroupName);
}
}
}
public void Test_JobOperationsWithJsonContent_E2E()
{
BasicDelegatingHandler handler = new BasicDelegatingHandler();
using (var undoContext = UndoContext.Current)
{
undoContext.Start();
string resourceGroupName = TestUtilities.GenerateName("StreamAnalytics");
string resourceName = TestUtilities.GenerateName("MyStreamingJobSubmittedBySDK");
string serviceLocation = TestHelper.GetDefaultLocation();
var resourceClient = TestHelper.GetResourceClient(handler);
var client = TestHelper.GetStreamAnalyticsManagementClient(handler);
try
{
ResourceGroup resourceGroup = new ResourceGroup()
{
Location = serviceLocation
};
resourceClient.ResourceGroups.CreateOrUpdate(resourceGroupName, resourceGroup);
Job job = new Job();
job.Location = serviceLocation;
string inputName = TestUtilities.GenerateName("input");
string outputName = TestUtilities.GenerateName("output");
string transformationName = TestUtilities.GenerateName("transformation");
// Create a streaming job
string content = File.ReadAllText(@"Resources\JobDefinition.json");
JobCreateOrUpdateResponse jobCreateOrUpdateResponse =
client.StreamingJobs.CreateOrUpdateWithRawJsonContent(resourceGroupName, resourceName,
new JobCreateOrUpdateWithRawJsonContentParameters()
{
Content = content
});
Assert.Equal(HttpStatusCode.OK, jobCreateOrUpdateResponse.StatusCode);
Assert.NotNull(jobCreateOrUpdateResponse.Job.Properties.Etag);
// Create an input for the streaming job
content = File.ReadAllText(@"Resources\InputDefinition.json");
InputCreateOrUpdateResponse inputCreateOrUpdateResponse =
client.Inputs.CreateOrUpdateWithRawJsonContent(resourceGroupName, resourceName, inputName,
new InputCreateOrUpdateWithRawJsonContentParameters()
{
Content = content
});
Assert.Equal(HttpStatusCode.OK, inputCreateOrUpdateResponse.StatusCode);
Assert.NotNull(inputCreateOrUpdateResponse.Input.Properties.Etag);
// Create an output for the streaming job
content = File.ReadAllText(@"Resources\OutputDefinition.json");
OutputCreateOrUpdateResponse outputCreateOrUpdateResponse =
client.Outputs.CreateOrUpdateWithRawJsonContent(resourceGroupName, resourceName, outputName,
new OutputCreateOrUpdateWithRawJsonContentParameters()
{
Content = content
});
Assert.Equal(HttpStatusCode.OK, outputCreateOrUpdateResponse.StatusCode);
Assert.NotNull(outputCreateOrUpdateResponse.Output.Properties.Etag);
// Create a tranformation for the streaming job
content = File.ReadAllText(@"Resources\TransformationDefinition.json");
TransformationCreateOrUpdateResponse transformationCreateOrUpdateResponse =
client.Transformations.CreateOrUpdateWithRawJsonContent(resourceGroupName, resourceName,
transformationName, new TransformationCreateOrUpdateWithRawJsonContentParameters()
{
Content = content
});
Assert.Equal(HttpStatusCode.OK, transformationCreateOrUpdateResponse.StatusCode);
Assert.NotNull(transformationCreateOrUpdateResponse.Transformation.Properties.Etag);
// Get a streaming job to check
JobGetParameters jobGetParameters = new JobGetParameters("inputs,transformation,outputs");
JobGetResponse jobGetResponse = client.StreamingJobs.Get(resourceGroupName, resourceName, jobGetParameters);
Assert.Equal(HttpStatusCode.OK, jobGetResponse.StatusCode);
Assert.Equal(serviceLocation, jobGetResponse.Job.Location);
Assert.Equal(resourceName, jobGetResponse.Job.Name);
Assert.Equal(inputName, jobGetResponse.Job.Properties.Inputs.SingleOrDefault().Name);
Assert.Equal(outputName, jobGetResponse.Job.Properties.Outputs.SingleOrDefault().Name);
Assert.Equal(transformationName, jobGetResponse.Job.Properties.Transformation.Name);
Assert.NotNull(jobGetResponse.Job.Properties.Etag);
Assert.NotEqual(jobCreateOrUpdateResponse.Job.Properties.Etag, jobGetResponse.Job.Properties.Etag);
}
finally
{
client.StreamingJobs.Delete(resourceGroupName, resourceName);
resourceClient.ResourceGroups.Delete(resourceGroupName);
}
}
}
public void Test_InputOperations_E2E()
{
BasicDelegatingHandler handler = new BasicDelegatingHandler();
using (var undoContext = UndoContext.Current)
{
undoContext.Start();
string resourceGroupName = TestUtilities.GenerateName("StreamAnalytics");
string resourceName = TestUtilities.GenerateName("MyStreamingJobSubmittedBySDK");
string serviceLocation = TestHelper.GetDefaultLocation();
var resourceClient = TestHelper.GetResourceClient(handler);
var client = TestHelper.GetStreamAnalyticsManagementClient(handler);
try
{
ResourceGroup resourceGroup = new ResourceGroup()
{
Location = serviceLocation
};
resourceClient.ResourceGroups.CreateOrUpdate(resourceGroupName, resourceGroup);
Job job = new Job();
job.Name = resourceName;
job.Location = serviceLocation;
// Construct the general properties for JobProperties
JobProperties jobProperties = new JobProperties();
jobProperties.Sku = new Sku()
{
Name = "standard"
};
jobProperties.EventsOutOfOrderPolicy = EventsOutOfOrderPolicy.Drop;
jobProperties.EventsOutOfOrderMaxDelayInSeconds = 0;
job.Properties = jobProperties;
// Construct the JobCreateProperties
JobCreateOrUpdateParameters jobCreateOrUpdateParameters = new JobCreateOrUpdateParameters();
jobCreateOrUpdateParameters.Job = job;
// Create a streaming job
JobCreateOrUpdateResponse jobCreateOrUpdateResponse = client.StreamingJobs.CreateOrUpdate(resourceGroupName, jobCreateOrUpdateParameters);
Assert.Equal(HttpStatusCode.OK, jobCreateOrUpdateResponse.StatusCode);
// Get a streaming job to check
JobGetParameters jobGetParameters = new JobGetParameters(string.Empty);
JobGetResponse jobGetResponse = client.StreamingJobs.Get(resourceGroupName, resourceName, jobGetParameters);
Assert.Equal(HttpStatusCode.OK, jobGetResponse.StatusCode);
Assert.Equal(serviceLocation, jobGetResponse.Job.Location);
Assert.Equal(resourceName, jobGetResponse.Job.Name);
// Construct the Input
StorageAccount storageAccount = new StorageAccount();
storageAccount.AccountName = TestHelper.AccountName;
storageAccount.AccountKey = TestHelper.AccountKey;
InputProperties inputProperties = new StreamInputProperties()
{
Serialization = new CsvSerialization()
{
Properties = new CsvSerializationProperties()
{
FieldDelimiter = ",",
Encoding = "UTF8"
}
},
DataSource = new BlobStreamInputDataSource()
{
Properties = new BlobStreamInputDataSourceProperties()
{
StorageAccounts = new[] { storageAccount },
Container = "state",
PathPattern = ""
}
}
};
string inputName = TestUtilities.GenerateName("inputtest");
Input input1 = new Input(inputName)
{
Properties = inputProperties
};
// Add an input
InputCreateOrUpdateParameters inputCreateOrUpdateParameters = new InputCreateOrUpdateParameters();
inputCreateOrUpdateParameters.Input = input1;
InputCreateOrUpdateResponse inputCreateOrUpdateResponse = client.Inputs.CreateOrUpdate(resourceGroupName, resourceName, inputCreateOrUpdateParameters);
Assert.Equal(HttpStatusCode.OK, inputCreateOrUpdateResponse.StatusCode);
Assert.Equal(inputName, inputCreateOrUpdateResponse.Input.Name);
Assert.Equal("Stream", inputCreateOrUpdateResponse.Input.Properties.Type);
Assert.True(inputCreateOrUpdateResponse.Input.Properties.Serialization is CsvSerialization);
CsvSerialization csvSerializationInResponse1 = (CsvSerialization)inputCreateOrUpdateResponse.Input.Properties.Serialization;
Assert.Equal(",", csvSerializationInResponse1.Properties.FieldDelimiter);
Assert.NotNull(inputCreateOrUpdateResponse.Input.Properties.Etag);
// Get the input
InputGetResponse inputGetResponse = client.Inputs.Get(resourceGroupName, resourceName, inputName);
Assert.Equal(HttpStatusCode.OK, inputGetResponse.StatusCode);
Assert.Equal(inputName, inputGetResponse.Input.Name);
Assert.True(inputGetResponse.Input.Properties.Serialization is CsvSerialization);
CsvSerialization csvSerializationInResponse2 = (CsvSerialization)inputGetResponse.Input.Properties.Serialization;
Assert.Equal(",", csvSerializationInResponse2.Properties.FieldDelimiter);
Assert.Equal(inputCreateOrUpdateResponse.Input.Properties.Etag, inputGetResponse.Input.Properties.Etag);
// List inputs
InputListResponse inputListResponse = client.Inputs.ListInputInJob(resourceGroupName, resourceName, new InputListParameters());
Assert.Equal(HttpStatusCode.OK, inputListResponse.StatusCode);
Assert.Equal(1, inputListResponse.Value.Count);
// Check that there is 1 input in the job
jobGetParameters = new JobGetParameters("inputs");
jobGetResponse = client.StreamingJobs.Get(resourceGroupName, resourceName, jobGetParameters);
Assert.Equal(HttpStatusCode.OK, jobGetResponse.StatusCode);
Assert.Equal(1, jobGetResponse.Job.Properties.Inputs.Count);
// Test input connectivity
DataSourceTestConnectionResponse response = client.Inputs.TestConnection(resourceGroupName, resourceName, inputName);
Assert.Equal(OperationStatus.Succeeded, response.Status);
Assert.Equal(DataSourceTestStatus.TestSucceeded, response.DataSourceTestStatus);
// Update the input
Serialization csvSerialization = new CsvSerialization()
{
Properties = new CsvSerializationProperties()
{
FieldDelimiter = "|",
Encoding = "UTF8"
}
};
inputProperties.Serialization = csvSerialization;
inputProperties.Etag = inputCreateOrUpdateResponse.Input.Properties.Etag;
InputPatchParameters inputPatchParameters = new InputPatchParameters(inputProperties);
InputPatchResponse inputPatchResponse = client.Inputs.Patch(resourceGroupName, resourceName, inputName, inputPatchParameters);
Assert.Equal(HttpStatusCode.OK, inputPatchResponse.StatusCode);
Assert.True(inputPatchResponse.Properties.Serialization is CsvSerialization);
CsvSerialization csvSerializationInResponse3 = (CsvSerialization)inputPatchResponse.Properties.Serialization;
Assert.Equal("|", csvSerializationInResponse3.Properties.FieldDelimiter);
Assert.NotNull(inputPatchResponse.Properties.Etag);
Assert.NotEqual(inputCreateOrUpdateResponse.Input.Properties.Etag, inputPatchResponse.Properties.Etag);
// Add second input
string inputName2 = TestUtilities.GenerateName("inputtest");
Input input2 = new Input(inputName2)
{
Properties = inputProperties
};
inputCreateOrUpdateParameters.Input = input2;
inputCreateOrUpdateResponse = client.Inputs.CreateOrUpdate(resourceGroupName, resourceName, inputCreateOrUpdateParameters);
// List inputs
inputListResponse = client.Inputs.ListInputInJob(resourceGroupName, resourceName, new InputListParameters());
Assert.Equal(HttpStatusCode.OK, inputListResponse.StatusCode);
Assert.Equal(2, inputListResponse.Value.Count);
// Check that there are 2 inputs in the job
jobGetParameters = new JobGetParameters("inputs");
jobGetResponse = client.StreamingJobs.Get(resourceGroupName, resourceName, jobGetParameters);
Assert.Equal(HttpStatusCode.OK, jobGetResponse.StatusCode);
Assert.Equal(2, jobGetResponse.Job.Properties.Inputs.Count);
// Delete the inputs
AzureOperationResponse deleteInputOperationResponse = client.Inputs.Delete(resourceGroupName, resourceName, inputName);
Assert.Equal(HttpStatusCode.OK, deleteInputOperationResponse.StatusCode);
deleteInputOperationResponse = client.Inputs.Delete(resourceGroupName, resourceName, inputName2);
Assert.Equal(HttpStatusCode.OK, deleteInputOperationResponse.StatusCode);
// Check that there are 0 inputs in the job
jobGetParameters = new JobGetParameters("inputs");
jobGetResponse = client.StreamingJobs.Get(resourceGroupName, resourceName, jobGetParameters);
Assert.Equal(HttpStatusCode.OK, jobGetResponse.StatusCode);
Assert.Equal(0, jobGetResponse.Job.Properties.Inputs.Count);
}
finally
{
client.StreamingJobs.Delete(resourceGroupName, resourceName);
resourceClient.ResourceGroups.Delete(resourceGroupName);
}
}
}
/// <summary>
/// Get a stream analytics job.
/// </summary>
/// <param name='operations'>
/// Reference to the
/// Microsoft.Azure.Management.StreamAnalytics.IJobOperations.
/// </param>
/// <param name='resourceGroupName'>
/// Required. The resource group name of the stream analytics job.
/// </param>
/// <param name='jobName'>
/// Required. The name of the stream analytics job.
/// </param>
/// <param name='parameters'>
/// Required. The parameters required to get a stream analytics job.
/// </param>
/// <returns>
/// The response of the get stream analytics job operation.
/// </returns>
public static Task <JobGetResponse> GetAsync(this IJobOperations operations, string resourceGroupName, string jobName, JobGetParameters parameters)
{
return(operations.GetAsync(resourceGroupName, jobName, parameters, CancellationToken.None));
}
/// <summary>
/// Get a stream analytics job.
/// </summary>
/// <param name='operations'>
/// Reference to the
/// Microsoft.Azure.Management.StreamAnalytics.IJobOperations.
/// </param>
/// <param name='resourceGroupName'>
/// Required. The resource group name of the stream analytics job.
/// </param>
/// <param name='jobName'>
/// Required. The name of the stream analytics job.
/// </param>
/// <param name='parameters'>
/// Required. The parameters required to get a stream analytics job.
/// </param>
/// <returns>
/// The response of the get stream analytics job operation.
/// </returns>
public static JobGetResponse Get(this IJobOperations operations, string resourceGroupName, string jobName, JobGetParameters parameters)
{
return(Task.Factory.StartNew((object s) =>
{
return ((IJobOperations)s).GetAsync(resourceGroupName, jobName, parameters);
}
, operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult());
}
public void Test_FunctionOperations_Scalar_JavaScript()
{
BasicDelegatingHandler handler = new BasicDelegatingHandler();
using (var undoContext = UndoContext.Current)
{
undoContext.Start();
string resourceGroupName = TestUtilities.GenerateName("StreamAnalytics");
string resourceName = TestUtilities.GenerateName("MyStreamingJobSubmittedBySDK");
string serviceLocation = TestHelper.GetDefaultLocation();
var resourceClient = TestHelper.GetResourceClient(handler);
var client = TestHelper.GetStreamAnalyticsManagementClient(handler);
try
{
ResourceGroup resourceGroup = new ResourceGroup()
{
Location = serviceLocation
};
resourceClient.ResourceGroups.CreateOrUpdate(resourceGroupName, resourceGroup);
// Construct the JobCreateProperties
JobCreateOrUpdateParameters jobCreateOrUpdateParameters =
new JobCreateOrUpdateParameters(TestHelper.GetDefaultJob(resourceName, serviceLocation));
// Create a streaming job
JobCreateOrUpdateResponse jobCreateOrUpdateResponse =
client.StreamingJobs.CreateOrUpdate(resourceGroupName, jobCreateOrUpdateParameters);
Assert.Equal(HttpStatusCode.OK, jobCreateOrUpdateResponse.StatusCode);
// Get a streaming job to check
JobGetParameters jobGetParameters = new JobGetParameters(string.Empty);
JobGetResponse jobGetResponse = client.StreamingJobs.Get(resourceGroupName, resourceName, jobGetParameters);
Assert.Equal(HttpStatusCode.OK, jobGetResponse.StatusCode);
Assert.Equal(serviceLocation, jobGetResponse.Job.Location);
Assert.Equal(resourceName, jobGetResponse.Job.Name);
// Retrieve default definition of the function
string functionName = TestUtilities.GenerateName("functiontest");
string javaScriptFunctionCode = @"function (x, y) { return x + y; }";
var retrieveDefaultDefinitionParameters = new JavaScriptFunctionRetrieveDefaultDefinitionParameters
()
{
BindingRetrievalProperties = new JavaScriptFunctionBindingRetrievalProperties()
{
Script = javaScriptFunctionCode,
UdfType = "Scalar"
}
};
CloudException cloudException =
Assert.Throws <CloudException>(
() =>
client.Functions.RetrieveDefaultDefinition(resourceGroupName, resourceName, functionName,
retrieveDefaultDefinitionParameters));
Assert.Equal(HttpStatusCode.InternalServerError, cloudException.Response.StatusCode);
Assert.Contains("not supported", cloudException.Error.Message, StringComparison.InvariantCulture);
// Add the function
Function javaScriptFunction = new Function(functionName)
{
Properties = new ScalarFunctionProperties()
{
Properties = new ScalarFunctionConfiguration()
{
Inputs = new List <FunctionInput>()
{
new FunctionInput()
{
DataType = "Any"
}
},
Output = new FunctionOutput()
{
DataType = "Any"
},
Binding = new JavaScriptFunctionBinding()
{
Properties = new JavaScriptFunctionBindingProperties()
{
Script = javaScriptFunctionCode
}
}
}
}
};
FunctionCreateOrUpdateParameters functionCreateOrUpdateParameters =
new FunctionCreateOrUpdateParameters {
Function = javaScriptFunction
};
FunctionCreateOrUpdateResponse functionCreateOrUpdateResponse =
client.Functions.CreateOrUpdate(resourceGroupName, resourceName,
functionCreateOrUpdateParameters);
Assert.Equal(HttpStatusCode.OK, functionCreateOrUpdateResponse.StatusCode);
Assert.Equal(functionName, functionCreateOrUpdateResponse.Function.Name);
var scalarFunctionProperties =
(ScalarFunctionProperties)functionCreateOrUpdateResponse.Function.Properties;
var javaScriptFunctionBinding =
(JavaScriptFunctionBinding)scalarFunctionProperties.Properties.Binding;
Assert.Equal(javaScriptFunctionCode, javaScriptFunctionBinding.Properties.Script);
Assert.NotNull(functionCreateOrUpdateResponse.Function.Properties.Etag);
// Get the function
FunctionGetResponse functionGetResponse = client.Functions.Get(resourceGroupName, resourceName, functionName);
Assert.Equal(HttpStatusCode.OK, functionGetResponse.StatusCode);
Assert.Equal(functionName, functionGetResponse.Function.Name);
scalarFunctionProperties =
(ScalarFunctionProperties)functionGetResponse.Function.Properties;
javaScriptFunctionBinding =
(JavaScriptFunctionBinding)scalarFunctionProperties.Properties.Binding;
Assert.Equal(javaScriptFunctionCode, javaScriptFunctionBinding.Properties.Script);
Assert.Equal(functionCreateOrUpdateResponse.Function.Properties.Etag, functionGetResponse.Function.Properties.Etag);
// List functions
FunctionListResponse functionListResponse = client.Functions.ListFunctionsInJob(resourceGroupName, resourceName);
Assert.Equal(HttpStatusCode.OK, functionListResponse.StatusCode);
Assert.Equal(1, functionListResponse.Value.Count);
// Check that there is 1 function in the job
jobGetParameters = new JobGetParameters("functions");
jobGetResponse = client.StreamingJobs.Get(resourceGroupName, resourceName, jobGetParameters);
Assert.Equal(HttpStatusCode.OK, jobGetResponse.StatusCode);
Assert.Equal(1, jobGetResponse.Job.Properties.Functions.Count);
// Test function connectivity
ResourceTestConnectionResponse response = client.Functions.TestConnection(resourceGroupName,
resourceName, functionName);
Assert.Equal(OperationStatus.Failed, response.Status);
Assert.Equal(ResourceTestStatus.TestFailed, response.ResourceTestStatus);
Assert.NotNull(response.Error);
Assert.Contains("not supported", response.Error.Message, StringComparison.InvariantCulture);
// Update the function
string newJavaScriptFunctionCode = @"function (x, y) { return x * y; }";
ScalarFunctionProperties scalarFunctionPropertiesForPatch = new ScalarFunctionProperties()
{
Properties = new ScalarFunctionConfiguration()
{
Binding = new JavaScriptFunctionBinding()
{
Properties = new JavaScriptFunctionBindingProperties()
{
Script = newJavaScriptFunctionCode
}
}
}
};
FunctionPatchParameters functionPatchParameters = new FunctionPatchParameters(scalarFunctionPropertiesForPatch);
FunctionPatchResponse functionPatchResponse = client.Functions.Patch(resourceGroupName, resourceName,
functionName, functionPatchParameters);
Assert.Equal(HttpStatusCode.OK, functionPatchResponse.StatusCode);
scalarFunctionProperties =
(ScalarFunctionProperties)functionPatchResponse.Properties;
javaScriptFunctionBinding =
(JavaScriptFunctionBinding)scalarFunctionProperties.Properties.Binding;
Assert.Equal(newJavaScriptFunctionCode, javaScriptFunctionBinding.Properties.Script);
Assert.NotEqual(javaScriptFunctionCode, javaScriptFunctionBinding.Properties.Script);
Assert.NotNull(functionPatchResponse.Properties.Etag);
Assert.NotEqual(functionCreateOrUpdateResponse.Function.Properties.Etag, functionPatchResponse.Properties.Etag);
// Delete the functions
AzureOperationResponse deleteFunctionOperationResponse = client.Functions.Delete(resourceGroupName,
resourceName, functionName);
Assert.Equal(HttpStatusCode.OK, deleteFunctionOperationResponse.StatusCode);
// Check that there are 0 functions in the job
jobGetParameters = new JobGetParameters("functions");
jobGetResponse = client.StreamingJobs.Get(resourceGroupName, resourceName, jobGetParameters);
Assert.Equal(HttpStatusCode.OK, jobGetResponse.StatusCode);
Assert.Equal(0, jobGetResponse.Job.Properties.Functions.Count);
}
finally
{
client.StreamingJobs.Delete(resourceGroupName, resourceName);
resourceClient.ResourceGroups.Delete(resourceGroupName);
}
}
}