/// <summary>
/// Load configuration from string. Used by automated tests.
/// </summary>
/// <param name="content">Configuration data to parse</param>
/// <param name="logger">Logging object</param>
/// <returns>An instance of <see cref="TFSAggregatorSettings"/> or null</returns>
public static TFSAggregatorSettings LoadXml(string content, ILogEvents logger)
{
// conventional point in time reference
DateTime staticTimestamp = new DateTime(0, DateTimeKind.Utc);
var parser = new AggregatorSettingsXmlParser(logger);
return parser.Parse(staticTimestamp, (xmlLoadOptions) => XDocument.Parse(content, xmlLoadOptions));
}
/// <summary>
/// Parse the specified <see cref="XDocument"/> to build a <see cref="TFSAggregatorSettings"/> instance.
/// </summary>
/// <param name="lastWriteTime">Last teime the document has been changed.</param>
/// <param name="load">A lambda returning the <see cref="XDocument"/> to parse.</param>
/// <returns></returns>
public static TFSAggregatorSettings Load(DateTime lastWriteTime, Func<LoadOptions, XDocument> load, ILogEvents logger)
{
var instance = new TFSAggregatorSettings();
LoadOptions xmlLoadOptions = LoadOptions.PreserveWhitespace | LoadOptions.SetBaseUri | LoadOptions.SetLineInfo;
XDocument doc = load(xmlLoadOptions);
instance.Hash = ComputeHash(doc, lastWriteTime);
if (!ValidateDocAgainstSchema(doc, logger))
{
// HACK we must handle this scenario with clean exit
return null;
}
// XML Schema has done lot of checking and set defaults, no need to recheck later, just manage missing pieces
ParseRuntimeSection(instance, doc);
Dictionary<string, Rule> rules = ParseRulesSection(instance, doc);
var ruleInUse = rules.Keys.ToDictionary(ruleName => ruleName, ruleName => false);
List<Policy> policies = ParsePoliciesSection(doc, rules, ruleInUse);
instance.Policies = policies;
// checks
foreach (var unusedRule in ruleInUse.Where(kv => kv.Value == false))
{
logger.UnreferencedRule(unusedRule.Key);
}
return instance;
}
public FilteredLogger(ILogEvents logger, IEnumerable <LogLevel> allowedLogLevels, ErrorBehaviourOptions individualLogEntryErrorBehaviour)
{
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
if (allowedLogLevels == null)
{
throw new ArgumentNullException(nameof(allowedLogLevels));
}
if ((individualLogEntryErrorBehaviour != ErrorBehaviourOptions.Ignore) && (individualLogEntryErrorBehaviour != ErrorBehaviourOptions.ThrowException))
{
// Note: Explicitly check for all valid values rather than using Enum.IsDefined since IsDefined uses reflection and logging should be as cheap as possible
// (so reflection is best avoided)
throw new ArgumentOutOfRangeException(nameof(individualLogEntryErrorBehaviour));
}
IndividualLogEntryErrorBehaviour = individualLogEntryErrorBehaviour;
_logger = logger;
AllowedLogLevels = allowedLogLevels.ToList().AsReadOnly();
foreach (var allowedLogLevel in AllowedLogLevels)
{
if ((allowedLogLevel != LogLevel.Debug) && (allowedLogLevel != LogLevel.Info) && (allowedLogLevel != LogLevel.Warning) && (allowedLogLevel != LogLevel.Error))
{
throw new ArgumentException("Invalid LogLevel value specified");
}
}
}
public WorkItemRepository(Uri tfsCollectionUri, IdentityDescriptor toImpersonate, IRuntimeContext context)
{
this.logger = context.Logger;
this.context = context;
this.tfs = new TfsTeamProjectCollection(tfsCollectionUri, toImpersonate);
this.workItemStore = this.tfs.GetService <WorkItemStore>();
}
public static TFSAggregatorSettings LoadXml(string content, ILogEvents logger)
{
// conventional point in time reference
DateTime staticTime = new DateTime(0, DateTimeKind.Utc);
return(LoadXml(content, staticTime, logger));
}
public DotLessCssCssLoader(
ITextFileLoader contentLoader,
InsertedMarkerRetriever markerIdRetriever,
string optionalTagNameToRemove,
ErrorBehaviourOptions reportedErrorBehaviour,
ILogEvents logger)
{
if (contentLoader == null)
{
throw new ArgumentNullException("contentLoader");
}
if (markerIdRetriever == null)
{
throw new ArgumentNullException("markerIdRetriever");
}
if (!Enum.IsDefined(typeof(ErrorBehaviourOptions), reportedErrorBehaviour))
{
throw new ArgumentOutOfRangeException("reportedErrorBehaviour");
}
if (logger == null)
{
throw new ArgumentNullException("logger");
}
_contentLoader = contentLoader;
_markerIdRetriever = markerIdRetriever;
_optionalTagNameToRemove = optionalTagNameToRemove;
_reportedErrorBehaviour = reportedErrorBehaviour;
_logger = logger;
}
public ScriptLibrary(IRuntimeContext context)
{
this.connectionInfo = context.GetConnectionInfo();
this.requestContext = context.RequestContext;
this.logger = context.Logger;
this.mailer = new Mailer(context.RequestContext.VssContext);
}
public static TFSAggregatorSettings LoadFromFile(string settingsPath, ILogEvents logger)
{
DateTime lastWriteTime
= System.IO.File.GetLastWriteTimeUtc(settingsPath);
return(Load(lastWriteTime, (xmlLoadOptions) => XDocument.Load(settingsPath, xmlLoadOptions), logger));
}
public WorkItemLinkCollectionWrapper(WorkItemLinkCollection workItemLinkCollection, IRuntimeContext context)
{
this.logger = context.Logger;
this.workItemLinkCollection = workItemLinkCollection;
this.store = context.WorkItemRepository;
this.context = context;
}
public DefaultNonCachedLessCssLoaderFactory(
ITextFileLoader contentLoader,
SourceMappingMarkerInjectionOptions sourceMappingMarkerInjection,
ErrorBehaviourOptions errorBehaviour,
ILogEvents logger)
{
if (contentLoader == null)
{
throw new ArgumentNullException("contentLoader");
}
if (!Enum.IsDefined(typeof(SourceMappingMarkerInjectionOptions), sourceMappingMarkerInjection))
{
throw new ArgumentOutOfRangeException("sourceMappingMarkerInjection");
}
if (!Enum.IsDefined(typeof(ErrorBehaviourOptions), errorBehaviour))
{
throw new ArgumentOutOfRangeException("lineNumberInjectionBehaviour");
}
if (logger == null)
{
throw new ArgumentNullException("logger");
}
_contentLoader = contentLoader;
_sourceMappingMarkerInjection = sourceMappingMarkerInjection;
_errorBehaviour = errorBehaviour;
_logger = logger;
}
/// <summary>
/// Load configuration from file. Main scenario.
/// </summary>
/// <param name="settingsPath">Path to policies file</param>
/// <param name="logger">Logging object</param>
/// <returns>An instance of <see cref="TFSAggregatorSettings"/> or null</returns>
public static TFSAggregatorSettings LoadFromFile(string settingsPath, ILogEvents logger)
{
DateTime lastWriteTime
= System.IO.File.GetLastWriteTimeUtc(settingsPath);
var parser = new AggregatorSettingsXmlParser(logger);
return parser.Parse(lastWriteTime, (xmlLoadOptions) => XDocument.Load(settingsPath, xmlLoadOptions));
}
public SameFolderImportFlatteningCssLoader(
ITextFileLoader contentLoader,
ContentLoaderCommentRemovalBehaviourOptions contentLoaderCommentRemovalBehaviour,
ErrorBehaviourOptions circularReferenceImportBehaviour,
ErrorBehaviourOptions unsupportedImportBehaviour,
ILogEvents logger)
{
if (contentLoader == null)
{
throw new ArgumentNullException("contentLoader");
}
if (!Enum.IsDefined(typeof(ContentLoaderCommentRemovalBehaviourOptions), contentLoaderCommentRemovalBehaviour))
{
throw new ArgumentOutOfRangeException("contentLoaderCommentRemovalBehaviour");
}
if (!Enum.IsDefined(typeof(ErrorBehaviourOptions), circularReferenceImportBehaviour))
{
throw new ArgumentOutOfRangeException("circularReferenceImportBehaviour");
}
if (!Enum.IsDefined(typeof(ErrorBehaviourOptions), unsupportedImportBehaviour))
{
throw new ArgumentOutOfRangeException("unsupportedImportBehaviour");
}
if (logger == null)
{
throw new ArgumentNullException("logger");
}
_contentLoader = contentLoader;
_contentLoaderCommentRemovalBehaviour = contentLoaderCommentRemovalBehaviour;
_circularReferenceImportBehaviour = circularReferenceImportBehaviour;
_unsupportedImportBehaviour = unsupportedImportBehaviour;
_logger = logger;
}
public ErrorWithBackTrackLogger(ILogEvents logger) : this(
logger,
Defaults.MaximumNumberOfHistoricalMessagesToMaintain,
Defaults.MaximumNumberOfHistoricalMessagesToIncludeWithAnErrorEntry,
Defaults.HistoryLoggingBehaviourOptions,
Defaults.IndividualLogEntryErrorBehaviour)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="EventProcessor"/> class.
/// </summary>
public EventProcessor(IWorkItemRepository workItemStore, IRuntimeContext runtime)
{
this.logger = runtime.Logger;
this.store = workItemStore;
this.settings = runtime.Settings;
this.engine = runtime.GetEngine(workItemStore);
}
/// <summary>
/// Initializes a new instance of the <see cref="EventProcessor"/> class.
/// </summary>
public EventProcessor(IWorkItemRepository workItemStore, IRuntimeContext runtime)
{
this.logger = runtime.Logger;
this.store = workItemStore;
this.settings = runtime.Settings;
this.engine = runtime.GetEngine(workItemStore);
}
/// <summary>
/// Wrap logging request in a try..catch and swallow any exception - this is an extension method that guarantees the exception will be caught, regardless
/// of the logger implementation
/// </summary>
public static void LogIgnoringAnyError(this ILogEvents logger, LogLevel logLevel, Func <string> contentGenerator, Exception exception)
{
try
{
logger.Log(logLevel, DateTime.Now, contentGenerator, exception);
}
catch { }
}
public DefaultNonCachedLessCssLoaderFactory(
IRelativePathMapper pathMapper,
SourceMappingMarkerInjectionOptions sourceMappingMarkerInjection,
ErrorBehaviourOptions errorBehaviour,
ILogEvents logger)
: this(new SimpleTextFileContentLoader(pathMapper), sourceMappingMarkerInjection, errorBehaviour, logger)
{
}
public ThrottlingLogger(ILogEvents logger) : this(
logger,
Defaults.MimimumFrequency,
Defaults.MaximumNumberOfBufferedItems,
Defaults.MessageEvaluationBehaviour,
Defaults.IndividualLogEntryErrorBehaviour)
{
}
internal static ScriptEngine MakeEngine(string scriptLanguage, IWorkItemRepository workItemRepository, ILogEvents logger, bool debug)
{
logger.BuildingScriptEngine(scriptLanguage);
Type t = GetScriptEngineType(scriptLanguage);
var ctor = t.GetConstructor(new Type[] { typeof(IWorkItemRepository), typeof(ILogEvents), typeof(bool) });
ScriptEngine engine = ctor.Invoke(new object[] { workItemRepository, logger, debug }) as ScriptEngine;
return engine;
}
/// <summary>
/// Load configuration from file. Main scenario.
/// </summary>
/// <param name="settingsPath">Path to policies file</param>
/// <param name="logger">Logging object</param>
/// <returns>An instance of <see cref="TFSAggregatorSettings"/> or null</returns>
public static TFSAggregatorSettings LoadFromFile(string settingsPath, ILogEvents logger)
{
DateTime lastWriteTime
= System.IO.File.GetLastWriteTimeUtc(settingsPath);
var parser = new AggregatorSettingsXmlParser(logger);
return(parser.Parse(lastWriteTime, (xmlLoadOptions) => XDocument.Load(settingsPath, xmlLoadOptions)));
}
/// <summary>
/// Load configuration from string. Used by automated tests.
/// </summary>
/// <param name="content">Configuration data to parse</param>
/// <param name="logger">Logging object</param>
/// <returns>An instance of <see cref="TFSAggregatorSettings"/> or null</returns>
public static TFSAggregatorSettings LoadXml(string content, ILogEvents logger)
{
// conventional point in time reference
DateTime staticTimestamp = new DateTime(0, DateTimeKind.Utc);
var parser = new AggregatorSettingsXmlParser(logger);
return(parser.Parse(staticTimestamp, (xmlLoadOptions) => XDocument.Parse(content, xmlLoadOptions)));
}
/// <summary>
/// Initializes a new instance of the <see cref="EventProcessor"/> class.
/// </summary>
public EventProcessor(IRuntimeContext runtime)
{
this.logger = runtime.Logger;
this.settings = runtime.Settings;
this.limiter = runtime.RateLimiter;
this.store = runtime.GetWorkItemRepository();
this.engine = runtime.GetEngine();
}
internal static ScriptEngine MakeEngine(string scriptLanguage, ILogEvents logger, bool debug)
{
logger.BuildingScriptEngine(scriptLanguage);
Type t = GetScriptEngineType(scriptLanguage);
var ctor = t.GetConstructor(new Type[] { typeof(ILogEvents), typeof(bool) });
ScriptEngine engine = ctor.Invoke(new object[] { logger, debug }) as ScriptEngine;
return(engine);
}
public static void Log(this ILogEvents logger, LogLevel logLevel, DateTime logDate, int managedThreadId, Func <string> contentGenerator, Exception exception)
{
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
logger.Log(new LogEventDetails(logLevel, logDate, managedThreadId, contentGenerator, exception));
}
/// <summary>
/// Initializes a new instance of the <see cref="EventProcessor"/> class.
/// </summary>
public EventProcessor(IRuntimeContext runtime)
{
this.logger = runtime.Logger;
this.settings = runtime.Settings;
this.limiter = runtime.RateLimiter;
this.store = runtime.WorkItemRepository;
this.engine = runtime.GetEngine();
}
public static void TransitionToState(IWorkItem workItem, string state, string commentPrefix, ILogEvents logger)
{
// Set the sourceWorkItem's state so that it is clear that it has been moved.
string originalState = (string)workItem.Fields["State"].Value;
// Try to set the state of the source work item to the "Deleted/Moved" state (whatever is defined in the file).
// We need an open work item to set the state
workItem.TryOpen();
// See if we can go directly to the planned state.
workItem.Fields["State"].Value = state;
if (workItem.Fields["State"].Status != FieldStatus.Valid)
{
// Revert back to the original value and start searching for a way to our "MovedState"
workItem.Fields["State"].Value = workItem.Fields["State"].OriginalValue;
// If we can't then try to go from the current state to another state. Saving each time till we get to where we are going.
foreach (string curState in FindNextState(workItem.Type, (string)workItem.Fields["State"].Value, state))
{
string comment;
if (curState == state)
{
comment = string.Format(
"{0}{1} State changed to {2}",
commentPrefix,
Environment.NewLine,
state);
}
else
{
comment = string.Format(
"{0}{1} State changed to {2} as part of move toward a state of {3}",
commentPrefix,
Environment.NewLine,
curState,
state);
}
bool success = ChangeWorkItemState(workItem, originalState, curState, comment, logger);
// If we could not do the incremental state change then we are done. We will have to go back to the original...
if (!success)
{
break;
}
}
}
else
{
// Just save it off if we can.
string comment = commentPrefix + "\n State changed to " + state;
ChangeWorkItemState(workItem, originalState, state, comment, logger);
}
}
public WorkItemRepository(IRuntimeContext context)
{
this.logger = context.Logger;
this.context = context;
var ci = context.GetConnectionInfo();
this.logger.Connecting(ci);
this.tfs = new TfsTeamProjectCollection(ci.ProjectCollectionUri, ci.Impersonate);
this.workItemStore = this.tfs.GetService <WorkItemStore>();
}
public MailPicker(ILogEvents logger, string hostname, int port, bool useSsl, string username, string password, string tempFolder)
{
this.logger = logger;
this.hostname = hostname;
this.port = port;
this.useSsl = useSsl;
this.username = username;
this.password = password;
this.tempFolder = tempFolder;
}
public AsyncLogger(ILogEvents logger)
: base(
logger,
TimeSpan.FromMilliseconds(500), // Minimum off-loading frequency
5, // Maximum buffer size
ThrottlingLogger.Defaults.MessageEvaluationBehaviour,
ThrottlingLogger.Defaults.IndividualLogEntryErrorBehaviour
)
{
}
public WorkItemRepository(IRuntimeContext context)
{
this.logger = context.Logger;
this.context = context;
var ci = context.GetConnectionInfo();
this.logger.Connecting(ci);
this.tfs = ci.Token.GetCollection(ci.ProjectCollectionUri);
this.tfs.Authenticate();
this.workItemStore = this.tfs.GetService <WorkItemStore>();
}
/// <summary>
/// Wrap logging request in a try..catch and swallow any exception - this is an extension method that guarantees the exception will be caught, regardless
/// of the logger implementation
/// </summary>
public static void LogIgnoringAnyError(this ILogEvents logger, LogLevel logLevel, string content, Exception exception = null)
{
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
try
{
logger.Log(new LogEventDetails(logLevel, DateTime.Now, Thread.CurrentThread.ManagedThreadId, content, exception));
}
catch { }
}
public DotLessCssPassThroughLogger(ILogEvents logger, ErrorBehaviourOptions reportedErrorBehaviour)
{
if (logger == null)
{
throw new ArgumentNullException("logger");
}
if (!Enum.IsDefined(typeof(ErrorBehaviourOptions), reportedErrorBehaviour))
{
throw new ArgumentOutOfRangeException("reportedErrorBehaviour");
}
_logger = logger;
_reportedErrorBehaviour = reportedErrorBehaviour;
}
private static bool ValidateDocAgainstSchema(XDocument doc, ILogEvents logger)
{
XmlSchemaSet schemas = new XmlSchemaSet();
var thisAssembly = Assembly.GetAssembly(typeof(TFSAggregatorSettings));
var stream = thisAssembly.GetManifestResourceStream("Aggregator.Core.Configuration.AggregatorConfiguration.xsd");
schemas.Add(string.Empty, XmlReader.Create(stream));
bool valid = true;
doc.Validate(schemas, (o, e) =>
{
logger.InvalidConfiguration(e.Severity, e.Message, e.Exception.LineNumber, e.Exception.LinePosition);
valid = false;
}, true);
return(valid);
}
public ThrottlingLogger(
ILogEvents logger,
TimeSpan mimimumFrequency,
int maximumNumberOfBufferedItems,
MessageEvaluationBehaviourOptions messageEvaluationBehaviour,
ErrorBehaviourOptions individualLogEntryErrorBehaviour)
{
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
if (mimimumFrequency.Ticks <= 0)
{
throw new ArgumentOutOfRangeException(nameof(mimimumFrequency), "must be a positive duration");
}
if (maximumNumberOfBufferedItems <= 0)
{
throw new ArgumentOutOfRangeException(nameof(maximumNumberOfBufferedItems), "must be a positive value");
}
if ((messageEvaluationBehaviour != MessageEvaluationBehaviourOptions.EvaluateWhenLogged) && (messageEvaluationBehaviour != MessageEvaluationBehaviourOptions.EvaluateWhenQueued))
{
// Note: Explicitly check for all valid values rather than using Enum.IsDefined since IsDefined uses reflection and logging should be as cheap as possible
// (so reflection is best avoided)
throw new ArgumentOutOfRangeException(nameof(messageEvaluationBehaviour));
}
if ((individualLogEntryErrorBehaviour != ErrorBehaviourOptions.Ignore) && (individualLogEntryErrorBehaviour != ErrorBehaviourOptions.ThrowException))
{
// Note: Explicitly check for all valid values rather than using Enum.IsDefined since IsDefined uses reflection and logging should be as cheap as possible
// (so reflection is best avoided)
throw new ArgumentOutOfRangeException(nameof(individualLogEntryErrorBehaviour));
}
MaximumNumberOfBufferedItems = maximumNumberOfBufferedItems;
MinimumFrequency = mimimumFrequency;
MessageEvaluationBehaviour = messageEvaluationBehaviour;
IndividualLogEntryErrorBehaviour = individualLogEntryErrorBehaviour;
_logger = logger;
_messages = new ConcurrentQueue <LogEventDetails>();
_timer = new PauseableTimer(
mimimumFrequency,
FlushQueueIfNotAlreadyDoingSo
);
_lastFlushedAt = null;
_flushInProgressIndicator = 0;
}
/// <summary>
/// Return a proper context
/// </summary>
/// <returns></returns>
public static RuntimeContext GetContext(
Func <string> settingsPathGetter,
IRequestContext requestContext,
ILogEvents logger,
Func <IRuntimeContext, IWorkItemRepository> repoBuilder,
Func <IRuntimeContext, IScriptLibrary> scriptLibraryBuilder)
{
string settingsPath = settingsPathGetter();
string cacheKey = CacheKey + settingsPath;
var runtime = (RuntimeContext)Cache.Get(cacheKey);
if (runtime == null)
{
logger.HelloWorld();
logger.LoadingConfiguration(settingsPath);
var settings = TFSAggregatorSettings.LoadFromFile(settingsPath, logger);
runtime = MakeRuntimeContext(settingsPath, settings, requestContext, logger, repoBuilder, scriptLibraryBuilder);
if (!runtime.HasErrors)
{
var itemPolicy = new CacheItemPolicy();
itemPolicy.Priority = CacheItemPriority.NotRemovable;
itemPolicy.ChangeMonitors.Add(new HostFileChangeMonitor(new List <string>()
{
settingsPath
}));
Cache.Set(cacheKey, runtime, itemPolicy);
}
logger.ConfigurationLoaded(settingsPath);
}
else
{
logger.UsingCachedConfiguration(settingsPath);
}
runtime = runtime.Clone() as RuntimeContext;
// as it changes at each invocation, must be set again here
runtime.RequestContext = requestContext;
runtime.workItemRepository = null;
return(runtime);
}
public static RuntimeContext MakeRuntimeContext(
string settingsPath,
TFSAggregatorSettings settings,
IRequestContext requestContext,
ILogEvents logger,
Func <Uri, Microsoft.TeamFoundation.Framework.Client.IdentityDescriptor, IRuntimeContext, IWorkItemRepository> repoBuilder)
{
var runtime = new RuntimeContext();
runtime.Logger = logger;
runtime.RequestContext = requestContext;
runtime.SettingsPath = settingsPath;
runtime.Settings = settings;
runtime.RateLimiter = new RateLimiter(runtime);
logger.MinimumLogLevel = runtime.Settings?.LogLevel ?? LogLevel.Normal;
runtime.repoBuilder = repoBuilder;
runtime.HasErrors = settings == null;
return(runtime);
}
/// <summary>
/// Wrap logging request in a try..catch and swallow any exception - this is an extension method that guarantees the exception will be caught, regardless
/// of the logger implementation.
/// </summary>
public static void LogIgnoringAnyError(this ILogEvents logger, Exception error)
{
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
// If there's no error then there's nothing to log, but this method is not supposed to throw an error when operating against a logger
// implementation (which is why the ArgumentNullException above is acceptable) so if error is null then do nothing
if (error == null)
{
return;
}
try
{
logger.Log(new LogEventDetails(LogLevel.Error, DateTime.Now, Thread.CurrentThread.ManagedThreadId, "", error));
}
catch { }
}
public static RuntimeContext MakeRuntimeContext(
string settingsPath,
TFSAggregatorSettings settings,
IRequestContext requestContext,
ILogEvents logger,
Func<Uri, Microsoft.TeamFoundation.Framework.Client.IdentityDescriptor, ILogEvents, IWorkItemRepository> repoBuilder)
{
var runtime = new RuntimeContext();
runtime.Logger = logger;
runtime.RequestContext = requestContext;
runtime.SettingsPath = settingsPath;
runtime.Settings = settings;
runtime.RateLimiter = new RateLimiter(runtime);
logger.MinimumLogLevel = runtime.Settings?.LogLevel ?? LogLevel.Normal;
runtime.repoBuilder = repoBuilder;
runtime.HasErrors = settings == null;
return runtime;
}
/// <summary>
/// Return a proper context
/// </summary>
/// <returns></returns>
public static RuntimeContext GetContext(
Func<string> settingsPathGetter,
IRequestContext requestContext,
ILogEvents logger,
Func<Uri, Microsoft.TeamFoundation.Framework.Client.IdentityDescriptor, ILogEvents, IWorkItemRepository> repoBuilder)
{
string settingsPath = settingsPathGetter();
string cacheKey = CacheKey + settingsPath;
var runtime = (RuntimeContext)Cache.Get(cacheKey);
if (runtime == null)
{
logger.HelloWorld();
logger.LoadingConfiguration(settingsPath);
var settings = TFSAggregatorSettings.LoadFromFile(settingsPath, logger);
runtime = MakeRuntimeContext(settingsPath, settings, requestContext, logger, repoBuilder);
if (!runtime.HasErrors)
{
var itemPolicy = new CacheItemPolicy();
itemPolicy.Priority = CacheItemPriority.NotRemovable;
itemPolicy.ChangeMonitors.Add(new HostFileChangeMonitor(new List<string>() { settingsPath }));
Cache.Set(cacheKey, runtime, itemPolicy);
}
logger.ConfigurationLoaded(settingsPath);
}
else
{
logger.UsingCachedConfiguration(settingsPath);
// as it changes at each invocation, must be set again here
runtime.RequestContext = requestContext;
}
return runtime.Clone() as RuntimeContext;
}
public ScriptEngine(IWorkItemRepository store, ILogEvents logger, bool debug)
{
this.Logger = logger;
this.Store = store;
this.Debug = debug;
}
public WorkItemRepository(string tfsCollectionUrl, IdentityDescriptor toImpersonate, ILogEvents logger)
{
this.logger = logger;
this.tfsCollectionUrl = tfsCollectionUrl;
this.toImpersonate = toImpersonate;
}
public WorkItemLinkCollectionWrapper(WorkItemLinkCollection workItemLinkCollection, IWorkItemRepository store, ILogEvents logger)
{
this.logger = logger;
this.workItemLinkCollection = workItemLinkCollection;
this.store = store;
}
private static bool ValidateDocAgainstSchema(XDocument doc, ILogEvents logger)
{
XmlSchemaSet schemas = new XmlSchemaSet();
var thisAssembly = Assembly.GetAssembly(typeof(TFSAggregatorSettings));
var stream = thisAssembly.GetManifestResourceStream("Aggregator.Core.Configuration.AggregatorConfiguration.xsd");
schemas.Add(string.Empty, XmlReader.Create(stream));
bool valid = true;
doc.Validate(schemas, (o, e) =>
{
logger.InvalidConfiguration(e.Severity, e.Message, e.Exception.LineNumber, e.Exception.LinePosition);
valid = false;
}, true);
return valid;
}
public static RuntimeContext MakeRuntimeContext(string settingsPath, TFSAggregatorSettings settings, IRequestContext requestContext, ILogEvents logger)
{
var runtime = new RuntimeContext();
runtime.Logger = logger;
runtime.RequestContext = requestContext;
runtime.SettingsPath = settingsPath;
runtime.Settings = settings;
logger.MinimumLogLevel = runtime.Settings.LogLevel;
runtime.HasErrors = false;
return runtime;
}
public PsScriptEngine(ILogEvents logger, bool debug)
: base(logger, debug)
{
}
public AggregatorSettingsXmlParser(ILogEvents logger)
{
this.logger = logger;
}
public WorkItemLinkWrapper(WorkItemLink link, IWorkItemRepository store, ILogEvents logger)
{
this.logger = logger;
this.link = link;
this.store = store;
}
public WorkItemWrapper(WorkItem workItem, IWorkItemRepository store, ILogEvents logger)
: base(store, logger)
{
this.workItem = workItem;
}
public ScriptEngine(ILogEvents logger, bool debug)
{
this.Logger = logger;
this.Debug = debug;
}
public static TFSAggregatorSettings LoadXml(string content, DateTime timestamp, ILogEvents logger)
{
return Load(timestamp, (xmlLoadOptions) => XDocument.Parse(content, xmlLoadOptions), logger);
}
public RuleLogger(ILogEvents logger)
{
this.logger = logger;
}
public static TFSAggregatorSettings LoadXml(string content, ILogEvents logger)
{
// conventional point in time reference
DateTime staticTime = new DateTime(0, DateTimeKind.Utc);
return LoadXml(content, staticTime, logger);
}
/// <summary>
/// Return a proper context
/// </summary>
/// <returns></returns>
public static RuntimeContext GetContext(Func<string> settingsPathGetter, IRequestContext requestContext, ILogEvents logger)
{
var runtime = (RuntimeContext)Cache.Get(CacheKey);
if (runtime == null)
{
string settingsPath = settingsPathGetter();
var settings = TFSAggregatorSettings.LoadFromFile(settingsPath, logger);
runtime = MakeRuntimeContext(settingsPath, settings, requestContext, logger);
var itemPolicy = new CacheItemPolicy();
itemPolicy.Priority = CacheItemPriority.NotRemovable;
itemPolicy.ChangeMonitors.Add(new HostFileChangeMonitor(new List<string>() { settingsPath }));
Cache.Set(CacheKey, runtime, itemPolicy);
}
else
{
runtime.RequestContext = requestContext;
}
return runtime.Clone() as RuntimeContext;
}
/// <summary>
/// Initializes a new instance of the <see cref="WorkItemImplementationBase"/> class.
/// </summary>
public WorkItemImplementationBase(IWorkItemRepository store, ILogEvents logger)
{
this.Store = store;
this.Logger = logger;
}
public static TFSAggregatorSettings LoadConfigFromResourceFile(string fileName, ILogEvents logger)
{
var configXml = LoadTextFromEmbeddedResource(fileName);
return TFSAggregatorSettings.LoadXml(configXml, logger);
}
public WorkItemRepository(Uri tfsCollectionUri, IdentityDescriptor toImpersonate, ILogEvents logger)
{
this.logger = logger;
this.tfs = new TfsTeamProjectCollection(tfsCollectionUri, toImpersonate);
this.workItemStore = (WorkItemStore)this.tfs.GetService(typeof(WorkItemStore));
}
private static bool ChangeWorkItemState(IWorkItem workItem, string orginalSourceState, string destState, string comment, ILogEvents logger)
{
// Try to save the new state. If that fails then we also go back to the original state.
try
{
workItem.TryOpen();
workItem.Fields["State"].Value = destState;
workItem.History = comment;
logger.AttemptingToMoveWorkItemToState(workItem, orginalSourceState, destState);
if (workItem.IsValid())
{
logger.WorkItemIsValidToSave(workItem);
}
else
{
logger.WorkItemIsInvalidInState(workItem, destState);
}
workItem.Save();
return true;
}
catch (Exception)
{
// Revert back to the original value.
workItem.Fields["State"].Value = orginalSourceState;
return false;
}
}
public PsScriptEngine(IWorkItemRepository store, ILogEvents logger, bool debug)
: base(store, logger, debug)
{
}
