public TaskLogger(Task task) { if (task == null) throw new ArgumentNullException("task"); this.task = task; }
public XnaContentProject(Task task, string msBuildPath, string xnaInstallPath) { m_engine = new Engine(msBuildPath); m_engine.RegisterLogger(new XnaContentLogger(task)); m_project = new Project(m_engine); m_project.AddNewUsingTaskFromAssemblyName("BuildContent", "Microsoft.Xna.Framework.Content.Pipeline, Version=1.0.0.0, Culture=neutral, PublicKeyToken=6d5c3888ef60e27d"); m_project.AddNewUsingTaskFromAssemblyName("BuildXact", "Microsoft.Xna.Framework.Content.Pipeline, Version=1.0.0.0, Culture=neutral, PublicKeyToken=6d5c3888ef60e27d"); // Add our Content Pipeline Assemblies m_pipelineGroup = m_project.AddNewItemGroup(); m_contentGroup = m_project.AddNewItemGroup(); m_contentTarget = m_project.Targets.AddNewTarget("_BuildXNAContentLists"); // Add our Build target m_xnaTarget = m_project.Targets.AddNewTarget("Build"); m_xnaTarget.DependsOnTargets = "_BuildXNAContentLists"; // Add Default Pipeline Assemblies. AddPilepineAssembly(xnaInstallPath + "Microsoft.Xna.Framework.Content.Pipeline.EffectImporter.dll"); AddPilepineAssembly(xnaInstallPath + "Microsoft.Xna.Framework.Content.Pipeline.FBXImporter.dll"); AddPilepineAssembly(xnaInstallPath + "Microsoft.Xna.Framework.Content.Pipeline.TextureImporter.dll"); AddPilepineAssembly(xnaInstallPath + "Microsoft.Xna.Framework.Content.Pipeline.XImporter.dll"); }
protected InstallerCreationCommand(MSIBase msi, NAnt.Core.Task task, Location location, XmlNode node) { this.msi = msi; this.task = task; this.location = location; this.node = node; guidCounter = msi.output.GetHashCode(); }
public NAntRunListener(Task task) { Ensure.ArgumentIsNotNull(task, "task"); _task = task; UpdateNAntProperties(_task.Properties, 0, 0, 0, 0, 0, 0); }
public TeamCityMessageProvider(TeamCityLogWriter writer, Task taskToUseForLogging) { Ensure.ArgumentIsNotNull(writer, "writer"); Ensure.ArgumentIsNotNull(taskToUseForLogging, "taskToUseForLogging"); _writer = writer; _writer.TaskToUseForLogging = taskToUseForLogging; }
public static void RenderReport(ReportResult result, Task task) { Ensure.ArgumentIsNotNull(result, "result"); Ensure.ArgumentIsNotNull(task, "task"); ITeamCityMessageProvider messageProvider = IoC.Resolve<ITeamCityMessageProvider>(new { taskToUseForLogging = task }); TeamCityReportGenerator report = new TeamCityReportGenerator(); report.Render(result, messageProvider); }
public static DefinedTaskContainer Create(Task parent, XmlNode taskNode) { DefinedTaskContainer container = new DefinedTaskContainer(); container.Parent = parent; container.Project = parent.Project; container.NamespaceManager = parent.NamespaceManager; container.XmlNode = taskNode; return container; }
protected override void Before_each_spec() { PropertyDictionary propertyDictionary = Mocks.Stub<PropertyDictionary>((Project) null); _task = Mocks.DynamicMock<Task>(); SetupResult.For(_task.Properties).Return(propertyDictionary); Mocks.Replay(_task); _sut = new NAntRunListener(_task); }
protected override void Before_each_spec() { _specificationInfo = new SpecificationInfo("Spec", "Type"); PropertyDictionary propertyDictionary = Mocks.Stub<PropertyDictionary>((Project) null); _task = Mocks.StrictMock<Task>(); SetupResult.For(_task.Properties).Return(propertyDictionary); Mocks.Replay(_task); _sut = new NAntRunListener(_task); }
protected override void Before_each_spec() { _contextInfo = new ContextInfo("Context", "Concern", "TypeName", "Namespace", "AssemblyName"); PropertyDictionary propertyDictionary = Mocks.Stub<PropertyDictionary>((Project) null); _task = Mocks.DynamicMock<Task>(); SetupResult.For(_task.Properties).Return(propertyDictionary); Mocks.Replay(_task); _sut = new NAntRunListener(_task); }
public MacroDefInvocation(string name, Task task, XmlNode invocationXml, ArrayList attributeList, MacroDefSequential sequential, ArrayList elements) { this.name = name; this.task = task; this.invocationXml = invocationXml; this.attributeList = attributeList; this.sequential = sequential; this.elements = elements; }
private static void RestoreProperties(ArrayList attributeList, Task task, PropertyDictionary oldValues) { PropertyDictionary projectProperties = task.Project.Properties; foreach (MacroAttribute macroAttribute in attributeList) { string localPropertyName = macroAttribute.LocalPropertyName; string oldValue = oldValues[localPropertyName]; if (projectProperties.Contains(localPropertyName)) projectProperties.Remove(localPropertyName); if (oldValue != null) projectProperties.Add(localPropertyName, oldValue); } }
public static void AddNAntListener(Task task) { try { if(task.Verbose) OutputType.Level = TraceLevel.Verbose; } catch { // Happens because NAnt throws an exception! } if(Trace.Listeners["NAnt"] != null) Trace.Listeners.Remove("NAnt"); Trace.Listeners.Add(new NAntTraceListener(task)); }
internal static NAntLogger Create(NAnt.Core.FrameworkInfo framework, Task task, NAntLoggerVerbosity verbosity, NAnt.MSBuild.BuildEngine.Engine engine) { CodeDomProvider codeDomProvider = CodeDomProvider.CreateProvider("C#"); CompilerParameters par = new CompilerParameters(); AssemblyName msbuildFrameworkName = engine.Assembly.GetName(); msbuildFrameworkName.Name = "Microsoft.Build.Framework"; Assembly msbuildFramework = Assembly.Load(msbuildFrameworkName); par.ReferencedAssemblies.Add(msbuildFramework.Location); par.ReferencedAssemblies.Add(typeof(NAnt.Core.Task).Assembly.Location); par.ReferencedAssemblies.Add(typeof(NAntLogger).Assembly.Location); par.GenerateInMemory = true; CompilerResults res = codeDomProvider.CompileAssemblyFromSource(par, _impl); if (res.Errors.HasErrors) { return null; } Type t = res.CompiledAssembly.GetType("NAntLoggerImpl"); return (NAntLogger)Activator.CreateInstance(t, task, verbosity); }
/// <summary> /// Writes a <see cref="Task" /> task level message to the build log /// with the given <see cref="Level" />. /// </summary> /// <param name="task">The <see cref="Task" /> from which the message originated.</param> /// <param name="messageLevel">The <see cref="Level" /> to log at.</param> /// <param name="message">The message to log.</param> public void Log(Task task, Level messageLevel, string message) { BuildEventArgs eventArgs = new BuildEventArgs(task); eventArgs.Message = message; eventArgs.MessageLevel = messageLevel; OnMessageLogged(eventArgs); }
/// <summary> /// Scans a given <see cref="Type" /> for tasks. /// </summary> /// <param name="extensionAssembly">The <see cref="ExtensionAssembly" /> containing the <see cref="Type" /> to scan.</param> /// <param name="type">The <see cref="Type" /> to scan.</param> /// <param name="task">The <see cref="Task" /> which will be used to output messages to the build log.</param> /// <returns> /// <see langword="true" /> if <paramref name="type" /> represents a /// <see cref="Task" />; otherwise, <see langword="false" />. /// </returns> private static bool ScanTypeForTasks(ExtensionAssembly extensionAssembly, Type type, Task task) { try { TaskNameAttribute taskNameAttribute = (TaskNameAttribute) Attribute.GetCustomAttribute(type, typeof(TaskNameAttribute)); if (type.IsSubclassOf(typeof(Task)) && !type.IsAbstract && taskNameAttribute != null) { task.Log(Level.Debug, string.Format(CultureInfo.InvariantCulture, ResourceUtils.GetString("String_CreatingTaskBuilder"), type.Name)); TaskBuilder tb = new TaskBuilder(extensionAssembly, type.FullName); if (TaskBuilders[tb.TaskName] == null) { task.Log(Level.Debug, string.Format(CultureInfo.InvariantCulture, ResourceUtils.GetString("String_AddingTask"), tb.TaskName, GetAssemblyLocation(tb.Assembly), tb.ClassName)); TaskBuilders.Add(tb); } // specified type represents a task return true; } else { // specified type does not represent valid task return false; } } catch { task.Log(Level.Error, "Failure scanning \"{0}\" for tasks.", type.AssemblyQualifiedName); throw; } }
/// <summary> /// Scans a given <see cref="Type" /> for functions. /// </summary> /// <param name="type">The <see cref="Type" /> to scan.</param> /// <param name="task">The <see cref="Task" /> which will be used to output messages to the build log.</param> /// <returns> /// <see langword="true" /> if <paramref name="type" /> represents a /// valid set of funtions; otherwise, <see langword="false" />. /// </returns> private static bool ScanTypeForFunctions(Type type, Task task) { try { FunctionSetAttribute functionSetAttribute = (FunctionSetAttribute) Attribute.GetCustomAttribute(type, typeof(FunctionSetAttribute)); if (functionSetAttribute == null) { // specified type does not represent a valid functionset return false; } bool acceptType = (type == typeof(ExpressionEvaluator)); if (type.IsSubclassOf(typeof(FunctionSetBase)) && !type.IsAbstract) { acceptType = true; } if (acceptType) { string prefix = functionSetAttribute.Prefix; if (prefix != null && prefix != String.Empty) { prefix += "::"; } else { task.Log(Level.Warning, "Ignoring functions in type \"{0}\":" + " no prefix was set.", type.AssemblyQualifiedName); // specified type does not represent a valid functionset return false; } // // add public static/instance methods // foreach (MethodInfo info in type.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static)) { FunctionAttribute functionAttribute = (FunctionAttribute) Attribute.GetCustomAttribute(info, typeof(FunctionAttribute)); if (functionAttribute != null) RegisterFunction(prefix + functionAttribute.Name, info); } // specified type represents a valid functionset return true; } else { // specified type does not represent a valid functionset return false; } } catch { task.Log(Level.Error, "Failure scanning \"{0}\" for functions.", type.AssemblyQualifiedName); throw; } }
private void ExecuteInProjectDirectory(Task task) { string oldBaseDir = SolutionTask.Project.BaseDirectory; SolutionTask.Project.BaseDirectory = ProjectDirectory.FullName; try { // increment indentation level task.Project.Indent(); // execute task task.Execute(); } finally { // restore original base directory SolutionTask.Project.BaseDirectory = oldBaseDir; // restore indentation level task.Project.Unindent(); } }
/// <summary> /// Initializes a new instance of the <see cref="BuildEventArgs" /> /// class for a <see cref="Task" /> level event. /// </summary> /// <param name="task">The <see cref="Task" /> that emitted the event.</param> public BuildEventArgs(Task task) { _project = task.Project; _target = task.Parent as Target; _task = task; }
public static bool ScanAssembly(Assembly assembly, Task task) { task.Log(Level.Verbose, "Scanning assembly \"{0}\" for extensions.", assembly.GetName().Name); foreach (Type type in assembly.GetExportedTypes()) { foreach (MethodInfo methodInfo in type.GetMethods()) { if (methodInfo.IsStatic) { task.Log(Level.Verbose, "Found method {0}.", methodInfo.Name); } } } bool isExtensionAssembly = false; ExtensionAssembly extensionAssembly = new ExtensionAssembly ( assembly); Type[] types; try { types = assembly.GetTypes(); } catch(ReflectionTypeLoadException ex) { if(ex.LoaderExceptions != null && ex.LoaderExceptions.Length > 0) { throw ex.LoaderExceptions[0]; } throw; } foreach (Type type in types) { // // each extension type is exclusive, meaning a given type // cannot be both a task and data type // // so it doesn't make sense to scan a type for, for example, // data types if the type has already been positively // identified as a task // bool extensionFound = ScanTypeForTasks(extensionAssembly, type, task); if (!extensionFound) { extensionFound = ScanTypeForDataTypes(extensionAssembly, type, task); } if (!extensionFound) { extensionFound = ScanTypeForFunctions(type, task); } if (!extensionFound) { extensionFound = ScanTypeForFilters(extensionAssembly, type, task); } if (!extensionFound) { extensionFound = _pluginScanner.ScanTypeForPlugins( extensionAssembly, type, task); } // if extension is found in type, then mark assembly as // extension assembly isExtensionAssembly = isExtensionAssembly || extensionFound; } // if no extension could be found at all, then we might be dealing // with an extension assembly that was built using an older version // of NAnt(.Core) if (!isExtensionAssembly) { AssemblyName coreAssemblyName = Assembly.GetExecutingAssembly(). GetName(false); foreach (AssemblyName assemblyName in assembly.GetReferencedAssemblies()) { if (assemblyName.Name == coreAssemblyName.Name) { // the given assembly references NAnt.Core, so check whether // it doesn't reference an older version of NAnt.Core if (assemblyName.Version != coreAssemblyName.Version) { task.Log(Level.Warning, "Assembly \"{0}\" is built" + " using version {1} of NAnt. If any problems" + " arise, then try using a version that is built" + " for NAnt version {2}.", assembly.GetName().Name, assemblyName.Version, coreAssemblyName.Version); } } } } return isExtensionAssembly; }
public static bool ScanAssembly(string assemblyFile, Task task) { Assembly assembly = Assembly.LoadFrom(assemblyFile); return ScanAssembly(assembly, task); }
public NAntLogger(Task task) { this.task = task; }
public XnaContentLogger(Task task) { m_task = task; }
/// <summary> /// Scans a given <see cref="Type" /> for tasks. /// </summary> /// <param name="type">The <see cref="Type" /> to scan.</param> /// <param name="task">The <see cref="Task" /> which will be used to output messages to the build log.</param> /// <returns> /// <see langword="true" /> if <paramref name="type" /> represents a /// <see cref="Task" />; otherwise, <see langword="false" />. /// </returns> private static bool ScanTypeForTasks(Type type, Task task) { try { TaskNameAttribute taskNameAttribute = (TaskNameAttribute) Attribute.GetCustomAttribute(type, typeof(TaskNameAttribute)); if (type.IsSubclassOf(typeof(Task)) && !type.IsAbstract && taskNameAttribute != null) { task.Log(Level.Debug, "Creating TaskBuilder for \"{0}\".", type.Name); TaskBuilder tb = new TaskBuilder(type.FullName, type.Assembly.Location); if (TaskBuilders[tb.TaskName] == null) { task.Log(Level.Debug, "Adding \"{0}\" from {1}:{2}.", tb.TaskName, tb.AssemblyFileName, tb.ClassName); TaskBuilders.Add(tb); foreach(WeakReference wr in _projects) { if (!wr.IsAlive) { task.Log(Level.Debug, "WeakReference for project is dead."); continue; } Project p = wr.Target as Project; if (p == null) { task.Log(Level.Debug, "WeakReference is not a" + " project! This should not be possible."); continue; } UpdateProjectWithBuilder(p, tb); } } // specified type represents a task return true; } else { // specified type does not represent valid task return false; } } catch { task.Log(Level.Error, "Failure scanning \"{0}\" for tasks.", type.AssemblyQualifiedName); throw; } }
/// <summary> /// Copies the specified file if the destination file does not exist, or /// the source file has been modified since it was previously copied. /// </summary> /// <param name="srcFile">The file to copy.</param> /// <param name="destFile">The destination file.</param> /// <param name="parent">The <see cref="Task" /> in which context the operation will be performed.</param> protected void CopyFile(FileInfo srcFile, FileInfo destFile, Task parent) { // create instance of Copy task CopyTask ct = new CopyTask(); // parent is solution task ct.Parent = parent; // inherit project from parent task ct.Project = parent.Project; // inherit namespace manager from parent task ct.NamespaceManager = parent.NamespaceManager; // inherit verbose setting from parent task ct.Verbose = parent.Verbose; // only output warning messages or higher, unless // we're running in verbose mode if (!ct.Verbose) { ct.Threshold = Level.Warning; } // make sure framework specific information is set ct.InitializeTaskConfiguration(); // set parent of child elements ct.CopyFileSet.Parent = ct; // inherit project for child elements from containing task ct.CopyFileSet.Project = ct.Project; // inherit namespace manager from containing task ct.CopyFileSet.NamespaceManager = ct.NamespaceManager; // set file to copy ct.SourceFile = srcFile; // set file ct.ToFile = destFile; // increment indentation level ct.Project.Indent(); try { // execute task ct.Execute(); } finally { // restore indentation level ct.Project.Unindent(); } }
/// <summary> /// Initializes a new instance of the <see cref="LogWriter" /> class /// for the specified <see cref="Task" /> with the specified output /// level and format provider. /// </summary> /// <param name="task">Determines the indentation level.</param> /// <param name="outputLevel">The <see cref="Level" /> with which messages will be output to the build log.</param> /// <param name="formatProvider">An <see cref="IFormatProvider" /> object that controls formatting.</param> public LogWriter(Task task, Level outputLevel, IFormatProvider formatProvider) : base(formatProvider) { _task = task; _outputLevel = outputLevel; }
public static void ScanDir(string path, Task task, bool failOnError) { // don't do anything if we don't have a valid directory path if (String.IsNullOrEmpty(path)) { return; } task.Log(Level.Info, "Scanning directory \"{0}\" for extension" + " assemblies.", path); // scan all dll's for tasks, types and functions DirectoryScanner scanner = new DirectoryScanner(); scanner.BaseDirectory = new DirectoryInfo(path); scanner.Includes.Add("*.dll"); foreach (string assemblyFile in scanner.FileNames) { try { TypeFactory.ScanAssembly(assemblyFile, task); } catch (Exception ex) { string msg = string.Format(CultureInfo.InvariantCulture, "Failure scanning \"{0}\" for extensions", assemblyFile); if (failOnError) { throw new BuildException(msg + ".", Location.UnknownLocation, ex); } task.Log(Level.Error, msg + ": " + assemblyFile, ex.Message); } } }
public NAntLogger(ConfigurationPropertyHolder configuration) { nant_task = configuration.NAntTask; }
/// <summary> /// Scans a given <see cref="Type" /> for data type. /// </summary> /// <param name="extensionAssembly">The <see cref="ExtensionAssembly" /> containing the <see cref="Type" /> to scan.</param> /// <param name="type">The <see cref="Type" /> to scan.</param> /// <param name="task">The <see cref="Task" /> which will be used to output messages to the build log.</param> /// <returns> /// <see langword="true" /> if <paramref name="type" /> represents a /// data type; otherwise, <see langword="false" />. /// </returns> private static bool ScanTypeForDataTypes(ExtensionAssembly extensionAssembly, Type type, Task task) { try { ElementNameAttribute elementNameAttribute = (ElementNameAttribute) Attribute.GetCustomAttribute(type, typeof(ElementNameAttribute)); if (type.IsSubclassOf(typeof(DataTypeBase)) && !type.IsAbstract && elementNameAttribute != null) { logger.Info(string.Format(CultureInfo.InvariantCulture, ResourceUtils.GetString("String_CreatingDataTypeBaseBuilder"), type.Name)); DataTypeBaseBuilder dtb = new DataTypeBaseBuilder(extensionAssembly, type.FullName); if (DataTypeBuilders[dtb.DataTypeName] == null) { logger.Debug(string.Format(CultureInfo.InvariantCulture, ResourceUtils.GetString("String_AddingDataType"), dtb.DataTypeName, GetAssemblyLocation(dtb.Assembly), dtb.ClassName)); DataTypeBuilders.Add(dtb); } // specified type represents a data type return true; } else { // specified type does not represent valid data type return false; } } catch { task.Log(Level.Error, "Failure scanning \"{0}\" for data types.", type.AssemblyQualifiedName); throw; } }
/// <summary> /// Scans a given <see cref="Type" /> for filters. /// </summary> /// <param name="extensionAssembly">The <see cref="ExtensionAssembly" /> containing the <see cref="Type" /> to scan.</param> /// <param name="type">The <see cref="Type" /> to scan.</param> /// <param name="task">The <see cref="Task" /> which will be used to output messages to the build log.</param> /// <returns> /// <see langword="true" /> if <paramref name="type" /> represents a /// <see cref="Filter" />; otherwise, <see langword="false" />. /// </returns> private static bool ScanTypeForFilters(ExtensionAssembly extensionAssembly, Type type, Task task) { try { ElementNameAttribute elementNameAttribute = (ElementNameAttribute) Attribute.GetCustomAttribute(type, typeof(ElementNameAttribute)); if (type.IsSubclassOf(typeof(Filter)) && !type.IsAbstract && elementNameAttribute != null) { task.Log(Level.Debug, "Creating FilterBuilder for \"{0}\".", type.Name); FilterBuilder builder = new FilterBuilder(extensionAssembly, type.FullName); if (FilterBuilders[builder.FilterName] == null) { FilterBuilders.Add(builder); task.Log(Level.Debug, "Adding filter \"{0}\" from {1}:{2}.", builder.FilterName, GetAssemblyLocation(builder.Assembly), builder.ClassName); } // specified type represents a filter return true; } // specified type does not represent a valid filter return false; } catch { task.Log(Level.Error, "Failure scanning \"{0}\" for filters.", type.AssemblyQualifiedName); throw; } }