/// <summary>
/// Initialize the callback holding object.
/// </summary>
/// <param name="workItemsGroup">The workItemGroup of the workitem</param>
/// <param name="workItemInfo">The WorkItemInfo of te workitem</param>
/// <param name="callback">Action delegate for the callback.</param>
/// <param name="state">Items with which to call the callback delegate.</param>
///
/// We assume that the WorkItem object is created within the thread
/// that meant to run the callback
public WorkItem(
IWorkItemsGroup workItemsGroup,
WorkItemInfo workItemInfo,
WorkItemCallback callback,
object state)
{
if (null == workItemInfo)
{
throw new ArgumentNullException("workItemInfo");
}
_workItemsGroup = workItemsGroup;
_workItemInfo = workItemInfo;
#if !(_WINDOWS_CE) && !(_SILVERLIGHT)
if (_workItemInfo.UseCallerCallContext || _workItemInfo.UseCallerHttpContext)
{
_callerContext = CallerThreadContext.Capture(_workItemInfo.UseCallerCallContext, _workItemInfo.UseCallerHttpContext);
}
#endif
_callback = callback;
_state = state;
_workItemResult = new WorkItemResult(this);
Initialize();
}
/// <summary>
/// Release the work items' wait handles
/// </summary>
/// <param name="workItemResults">An array of work item results</param>
private static void ReleaseWaitHandles(IWorkItemResult[] workItemResults)
{
for (int i = 0; i < workItemResults.Length; i++)
{
WorkItemResult result = workItemResults[i] as WorkItemResult;
result.GetWorkItem().ReleaseWaitHandle();
}
}
/// <summary>
/// Fill an array of wait handles with the work items wait handles.
/// </summary>
/// <param name="workItemResults">An array of work item results</param>
/// <param name="waitHandles">An array of wait handles to fill</param>
private static void GetWaitHandles(IWorkItemResult[] workItemResults, WaitHandle[] waitHandles)
{
for (int i = 0; i < workItemResults.Length; i++)
{
WorkItemResult result = workItemResults[i] as WorkItemResult;
waitHandles[i] = result.GetWorkItem().GetWaitHandle();
}
}
internal WorkItemResult ListWorkItems(PageHandle pageHandle)
{
ReAuthenticateIfRequired();
WorkItemResult result = fWorkflowService.ListWorkItems(ref fWorkflowAuthentication, pageHandle);
UpdateAuthenticationTokens(fWorkflowAuthentication.AuthenticationToken);
return(result);
}
/// <summary>
/// Initialize the callback holding object.
/// </summary>
/// <param name="workItemsGroup">The workItemGroup of the workitem</param>
/// <param name="workItemInfo">The WorkItemInfo of te workitem</param>
/// <param name="callback">Callback delegate for the callback.</param>
/// <param name="state">State with which to call the callback delegate.</param>
///
/// We assume that the WorkItem object is created within the thread
/// that meant to run the callback
public WorkItem(IWorkItemsGroup workItemsGroup, WorkItemInfo workItemInfo, WorkItemCallback callback, object state)
{
_workItemsGroup = workItemsGroup;
_workItemInfo = workItemInfo;
_callback = callback;
_state = state;
_workItemResult = new WorkItemResult(this);
Initialize();
}
/// <summary>
/// Release the work items' wait handles
/// </summary>
/// <param name="waitableResults">An array of work item results</param>
private static void ReleaseWaitHandles(IWaitableResult[] waitableResults)
{
for (int i = 0; i < waitableResults.Length; ++i)
{
WorkItemResult wir = (WorkItemResult)waitableResults[i].GetWorkItemResult();
wir.GetWorkItem().ReleaseWaitHandle();
}
}
/// <summary>
/// Release the work items' wait handles
/// </summary>
/// <param name="workItemResults">An array of work item results</param>
private static void ReleaseWaitHandles(IWorkItemResult [] workItemResults)
{
for (int i = 0; i < workItemResults.Length; ++i)
{
WorkItemResult wir = workItemResults[i] as WorkItemResult;
wir.GetWorkItem().ReleaseWaitHandle();
}
}
/// <summary>
/// Fill an array of wait handles with the work items wait handles.
/// </summary>
/// <param name="waitableResults">An array of work item results</param>
/// <param name="waitHandles">An array of wait handles to fill</param>
private static void GetWaitHandles(
IWaitableResult[] waitableResults,
WaitHandle[] waitHandles)
{
for (int i = 0; i < waitableResults.Length; ++i)
{
WorkItemResult wir = waitableResults[i].GetWorkItemResult() as WorkItemResult;
Debug.Assert(null != wir, "All waitableResults must be WorkItemResult objects");
waitHandles[i] = wir.GetWorkItem().GetWaitHandle();
}
}
/// <summary>
/// Initialize the callback holding object.
/// </summary>
/// <param name="workItemsGroup"></param>
/// <param name="workItemInfo"></param>
/// <param name="callback">Callback delegate for the callback.</param>
/// <param name="state">State with which to call the callback delegate.</param>
///
/// We assume that the WorkItem object is created within the thread
/// that meant to run the callback
public WorkItem(IWorkItemsGroup workItemsGroup, WorkItemInfo workItemInfo, WorkItemCallback callback, object state)
{
this._workItemsGroup = workItemsGroup;
this._workItemInfo = workItemInfo;
if (this._workItemInfo.UseCallerCallContext || this._workItemInfo.UseCallerHttpContext)
{
this._callerContext = CallerThreadContext.Capture(this._workItemInfo.UseCallerCallContext, this._workItemInfo.UseCallerHttpContext);
}
this._callback = callback;
this._state = state;
this._workItemResult = new WorkItemResult(this);
this.Initialize();
}
public void Preserve_given_precomputed_results()
{
// Arrange
var result = new WorkItemResult(WorkStatus.Successful);
var preComputedResult = new [] { DummyData };
var testBatch = new TestWorkBatch(BatchId);
var workBatch = new WorkBatch(1, testBatch, preComputedResult);
// Act
workBatch.DoFinally(result, CancellationToken.None);
// Assert
testBatch.Result.Data.Should().Contain(DummyData);
}
public void Pass_result_to_batch()
{
// Arrange
var batchedWorkItem = new BatchedWorkItem(_workBatchMock.Object, _workItemMock.Object);
var result = new WorkItemResult(WorkStatus.Successful);
_workItemMock.Setup(x => x.Do(It.Is <CancellationToken>(y => y == _cancellationToken))).Returns(result);
// Act
batchedWorkItem.Do(_cancellationToken);
// Assert
_workBatchMock.Verify(x => x.DoFinally(result, _cancellationToken), Times.Once);
}
public void DoFinally(WorkItemResult result, CancellationToken cancellationToken)
{
try
{
FormattedConsole.WriteLine($"{Id} dofinally started");
_processResults(result, int.Parse(Id));
FormattedConsole.WriteLine($"Batch {Id} done");
}
catch (Exception e)
{
FormattedConsole.WriteLine($"Batch {Id} : exception in dofinally, {e}");
}
}
/// <summary>
/// Release the work items' wait handles
/// </summary>
/// <param name = "workItemResults">An array of work item results</param>
private static void ReleaseWaitHandles(IWorkItemResult[] workItemResults)
{
#if (!ISWIN)
foreach (IWorkItemResult result in workItemResults)
{
WorkItemResult wir = result as WorkItemResult;
if (wir != null)
{
wir.GetWorkItem().ReleaseWaitHandle();
}
}
#else
foreach (WorkItemResult wir in workItemResults.OfType <WorkItemResult>())
{
wir.GetWorkItem().ReleaseWaitHandle();
}
#endif
}
public static void TimerElapsed(object state)
{
WorkItemService service = new WorkItemService(_configurations);
var itens = new ApiAzureDevopsCloud(_configurations.Url
, _configurations.BasicToken, _configurations.Project).getWorkItens();
while (!itens.IsCompleted)
{
;
}
foreach (var item in itens.Result.ToList())
{
var workItem = new WorkItemResult
{
IdWorkItem = item.Id.Value
};
foreach (var valor in item.Fields)
{
if (valor.Key == "System.Title")
{
workItem.Titulo = valor.Value.ToString();
}
if (valor.Key == "System.WorkItemType")
{
workItem.Tipo = valor.Value.ToString();
}
if (valor.Key == "System.ChangedDate")
{
workItem.DataCriacaoWorkItem = DateTime.Parse(valor.Value.ToString());
}
}
if (!service.GetByWorkId(item.Id.Value))
{
service.Create(workItem);
}
Console.WriteLine(JsonConvert.SerializeObject(workItem));
}
}
/// <summary>
/// Initialize the callback holding object.
/// </summary>
/// <param name="workItemsGroup"></param>
/// <param name="workItemInfo"></param>
/// <param name="callback">Callback delegate for the callback.</param>
/// <param name="state">State with which to call the callback delegate.</param>
///
/// We assume that the WorkItem object is created within the thread
/// that meant to run the callback
public WorkItem(
IWorkItemsGroup workItemsGroup,
WorkItemInfo workItemInfo,
WorkItemCallback callback,
object state)
{
_workItemsGroup = workItemsGroup;
_workItemInfo = workItemInfo;
if (_workItemInfo.UseCallerCallContext || _workItemInfo.UseCallerHttpContext)
{
_callerContext = CallerThreadContext.Capture(_workItemInfo.UseCallerCallContext, _workItemInfo.UseCallerHttpContext);
}
_callback = callback;
_state = state;
_workItemResult = new WorkItemResult(this);
Initialize();
}
private static void runByBuild(ProjectType project, Build build)
{
Console.WriteLine($"Build Id:{build.Id}");
try
{
var buildFailedPBIId = 0;
var wiqlResult_PBI = WorkItemResult.Query(ProjectType.b, $@"
SELECT [System.Id], [System.Title], [System.State]
FROM WorkItems
WHERE [System.WorkItemType] = 'Product Backlog Item' AND [System.Title] = '{Config.PBITitle}' AND [System.IterationPath] = '{WorkItemResult.GetCurrentIteration(ProjectType.b)}'");
// create a PBI, if it is not exist
if (wiqlResult_PBI.WorkItems.Any())
{
buildFailedPBIId = wiqlResult_PBI.WorkItems.Select(wi => wi.Id).Single();
}
else
{
buildFailedPBIId = WorkItemResult.Create(ProjectType.b, WorkItemType.PBI, Config.PBITitle, Area.CICD);
Console.WriteLine($"pbi created:[id:{buildFailedPBIId}][title:{Config.PBITitle}]");
}
// create a task, if there is no tag in the build
if (!BuildResult.GetTags(project, build.Id).Contains(Config.TagName))
{
var taskTitle = _taskTitleFormat
.Replace("$Date", DateTime.Now.ToString(@"yyyy/MM/dd"))
.Replace("$Repository", RepositoryResult.Get(project, build.Repository.Id).Name);
var description = (@"<a href=""$url"" aria-label=""CTRL+Click or CTRL+Enter to follow link $url"">$url</a>")
.Replace("$url", build.Links.Web.Href);
var taskId = WorkItemResult.Create(ProjectType.b, WorkItemType.Task, taskTitle, Area.CICD, build.RequestedFor.UniqueName, description, buildFailedPBIId);
BuildResult.AddTag(project, build.Id, Config.TagName);
Console.WriteLine($"task created:[id:{taskId}][title:{taskTitle}]");
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
public WorkItem(IWorkItemsGroup workItemsGroup, WorkItemInfo workItemInfo, WaitCallback callback, object state)
{
_workItemsGroup = workItemsGroup;
_workItemInfo = workItemInfo;
if (_workItemInfo.UseCallerCallContext && !ExecutionContext.IsFlowSuppressed())
{
ExecutionContext ec = ExecutionContext.Capture();
if (ec != null)
{
_callerContext = ec.CreateCopy();
}
ec.Dispose();
ec = null;
}
_callbackNoResult = callback;
_state = state;
_workItemResult = new WorkItemResult(this);
Initialize();
}
/// <summary>
/// Initialize the callback holding object.
/// </summary>
/// <param name="callback">Callback delegate for the callback.</param>
/// <param name="state">State with which to call the callback delegate.</param>
///
/// We assume that the WorkItem object is created within the thread
/// that meant to run the callback
public WorkItem(
WorkItemCallback callback,
object state,
bool useCallerContext,
PostExecuteWorkItemCallback postExecuteWorkItemCallback,
CallToPostExecute callToPostExecute)
{
if (useCallerContext)
{
_callerContext = ChoCallerThreadContext.Capture();
}
_postExecuteWorkItemCallback = postExecuteWorkItemCallback;
_callToPostExecute = callToPostExecute;
_callback = callback;
_state = state;
_workItemState = WorkItemState.InQueue;
_workItemCompleted = null;
_workItemCompletedRefCount = 0;
_workItemResult = new WorkItemResult(this);
}
/// <summary>
/// Initialize the callback holding object.
/// </summary>
/// <param name="workItemsGroup">The workItemGroup of the workitem</param>
/// <param name="workItemInfo">The WorkItemInfo of te workitem</param>
/// <param name="callback">Callback delegate for the callback.</param>
/// <param name="state">State with which to call the callback delegate.</param>
///
/// We assume that the WorkItem object is created within the thread
/// that meant to run the callback
public WorkItem(
IWorkItemsGroup workItemsGroup,
WorkItemInfo workItemInfo,
WorkItemCallback callback,
object state)
{
_workItemsGroup = workItemsGroup;
_workItemInfo = workItemInfo;
#if !(_WINDOWS_CE) && !(_SILVERLIGHT) && !(WINDOWS_PHONE) && !(NETSTANDARD2_0)
if (_workItemInfo.UseCallerCallContext || _workItemInfo.UseCallerHttpContext)
{
_callerContext = CallerThreadContext.Capture(_workItemInfo.UseCallerCallContext, _workItemInfo.UseCallerHttpContext);
}
#endif
_callback = callback;
_state = state;
_workItemResult = new WorkItemResult(this);
Initialize();
}
public void DoFinally(WorkItemResult result, CancellationToken cancellationToken)
{
_finalizeBatch(result, cancellationToken);
}
public WorkItemResultEventArgs(T workItem, WorkItemResult result)
: base(workItem)
{
this.Result = result;
}
/// <summary>
/// Initialize the callback holding object.
/// </summary>
/// <param name="workItemsGroup"></param>
/// <param name="workItemInfo"></param>
/// <param name="callback">Callback delegate for the callback.</param>
/// <param name="state">State with which to call the callback delegate.</param>
///
/// We assume that the WorkItem object is created within the thread
/// that meant to run the callback
public WorkItem(
IWorkItemsGroup workItemsGroup,
WorkItemInfo workItemInfo,
WorkItemCallback callback,
object state)
{
_workItemsGroup = workItemsGroup;
_workItemInfo = workItemInfo;
if (_workItemInfo.UseCallerCallContext || _workItemInfo.UseCallerHttpContext)
{
_callerContext = CallerThreadContext.Capture(_workItemInfo.UseCallerCallContext, _workItemInfo.UseCallerHttpContext);
}
_callback = callback;
_state = state;
_workItemResult = new WorkItemResult(this);
Initialize();
}
/// <summary>
/// Initialize the callback holding object.
/// </summary>
/// <param name="workItemsGroup">The workItemGroup of the workitem</param>
/// <param name="workItemInfo">The WorkItemInfo of te workitem</param>
/// <param name="callback">Callback delegate for the callback.</param>
/// <param name="state">State with which to call the callback delegate.</param>
///
/// We assume that the WorkItem object is created within the thread
/// that meant to run the callback
public WorkItem(
IWorkItemsGroup workItemsGroup,
WorkItemInfo workItemInfo,
WorkItemCallback callback,
object state)
{
_workItemsGroup = workItemsGroup;
_workItemInfo = workItemInfo;
#if !(_WINDOWS_CE) && !(_SILVERLIGHT) && !(WINDOWS_PHONE)
if (_workItemInfo.UseCallerCallContext || _workItemInfo.UseCallerHttpContext)
{
_callerContext = CallerThreadContext.Capture(_workItemInfo.UseCallerCallContext, _workItemInfo.UseCallerHttpContext);
}
#endif
_callback = callback;
_state = state;
_workItemResult = new WorkItemResult(this);
Initialize();
}
public void ProcessWorkItem(CopyFileWorkItem workItem)
{
WorkItemResult result = WorkItemResult.Completed;
if (!OnStart(new CancelWorkItemEventArgs <CopyFileWorkItem>(workItem)))
{
result = WorkItemResult.Cancelled;
}
else
{
try
{
FileSystemInfo fsi = workItem.Item;
if (fsi is FileInfo)
{
int cancel = 0;
GX.IO.Utilities.CopyFile(fsi as FileInfo, workItem.Destination, RetryCount, ref cancel, workItem, CopyFileProgressUpdate, ConfirmCopy, NotifyCopy);
}
else if (fsi is DirectoryInfo)
{
DirectoryInfo di = fsi as DirectoryInfo;
bool destDirectoryExists = Directory.Exists(workItem.Destination);
if (!destDirectoryExists)
{
destDirectoryExists = GX.IO.Utilities.CreateDirectory(workItem.Destination, ConfirmCreateDirectory, NotifyCreateDirectory);
}
if (destDirectoryExists)
{
FileSystemInfo[] children = di.GetFileSystemInfos();
List <FileSystemInfo> orderedChildren = new List <FileSystemInfo>();
foreach (FileSystemInfo cfsi in children)
{
if (cfsi is FileInfo)
{
orderedChildren.Add(cfsi);
}
}
foreach (FileSystemInfo cfsi in children)
{
if (cfsi is DirectoryInfo)
{
orderedChildren.Add(cfsi);
}
}
workItem.ProgressWeight = workItem.ProgressWeight / (orderedChildren.Count + 1);
foreach (FileSystemInfo cfi in orderedChildren)
{
string destDirectoryName = Path.Combine(workItem.Destination, cfi.Name);
OnNewWorkItem(new NewWorkItemEventArgs <CopyFileWorkItem>(workItem, new CopyFileWorkItem()
{
Destination = destDirectoryName,
Item = cfi,
ProgressWeight = workItem.ProgressWeight,
FinishedSize = 0
}));
}
}
}
}
catch (Exception ex)
{
workItem.FailedReason = ex;
result = WorkItemResult.Failed;
}
}
OnComplete(new WorkItemResultEventArgs <CopyFileWorkItem>(workItem, result));
}
public void DoFinally(WorkItemResult result, CancellationToken cancellationToken)
{
Result = result;
Executions++;
}
private static void ProcessResults(WorkItemResult batchResult, int batchId)
{
// TODO: write success file
}
public void EndItem(WorkItemResult result)
{
if (this.progressDialog.InvokeRequired)
{
this.progressDialog.BeginInvoke(new Procedure<WorkItemResult>(EndItem), new object[] { result });
}
else
{
}
}
public void DoFinally(WorkItemResult result, CancellationToken cancellationToken)
{
FormattedConsole.WriteLine($"Consumer {Thread.CurrentThread.ManagedThreadId} finalized batch in work item {Id}");
}
public WorkItemResult Create(WorkItemResult item)
{
_workItens.InsertOne(item);
return(item);
}
