public JObject Heartbeat(ActivityTask task, int?progress = null, string message = null)
{
JToken progressData;
task.Input.TryGetValue("progressData", out progressData);
var heartbeatRequest = new
{
status = "heartbeat",
progress,
message,
progressData
};
var json = JsonConvert.SerializeObject(heartbeatRequest, Formatting.None);
var content = new StringContent(json, Encoding.UTF8);
var response = client.PostAsync("tasks/" + task.TaskToken, content).Result;
if (response.StatusCode != HttpStatusCode.OK)
{
logger.WarnFormat("HTTP Status code = {0} ({1})", Enum.GetName(typeof(HttpStatusCode), response.StatusCode), (int)response.StatusCode);
return(null);
}
json = response.Content.ReadAsStringAsync().Result;
return(JObject.Parse(json));
}
/// <summary>
/// Complete task sucessfully
/// Use the JObject to create the task outputs
/// </summary>
/// <param name="task">Task</param>
/// <param name="result">Result JSON object</param>
protected void RespondSuccess(ActivityTask task, JObject result)
{
var successObj = new JObject(new JProperty("status", "success"),
new JProperty("result", result));
workflowClient.Respond(task, JsonConvert.SerializeObject(successObj, Formatting.None));
}
/// <summary>
/// Fetch the value of a single task input variable
/// returns null if not present
/// </summary>
/// <param name="task">Task</param>
/// <param name="name">Input name</param>
/// <returns></returns>
protected JToken GetInput(ActivityTask task, string name)
{
JToken input;
task.Input.TryGetValue(name, out input);
return(input);
}
/// <summary>
/// Override this to do real work
/// </summary>
/// <param name="task">Task</param>
protected virtual void DoNotification(ActivityTask task)
{
// The dafault behaviour for notifications is to log and ignore them
var type = GetInput(task, "type", "(Unknown type)");
Console.WriteLine($"Notification, type = {type}");
}
/// <summary>
/// Override this to do real work
/// </summary>
/// <param name="task">Task</param>
protected virtual void DoTask(ActivityTask task)
{
Task.Run(() =>
{
// Sample code for simple delaying activity with heartbeat and cancellation
Console.WriteLine($"Starting activity, id = {task.ActivityId}");
var delay = (int?)GetInput(task, "delay") ?? 50000;
for (var progress = 0; progress < 100; progress += 10)
{
Thread.Sleep(delay / 10);
var hb = workflowClient.Heartbeat(task, progress);
if (hb == null)
{
RespondFailure(task, "Heartbeat failed");
return;
}
if ((bool?)hb.SelectToken("cancellationRequested") == true)
{
RespondCancelled(task);
return;
}
}
var result = new JObject {
["output"] = 42
};
RespondSuccess(task, result);
});
}
public void SendSignal(ActivityTask task, WorkflowSignalledEvent signal)
{
var signalJson = JsonConvert.SerializeObject(signal);
var content = new StringContent(signalJson, Encoding.UTF8, "application/json");
var url = $"/executions/{task.ExecutionId}/signal";
client.PostAsync(url, content);
}
/// <summary>
/// Signal for response from an asynchronous task
/// </summary>
/// <param name="task"></param>
/// <param name="signalName"></param>
protected void SignalCancelled(ActivityTask task, string signalName)
{
var signal = new WorkflowSignalledEvent
{
SignalName = signalName,
Status = "cancelled"
};
workflowClient.SendSignal(task, signal);
}
/// <summary>
/// Attempt to extract the required type of value from a variable with a default
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="task"></param>
/// <param name="name"></param>
/// <param name="defaultValue"></param>
/// <returns></returns>
protected T GetInput <T>(ActivityTask task, string name, T defaultValue)
{
var value = GetInput(task, name);
if (value == null)
{
return(defaultValue);
}
return(value.ToObject <T>());
}
/// <summary>
/// Attempt to extract the required type of value from a variable
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="task"></param>
/// <param name="name"></param>
/// <returns></returns>
protected T GetInput <T>(ActivityTask task, string name)
{
var value = GetInput(task, name);
if (value == null)
{
throw new ApplicationException($"Missing required value of input parameter: {name}");
}
return(value.ToObject <T>());
}
/// <summary>
/// Signal for response from an asynchronous task
/// </summary>
/// <param name="task"></param>
/// <param name="signalName"></param>
/// <param name="result"></param>
protected void SignalSuccess(ActivityTask task, string signalName, JObject result)
{
var signal = new WorkflowSignalledEvent
{
SignalName = signalName,
Status = "success",
Result = result
};
workflowClient.SendSignal(task, signal);
}
public void Respond(ActivityTask task, string json)
{
var content = new StringContent(json, Encoding.UTF8, "application/json");
logger.Info($"Responding with content - {json}");
var response = client.PostAsync("/tasks/" + task.TaskToken, content).Result;
if (response.StatusCode != HttpStatusCode.OK)
{
logger.WarnFormat("HTTP Status code = {0} ({1})", Enum.GetName(typeof(HttpStatusCode), response.StatusCode), (int)response.StatusCode);
}
}
/// <summary>
/// Signal for response from an asynchronous task
/// </summary>
/// <param name="task"></param>
/// <param name="signalName"></param>
/// <param name="reason"></param>
/// <param name="details"></param>
protected void SignalFailure(ActivityTask task, string signalName, string reason, JObject details = null)
{
var signal = new WorkflowSignalledEvent
{
SignalName = signalName,
Status = "failure",
Reason = reason,
Details = details
};
workflowClient.SendSignal(task, signal);
}
/// <summary>
/// Responds with cancelled synchronously or asynchronously as appropriate
/// </summary>
/// <param name="task"></param>
protected void Cancelled(ActivityTask task)
{
var signalName = GetInput <string>(task, "signalName");
if (string.IsNullOrWhiteSpace(signalName))
{
RespondCancelled(task);
}
else
{
SignalCancelled(task, signalName);
}
}
/// <summary>
/// Responds with failure synchronously or asynchronously as appropriate
/// </summary>
/// <param name="task"></param>
/// <param name="reason"></param>
/// <param name="details"></param>
protected void Failure(ActivityTask task, string reason, JObject details = null)
{
var signalName = GetInput <string>(task, "signalName");
if (string.IsNullOrWhiteSpace(signalName))
{
RespondFailure(task, reason, details);
}
else
{
SignalFailure(task, signalName, reason, details);
}
}
/// <summary>
/// Responds with success synchronously or asynchronously as appropriate
/// </summary>
/// <param name="task"></param>
/// <param name="result"></param>
protected void Success(ActivityTask task, JObject result)
{
var signalName = GetInput <string>(task, "signalName");
if (string.IsNullOrWhiteSpace(signalName))
{
RespondSuccess(task, result);
}
else
{
SignalSuccess(task, signalName, result);
}
}
/// <summary>
/// Complete task sucessfully
/// Use the reponse object to create the outputs
/// The response object will usually be an anonymous object
/// </summary>
/// <param name="task">Task</param>
/// <param name="result">Result object</param>
protected void RespondSuccess(ActivityTask task, object result)
{
string json;
try
{
json = JsonConvert.SerializeObject(result, Formatting.None);
}
catch (Exception)
{
RespondFailure(task, "Invalid JSON response object");
return;
}
RespondSuccess(task, json);
}
protected void RespondRescheduled(ActivityTask task)
{
var cancelObj = new { status = "rescheduled" };
workflowClient.Respond(task, JsonConvert.SerializeObject(cancelObj, Formatting.None));
}
/// <summary>
/// Complete task sucessfully with no result
/// </summary>
/// <param name="task"></param>
protected void RespondSuccess(ActivityTask task)
{
var successObj = new JObject();
RespondSuccess(task, successObj);
}
/// <summary>
/// Complete task sucessfully
/// Use the supplied text as the result
/// </summary>
/// <param name="task">Task</param>
/// <param name="jsonObjectResult">Result text</param>
protected void RespondSuccess(ActivityTask task, string jsonObjectResult)
{
RespondSuccess(task, JObject.Parse(jsonObjectResult));
}
/// <summary>
/// Complete task with failure
/// </summary>
/// <param name="task">Task</param>
/// <param name="reason">Reason string</param>
/// <param name="details">JSON details object</param>
protected void RespondFailure(ActivityTask task, string reason, JToken details = null)
{
var failObj = new { status = "failure", reason, details };
workflowClient.Respond(task, JsonConvert.SerializeObject(failObj, Formatting.None));
}
