public void VerifyGetTaskParameters()
{
TaskPropertyInfo[] propertyInfos = _taskFactory.GetTaskParameters();
LoadedType comparisonType = new LoadedType(typeof(TaskToTestFactories), _loadInfo);
PropertyInfo[] comparisonInfo = comparisonType.Type.GetProperties(BindingFlags.Instance | BindingFlags.Public);
Assert.Equal(comparisonInfo.Length, propertyInfos.Length);
bool foundExpectedParameter = false;
bool foundNotExpectedParameter = false;
for (int i = 0; i < propertyInfos.Length; i++)
{
if (propertyInfos[i].Name.Equals("ExpectedParameter", StringComparison.OrdinalIgnoreCase))
{
foundExpectedParameter = true;
}
if (propertyInfos[i].Name.Equals("NotExpectedParameter", StringComparison.OrdinalIgnoreCase))
{
foundNotExpectedParameter = true;
}
}
Assert.True(foundExpectedParameter);
Assert.False(foundNotExpectedParameter);
}
/// <summary>
/// Abstract out the creation of the new AssemblyTaskFactory with default task, and
/// with some basic validation.
/// </summary>
private void SetupTaskFactory(IDictionary <string, string> factoryParameters, bool explicitlyLaunchTaskHost)
{
_taskFactory = new AssemblyTaskFactory();
_loadInfo = AssemblyLoadInfo.Create(null, Assembly.GetAssembly(typeof(TaskToTestFactories)).Location);
_loadedType = _taskFactory.InitializeFactory(_loadInfo, "TaskToTestFactories", new Dictionary <string, TaskPropertyInfo>(), string.Empty, factoryParameters, explicitlyLaunchTaskHost, null, ElementLocation.Create("NONE"), String.Empty);
Assert.True(_loadedType.Assembly.Equals(_loadInfo)); // "Expected the AssemblyLoadInfo to be equal"
}
public TaskHostTask(IElementLocation taskLocation, TaskLoggingContext taskLoggingContext, IBuildComponentHost buildComponentHost, IDictionary <string, string> taskHostParameters, LoadedType taskType
#if FEATURE_APPDOMAIN
, AppDomainSetup appDomainSetup
#endif
)
{
ErrorUtilities.VerifyThrowInternalNull(taskType, nameof(taskType));
_taskLocation = taskLocation;
_taskLoggingContext = taskLoggingContext;
_buildComponentHost = buildComponentHost;
_taskType = taskType;
#if FEATURE_APPDOMAIN
_appDomainSetup = appDomainSetup;
#endif
_taskHostParameters = taskHostParameters;
_packetFactory = new NodePacketFactory();
(this as INodePacketFactory).RegisterPacketHandler(NodePacketType.LogMessage, LogMessagePacket.FactoryForDeserialization, this);
(this as INodePacketFactory).RegisterPacketHandler(NodePacketType.TaskHostTaskComplete, TaskHostTaskComplete.FactoryForDeserialization, this);
(this as INodePacketFactory).RegisterPacketHandler(NodePacketType.NodeShutdown, NodeShutdown.FactoryForDeserialization, this);
_packetReceivedEvent = new AutoResetEvent(false);
_receivedPackets = new ConcurrentQueue <INodePacket>();
_taskHostLock = new Object();
_setParameters = new Dictionary <string, object>();
}
public void SetUp()
{
// Whole bunch of setup code.
XmlElement taskNode = new XmlDocument().CreateElement("MockTask");
LoadedType taskClass = new LoadedType(typeof(MockTask), new AssemblyLoadInfo(typeof(MockTask).Assembly.FullName, null));
Engine engine = new Engine(@"c:\");
loggingHelper = new EngineLoggingServicesHelper();
engine.LoggingServices = loggingHelper;
Project project = new Project(engine);
taskExecutionModule = new MockTaskExecutionModule(new EngineCallback(engine));
// Set up some "fake data" which will be passed to the Task Execution State object
Hashtable[] fakeArray = new Hashtable[1];
fakeArray[0] = new Hashtable();
projectLevelProprtiesForInference = new BuildPropertyGroup();
projectLevelPropertiesForExecution = new BuildPropertyGroup();
inferenceBucketItemsByName = fakeArray;
inferenceBucketMetaData = fakeArray;
projectLevelItemsForInference = new Hashtable();
executionBucketItemsByName = fakeArray;
executionBucketMetaData = fakeArray;
projectLevelItemsForExecution = new Hashtable();
hostObject = null;
projectFileOfTaskNode = "In Memory";
parentProjectFullFileName = project.FullFileName;
nodeProxyId = engine.EngineCallback.CreateTaskContext(project, null, null, taskNode, EngineCallback.inProcNode, new BuildEventContext(BuildEventContext.InvalidNodeId, BuildEventContext.InvalidTargetId, BuildEventContext.InvalidProjectContextId, BuildEventContext.InvalidTaskId));
executionDirectory = Directory.GetCurrentDirectory();
projectId = project.Id;
}
public void SetUp()
{
// Whole bunch of setup code.
XmlElement taskNode = new XmlDocument().CreateElement("MockTask");
LoadedType taskClass = new LoadedType(typeof(MockTask), new AssemblyLoadInfo(typeof(MockTask).Assembly.FullName, null));
engine = new Engine(@"c:\");
Project project = new Project(engine);
EngineCallback engineCallback = new EngineCallback(engine);
taskExecutionModule = new MockTaskExecutionModule(engineCallback);
int handleId = engineCallback.CreateTaskContext(project, null, null, taskNode, EngineCallback.inProcNode, new BuildEventContext(BuildEventContext.InvalidNodeId, BuildEventContext.InvalidTargetId, BuildEventContext.InvalidProjectContextId, BuildEventContext.InvalidTaskId));
TaskEngine taskEngine = new TaskEngine
(
taskNode,
null, /* host object */
"In Memory",
project.FullFileName,
engine.LoggingServices,
handleId,
taskExecutionModule,
null
);
taskEngine.TaskClass = taskClass;
engineProxy = new EngineProxy(taskExecutionModule, handleId, project.FullFileName, project.FullFileName, engine.LoggingServices, null);
taskExecutionModule2 = new MockTaskExecutionModule(engineCallback, TaskExecutionModule.TaskExecutionModuleMode.MultiProcFullNodeMode);
engineProxy2 = new EngineProxy(taskExecutionModule2, handleId, project.FullFileName, project.FullFileName, engine.LoggingServices, null);
}
public void NoTypeNamePicksFirstType()
{
Type forwardingLoggerType = typeof(net.r_eg.IeXod.Logging.ConfigurableForwardingLogger);
string forwardingLoggerAssemblyLocation = forwardingLoggerType.Assembly.Location;
Func <Type, object, bool> forwardingLoggerfilter = IsForwardingLoggerClass;
Type firstPublicType = FirstPublicDesiredType(forwardingLoggerfilter, forwardingLoggerAssemblyLocation);
TypeLoader loader = new TypeLoader(forwardingLoggerfilter);
LoadedType loadedType = loader.Load(String.Empty, AssemblyLoadInfo.Create(null, forwardingLoggerAssemblyLocation));
Assert.NotNull(loadedType);
Assert.Equal(forwardingLoggerAssemblyLocation, loadedType.Assembly.AssemblyLocation);
Assert.Equal(firstPublicType, loadedType.Type);
Type fileLoggerType = typeof(net.r_eg.IeXod.Logging.FileLogger);
string fileLoggerAssemblyLocation = forwardingLoggerType.Assembly.Location;
Func <Type, object, bool> fileLoggerfilter = IsLoggerClass;
firstPublicType = FirstPublicDesiredType(fileLoggerfilter, fileLoggerAssemblyLocation);
loader = new TypeLoader(fileLoggerfilter);
loadedType = loader.Load(String.Empty, AssemblyLoadInfo.Create(null, fileLoggerAssemblyLocation));
Assert.NotNull(loadedType);
Assert.Equal(fileLoggerAssemblyLocation, loadedType.Assembly.AssemblyLocation);
Assert.Equal(firstPublicType, loadedType.Type);
}
public void NoTypeNamePicksFirstType()
{
Type forwardingLoggerType = typeof(Microsoft.Build.Logging.ConfigurableForwardingLogger);
string forwardingLoggerAssemblyLocation = forwardingLoggerType.Assembly.Location;
Func <Type, object, bool> forwardingLoggerfilter = IsForwardingLoggerClass;
Type firstPublicType = FirstPublicDesiredType(forwardingLoggerfilter, forwardingLoggerAssemblyLocation);
TypeLoader loader = new TypeLoader(forwardingLoggerfilter);
LoadedType loadedType = loader.Load(String.Empty, AssemblyLoadInfo.Create(null, forwardingLoggerAssemblyLocation));
Assert.NotNull(loadedType);
Assert.True(loadedType.Assembly.AssemblyLocation.Equals(forwardingLoggerAssemblyLocation, StringComparison.OrdinalIgnoreCase));
Assert.True(loadedType.Type.Equals(firstPublicType));
Type fileLoggerType = typeof(Microsoft.Build.Logging.FileLogger);
string fileLoggerAssemblyLocation = forwardingLoggerType.Assembly.Location;
Func <Type, object, bool> fileLoggerfilter = IsLoggerClass;
firstPublicType = FirstPublicDesiredType(fileLoggerfilter, fileLoggerAssemblyLocation);
loader = new TypeLoader(fileLoggerfilter);
loadedType = loader.Load(String.Empty, AssemblyLoadInfo.Create(null, fileLoggerAssemblyLocation));
Assert.NotNull(loadedType);
Assert.True(loadedType.Assembly.AssemblyLocation.Equals(fileLoggerAssemblyLocation, StringComparison.OrdinalIgnoreCase));
Assert.True(loadedType.Type.Equals(firstPublicType));
}
/// <summary>
/// Is the given task name able to be created by the task factory. In the case of an assembly task factory
/// this question is answered by checking the assembly wrapped by the task factory to see if it exists.
/// </summary>
internal bool TaskNameCreatableByFactory(string taskName, IDictionary <string, string> taskIdentityParameters, string taskProjectFile, TargetLoggingContext targetLoggingContext, ElementLocation elementLocation)
{
if (!TaskIdentityParametersMatchFactory(_factoryIdentityParameters, taskIdentityParameters))
{
return(false);
}
// Parameters match, so now we check to see if the task exists.
LoadedType taskClass = null;
try
{
ErrorUtilities.VerifyThrowArgumentLength(taskName, "TaskName");
taskClass = _typeLoader.ReflectionOnlyLoad(taskName, _loadedType.Assembly);
if (taskClass != null)
{
return(true);
}
else
{
return(false);
}
}
catch (TargetInvocationException e)
{
// Exception thrown by the called code itself
// Log the stack, so the task vendor can fix their code
ProjectErrorUtilities.ThrowInvalidProject(elementLocation, "TaskLoadFailure", taskName, _loadedType.Assembly.AssemblyLocation, Environment.NewLine + e.InnerException.ToString());
}
catch (ReflectionTypeLoadException e)
{
// ReflectionTypeLoadException.LoaderExceptions may contain nulls
foreach (Exception exception in e.LoaderExceptions)
{
if (exception != null)
{
targetLoggingContext.LogError(new BuildEventFileInfo(taskProjectFile), "TaskLoadFailure", taskName, _loadedType.Assembly.AssemblyLocation, exception.Message);
}
}
ProjectErrorUtilities.ThrowInvalidProject(elementLocation, "TaskLoadFailure", taskName, _loadedType.Assembly.AssemblyLocation, e.Message);
}
catch (ArgumentNullException e)
{
// taskName may be null
ProjectErrorUtilities.ThrowInvalidProject(elementLocation, "TaskLoadFailure", taskName, _loadedType.Assembly.AssemblyLocation, e.Message);
}
catch (Exception e) // Catching Exception, but rethrowing unless it's a well-known exception.
{
if (ExceptionHandling.NotExpectedReflectionException(e))
{
throw;
}
ProjectErrorUtilities.ThrowInvalidProject(elementLocation, "TaskLoadFailure", taskName, _loadedType.Assembly.AssemblyLocation, e.Message);
}
return(false);
}
/// <summary>
/// We just need the loaded type information because the task factory which is not instance specific should
/// already have loaded the assembly and got the information.
/// </summary>
public AssemblyTaskFactoryInstance(string taskName, LoadedType loadedType)
{
ErrorUtilities.VerifyThrowArgumentLength(taskName, "taskName");
ErrorUtilities.VerifyThrowArgumentNull(loadedType, "loadedType");
this.taskName = taskName;
this.loadedType = loadedType;
}
/// <summary>
/// Loads a logger from its assembly, instantiates it, and handles errors.
/// </summary>
/// <returns>Instantiated logger.</returns>
private ILogger CreateLogger(bool forwardingLogger)
{
ILogger logger = null;
try
{
if (forwardingLogger)
{
// load the logger from its assembly
LoadedType loggerClass = (new TypeLoader(s_forwardingLoggerClassFilter)).Load(_loggerClassName, _loggerAssembly);
if (loggerClass != null)
{
// instantiate the logger
logger = (IForwardingLogger)Activator.CreateInstance(loggerClass.Type);
}
}
else
{
// load the logger from its assembly
LoadedType loggerClass = (new TypeLoader(s_loggerClassFilter)).Load(_loggerClassName, _loggerAssembly);
if (loggerClass != null)
{
// instantiate the logger
logger = (ILogger)Activator.CreateInstance(loggerClass.Type);
}
}
}
catch (InvalidCastException e)
{
// The logger when trying to load has hit an invalid case, this is usually due to the framework assembly being a different version
string message = ResourceUtilities.FormatResourceString("LoggerInstantiationFailureErrorInvalidCast", _loggerClassName, _loggerAssembly.AssemblyLocation, e.Message);
throw new LoggerException(message, e.InnerException);
}
catch (TargetInvocationException e)
{
// At this point, the interesting stack is the internal exception;
// the outer exception is System.Reflection stuff that says nothing
// about the nature of the logger failure.
Exception innerException = e.InnerException;
if (innerException is LoggerException)
{
// Logger failed politely during construction. In order to preserve
// the stack trace at which the error occured we wrap the original
// exception instead of throwing.
LoggerException l = ((LoggerException)innerException);
throw new LoggerException(l.Message, innerException, l.ErrorCode, l.HelpKeyword);
}
else
{
throw;
}
}
return(logger);
}
/// <summary>
/// Creates an instance of this class for the given type.
/// </summary>
internal TaskFactoryWrapper(ITaskFactory taskFactory, LoadedType taskFactoryLoadInfo, string taskName, IDictionary <string, string> factoryIdentityParameters)
{
ErrorUtilities.VerifyThrowArgumentNull(taskFactory, "taskFactory");
ErrorUtilities.VerifyThrowArgumentLength(taskName, "taskName");
_taskFactory = taskFactory;
_taskName = taskName;
TaskFactoryLoadedType = taskFactoryLoadInfo;
_factoryIdentityParameters = factoryIdentityParameters;
}
/// <summary>
/// Given a task name and a list of assemblies, this helper method checks if the task exists in any of the assemblies.
/// </summary>
/// <remarks>
/// If the task name is fully qualified, then a match (if any) is unambiguous; otherwise, if there are multiple tasks with
/// the same name in different namespaces/assemblies, the first task found will be returned.
/// </remarks>
/// <param name="taskName"></param>
/// <param name="taskAssemblies"></param>
/// <param name="taskProjectFile"></param>
/// <param name="taskNode"></param>
/// <param name="loggingServices"></param>
/// <param name="buildEventContext"></param>
/// <param name="taskClass"></param>
/// <returns>true, if task is successfully loaded</returns>
private bool GetTaskFromAssembly
(
string taskName,
ArrayList taskAssemblies,
string taskProjectFile,
XmlNode taskNode,
EngineLoggingServices loggingServices,
BuildEventContext buildEventContext,
out LoadedType taskClass
)
{
taskClass = null;
foreach (AssemblyLoadInfo assembly in taskAssemblies)
{
try
{
taskClass = typeLoader.Load(taskName, assembly);
}
catch (TargetInvocationException e)
{
// Exception thrown by the called code itself
// Log the stack, so the task vendor can fix their code
ProjectErrorUtilities.VerifyThrowInvalidProject(false, taskNode, "TaskLoadFailure", taskName, assembly.ToString(), Environment.NewLine + e.InnerException.ToString());
}
catch (ReflectionTypeLoadException e)
{
// ReflectionTypeLoadException.LoaderExceptions may contain nulls
foreach (Exception exception in e.LoaderExceptions)
{
if (exception != null)
{
loggingServices.LogError(buildEventContext, new BuildEventFileInfo(taskProjectFile), "TaskLoadFailure", taskName, assembly.ToString(), exception.Message);
}
}
ProjectErrorUtilities.VerifyThrowInvalidProject(false, taskNode, "TaskLoadFailure", taskName, assembly.ToString(), e.Message);
}
catch (Exception e) // Catching Exception, but rethrowing unless it's a well-known exception.
{
if (ExceptionHandling.NotExpectedReflectionException(e))
{
throw;
}
ProjectErrorUtilities.VerifyThrowInvalidProject(false, taskNode, "TaskLoadFailure", taskName, assembly.ToString(), e.Message);
}
if (taskClass != null)
{
return(true);
}
}
return(false);
}
public static TaskPropertyInfo[] GetTaskParameters(LoadedType loadedType)
{
PropertyInfo[] infos = loadedType.Type.GetProperties(BindingFlags.Instance | BindingFlags.Public);
var propertyInfos = new TaskPropertyInfo[infos.Length];
for (int i = 0; i < infos.Length; i++)
{
propertyInfos[i] = new ReflectableTaskPropertyInfo(infos[i]);
}
return(propertyInfos);
}
/// <summary>
/// Loads a logger from its assembly, instantiates it, and handles errors.
/// </summary>
/// <returns>Instantiated logger.</returns>
private ILogger CreateLogger(bool forwardingLogger)
{
ILogger logger = null;
try
{
if (forwardingLogger)
{
// load the logger from its assembly
LoadedType loggerClass = (new TypeLoader(forwardingLoggerClassFilter)).Load(loggerClassName, loggerAssembly);
if (loggerClass != null)
{
// instantiate the logger
logger = (IForwardingLogger)Activator.CreateInstance(loggerClass.Type);
}
}
else
{
// load the logger from its assembly
LoadedType loggerClass = (new TypeLoader(loggerClassFilter)).Load(loggerClassName, loggerAssembly);
if (loggerClass != null)
{
// instantiate the logger
logger = (ILogger)Activator.CreateInstance(loggerClass.Type);
}
}
}
catch (TargetInvocationException e)
{
// At this point, the interesting stack is the internal exception;
// the outer exception is System.Reflection stuff that says nothing
// about the nature of the logger failure.
Exception innerException = e.InnerException;
if (innerException is LoggerException)
{
// Logger failed politely during construction. In order to preserve
// the stack trace at which the error occurred we wrap the original
// exception instead of throwing.
LoggerException l = ((LoggerException)innerException);
throw new LoggerException(l.Message, innerException, l.ErrorCode, l.HelpKeyword);
}
else
{
throw;
}
}
return(logger);
}
public IElement EnterArray(IElement index)
{
if (!IsIndexable)
{
throw new NotSupportedException("This element does not support indexing.");
}
var arrayElement = (BaseElement)this[index];
arrayElement.previous = this;
next = arrayElement;
arrayElement.LoadedType = LoadedType.GetElementType();
return(next);
}
public void Regress640476PartialName()
{
string forwardingLoggerLocation = typeof(net.r_eg.IeXod.Logging.ConfigurableForwardingLogger).Assembly.Location;
TypeLoader loader = new TypeLoader(IsForwardingLoggerClass);
LoadedType loadedType = loader.Load("ConfigurableForwardingLogger", AssemblyLoadInfo.Create(null, forwardingLoggerLocation));
Assert.NotNull(loadedType);
Assert.Equal(forwardingLoggerLocation, loadedType.Assembly.AssemblyLocation);
string fileLoggerLocation = typeof(net.r_eg.IeXod.Logging.FileLogger).Assembly.Location;
loader = new TypeLoader(IsLoggerClass);
loadedType = loader.Load("FileLogger", AssemblyLoadInfo.Create(null, fileLoggerLocation));
Assert.NotNull(loadedType);
Assert.Equal(fileLoggerLocation, loadedType.Assembly.AssemblyLocation);
}
public void Regress640476PartialName()
{
string forwardingLoggerLocation = typeof(Microsoft.Build.Logging.ConfigurableForwardingLogger).Assembly.Location;
TypeLoader loader = new TypeLoader(IsForwardingLoggerClass);
LoadedType loadedType = loader.Load("ConfigurableForwardingLogger", AssemblyLoadInfo.Create(null, forwardingLoggerLocation));
Assert.NotNull(loadedType);
Assert.True(loadedType.Assembly.AssemblyLocation.Equals(forwardingLoggerLocation, StringComparison.OrdinalIgnoreCase));
string fileLoggerLocation = typeof(Microsoft.Build.Logging.FileLogger).Assembly.Location;
loader = new TypeLoader(IsLoggerClass);
loadedType = loader.Load("FileLogger", AssemblyLoadInfo.Create(null, fileLoggerLocation));
Assert.NotNull(loadedType);
Assert.True(loadedType.Assembly.AssemblyLocation.Equals(fileLoggerLocation, StringComparison.OrdinalIgnoreCase));
}
public void Regress640476FullyQualifiedName()
{
Type forwardingLoggerType = typeof(Microsoft.Build.Logging.ConfigurableForwardingLogger);
string forwardingLoggerLocation = forwardingLoggerType.Assembly.Location;
TypeLoader loader = new TypeLoader(IsForwardingLoggerClass);
LoadedType loadedType = loader.Load(forwardingLoggerType.FullName, AssemblyLoadInfo.Create(null, forwardingLoggerLocation));
Assert.NotNull(loadedType);
Assert.Equal(forwardingLoggerLocation, loadedType.Assembly.AssemblyLocation);
Type fileLoggerType = typeof(Microsoft.Build.Logging.FileLogger);
string fileLoggerLocation = fileLoggerType.Assembly.Location;
loader = new TypeLoader(IsLoggerClass);
loadedType = loader.Load(fileLoggerType.FullName, AssemblyLoadInfo.Create(null, fileLoggerLocation));
Assert.NotNull(loadedType);
Assert.Equal(fileLoggerLocation, loadedType.Assembly.AssemblyLocation);
}
public virtual void Load(Emit g, TypeOfContent content)
{
if (Index != null)
{
InternalLoad(g, TypeOfContent.Value);
if (LoadedType.IsByRef)
{
g.LoadIndirect(LoadedType.GetElementType());
}
Index.Load(g, TypeOfContent.Value);
if (content == TypeOfContent.Value)
{
g.LoadElement(LoadedType);
}
else
{
g.LoadElementAddress(LoadedType);
}
}
else
{
if (LoadedType.IsByRef)
{
InternalLoad(g, TypeOfContent.Value);
if (content == TypeOfContent.Value)
{
g.LoadIndirect(LoadedType.GetElementType());
}
}
else
{
InternalLoad(g, content);
}
}
}
public override string ToString()
{
return($"{GetType().ToString()}; Load: {LoadedType.ToString()};");
}
/// <summary>
/// Initialize the factory from the task registry
/// </summary>
internal LoadedType InitializeFactory
(
AssemblyLoadInfo loadInfo,
string taskName,
IDictionary <string, TaskPropertyInfo> taskParameters,
string taskElementContents,
IDictionary <string, string> taskFactoryIdentityParameters,
bool taskHostFactoryExplicitlyRequested,
TargetLoggingContext targetLoggingContext,
ElementLocation elementLocation,
string taskProjectFile
)
{
ErrorUtilities.VerifyThrowArgumentNull(loadInfo, "loadInfo");
VerifyThrowIdentityParametersValid(taskFactoryIdentityParameters, elementLocation, taskName, "Runtime", "Architecture");
if (taskFactoryIdentityParameters != null)
{
_factoryIdentityParameters = new Dictionary <string, string>(taskFactoryIdentityParameters, StringComparer.OrdinalIgnoreCase);
}
_taskHostFactoryExplicitlyRequested = taskHostFactoryExplicitlyRequested;
try
{
ErrorUtilities.VerifyThrowArgumentLength(taskName, "taskName");
_taskName = taskName;
_loadedType = _typeLoader.Load(taskName, loadInfo);
ProjectErrorUtilities.VerifyThrowInvalidProject(_loadedType != null, elementLocation, "TaskLoadFailure", taskName, loadInfo.AssemblyLocation, String.Empty);
}
catch (TargetInvocationException e)
{
// Exception thrown by the called code itself
// Log the stack, so the task vendor can fix their code
ProjectErrorUtilities.VerifyThrowInvalidProject(false, elementLocation, "TaskLoadFailure", taskName, loadInfo.AssemblyLocation, Environment.NewLine + e.InnerException.ToString());
}
catch (ReflectionTypeLoadException e)
{
// ReflectionTypeLoadException.LoaderExceptions may contain nulls
foreach (Exception exception in e.LoaderExceptions)
{
if (exception != null)
{
targetLoggingContext.LogError(new BuildEventFileInfo(taskProjectFile), "TaskLoadFailure", taskName, loadInfo.AssemblyLocation, exception.Message);
}
}
ProjectErrorUtilities.VerifyThrowInvalidProject(false, elementLocation, "TaskLoadFailure", taskName, loadInfo.AssemblyLocation, e.Message);
}
catch (ArgumentNullException e)
{
// taskName may be null
ProjectErrorUtilities.VerifyThrowInvalidProject(false, elementLocation, "TaskLoadFailure", taskName, loadInfo.AssemblyLocation, e.Message);
}
catch (Exception e) // Catching Exception, but rethrowing unless it's a well-known exception.
{
if (ExceptionHandling.NotExpectedReflectionException(e))
{
throw;
}
ProjectErrorUtilities.VerifyThrowInvalidProject(false, elementLocation, "TaskLoadFailure", taskName, loadInfo.AssemblyLocation, e.Message);
}
return(_loadedType);
}
private List <TaskExecutionStateHelper> InitializeTaskState()
{
BuildPropertyGroup projectLevelProprtiesForInference;
BuildPropertyGroup projectLevelPropertiesForExecution;
Hashtable[] inferenceBucketItemsByName;
Hashtable[] inferenceBucketMetaData;
Hashtable projectLevelItemsForInference;
Hashtable[] executionBucketItemsByName;
Hashtable[] executionBucketMetaData;
Hashtable projectLevelItemsForExecution;
ITaskHost hostObject;
EngineLoggingServicesHelper loggingHelper;
string projectFileOfTaskNode;
string parentProjectFullFileName;
int nodeProxyId;
int projectId;
string executionDirectory;
XmlElement taskNode = new XmlDocument().CreateElement("MockTask");
LoadedType taskClass = new LoadedType(typeof(MockTask), new AssemblyLoadInfo(typeof(MockTask).Assembly.FullName, null));
loggingHelper = new EngineLoggingServicesHelper();
engine.LoggingServices = loggingHelper;
Project project = new Project(engine);
nodeProxyId = engine.EngineCallback.CreateTaskContext(project, null, null, taskNode, EngineCallback.inProcNode, new BuildEventContext(BuildEventContext.InvalidNodeId, BuildEventContext.InvalidTargetId, BuildEventContext.InvalidProjectContextId, BuildEventContext.InvalidTaskId));
// Set up some "fake data" which will be passed to the Task Execution State object
Hashtable[] fakeArray = new Hashtable[1];
fakeArray[0] = new Hashtable();
projectLevelProprtiesForInference = new BuildPropertyGroup();
projectLevelPropertiesForExecution = new BuildPropertyGroup();
inferenceBucketItemsByName = fakeArray;
inferenceBucketMetaData = fakeArray;
projectLevelItemsForInference = new Hashtable();
executionBucketItemsByName = fakeArray;
executionBucketMetaData = fakeArray;
projectLevelItemsForExecution = new Hashtable();
hostObject = null;
projectFileOfTaskNode = "In Memory";
parentProjectFullFileName = project.FullFileName;
executionDirectory = Directory.GetCurrentDirectory();
projectId = project.Id;
MockTaskExecutionModule taskExecutionModule = taskExecutionModule = new MockTaskExecutionModule(new EngineCallback(engine));
TaskExecutionMode howToExecuteTask = TaskExecutionMode.InferOutputsOnly;
List <TaskExecutionStateHelper> executionStates = new List <TaskExecutionStateHelper>();
TaskExecutionStateHelper executionStateNormal1 = new TaskExecutionStateHelper(
howToExecuteTask,
LookupHelpers.CreateLookup(projectLevelProprtiesForInference, projectLevelItemsForInference),
LookupHelpers.CreateLookup(projectLevelPropertiesForExecution, projectLevelItemsForExecution),
taskNode,
hostObject,
projectFileOfTaskNode,
parentProjectFullFileName,
executionDirectory,
nodeProxyId);
executionStateNormal1.LoggingService = loggingHelper;
executionStateNormal1.TargetInferenceSuccessful = true;
executionStateNormal1.ParentModule = taskExecutionModule;
executionStates.Add(executionStateNormal1);
TaskExecutionStateHelper executionStateCallBack = new TaskExecutionStateHelper(
howToExecuteTask,
LookupHelpers.CreateLookup(projectLevelProprtiesForInference, projectLevelItemsForInference),
LookupHelpers.CreateLookup(projectLevelPropertiesForExecution, projectLevelItemsForExecution),
taskNode,
hostObject,
projectFileOfTaskNode,
parentProjectFullFileName,
executionDirectory,
nodeProxyId);
executionStateCallBack.LoggingService = loggingHelper;
executionStateCallBack.TargetInferenceSuccessful = true;
executionStates.Add(executionStateCallBack);
TaskExecutionStateHelper executionStateNormal2 = new TaskExecutionStateHelper(
howToExecuteTask,
LookupHelpers.CreateLookup(projectLevelProprtiesForInference, projectLevelItemsForInference),
LookupHelpers.CreateLookup(projectLevelPropertiesForExecution, projectLevelItemsForExecution),
taskNode,
hostObject,
projectFileOfTaskNode,
parentProjectFullFileName,
executionDirectory,
nodeProxyId);
executionStateNormal2.LoggingService = loggingHelper;
executionStateNormal2.TargetInferenceSuccessful = true;
executionStateNormal2.ParentModule = taskExecutionModule;
executionStates.Add(executionStateNormal2);
TaskExecutionStateHelper executionStateNormal3 = new TaskExecutionStateHelper(
howToExecuteTask,
LookupHelpers.CreateLookup(projectLevelProprtiesForInference, projectLevelItemsForInference),
LookupHelpers.CreateLookup(projectLevelPropertiesForExecution, projectLevelItemsForExecution),
taskNode,
hostObject,
projectFileOfTaskNode,
parentProjectFullFileName,
executionDirectory,
nodeProxyId);
executionStateNormal3.LoggingService = loggingHelper;
executionStateNormal3.TargetInferenceSuccessful = true;
executionStateNormal3.ParentModule = taskExecutionModule;
executionStates.Add(executionStateNormal3);
return(executionStates);
}
/// <summary>
/// Execute a task on the STA thread.
/// </summary>
/// <comment>
/// STA thread launching code lifted from XMakeBuildEngine\BackEnd\Components\RequestBuilder\TaskBuilder.cs, ExecuteTaskInSTAThread method.
/// Any bug fixes made to this code, please ensure that you also fix that code.
/// </comment>
private OutOfProcTaskHostTaskResult InstantiateAndExecuteTaskInSTAThread
(
IBuildEngine oopTaskHostNode,
LoadedType taskType,
string taskName,
string taskLocation,
string taskFile,
int taskLine,
int taskColumn,
#if FEATURE_APPDOMAIN
AppDomainSetup appDomainSetup,
#endif
IDictionary <string, TaskParameter> taskParams
)
{
ManualResetEvent taskRunnerFinished = new ManualResetEvent(false);
OutOfProcTaskHostTaskResult taskResult = null;
Exception exceptionFromExecution = null;
try
{
ThreadStart taskRunnerDelegate = delegate()
{
try
{
taskResult = InstantiateAndExecuteTask
(
oopTaskHostNode,
taskType,
taskName,
taskLocation,
taskFile,
taskLine,
taskColumn,
#if FEATURE_APPDOMAIN
appDomainSetup,
#endif
taskParams
);
}
catch (Exception e)
{
if (ExceptionHandling.IsCriticalException(e))
{
throw;
}
exceptionFromExecution = e;
}
finally
{
taskRunnerFinished.Set();
}
};
Thread staThread = new Thread(taskRunnerDelegate);
staThread.SetApartmentState(ApartmentState.STA);
staThread.Name = "MSBuild STA task runner thread";
staThread.CurrentCulture = Thread.CurrentThread.CurrentCulture;
staThread.CurrentUICulture = Thread.CurrentThread.CurrentUICulture;
staThread.Start();
// TODO: Why not just Join on the thread???
taskRunnerFinished.WaitOne();
}
finally
{
#if CLR2COMPATIBILITY
taskRunnerFinished.Close();
#else
taskRunnerFinished.Dispose();
#endif
taskRunnerFinished = null;
}
if (exceptionFromExecution != null)
{
// Unfortunately this will reset the callstack
throw exceptionFromExecution;
}
return(taskResult);
}
/// <summary>
/// Given a task name, this method retrieves the task class. If the task has been requested before, it will be found in
/// the class cache; otherwise, <UsingTask> declarations will be used to search the appropriate assemblies.
/// </summary>
/// <param name="taskName"></param>
/// <param name="taskProjectFile"></param>
/// <param name="taskNode"></param>
/// <param name="exactMatchRequired"></param>
/// <param name="loggingServices"></param>
/// <param name="buildEventContext"></param>
/// <param name="taskClass"></param>
/// <returns>true, if task is found</returns>
public bool GetRegisteredTask
(
string taskName,
string taskProjectFile,
XmlNode taskNode,
bool exactMatchRequired,
EngineLoggingServices loggingServices,
BuildEventContext buildEventContext,
out LoadedType taskClass
)
{
taskClass = null;
// If there are no using tags in the project don't bother caching or looking for tasks
if (registeredTasks == null)
{
return(false);
}
Hashtable cachedTaskClasses = exactMatchRequired ? this.cachedTaskClassesWithExactMatch : this.cachedTaskClassesWithFuzzyMatch;
if (cachedTaskClasses.Contains(taskName))
{
// Caller has asked us before for this same task name, and for the same value of "bool exactMatchRequired".
// Return whatever the previous result was, even if it was null. Why would the result be different than
// it was before? NOTE: Hash tables CAN have "null" as their value, and this still returns "true" for Contains(...).
taskClass = (LoadedType)cachedTaskClasses[taskName];
}
else
{
Hashtable registeredTasksFound;
// look for the given task name in the registry; if not found, gather all registered task names that partially
// match the given name
if (FindRegisteredTasks(taskName, exactMatchRequired, out registeredTasksFound))
{
foreach (DictionaryEntry registeredTaskFound in registeredTasksFound)
{
string mostSpecificTaskName = (string)registeredTaskFound.Key;
// if the given task name is longer than the registered task name
if (taskName.Length > ((string)registeredTaskFound.Key).Length)
{
// we will use the longer name to help disambiguate between multiple matches
mostSpecificTaskName = taskName;
}
if (GetTaskFromAssembly(mostSpecificTaskName, (ArrayList)registeredTaskFound.Value, taskProjectFile, taskNode, loggingServices, buildEventContext, out taskClass))
{
// Whilst we are within the processing of the task, we haven't actually started executing it, so
// our using task message needs to be in the context of the target. However any errors should be reported
// at the point where the task appears in the project.
BuildEventContext usingTaskContext = new BuildEventContext(buildEventContext.NodeId, buildEventContext.TargetId, buildEventContext.ProjectContextId, BuildEventContext.InvalidTaskId);
loggingServices.LogComment(usingTaskContext, "TaskFound", taskName, taskClass.Assembly.ToString());
break;
}
}
}
// Cache the result, even if it is null. We should never again do the work we just did, for this task name.
cachedTaskClasses[taskName] = taskClass;
}
return(taskClass != null);
}
public void TearDownAttribute()
{
_taskFactory = null;
_loadInfo = null;
_loadedType = null;
}
public Character(MemoryStream inStream)
{
LoadType = LoadedType.Client;
PendingFlags = PendingFlag.None;
Byte[] stringBuffer = new Byte[20];
Byte[] expBuffer = new Byte[4];
AccountId = 0;
inStream.Seek(22, SeekOrigin.Current);
Slot = (Byte)inStream.ReadByte();
inStream.Seek(3, SeekOrigin.Current);
inStream.Read(stringBuffer, 0, 20);
Name = Encoding.ASCII.GetString(stringBuffer).Split((Char)0)[0];
Agility = (Byte)inStream.ReadByte();
Constitution = (Byte)inStream.ReadByte();
Memory = (Byte)inStream.ReadByte();
Reasoning = (Byte)inStream.ReadByte();
Discipline = (Byte)inStream.ReadByte();
Empathy = (Byte)inStream.ReadByte();
Intuition = (Byte)inStream.ReadByte();
Presence = (Byte)inStream.ReadByte();
Quickness = (Byte)inStream.ReadByte();
Strength = (Byte)inStream.ReadByte();
SpentStatPoints = 0;
BonusStatPoints = 0;
BonusStatPointsSpent = 0;
inStream.Seek(14, SeekOrigin.Current);
List1 = (Byte)inStream.ReadByte();
List2 = (Byte)inStream.ReadByte();
List3 = (Byte)inStream.ReadByte();
List4 = (Byte)inStream.ReadByte();
List5 = (Byte)inStream.ReadByte();
List6 = (Byte)inStream.ReadByte();
List7 = (Byte)inStream.ReadByte();
List8 = (Byte)inStream.ReadByte();
List9 = (Byte)inStream.ReadByte();
List10 = (Byte)inStream.ReadByte();
inStream.Seek(2, SeekOrigin.Current);
ListLevel1 = (Byte)inStream.ReadByte();
ListLevel2 = (Byte)inStream.ReadByte();
ListLevel3 = (Byte)inStream.ReadByte();
ListLevel4 = (Byte)inStream.ReadByte();
ListLevel5 = (Byte)inStream.ReadByte();
ListLevel6 = (Byte)inStream.ReadByte();
ListLevel7 = (Byte)inStream.ReadByte();
ListLevel8 = (Byte)inStream.ReadByte();
ListLevel9 = (Byte)inStream.ReadByte();
ListLevel10 = (Byte)inStream.ReadByte();
inStream.Seek(2, SeekOrigin.Current);
Byte pClass = (Byte)inStream.ReadByte();
if (pClass > 3)
{
pClass = 0;
}
Class = (PlayerClass)pClass;
Level = (Byte)inStream.ReadByte();
SpellPicks = (Byte)inStream.ReadByte();
inStream.Seek(1, SeekOrigin.Current);
Model = (Byte)inStream.ReadByte();
inStream.Seek(3, SeekOrigin.Current);
inStream.Read(expBuffer, 0, 4);
Experience = NetHelper.FlipBytes(BitConverter.ToUInt32(expBuffer, 0));
Byte[] kBuffer = new Byte[2];
inStream.Read(kBuffer, 0, 2);
SpellKey1 = NetHelper.FlipBytes(BitConverter.ToUInt16(kBuffer, 0));
inStream.Read(kBuffer, 0, 2);
SpellKey2 = NetHelper.FlipBytes(BitConverter.ToUInt16(kBuffer, 0));
inStream.Read(kBuffer, 0, 2);
SpellKey3 = NetHelper.FlipBytes(BitConverter.ToUInt16(kBuffer, 0));
inStream.Read(kBuffer, 0, 2);
SpellKey4 = NetHelper.FlipBytes(BitConverter.ToUInt16(kBuffer, 0));
inStream.Read(kBuffer, 0, 2);
SpellKey5 = NetHelper.FlipBytes(BitConverter.ToUInt16(kBuffer, 0));
inStream.Read(kBuffer, 0, 2);
SpellKey6 = NetHelper.FlipBytes(BitConverter.ToUInt16(kBuffer, 0));
inStream.Read(kBuffer, 0, 2);
SpellKey7 = NetHelper.FlipBytes(BitConverter.ToUInt16(kBuffer, 0));
inStream.Read(kBuffer, 0, 2);
SpellKey8 = NetHelper.FlipBytes(BitConverter.ToUInt16(kBuffer, 0));
inStream.Read(kBuffer, 0, 2);
SpellKey9 = NetHelper.FlipBytes(BitConverter.ToUInt16(kBuffer, 0));
inStream.Read(kBuffer, 0, 2);
SpellKey10 = NetHelper.FlipBytes(BitConverter.ToUInt16(kBuffer, 0));
inStream.Read(kBuffer, 0, 2);
SpellKey11 = BitConverter.ToUInt16(kBuffer, 0);
inStream.Read(kBuffer, 0, 2);
SpellKey12 = BitConverter.ToUInt16(kBuffer, 0);
inStream.Seek(12, SeekOrigin.Current);
OpLevel = (Byte)inStream.ReadByte();
inStream.Read(expBuffer, 0, 4);
PlayerFlags = (PlayerFlag)NetHelper.FlipBytes(BitConverter.ToUInt32(expBuffer, 0));
SpellTrees = new SpellTreeCollection
{
new SpellTree(SpellManager.SpellTrees.FindById(List1), ListLevel1),
new SpellTree(SpellManager.SpellTrees.FindById(List2), ListLevel2),
new SpellTree(SpellManager.SpellTrees.FindById(List3), ListLevel3),
new SpellTree(SpellManager.SpellTrees.FindById(List4), ListLevel4),
new SpellTree(SpellManager.SpellTrees.FindById(List5), ListLevel5),
new SpellTree(SpellManager.SpellTrees.FindById(List6), ListLevel6),
new SpellTree(SpellManager.SpellTrees.FindById(List7), ListLevel7),
new SpellTree(SpellManager.SpellTrees.FindById(List8), ListLevel8),
new SpellTree(SpellManager.SpellTrees.FindById(List9), ListLevel9),
new SpellTree(SpellManager.SpellTrees.FindById(List10), ListLevel10)
};
SpellTrees.RemoveAll(spellTrees => spellTrees.TreeSpells == null);
}
public Character(Player player, DataRow data)
{
LoadType = LoadedType.Server;
PendingFlags = PendingFlag.None;
CharacterId = data.Field <Int32>("charid");
AccountId = data.Field <Int32>("accountid");
Slot = data.Field <Byte>("slot");
Name = data.Field <String>("name");
Agility = data.Field <Byte>("agility");
Constitution = data.Field <Byte>("constitution");
Memory = data.Field <Byte>("memory");
Reasoning = data.Field <Byte>("reasoning");
Discipline = data.Field <Byte>("discipline");
Empathy = data.Field <Byte>("empathy");
Intuition = data.Field <Byte>("intuition");
Presence = data.Field <Byte>("presence");
Quickness = data.Field <Byte>("quickness");
Strength = data.Field <Byte>("strength");
SpentStatPoints = data.Field <UInt32>("spent_stat");
BonusStatPoints = data.Field <UInt32>("bonus_stat");
BonusStatPointsSpent = data.Field <UInt32>("bonus_spent");
List1 = data.Field <Byte>("list_1");
List2 = data.Field <Byte>("list_2");
List3 = data.Field <Byte>("list_3");
List4 = data.Field <Byte>("list_4");
List5 = data.Field <Byte>("list_5");
List6 = data.Field <Byte>("list_6");
List7 = data.Field <Byte>("list_7");
List8 = data.Field <Byte>("list_8");
List9 = data.Field <Byte>("list_9");
List10 = data.Field <Byte>("list_10");
ListLevel1 = data.Field <Byte>("list_level_1");
ListLevel2 = data.Field <Byte>("list_level_2");
ListLevel3 = data.Field <Byte>("list_level_3");
ListLevel4 = data.Field <Byte>("list_level_4");
ListLevel5 = data.Field <Byte>("list_level_5");
ListLevel6 = data.Field <Byte>("list_level_6");
ListLevel7 = data.Field <Byte>("list_level_7");
ListLevel8 = data.Field <Byte>("list_level_8");
ListLevel9 = data.Field <Byte>("list_level_9");
ListLevel10 = data.Field <Byte>("list_level_10");
Class = (PlayerClass)data.Field <Byte>("class");
Level = data.Field <Byte>("level");
SpellPicks = data.Field <Byte>("spell_picks");
Model = data.Field <Byte>("model");
Experience = data.Field <UInt64>("experience");
SpellKey1 = data.Field <UInt16>("spell_key_1");
SpellKey2 = data.Field <UInt16>("spell_key_2");
SpellKey3 = data.Field <UInt16>("spell_key_3");
SpellKey4 = data.Field <UInt16>("spell_key_4");
SpellKey5 = data.Field <UInt16>("spell_key_5");
SpellKey6 = data.Field <UInt16>("spell_key_6");
SpellKey7 = data.Field <UInt16>("spell_key_7");
SpellKey8 = data.Field <UInt16>("spell_key_8");
SpellKey9 = data.Field <UInt16>("spell_key_9");
SpellKey10 = data.Field <UInt16>("spell_key_10");
SpellKey11 = data.Field <UInt16>("spell_key_11");
SpellKey12 = data.Field <UInt16>("spell_key_12");
OpLevel = data.Field <Byte>("oplevel");
PlayerFlags = (PlayerFlag)data.Field <UInt32>("flags");
Statistics = new StatisticSheet(player, this);
SpellTrees = new SpellTreeCollection
{
new SpellTree(SpellManager.SpellTrees.FindById(List1), ListLevel1),
new SpellTree(SpellManager.SpellTrees.FindById(List2), ListLevel2),
new SpellTree(SpellManager.SpellTrees.FindById(List3), ListLevel3),
new SpellTree(SpellManager.SpellTrees.FindById(List4), ListLevel4),
new SpellTree(SpellManager.SpellTrees.FindById(List5), ListLevel5),
new SpellTree(SpellManager.SpellTrees.FindById(List6), ListLevel6),
new SpellTree(SpellManager.SpellTrees.FindById(List7), ListLevel7),
new SpellTree(SpellManager.SpellTrees.FindById(List8), ListLevel8),
new SpellTree(SpellManager.SpellTrees.FindById(List9), ListLevel9),
new SpellTree(SpellManager.SpellTrees.FindById(List10), ListLevel10)
};
SpellTrees.RemoveAll(spellTrees => spellTrees.TreeSpells == null);
LoadMilestones();
}
/// <summary>
/// This is responsible for invoking Execute on the Task
/// Any method calling ExecuteTask must remember to call CleanupTask
/// </summary>
/// <remarks>
/// We also allow the Task to have a reference to the BuildEngine by design
/// at ITask.BuildEngine
/// </remarks>
/// <param name="oopTaskHostNode">The OutOfProcTaskHostNode as the BuildEngine</param>
/// <param name="taskName">The name of the task to be executed</param>
/// <param name="taskLocation">The path of the task binary</param>
/// <param name="taskFile">The path to the project file in which the task invocation is located.</param>
/// <param name="taskLine">The line in the project file where the task invocation is located.</param>
/// <param name="taskColumn">The column in the project file where the task invocation is located.</param>
/// <param name="appDomainSetup">The AppDomainSetup that we want to use to launch our AppDomainIsolated tasks</param>
/// <param name="taskParams">Parameters that will be passed to the task when created</param>
/// <returns>Task completion result showing success, failure or if there was a crash</returns>
internal OutOfProcTaskHostTaskResult ExecuteTask
(
IBuildEngine oopTaskHostNode,
string taskName,
string taskLocation,
string taskFile,
int taskLine,
int taskColumn,
#if FEATURE_APPDOMAIN
AppDomainSetup appDomainSetup,
#endif
IDictionary <string, TaskParameter> taskParams
)
{
buildEngine = oopTaskHostNode;
this.taskName = taskName;
#if FEATURE_APPDOMAIN
_taskAppDomain = null;
#endif
wrappedTask = null;
LoadedType taskType = null;
try
{
TypeLoader typeLoader = new TypeLoader(TaskLoader.IsTaskClass);
taskType = typeLoader.Load(taskName, AssemblyLoadInfo.Create(null, taskLocation));
}
catch (Exception e)
{
if (ExceptionHandling.IsCriticalException(e))
{
throw;
}
Exception exceptionToReturn = e;
// If it's a TargetInvocationException, we only care about the contents of the inner exception,
// so just save that instead.
if (e is TargetInvocationException)
{
exceptionToReturn = e.InnerException;
}
return(new OutOfProcTaskHostTaskResult
(
TaskCompleteType.CrashedDuringInitialization,
exceptionToReturn,
"TaskInstantiationFailureError",
new string[] { taskName, taskLocation, String.Empty }
));
}
OutOfProcTaskHostTaskResult taskResult;
if (taskType.HasSTAThreadAttribute())
{
#if FEATURE_APARTMENT_STATE
taskResult = InstantiateAndExecuteTaskInSTAThread(oopTaskHostNode, taskType, taskName, taskLocation, taskFile, taskLine, taskColumn,
#if FEATURE_APPDOMAIN
appDomainSetup,
#endif
taskParams);
#else
return(new OutOfProcTaskHostTaskResult
(
TaskCompleteType.CrashedDuringInitialization,
null,
"TaskInstantiationFailureNotSupported",
new string[] { taskName, taskLocation, typeof(RunInSTAAttribute).FullName }
));
#endif
}
else
{
taskResult = InstantiateAndExecuteTask(oopTaskHostNode, taskType, taskName, taskLocation, taskFile, taskLine, taskColumn,
#if FEATURE_APPDOMAIN
appDomainSetup,
#endif
taskParams);
}
return(taskResult);
}
/// <summary>
/// Do the work of actually instantiating and running the task.
/// </summary>
private OutOfProcTaskHostTaskResult InstantiateAndExecuteTask
(
IBuildEngine oopTaskHostNode,
LoadedType taskType,
string taskName,
string taskLocation,
string taskFile,
int taskLine,
int taskColumn,
#if FEATURE_APPDOMAIN
AppDomainSetup appDomainSetup,
#endif
IDictionary <string, TaskParameter> taskParams
)
{
#if FEATURE_APPDOMAIN
_taskAppDomain = null;
#endif
wrappedTask = null;
try
{
wrappedTask = TaskLoader.CreateTask(taskType, taskName, taskFile, taskLine, taskColumn, new TaskLoader.LogError(LogErrorDelegate),
#if FEATURE_APPDOMAIN
appDomainSetup,
#endif
true /* always out of proc */
#if FEATURE_APPDOMAIN
, out _taskAppDomain
#endif
);
wrappedTask.BuildEngine = oopTaskHostNode;
}
catch (Exception e)
{
if (ExceptionHandling.IsCriticalException(e))
{
throw;
}
Exception exceptionToReturn = e;
// If it's a TargetInvocationException, we only care about the contents of the inner exception,
// so just save that instead.
if (e is TargetInvocationException)
{
exceptionToReturn = e.InnerException;
}
return(new OutOfProcTaskHostTaskResult
(
TaskCompleteType.CrashedDuringInitialization,
exceptionToReturn,
"TaskInstantiationFailureError",
new string[] { taskName, taskLocation, String.Empty }
));
}
foreach (KeyValuePair <string, TaskParameter> param in taskParams)
{
try
{
PropertyInfo paramInfo = wrappedTask.GetType().GetProperty(param.Key, BindingFlags.Instance | BindingFlags.Public);
paramInfo.SetValue(wrappedTask, param.Value?.WrappedParameter, null);
}
catch (Exception e)
{
if (ExceptionHandling.IsCriticalException(e))
{
throw;
}
Exception exceptionToReturn = e;
// If it's a TargetInvocationException, we only care about the contents of the inner exception,
// so just save that instead.
if (e is TargetInvocationException)
{
exceptionToReturn = e.InnerException;
}
return(new OutOfProcTaskHostTaskResult
(
TaskCompleteType.CrashedDuringInitialization,
exceptionToReturn,
"InvalidTaskAttributeError",
new string[] { param.Key, param.Value.ToString(), taskName }
));
}
}
bool success = false;
try
{
if (CancelPending)
{
return(new OutOfProcTaskHostTaskResult(TaskCompleteType.Failure));
}
// If it didn't crash and return before now, we're clear to go ahead and execute here.
success = wrappedTask.Execute();
}
catch (Exception e)
{
if (ExceptionHandling.IsCriticalException(e))
{
throw;
}
return(new OutOfProcTaskHostTaskResult(TaskCompleteType.CrashedDuringExecution, e));
}
PropertyInfo[] finalPropertyValues = wrappedTask.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public);
IDictionary <string, Object> finalParameterValues = new Dictionary <string, Object>(StringComparer.OrdinalIgnoreCase);
foreach (PropertyInfo value in finalPropertyValues)
{
// only record outputs
if (value.GetCustomAttributes(typeof(OutputAttribute), true).Count() > 0)
{
try
{
finalParameterValues[value.Name] = value.GetValue(wrappedTask, null);
}
catch (Exception e)
{
if (ExceptionHandling.IsCriticalException(e))
{
throw;
}
// If it's not a critical exception, we assume there's some sort of problem in the parameter getter --
// so save the exception, and we'll re-throw once we're back on the main node side of the
// communications pipe.
finalParameterValues[value.Name] = e;
}
}
}
return(new OutOfProcTaskHostTaskResult(success ? TaskCompleteType.Success : TaskCompleteType.Failure, finalParameterValues));
}
private static int RunTarget()
{
StaticTarget target;
var ser = new DataContractJsonSerializer(typeof(StaticTarget));
using (var memoryStream = new MemoryStream())
{
using (var writer = new StreamWriter(memoryStream, Encoding.Default, 1024 * 4, true))
{
string s;
while ((s = Console.ReadLine()) != null)
{
writer.WriteLine(s);
}
}
memoryStream.Position = 0;
target = (StaticTarget)ser.ReadObject(memoryStream);
}
foreach (StaticTarget.Task staticTask in target.Tasks)
{
Type type;
if (staticTask.AssemblyFile != null)
{
AssemblyName an = AssemblyName.GetAssemblyName(staticTask.AssemblyFile);
if (an == null)
{
Console.WriteLine("Caouldn't get assembly name for assembly file: " + staticTask.AssemblyFile);
return(1);
}
Assembly a = Assembly.Load(an);
if (a == null)
{
Console.WriteLine("Couldn't loaded assembly for assembly: " + an.FullName + " from file: " + staticTask.AssemblyFile);
return(1);
}
type = a.GetType(staticTask.Name.Split(',')[0]);
if (type == null)
{
Console.WriteLine("Couldn't create type for string: " + staticTask.Name.Split(',')[0] + " assembly file: " + (staticTask.AssemblyFile ?? "null") + " and assembly name: " + (staticTask.AssemblyName ?? "null"));
Console.WriteLine("Types in the assembly:\n" + string.Join(",\n", a.GetTypes().Select(availableType => availableType.FullName)));
return(1);
}
}
else
{
type = Type.GetType(staticTask.Name);
if (type == null)
{
Console.WriteLine("Couldn't create type for string: " + staticTask.Name + " assembly file: " + (staticTask.AssemblyFile ?? "null") + " and assembly name: " + (staticTask.AssemblyName ?? "null"));
return(1);
}
}
var assemblyLoadInfo = AssemblyLoadInfo.Create(assemblyFile: staticTask.AssemblyFile, assemblyName: staticTask.AssemblyName);
if (assemblyLoadInfo == null)
{
Console.WriteLine("Couldn't create type for assembly file: " + (staticTask.AssemblyFile ?? "null") + " and name: " + (staticTask.AssemblyName ?? "null"));
return(1);
}
LoadedType loadedType = new LoadedType(type, assemblyLoadInfo, null);
TaskPropertyInfo[] taskProperties = AssemblyTaskFactory.GetTaskParameters(loadedType);
ITask task = TaskLoader.CreateTask(loadedType, staticTask.Name, staticTask.AssemblyName, 0, 0, null
#if FEATURE_APPDOMAIN
, null
#endif
, false
#if FEATURE_APPDOMAIN
, out var appDomain
#endif
);
foreach (var parameter in staticTask.Parameters)
{
var taskPropertyInfo = taskProperties.FirstOrDefault(property => property.Name == parameter.Key);
if (taskPropertyInfo == null)
{
Console.Error.WriteLine("Could not find property: \"" + parameter.Key + "\" for task + \"" + staticTask.Name + "\"");
return(1);
}
StaticTarget.Task.ParameterType parameterType = parameter.Value.ParameterType;
switch (parameterType)
{
case StaticTarget.Task.ParameterType.Primitive:
object value = GetTypedValue(parameter.Value.Primitive.Type, parameter.Value.Primitive.Value);
TaskFactoryWrapper.SetPropertyValue(task, taskPropertyInfo, value);
break;
case StaticTarget.Task.ParameterType.Primitives:
var values = GetTypedArrayValue(parameter.Value.Primitives.Type, parameter.Value.Primitives.Values);
TaskFactoryWrapper.SetPropertyValue(task, taskPropertyInfo, values);
break;
case StaticTarget.Task.ParameterType.TaskItem:
TaskFactoryWrapper.SetPropertyValue(task, taskPropertyInfo, new TaskItem(parameter.Value.TaskItem.ItemSpec, parameter.Value.TaskItem.Metadata));
break;
case StaticTarget.Task.ParameterType.TaskItems:
ITaskItem[] taskItems = parameter.Value.TaskItems.Select(taskItem => new TaskItem(taskItem.ItemSpec, taskItem.Metadata)).ToArray();
TaskFactoryWrapper.SetPropertyValue(task, taskPropertyInfo, taskItems);
break;
}
}
task.BuildEngine = new SimpleBuildEngine();
try
{
// MSBuild ignores this return value :(
task.Execute();
}
catch (Exception e)
{
Console.Error.WriteLine("TASK ERROR: " + e);
return(1);
}
}
return(0);
}
