public void ConfigurationTests_Configuration_Filters()
{
var pipelineId = Guid.NewGuid().ToString();
var config = new PipelineConfiguration
{
Id = pipelineId,
InputHandler = new HandlerNode(typeof(GenericInputHandler <LogMessage>)),
OutputHandlers = new List <HandlerNode>
{
new HandlerNode("ConsoleOutput")
{
Filters = new List <string>
{
"Message -> msg"
}
}
}
};
var builder = new PipelineBuilder();
builder.BuildPipeline(ProcessingServer.Server, config);
var client = new EventDispatcher();
client.Process(pipelineId, new LogMessage {
Message = "ConfigurationTests_NewPipelinePerEvent1"
});
client.Process(pipelineId, new LogMessage {
Message = "ConfigurationTests_NewPipelinePerEvent2"
});
ProcessingServer.Server.WaitAll(pipelineId);
}
private static async Task <long> ExecutePipelineAsync(Type pipelineType, PipelineConfiguration configuration, CancellationToken cancellationToken)
{
IAsyncPipeline asyncPipeline;
if ((object)pipelineType == null)
{
throw new ArgumentNullException(nameof(pipelineType));
}
if ((object)configuration == null)
{
throw new ArgumentNullException(nameof(configuration));
}
asyncPipeline = (IAsyncPipeline)Activator.CreateInstance(pipelineType);
if ((object)asyncPipeline == null)
{
throw new InvalidOperationException(nameof(asyncPipeline));
}
using (AsyncDisposal.Await(asyncPipeline, cancellationToken))
{
asyncPipeline.Configuration = configuration;
await asyncPipeline.CreateAsync(cancellationToken);
IAsyncContext asyncContext;
using (AsyncDisposal.Await(asyncContext = asyncPipeline.CreateContextAsync(), cancellationToken))
{
await asyncContext.CreateAsync(cancellationToken);
return(await asyncPipeline.ExecuteAsync(asyncContext, cancellationToken));
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="PipelineBuilderCommand"/> class.
/// Adds our command handlers for menu (commands must exist in the command table file)
/// </summary>
/// <param name="package">Owner package, not null.</param>
private PipelineBuilderCommand(Package package, DTE2 dte)
{
if (package == null)
{
throw new ArgumentNullException("package");
}
if (dte == null)
{
throw new ArgumentNullException("dte");
}
this.package = package;
this.dte = dte;
this.config = new PipelineConfiguration();
OleMenuCommandService commandService = this.ServiceProvider.GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
if (commandService != null)
{
var menuCommandID = new CommandID(CommandSet, CommandId);
var menuItem = new MenuCommand(this.MenuItemCallback, menuCommandID);
commandService.AddCommand(menuItem);
}
}
public void ConfigurationTests_Configuration()
{
var pipelineId = Guid.NewGuid().ToString();
var config = new PipelineConfiguration
{
Id = pipelineId,
InputHandler = new HandlerNode("CustomInput"),
OutputHandlers = new List <HandlerNode>
{
new HandlerNode("ConsoleOutput")
}
};
var builder = new PipelineBuilder();
builder.BuildPipeline(config);
var client = new EventDispatcher();
client.Process(pipelineId, new LogMessage {
Message = "ConfigurationTests_NewPipelinePerEvent1"
});
client.Process(pipelineId, new LogMessage {
Message = "ConfigurationTests_NewPipelinePerEvent2"
});
}
public void LoadTesting_MultipleProcessors()
{
GlobalConfiguration.Setup(s => s.UseOptions(new Options
{
MaxItemsInQueue = 10,
MinProcessors = 10,
MaxProcessors = 50
}));
var pipelineId = Guid.NewGuid().ToString();
var config = new PipelineConfiguration
{
Id = pipelineId,
InputHandler = new HandlerNode("CustomInput"),
OutputHandlers = new List <HandlerNode>
{
new HandlerNode("ConsoleOutput")
{
Filters = new List <string>
{
"Message -> msg",
"Level -> lvl"
}
},
new HandlerNode(typeof(ThreadWaitHandler))
}
};
var builder = new PipelineBuilder();
builder.BuildPipeline(config);
var result = ProfilerSession.StartSession()
.Task(ctx =>
{
var client = new EventDispatcher();
client.Process(pipelineId, new LogMessage {
Level = "Info", Message = $"Loadtesting {ctx.Get<int>(ContextKeys.Iteration)} on Thread {ctx.Get<int>(ContextKeys.ThreadId)}", Title = "Loadtest"
});
})
.SetIterations(100)
.SetThreads(10)
.Settings(s => s.RunWarmup = false)
.RunSession();
ProcessingServer.Server.WaitAll(pipelineId);
// delay to ensure all threads are ended
System.Threading.Tasks.Task.Delay(3000);
var storage = GlobalConfiguration.Configuration.Resolve <IStorage>();
Assert.GreaterOrEqual(100 * 10, storage.Get <long>(new StorageKey(pipelineId, "ProcessedEventsMetric")));
var stats = new StatisticsApi(pipelineId);
Assert.AreEqual(10, stats.GetMetricValue(MetricType.ThreadCount));
result.Trace("### LoadTesting");
}
public TestResultSummaryViewModel(TestResultSummary summary, PipelineConfiguration pipelineConfiguration, bool includeOthersInTotal)
{
PassedTests = 0;
FailedTests = 0;
if (summary.AggregatedResultsAnalysis.ResultsByOutcome.ContainsKey(TestOutcome.Passed))
{
PassedTests = summary.AggregatedResultsAnalysis.ResultsByOutcome[TestOutcome.Passed].Count;
}
if (summary.AggregatedResultsAnalysis.ResultsByOutcome.ContainsKey(TestOutcome.Failed))
{
FailedTests = summary.AggregatedResultsAnalysis.ResultsByOutcome[TestOutcome.Failed].Count;
}
TotalTests = summary.AggregatedResultsAnalysis.TotalTests;
OtherTests = TotalTests - PassedTests - FailedTests;
if (!includeOthersInTotal)
{
TotalTests -= OtherTests;
}
PassingRate = TestResultsHelper.GetTestOutcomePercentageString(PassedTests, TotalTests);
Duration = TimeSpanFormatter.FormatDurationWithUnit(summary.AggregatedResultsAnalysis.Duration);
Url = pipelineConfiguration.TestTabLink;
}
public ICodeGenerationPipeline Build(JObject configuration)
{
this.logger.Write(new StageTopLevelInfoRecord("Building code generation pipeline."));
try
{
var context = new PipelineCreationContext(this.basePath);
var reader = new PipelineConfiguration(configuration);
var result = new CodeGenerationPipeline(this.logger);
result.PipelineEnvironment = this.CreatePipelineEnvironment(result.PipelineExecutionInfo, reader);
var inputConfig = reader.InputCodeStreamProviderConfiguration;
if (inputConfig != null)
{
var inputBuilder = new CodeStreamProviderBuilder(result.PipelineEnvironment, this.workspaceManagers.OutputWorkspace, this.fileSystem, this.basePath);
result.InputCodeStreamProvider = inputBuilder.Build(inputConfig);
}
result.Batches = this.BuildBatches(reader.BatchConfigurations, context);
return(result);
}
catch (Exception ex)
{
this.logger.Write(new ErrorLogRecord("Error occurred while building code generation pipeline.", ex));
throw;
}
}
/// <summary>
/// Build the pipeline based on the configuration
/// </summary>
/// <param name="server"></param>
/// <param name="config"></param>
public void BuildPipeline(IProcessingServer server, PipelineConfiguration config)
{
_logger.Write($"Setup Pipeline:{config}", Category.Log, LogLevel.Debug, "PipelineBuilder");
server.SetupPipeline(config.Id, s =>
{
var rootCtx = GlobalConfiguration.Configuration.Resolve <IActivationContext>();
s.Register(() =>
{
var pipeline = new EventPipeline();
foreach (var node in config.OutputHandlers)
{
var ctx = rootCtx.ChildContext();
var outputHandler = BuildHandler <IOutputHandler>(ctx, node);
var converter = node.BuildDataFilter();
if (converter.Filters.Any(f => f.FilterType == Filters.FilterType.Property))
{
outputHandler = new DataFilterDecorator(converter, outputHandler);
}
pipeline.AddHandler(outputHandler);
}
return(pipeline);
}, config.Options);
var inputHandler = BuildHandler <IInputHandler>(rootCtx.ChildContext(), config.InputHandler);
s.Register(inputHandler);
});
}
/// <summary>
/// Run the validation of the supplied source document, optionally
/// writing the validated document to the supplied destination.
/// </summary>
public void Run()
{
AugmentedSource aug = AugmentedSource.makeAugmentedSource(source);
aug.setSchemaValidationMode(lax ? Validation.LAX : Validation.STRICT);
JReceiver receiver;
if (destination == null)
{
receiver = new Sink();
}
else if (destination is Serializer)
{
receiver = ((Serializer)destination).GetReceiver(config);
}
else
{
Result result = destination.GetResult();
if (result is JReceiver)
{
receiver = (JReceiver)result;
}
else
{
throw new ArgumentException("Unknown type of destination");
}
}
PipelineConfiguration pipe = config.makePipelineConfiguration();
if (errorList != null)
{
pipe.setErrorListener(new ErrorGatherer(errorList));
}
new Sender(pipe).send(aug, receiver, true);
}
public void ProcessingServer_PipelineOptions()
{
var factory = new EventBusFactory();
var server = new ProcessingServer(factory);
var config = new PipelineConfiguration
{
Id = "test",
InputHandler = new HandlerNode
{
Type = typeof(LogInputHandler)
},
OutputHandlers = new List <HandlerNode>
{
new HandlerNode
{
Type = typeof(ConsoleOutputHandler)
}
},
Options = new PipelineOptions
{
MinProcessors = 1,
MaxItemsInQueue = 100,
MaxProcessors = 1
}
};
server.SetupPipeline("test", config);
var bus = factory.GetEventBus("test");
Assert.AreSame(bus.PipelineFactory.Options, config.Options);
}
static async Task Run()
{
var configuration = new PipelineConfiguration()
.AddGlobalVariable("ID", Guid.NewGuid())
.NextStep(new StepOne(), Variables.Empty)
.NextStep(new StepGlobalVariable())
.NextStepWithCommand(new StepShowMessageFromCommand(), new StepCommand()
{
Message = "Hello world"
})
.NextStep(new StepLocalVariable(), new Variables {
{ "MESSAGE", "Hello from variables" }
})
.NextStep(new StepAddObjectScope())
.NextStep(new StepReadScope(), Variables.Empty, "MAIN")
.AddAlwaysEnd(x =>
{
Console.WriteLine("----------- END -----------");
})
.AddBeforeStart(x =>
{
Console.WriteLine("----------- START -----------");
});
var manager = new PipelineManager();
await manager.Configure(configuration)
.Run();
}
public static PipelineConfiguration RegisterCustomerPublications(this PipelineConfiguration configuration)
{
configuration.customerPublisher.CustomerFoundHandler += async(s, e) => await configuration.transactionRegistration.OnCustomerCheckEvent(s, e).ConfigureAwait(true);
configuration.customerPublisher.LogHandler += async(s, e) => await configuration.LogSubscriber.OnLogReceivedEvent(s, e).ConfigureAwait(true);
return(configuration);
}
public ChangeViewModel(ChangeData change, PipelineConfiguration config)
: this(change.Id,
StringUtils.CompressNewLines(change.Message),
change.Author?.DisplayName,
DateTimeHelper.GetLocalTimeWithTimeZone(change.Timestamp),
LinkHelper.GetCommitLink(change.Id, change.Location.AbsoluteUri, config))
{
}
public TestSummaryGroupViewModel(TestSummaryGroup testSummaryGroup, PipelineConfiguration config,
bool includeOthersInTotal)
{
GroupName = testSummaryGroup.GroupingType.GetDescription();
InitializeSummaryItems(testSummaryGroup, config, includeOthersInTotal);
InitializeSupportedPriorityColumns();
}
private static string GetBuildLink(PipelineConfiguration config, string collectionUri,
Dictionary <string, object> parameters)
{
var uri = new Uri(GetBaseUri(collectionUri),
GetBuildRelativeUrl(config.ProjectName) + GetQueryParameter(parameters))
.AbsoluteUri;
return(uri);
}
public static string GetCreateBugLinkForTest(PipelineConfiguration config,
TestCaseResult testResult)
{
return(GetTestResultLink(config, testResult.TestRun?.Id,
testResult.Id, new Dictionary <string, string>
{
{ "create-bug", "true" }
}));
}
private void InitializeSummaryItems(TestSummaryGroup testSummaryGroup, PipelineConfiguration config,
bool includeOthersInTotal)
{
SummaryItems = new List <TestSummaryItemViewModel>();
foreach (var testSummaryItem in testSummaryGroup.Runs)
{
SummaryItems.Add(new TestSummaryItemViewModel(testSummaryGroup.GroupingType, testSummaryItem, config, includeOthersInTotal));
}
}
public static PipelineConfiguration RegisterSiteSubscriptions(this PipelineConfiguration configuration)
{
configuration.transactionRegistration.TransactionHandler += async(s, e) => await configuration.siteSubscriber.OnTransactionReceivedEvent(s, e).ConfigureAwait(true);
configuration.transactionRegistration.LogHandler += async(s, e) => await configuration.LogSubscriber.OnLogReceivedEvent(s, e).ConfigureAwait(true);
configuration.siteSubscriber.LogHandler += async(s, e) => await configuration.LogSubscriber.OnLogReceivedEvent(s, e).ConfigureAwait(true);
return(configuration);
}
public async override Task <TestResultSummary> QueryTestResultsReportAsync(PipelineConfiguration releaseConfig = null)
{
var releaseConfiguration = (releaseConfig != null && releaseConfig is ReleaseConfiguration)
? (releaseConfig as ReleaseConfiguration) : _releaseConfig;
return //TODO - RetryHelper.Retry(()
(await _tcmClient.QueryTestResultsReportForReleaseAsync(
releaseConfiguration.ProjectName,
releaseConfiguration.Id,
releaseConfiguration.EnvironmentId));
}
private void InitializeAssociatedChanges(AbstractReport emailReportDto, PipelineConfiguration config)
{
if (emailReportDto.AssociatedChanges?.Any() == true)
{
AssociatedChanges = new List <ChangeViewModel>();
foreach (var associatedChange in emailReportDto.AssociatedChanges)
{
AssociatedChanges.Add(new ChangeViewModel(associatedChange, config));
}
}
}
public override ReleaseViewModel GetReleaseViewModel(PipelineConfiguration config)
{
var releaseConfig = config.Clone() as ReleaseConfiguration;
if (releaseConfig == null)
{
throw new NotSupportedException();
}
return(new ReleaseViewModel(Environment, releaseConfig));
}
private void ButtonExecute_Click(object sender, RoutedEventArgs e)
{
if (Configuration is null)
{
return;
}
var win = new PipelineExecuterWindow(Configuration);
win.ShowDialog();
Configuration = win.Configuration;
}
private static async Task Main(string[] args)
{
var files = Directory.GetFiles(@"TestData\", "*.cs");
var configure = new PipelineConfiguration(2, 2, 2);
var pipeline = new Pipeline(configure);
var outputDirectory = Directory.GetCurrentDirectory() + @"\TestResult\";
await pipeline.Processing(files, outputDirectory);
}
public static EmailReportConfiguration CreateConfiguration(IHeaderDictionary headers, string jsonRequest, ILogger logger)
{
var data = (JObject)JsonConvert.DeserializeObject(jsonRequest);
JToken executeConditionObject;
if (data.TryGetValue("ExecuteCondition", out executeConditionObject) && executeConditionObject != null)
{
var executeCondition = JsonConvert.DeserializeObject <ExecuteCondition>(executeConditionObject.ToString());
// Evaluate condition and if fails, exit
if (!executeCondition.Evaluate())
{
return(null);
}
}
StringValues authTokenValues;
headers.TryGetValue("AuthToken", out authTokenValues);
var accessToken = authTokenValues.FirstOrDefault();
if (!string.IsNullOrWhiteSpace(accessToken))
{
var credentials = new VssBasicCredential("", accessToken);
var reportDataConfiguration = JsonConvert.DeserializeObject <ReportDataConfiguration>(data.GetValue("ReportDataConfiguration").ToString());
var mailConfiguration = JsonConvert.DeserializeObject <MailConfiguration[]>(data.GetValue("EmailConfiguration").ToString());
var pipelineInfoObject = (JObject)JsonConvert.DeserializeObject(data.GetValue("PipelineInfo").ToString());
var pipelineType = pipelineInfoObject.GetValue("PipelineType").ToObject <PipelineType>();
PipelineConfiguration pipelineConfiguration = null;
if (pipelineType == PipelineType.Release)
{
pipelineConfiguration = JsonConvert.DeserializeObject <ReleaseConfiguration>(data.GetValue("PipelineInfo").ToString());
pipelineConfiguration.Credentials = credentials;
}
else
{
// TODO
return(null);
}
return(new EmailReportConfiguration()
{
PipelineType = pipelineType,
ReportDataConfiguration = reportDataConfiguration,
MailConfigurations = mailConfiguration,
PipelineConfiguration = pipelineConfiguration
});
}
return(null);
}
public static string GetBuildSummaryLink(string buildId, PipelineConfiguration config)
{
var collectionUri = config.ServerUri;
var parameters = new Dictionary <string, object>
{
{ "buildId", buildId },
{ "_a", "summary" }
};
var uri = GetBuildLink(config, collectionUri, parameters);
return(uri);
}
public static string GetBuildDefinitionLink(string definitionId, PipelineConfiguration config)
{
var collectionUri = config.ServerUri;
var parameters = new Dictionary <string, object>
{
{ "definitionId", definitionId },
{ "_a", "completed" }
};
var uri = GetBuildLink(config, collectionUri, parameters);
return(uri);
}
public static string GetWorkItemLink(PipelineConfiguration config, int workItemId)
{
var queryParams = new Dictionary <string, object>
{
{ "id", workItemId }
};
return(new Uri(
GetBaseUri(config.ServerUri),
GetWorkItemRelativeUrl(config.ProjectName) + GetQueryParameter(queryParams))
.AbsoluteUri);
}
public ArtifactViewModel(Artifact artifact, PipelineConfiguration config)
{
Version = GetArtifactInfo(artifact, ArtifactDefinitionConstants.Version);
BranchName = GetArtifactInfo(artifact, ArtifactDefinitionConstants.Branch);
Name = artifact.Alias;
IsPrimary = artifact.IsPrimary;
BuildSummaryUrl = LinkHelper.GetBuildSummaryLink(artifact, config);
ArtifactDefinitionUrl = LinkHelper.GetBuildDefinitionLink(artifact, config);
}
/// <summary>
/// Supply the instance document to be validated, in the form of an XmlReader.
/// </summary>
/// <remarks>
/// The XmlReader is responsible for parsing the document; this method validates it.
/// </remarks>
/// <param name="reader">The <c>XmlReader</c> used to read and parse the instance
/// document being validated. This is used as supplied. For conformance, use of a
/// plain <c>XmlTextReader</c> is discouraged, because it does not expand entity
/// references. This may cause validation failures.
/// </param>
public void SetSource(XmlReader reader)
{
PullProvider pp = new DotNetPullProvider(reader);
PipelineConfiguration pipe = config.makePipelineConfiguration();
pipe.setUseXsiSchemaLocation(useXsiSchemaLocation);
pp.setPipelineConfiguration(pipe);
// pp = new PullTracer(pp); /* diagnostics */
PullSource psource = new PullSource(pp);
psource.setSystemId(reader.BaseURI);
this.source = psource;
}
private static string GetReleaseLinkTab(PipelineConfiguration config, string tab)
{
var collectionUri = config.ServerUri;
var releaseConfig = config as ReleaseConfiguration;
var parameters = GetQueryParameter(new Dictionary <string, object> {
{ "_a", ReleaseEnvironmentExtension },
{ "releaseId", releaseConfig.Id },
{ "environmentId", releaseConfig.EnvironmentId },
{ "extensionId", tab }
});
return(new Uri(GetBaseUri(collectionUri), config.ProjectName + "/" + ReleaseProgressView + parameters).AbsoluteUri);
}
