public override void ExecuteRecursive(TaskExecutionNode node) { //Debugger.Break(); var assemblyProviders = new IAssemblyTaskProvider[] { new MsTestAssemblyTaskProvider(), new NUnitAssemblyTaskProvider(), new XUnitAssemblyTaskProvider() }; var classProviders = new IClassTaskProvider[] { new MsTestClassTaskProvider(), new NUnitClassTaskProvider(), new XUnitClassTaskProvider() }; var methodProviders = new IMethodTaskProvider[] { new MsTestMethodTaskProvider(), new NUnitMethodTaskProvider(), new XUnitMethodTaskProvider() }; var taskEnvironment = new TaskEnvironment(Server, assemblyProviders, classProviders, methodProviders); var taskNode = new TaskNode(node, taskEnvironment); foreach (var silverlightTaskNode in taskNode.GetSilverlightTasks()) { silverlightTaskNode.Execute(Execute); } }
protected void SetupTasks(TaskEnvironment environment, IList <ITask> target, XElement config) { if (null == config) { return; } foreach (var element in config.Elements()) { var name = element.Name.LocalName; if (name == "before" || name == "after" || name == "fallback" || name == "project") { continue; } if (null == TaskFactory) { throw new Exception("no task factory configured"); } var task = TaskFactory.Create(environment, element); if (null != task) { target.Add(task); task.Initialize(environment, this, element); } } }
private void ProcessTargets(TaskEnvironment env) { var targets = env.Config.Elements("target").ToDictionary(_ => _.Attr("code"), _ => _); foreach (var target in env.Targets) { ProcessTarget(env, targets, target, new List <string>()); } }
public void Execute(TaskEnvironment env) { env.Log.Debug("> project " + env.Config.Attr("code")); SetupEnvironment(env); ProcessSubprojects(env, "before", env.Config); ProcessTargets(env); ProcessSubprojects(env, "after", env.Config); env.Log.Debug("< project " + env.Config.Attr("code")); }
public int Execute(TaskConsoleParameters args) { var context = BSharpCompiler.CompileDirectory(args.ScriptDirectory, new BSharpConfig { Global = new Scope(args.Global), KeepLexInfo = true }); var cls = context[args.ScriptClass]; if (null == cls) { throw new Exception("cannot find class " + args.ScriptClass); } var container = ContainerFactory.CreateDefault(); container.RegisterAssembly(typeof(TaskProcess).Assembly); var configProvider = new GenericConfiguration(cls.Compiled, context) { Custom = args }; container.Set <IConfigProvider>(configProvider); Loggy.Manager = container.Get <ILoggyManager>(); var defloggy = Loggy.Manager.Get(); defloggy.Level = args.LogLevel; var consoleAppender = defloggy.Appenders.OfType <ConsoleAppender>().FirstOrDefault(); if (null == consoleAppender) { defloggy.Appenders.Add(new ConsoleAppender { Format = args.LogFormat, Level = args.LogLevel, Manager = Loggy.Manager }); } else { consoleAppender.Format = args.LogFormat; consoleAppender.Level = args.LogLevel; } var loggy = Loggy.Manager.Get("bcinst"); var installRequest = new TaskEnvironment { Config = cls.Compiled, Context = context, Log = loggy, Globals = new Scope(args.Global), Targets = args.Targets.ToArray() }; var processor = container.Get <ITaskProcessor>(); processor.Execute(installRequest); return(0); }
public ITask Create(TaskEnvironment environment, XElement definition) { foreach (var taskSource in Extensions) { var task = taskSource.Create(environment, definition); if (null != task) { return(task); } } return(null); }
private void ExecuteSilverlightTasks(TaskExecutionNode node) { var assemblyTaskProviders = UnitTestTaskProviderFactory.GetAssemblyTaskProviders(); var classTaskProviders = UnitTestTaskProviderFactory.GetClassTaskProviders(); var methodTaskProviders = UnitTestTaskProviderFactory.GetMethodTaskProviders(); var taskEnvironment = new TaskEnvironment(Server, assemblyTaskProviders, classTaskProviders, methodTaskProviders); var taskNode = new TaskNode(node, taskEnvironment); foreach (var silverlightTaskNode in taskNode.GetSilverlightTasks()) { silverlightTaskNode.Execute(Execute); } }
public override void ExecuteRecursive(TaskExecutionNode node) { //Debugger.Break(); var assemblyTaskProviders = UnitTestTaskProviderFactory.GetAssemblyTaskProviders(); var classTaskProviders = UnitTestTaskProviderFactory.GetClassTaskProviders(); var methodTaskProviders = UnitTestTaskProviderFactory.GetMethodTaskProviders(); var taskEnvironment = new TaskEnvironment(Server, assemblyTaskProviders, classTaskProviders, methodTaskProviders); var taskNode = new TaskNode(node, taskEnvironment); foreach (var silverlightTaskNode in taskNode.GetSilverlightTasks()) { silverlightTaskNode.Execute(Execute); } }
private void ProcessTarget(TaskEnvironment env, XElement target) { var iocname = target.Attr("component"); if (string.IsNullOrWhiteSpace(iocname)) { iocname = "qorpent.tasks.compound"; } var task = env.Container.Get <ITask>(iocname); task.Initialize(env, null, target); var scope = new Scope(env.Globals); ProcessSubprojects(env, "before", target); task.Execute(scope); ProcessSubprojects(env, "after", target); }
public override void Initialize(TaskEnvironment environment, ITask parent, XElement config) { base.Initialize(environment, parent, config); var libname = config.Attr("code"); if (environment.LibNameCache.Contains(libname)) { L.Trace("lib " + libname + " already in cache"); } else { environment.Container.RegisterAssembly(Assembly.Load(libname)); var factory = environment.Container.Get <ITaskFactory>(); factory.UpdateSourceList(); L.Trace("lib " + libname + " registered in Container"); } }
public virtual void Initialize(TaskEnvironment environment, ITask parent, XElement config) { Environment = environment; TaskFactory = TaskFactory ?? environment.Container.Get <ITaskFactory>(); Parent = parent; Config = config; L = Environment.Log; ErrorLevel = config.Attr("errorlevel", "Error").To <LogLevel>(); Condition = config.Attr("condition"); TaskScope = config.Attr("scope").To <TaskScope>(); var name = config.Attr("name"); if (!string.IsNullOrWhiteSpace(name)) { Name = name; } if (config.Attr("async").ToBool()) { Flags |= TaskFlags.Async; } SetupTasks(environment, Before, config.Element("before")); SetupTasks(environment, After, config.Element("after")); SetupTasks(environment, Fallback, config.Element("fallback")); TaskCode = config.Attr("code"); TaskName = config.Attr("name"); var current = config; while (true) { if (null == current) { break; } foreach (var a in current.Attributes()) { if (!PlainConfig.ContainsKey(a.Name.LocalName)) { PlainConfig[a.Name.LocalName] = a.Value; } } current = current.Parent; } }
private void SetupEnvironment(TaskEnvironment request) { request.Container = request.Container ?? Container; foreach (var element in request.Config.Elements("lib")) { var libname = element.AttrOrValue("code"); if (!request.LibNameCache.Contains(libname)) { request.Container.RegisterAssembly(Assembly.Load(libname)); request.LibNameCache.Add(libname); } } if (null == request.Targets || 0 == request.Targets.Length) { request.Targets = new[] { "default" }; } }
public ITask Create(TaskEnvironment environment, XElement definition) { if (definition.Name.LocalName == "task") { var name = definition.Attr("code"); if (string.IsNullOrWhiteSpace(name)) { throw new Exception("invalid generic task - no code"); } var gt = ResolveService <ITask>(name); if (null == gt) { throw new Exception("no configured task with name " + name); } return(gt); } else { var name = "qorpent.tasks." + definition.Name.LocalName.ToLowerInvariant() + ".task"; var deft = ResolveService <ITask>(name); return(deft); } }
private void ProcessTarget(TaskEnvironment env, Dictionary <string, XElement> targets, string targetName, List <string> visited) { if (visited.Contains(targetName)) { return; } visited.Add(targetName); env.Log.Debug(">> target '" + targetName + "'"); if (!targets.ContainsKey(targetName)) { throw new Exception("Cannot find target '" + targetName + "' in project '" + env.Config.Attr("code") + "'"); } var target = targets[targetName]; var pretargets = target.Attr("targets").SmartSplit(false, true, ',', ';', ' '); foreach (var pretarget in pretargets) { ProcessTarget(env, targets, pretarget, visited); } ProcessTarget(env, target); env.Log.Debug("<< target " + targetName); }
private void ProcessSubprojects(TaskEnvironment request, string mode, XElement root) { var requirements = request.Config.Elements("project") .Where( _ => _.Attr("mode") == mode || (mode == "before" && string.IsNullOrWhiteSpace(_.Attr("mode")))); foreach (var requirement in requirements) { var clsname = requirement.Attr("code"); var cls = request.Context[clsname]; if (null == clsname) { throw new Exception("cannot find required subproject " + cls); } var targets = requirement.Attr("targets"); var subenvironment = request.Copy(); if (!string.IsNullOrWhiteSpace(targets)) { subenvironment.Targets = targets.SmartSplit(false, true, ',', ';', ' ').ToArray(); } Execute(subenvironment); } }
public override void Initialize(TaskEnvironment environment, ITask parent, XElement config) { base.Initialize(environment, parent, config); ConnectionName = config.Attr("connection", "default"); Database = config.Attr("database"); }
public override void Initialize(TaskEnvironment environment, ITask parent, XElement config) { base.Initialize(environment, parent, config); CommandText = config.AttrOrValue("script"); }
public override void Initialize(TaskEnvironment environment, ITask parent, XElement config) { base.Initialize(environment, parent, config); this.Directory = config.ChooseAttr("dir", "directory"); }
public override void Initialize(TaskEnvironment environment, ITask parent, XElement config) { base.Initialize(environment, parent, config); SetupTasks(environment, Main, config); }
public override void Initialize(TaskEnvironment environment, ITask parent, XElement config) { base.Initialize(environment, parent, config); Message = config.AttrOrValue("message"); Level = config.Attr("level", "warn").To <LogLevel>(); }
public override void Initialize(TaskEnvironment environment, ITask parent, XElement config) { base.Initialize(environment, parent, config); this.DirectoryToCreate = config.Attr("code"); }