public async Task TriggerSample()
{
#region Snippet:CreateTriggerClient
// Replace the string below with your actual endpoint url.
string endpoint = "<my-endpoint-url>";
/*@@*/ endpoint = TestEnvironment.EndpointUrl;
TriggerClient client = new TriggerClient(endpoint: new Uri(endpoint), credential: new DefaultAzureCredential());
#endregion
#region Snippet:CreateTrigger
TriggerResource triggerResource = new TriggerResource(new ScheduleTrigger(new ScheduleTriggerRecurrence()));
TriggerCreateOrUpdateTriggerOperation operation = client.StartCreateOrUpdateTrigger("MyTrigger", triggerResource);
Response <TriggerResource> createdTrigger = await operation.WaitForCompletionAsync();
#endregion
#region Snippet:RetrieveTrigger
TriggerResource retrievedTrigger = client.GetTrigger("MyTrigger");
#endregion
#region Snippet:ListTriggers
Pageable <TriggerResource> triggers = client.GetTriggersByWorkspace();
foreach (TriggerResource trigger in triggers)
{
System.Console.WriteLine(trigger.Name);
}
#endregion
#region Snippet:DeleteTrigger
client.StartDeleteTrigger("MyTrigger");
#endregion
}
public SynapseAnalyticsArtifactsClient(string workspaceName, IAzureContext context)
{
if (context == null)
{
throw new SynapseException(Resources.InvalidDefaultSubscription);
}
Settings = new JsonSerializerSettings
{
DateFormatHandling = Newtonsoft.Json.DateFormatHandling.IsoDateFormat,
DateTimeZoneHandling = Newtonsoft.Json.DateTimeZoneHandling.Utc,
NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore,
ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Serialize,
ContractResolver = new ReadOnlyJsonContractResolver(),
Converters = new List <JsonConverter>
{
new Iso8601TimeSpanConverter()
}
};
Settings.Converters.Add(new TransformationJsonConverter());
Settings.Converters.Add(new PolymorphicDeserializeJsonConverter <PSActivity>("type"));
Settings.Converters.Add(new PolymorphicDeserializeJsonConverter <PSLinkedService>("type"));
Settings.Converters.Add(new PolymorphicDeserializeJsonConverter <PSTrigger>("type"));
string suffix = context.Environment.GetEndpoint(AzureEnvironment.ExtendedEndpoint.AzureSynapseAnalyticsEndpointSuffix);
Uri uri = new Uri("https://" + workspaceName + "." + suffix);
_pipelineClient = new PipelineClient(uri, new AzureSessionCredential(context));
_pipelineRunClient = new PipelineRunClient(uri, new AzureSessionCredential(context));
_linkedServiceClient = new LinkedServiceClient(uri, new AzureSessionCredential(context));
_notebookClient = new NotebookClient(uri, new AzureSessionCredential(context));
_triggerClient = new TriggerClient(uri, new AzureSessionCredential(context));
_triggerRunClient = new TriggerRunClient(uri, new AzureSessionCredential(context));
}
public SynapseAnalyticsArtifactsClient(string workspaceName, IAzureContext context)
{
if (context == null)
{
throw new AzPSInvalidOperationException(Resources.InvalidDefaultSubscription);
}
_context = context;
string suffix = context.Environment.GetEndpoint(AzureEnvironment.ExtendedEndpoint.AzureSynapseAnalyticsEndpointSuffix);
Uri uri = new Uri("https://" + workspaceName + "." + suffix);
_endpoint = uri;
_pipelineClient = new PipelineClient(uri, new AzureSessionCredential(context));
_pipelineRunClient = new PipelineRunClient(uri, new AzureSessionCredential(context));
_linkedServiceClient = new LinkedServiceClient(uri, new AzureSessionCredential(context));
_notebookClient = new NotebookClient(uri, new AzureSessionCredential(context));
_triggerClient = new TriggerClient(uri, new AzureSessionCredential(context));
_triggerRunClient = new TriggerRunClient(uri, new AzureSessionCredential(context));
_datasetClient = new DatasetClient(uri, new AzureSessionCredential(context));
_dataFlowClient = new DataFlowClient(uri, new AzureSessionCredential(context));
_dataFlowDebugSessionClient = new DataFlowDebugSessionClient(uri, new AzureSessionCredential(context));
_bigDataPoolsClient = new BigDataPoolsClient(uri, new AzureSessionCredential(context));
_sparkJobDefinitionClient = new SparkJobDefinitionClient(uri, new AzureSessionCredential(context));
_sqlScriptClient = new SqlScriptClient(uri, new AzureSessionCredential(context));
}
public static async ValueTask <TriggerResource> CreateResource(TriggerClient client, TestRecording recording)
{
string triggerName = recording.GenerateId("Trigger", 16);
TriggerResource trigger = new TriggerResource(new ScheduleTrigger(new ScheduleTriggerRecurrence()));
TriggerCreateOrUpdateTriggerOperation createOperation = await client.StartCreateOrUpdateTriggerAsync(triggerName, trigger);
return(await createOperation.WaitForCompletionAsync());
}
public async Task TestCreateTrigger()
{
string triggerName = Recording.GenerateName("Trigger");
TriggerCreateOrUpdateTriggerOperation operation = await TriggerClient.StartCreateOrUpdateTriggerAsync(triggerName, new TriggerResource(new Trigger()));
TriggerResource trigger = await operation.WaitForCompletionAsync();
Assert.AreEqual(triggerName, trigger.Name);
}
public async Task TestDeleteSparkJob()
{
TriggerClient client = CreateClient();
TriggerResource resource = await DisposableTrigger.CreateResource(client, Recording);
TriggerDeleteTriggerOperation deleteOperation = await client.StartDeleteTriggerAsync(resource.Name);
await deleteOperation.WaitAndAssertSuccessfulCompletion();
}
public async Task TestGetTrigger()
{
await foreach (var expectedTrigger in TriggerClient.GetTriggersByWorkspaceAsync())
{
TriggerResource actualTrigger = await TriggerClient.GetTriggerAsync(expectedTrigger.Name);
Assert.AreEqual(expectedTrigger.Name, actualTrigger.Name);
Assert.AreEqual(expectedTrigger.Id, actualTrigger.Id);
}
}
public async Task TestCreateTrigger()
{
var operation = await TriggerClient.StartCreateOrUpdateTriggerAsync("MyTrigger", new TriggerResource(new Trigger()));
while (!operation.HasValue)
{
operation.UpdateStatus();
}
Assert.AreEqual("MyTrigger", operation.Value.Name);
}
public async Task TestDeleteTrigger()
{
var operation = await TriggerClient.StartDeleteTriggerAsync("MyTrigger");
while (!operation.HasValue)
{
operation.UpdateStatus();
}
Assert.AreEqual(200, operation.Value.Status);
}
public async Task TestEventStatus()
{
TriggerClient client = CreateClient();
await using DisposableTrigger trigger = await DisposableTrigger.Create(client, Recording);
TriggerSubscriptionOperationStatus statusOperation = await client.GetEventSubscriptionStatusAsync(trigger.Name);
Assert.AreEqual(statusOperation.TriggerName, trigger.Name);
}
public async Task TestCreateTrigger()
{
TriggerClient client = CreateClient();
string triggerName = Recording.GenerateId("Trigger", 16);
TriggerCreateOrUpdateTriggerOperation operation = await client.StartCreateOrUpdateTriggerAsync(triggerName, new TriggerResource(new ScheduleTrigger(new ScheduleTriggerRecurrence())));
TriggerResource trigger = await operation.WaitForCompletionAsync();
Assert.AreEqual(triggerName, trigger.Name);
}
public void CreateClient()
{
// Environment variable with the Synapse workspace endpoint.
string workspaceUrl = TestEnvironment.WorkspaceUrl;
#region Snippet:CreateTriggerClient
// Create a new Trigger client using the default credential from Azure.Identity using environment variables previously set,
// including AZURE_CLIENT_ID, AZURE_CLIENT_SECRET, and AZURE_TENANT_ID.
TriggerClient client = new TriggerClient(endpoint: new Uri(workspaceUrl), credential: new DefaultAzureCredential());
#endregion
this.TriggerClient = client;
}
public async Task TestGetTrigger()
{
TriggerClient client = CreateClient();
await using DisposableTrigger singleTrigger = await DisposableTrigger.Create(client, Recording);
await foreach (var trigger in client.GetTriggersByWorkspaceAsync())
{
TriggerResource actualTrigger = await client.GetTriggerAsync(trigger.Name);
Assert.AreEqual(trigger.Name, actualTrigger.Name);
Assert.AreEqual(trigger.Id, actualTrigger.Id);
}
}
public async Task TestDeleteTrigger()
{
string triggerName = Recording.GenerateName("Trigger");
TriggerCreateOrUpdateTriggerOperation createOperation = await TriggerClient.StartCreateOrUpdateTriggerAsync(triggerName, new TriggerResource(new Trigger()));
await createOperation.WaitForCompletionAsync();
TriggerDeleteTriggerOperation deleteOperation = await TriggerClient.StartDeleteTriggerAsync(triggerName);
Response response = await deleteOperation.WaitForCompletionAsync();
Assert.AreEqual(200, response.Status);
}
static public void DeleteTriggerClienr(TriggerClient triggerClient)
{
int currentClientIndex = triggerClients.IndexOf(triggerClient);
try
{
if (currentClientIndex == -1)
{
return;
}
triggerClients.RemoveAt(currentClientIndex);
}
catch (Exception) { };
}
static public void SetClientState(TriggerClient triggerClient, bool isPaused)
{
int currentClientIndex = triggerClients.IndexOf(triggerClient);
try
{
if (currentClientIndex == -1)
{
return;
}
triggerClients[currentClientIndex].isPaused = isPaused;
}
catch (Exception) { };
}
public async Task TestQueryRuns()
{
TriggerClient triggerClient = CreateTriggerClient();
TriggerRunClient runClient = CreateRunClient();
TriggerResource resource = await DisposableTrigger.CreateResource(triggerClient, Recording);
TriggerStartTriggerOperation startOperation = await triggerClient.StartStartTriggerAsync(resource.Name);
await startOperation.WaitAndAssertSuccessfulCompletion();
TriggerRunsQueryResponse response = await runClient.QueryTriggerRunsByWorkspaceAsync(new RunFilterParameters (DateTimeOffset.MinValue, DateTimeOffset.MaxValue));
Assert.GreaterOrEqual(response.Value.Count, 1);
}
public async Task TestCancelRerun()
{
TriggerClient triggerClient = CreateTriggerClient();
TriggerRunClient runClient = CreateRunClient();
TriggerResource resource = await DisposableTrigger.CreateResource(triggerClient, Recording);
TriggerStartTriggerOperation startOperation = await triggerClient.StartStartTriggerAsync(resource.Name);
await startOperation.WaitAndAssertSuccessfulCompletion();
TriggerRunsQueryResponse response = await runClient.QueryTriggerRunsByWorkspaceAsync(new RunFilterParameters (DateTimeOffset.MinValue, DateTimeOffset.MaxValue));
// Find the active run and cancel (CancelTriggerInstanceAsync)
// Rerun canceled run (RerunTriggerInstanceAsync)
}
public async Task TestSubscribeUnsubscribe()
{
TriggerClient client = CreateClient();
await using DisposableTrigger trigger = await DisposableTrigger.Create(client, Recording);
TriggerSubscribeTriggerToEventsOperation subOperation = await client.StartSubscribeTriggerToEventsAsync(trigger.Name);
TriggerSubscriptionOperationStatus subResponse = await subOperation.WaitForCompletionAsync();
Assert.AreEqual(EventSubscriptionStatus.Enabled, subResponse.Status);
TriggerUnsubscribeTriggerFromEventsOperation unsubOperation = await client.StartUnsubscribeTriggerFromEventsAsync(trigger.Name);
TriggerSubscriptionOperationStatus unsubResponse = await unsubOperation.WaitForCompletionAsync();
Assert.AreEqual(EventSubscriptionStatus.Disabled, unsubResponse.Status);
}
static public int AddTriggerClient(TriggerClient triggerClient)
{
int retValue = -1;
int currentClientIndex = triggerClients.IndexOf(triggerClient);
if (currentClientIndex == -1)
{
triggerClient.clientID = triggerClients.Count + 1;
triggerClients.Add(triggerClient);
retValue = triggerClient.clientID;
}
else
{
retValue = currentClientIndex;
triggerClients[currentClientIndex].isPaused = true;
}
return(retValue);
}
static async Task Execute()
{
TriggerClient client = new TriggerClient("http://*****:*****@gmail.com",
UserTestResultInput = "60",
UserName = "******",
TestName = "Entry Form",
CertificateName = "Entry Sertificate",
TrainingId = new Guid()
}
);
var t = JsonConvert.SerializeObject(new
{
UserEmailAddress = "*****@*****.**",
UserTestResultInput = 60,
UserName = "******",
TestName = "Entry Form",
CertificateName = "Entry Sertificate",
TrainingId = new Guid()
});
var t1 = JObject.Parse(t);
var response2 = await client.Fire("testTrigger", new
{
UserEmailAddress = "*****@*****.**",
UserTestResultInput = 60,
UserName = "******",
TestName = "Entry Form",
CertificateName = "Entry Sertificate",
TrainingId = 12213132
});
Console.WriteLine(response2);
Console.ReadLine();
}
public async Task TestStartStop()
{
TriggerClient client = CreateClient();
PipelineClient pipelineClient = CreatePipelineClient();
await using DisposableTrigger trigger = await DisposableTrigger.Create(client, Recording);
await using DisposablePipeline pipeline = await DisposablePipeline.Create(pipelineClient, Recording);
// SYNAPSE_API_ISSUE - How do we point the trigger to our pipeline
TriggerStartTriggerOperation startOperation = await client.StartStartTriggerAsync(trigger.Name);
Response startResponse = await startOperation.WaitForCompletionResponseAsync();
startResponse.AssertSuccess();
TriggerStopTriggerOperation stopOperation = await client.StartStopTriggerAsync(trigger.Name);
Response stopResponse = await stopOperation.WaitForCompletionResponseAsync();
stopResponse.AssertSuccess();
}
private DisposableTrigger(TriggerClient client, TriggerResource resource)
{
_client = client;
Resource = resource;
}
public static async ValueTask <DisposableTrigger> Create(TriggerClient client, TestRecording recording) => new DisposableTrigger(client, await CreateResource(client, recording));
