/// <summary>
/// "Builds" values for parameters by building a set of <see cref="UnitInfo" />(<paramref name="parameters" />[i], <see cref="SpecialToken.InjectValue" />)
/// one by one via current build session
/// </summary>
public static object[] GetValuesForParameters([NotNull] this IBuildSession buildSession, [NotNull] ParameterInfo[] parameters)
{
if (buildSession == null)
{
throw new ArgumentNullException(nameof(buildSession));
}
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
if (parameters.Length == 0)
{
throw new ArgumentException("At least one parameters should be provided", nameof(parameters));
}
var values = new object[parameters.Length];
for (var i = 0; i < parameters.Length; i++)
{
var buildResult = buildSession.BuildUnit(new UnitInfo(parameters[i], SpecialToken.InjectValue));
if (!buildResult.HasValue)
{
throw new ArmatureException(string.Format("Can't build value for parameter {0}", parameters[i]));
}
values[i] = buildResult.Value;
}
return(values);
}
public object Get(Type pluginType, Instance instance, IBuildSession session)
{
object result;
var key = instance.InstanceKey(pluginType);
_lock.EnterUpgradeableReadLock();
try
{
if (_objects.ContainsKey(key))
{
result = _objects[key];
}
else
{
_lock.EnterWriteLock();
try
{
result = buildWithSession(pluginType, instance, session);
_objects.Add(key, result);
}
finally
{
_lock.ExitWriteLock();
}
}
}
finally
{
_lock.ExitUpgradeableReadLock();
}
return(result);
}
public void SetUp()
{
theResolver = MockRepository.GenerateMock <IBuildSession>();
theCache = new SessionCache(theResolver);
thePipeline = MockRepository.GenerateMock <IPipelineGraph>();
}
public void Process(IBuildSession buildSession)
{
var unitType = buildSession.GetUnitUnderConstruction().GetUnitType();
var ctor = GetConstructor(unitType.GetConstructors());
buildSession.BuildResult = new BuildResult(ctor);
}
public void PostProcess(IBuildSession buildSession)
{
var assembleResult = buildSession.BuildResult;
var value = (string)assembleResult.Value;
buildSession.BuildResult = new BuildResult(value + _postfix);
}
/// <summary>
/// "Builds" a list of properties of currently building Unit (<paramref name="type" />) for injecting dependencies
/// </summary>
public static IReadOnlyList <PropertyInfo> GetPropertiesToInject(this IBuildSession buildSession, Type type)
{
var unitInfo = new UnitInfo(type, SpecialToken.Property);
var result = buildSession.BuildAllUnits(unitInfo);
return(result?.SelectMany(_ => (IReadOnlyList <PropertyInfo>)_.Value).ToArray() ?? EmptyArray <PropertyInfo> .Instance);
}
public void Process(IBuildSession buildSession)
{
if (buildSession.GetUnitUnderConstruction().Id is ParameterInfo parameterInfo && parameterInfo.HasDefaultValue)
{
buildSession.BuildResult = new BuildResult(parameterInfo.DefaultValue);
}
}
public object Get(Type pluginType, Instance instance, IBuildSession session)
{
object result = null;
int key = instance.InstanceKey(pluginType);
_lock.EnterUpgradeableReadLock();
if (_objects.ContainsKey(key))
{
result = _objects[key];
_lock.ExitUpgradeableReadLock();
}
else
{
_lock.EnterWriteLock();
try
{
result = buildWithSession(pluginType, instance, session);
_objects.Add(key, result);
}
finally
{
_lock.ExitWriteLock();
}
}
return result;
}
public void PostProcess(IBuildSession buildSession)
{
if (buildSession.BuildResult.HasValue)
{
_instance = new Instance(buildSession.BuildResult.Value);
}
}
public void Process(IBuildSession buildSession)
{
if (_instance != null)
{
buildSession.BuildResult = new BuildResult(_instance.Value);
}
}
public static TPluginType Build <TPluginType>(this Instance instance, IBuildSession session = null) where TPluginType : class
{
var plan = instance.ResolveBuildPlan(typeof(TPluginType), new Policies());
var buildSession = session ?? new FakeBuildSession();
return(plan.Build(buildSession, buildSession.As <IContext>()).As <TPluginType>());
}
public void PostProcess(IBuildSession buildSession)
{
if (_effectiveBuildActions.TryRemove(buildSession, out var effectiveBuildAction))
{
effectiveBuildAction.PostProcess(buildSession);
Log.WriteLine(LogLevel.Info, () => string.Format("redirected execution to {0}", effectiveBuildAction));
}
}
/// <summary>
/// Builds an argument to inject into the property representing by <paramref name="propertyInfo" />
/// </summary>
public static object?BuildPropertyArgument(this IBuildSession buildSession, PropertyInfo propertyInfo)
{
var buildResult = buildSession.BuildUnit(new UnitId(propertyInfo, SpecialTag.Argument));
return(buildResult.HasValue
? buildResult.Value
: throw new ArmatureException(string.Format("Argument for property '{0}' of {1} is not built", propertyInfo, propertyInfo.DeclaringType)));
}
public SessionCache(IBuildSession resolver, ExplicitArguments arguments)
: this(resolver)
{
if (arguments != null)
{
_defaults = arguments.Defaults;
}
}
public void Process(IBuildSession buildSession)
{
if (!buildSession.BuildResult.HasValue)
{
var type = buildSession.GetUnitUnderConstruction().GetUnitType();
// ReSharper disable once PossibleNullReferenceException
if (!type.IsInterface && !type.IsAbstract)
{
ConstructorInfo constructor;
using (Log.Block(LogLevel.Trace, "Looking for constructor"))
{
constructor = buildSession.GetConstructorOf(type);
}
var parameters = constructor.GetParameters();
if (parameters.Length == 0 && type.IsValueType) // do not create default value of value type, it can confuse logic
{
return;
}
try
{
object instance;
if (parameters.Length == 0)
{
instance = constructor.Invoke(EmptyArray <object> .Instance);
}
else
{
object[] valuesForParameters;
using (Log.Block(LogLevel.Trace, () => "Looking for parameters [" + string.Join(", ", parameters.Select(_ => _.ToString()).ToArray()) + "]"))
{
valuesForParameters = buildSession.GetValuesForParameters(parameters);
}
instance = constructor.Invoke(valuesForParameters);
}
buildSession.BuildResult = new BuildResult(instance);
}
catch (TargetInvocationException exception)
{
if (exception.InnerException == null)
{
throw;
}
// extract original exception from TargetInvocationException and throw it,
// store original stack trace as exception data since throwing will replace it
exception.InnerException.AddData(ExceptionData.TargetInvocationStackTrace, exception.StackTrace);
exception.InnerException.AddData(ExceptionData.OriginalStackTrace, exception.InnerException.StackTrace);
throw exception.InnerException;
}
}
}
}
public void Process(IBuildSession buildSession)
{
var unitUnderConstruction = buildSession.GetUnitUnderConstruction();
var effectiveToken = Equals(_token, Token.Propagate) ? unitUnderConstruction.Token : _token;
var genericType = _redirectTo.MakeGenericType(buildSession.GetUnitUnderConstruction().GetUnitType().GetGenericArguments());
buildSession.BuildResult = buildSession.BuildUnit(new UnitInfo(genericType, effectiveToken));
}
public static string GetParameterOrDefault(this IBuildSession session, string name, string defaultValue)
{
if (session.HasParameter(name))
{
return(session.GetParameter(name));
}
return(defaultValue);
}
public void Process(IBuildSession buildSession)
{
if (!buildSession.BuildResult.HasValue)
{
var parameters = GetMethod().GetParameters().ToArray();
var result = Execute(buildSession.GetValuesForParameters(parameters));
buildSession.BuildResult = new BuildResult(result);
}
}
public object Get(Type pluginType, Instance instance, IBuildSession session)
{
var @object = session.BuildNewInSession(pluginType, instance);
if (@object is IDisposable)
{
_tracked.Add(@object);
}
return @object;
}
public static int Exec(this IBuildSession session, string filename, string arguments, TimeSpan timeout)
{
return(Exec(session, config =>
{
config.StartInfo.FileName = filename;
config.StartInfo.Arguments = arguments;
config.Timeout = timeout;
config.OnErrorMessage = m => session.Tracer().Error(m);
config.OnOutputMessage = m => session.Tracer().Log(m);
}));
}
public void Process(IBuildSession buildSession)
{
if (!buildSession.BuildResult.HasValue)
{
var unitUnderConstruction = buildSession.GetUnitUnderConstruction();
var effectiveToken = Equals(_token, Token.Propagate) ? unitUnderConstruction.Token : _token;
var unitInfo = new UnitInfo(_redirectTo, effectiveToken);
buildSession.BuildResult = buildSession.BuildUnit(unitInfo);
}
}
public object Get(Type pluginType, Instance instance, IBuildSession session)
{
var lightweigtInstance = instance as LightweightObjectInstance;
if (lightweigtInstance == null)
{
throw new InvalidOperationException("No lifecycle " +
"only works with lightweight object instances.");
}
return(lightweigtInstance.Object);
}
public static string GetParameter(this IBuildSession session, string name)
{
string value;
if (!session.Parameters.TryGetValue(name, out value))
{
throw new BuildCsException("Build parameter '{0}' was not supplied.".F(name));
}
return(value);
}
public static void RunTargetOrDefault(this IBuildSession session, string defaultTarget)
{
var runner = session.TargetRunner();
if (runner.TargetsToRun.Count == 0)
{
runner.TargetsToRun.Add(defaultTarget);
}
Run(session);
}
public object Get(Type pluginType, Instance instance, IBuildSession session)
{
var @object = session.BuildNewInSession(pluginType, instance);
if (@object is IDisposable)
{
_tracked.Add(@object);
}
return(@object);
}
public SessionCacheTester()
{
theResolverMock = Substitute.For<IBuildSession>();
theCache = new SessionCache(theResolverMock);
thePipeline = Substitute.For<IPipelineGraph>();
thePipeline.ToModel().Returns(new Container().Model);
instanceGraphMock = Substitute.For<IInstanceGraph>();
thePipeline.Instances.Returns(instanceGraphMock);
}
public object Build(IBuildSession session, IContext context)
{
try
{
return(_func(session, context));
}
catch (StructureMapException e)
{
e.Instances.Add(Instance.Id);
throw;
}
}
public void SetUp()
{
theResolver = MockRepository.GenerateMock<IBuildSession>();
theCache = new SessionCache(theResolver);
thePipeline = MockRepository.GenerateMock<IPipelineGraph>();
thePipeline.Stub(x => x.ToModel()).Return(new Container().Model);
theInstances = MockRepository.GenerateMock<IInstanceGraph>();
thePipeline.Stub(x => x.Instances).Return(theInstances);
}
public SessionCacheTester()
{
theResolverMock = Substitute.For <IBuildSession>();
theCache = new SessionCache(theResolverMock);
thePipeline = Substitute.For <IPipelineGraph>();
thePipeline.ToModel().Returns(new Container().Model);
instanceGraphMock = Substitute.For <IInstanceGraph>();
thePipeline.Instances.Returns(instanceGraphMock);
}
public void SetUp()
{
theResolver = MockRepository.GenerateMock <IBuildSession>();
theCache = new SessionCache(theResolver);
thePipeline = MockRepository.GenerateMock <IPipelineGraph>();
thePipeline.Stub(x => x.ToModel()).Return(new Container().Model);
theInstances = MockRepository.GenerateMock <IInstanceGraph>();
thePipeline.Stub(x => x.Instances).Return(theInstances);
}
public void Process(IBuildSession buildSession)
{
var exceptions = new List <Exception>();
foreach (var buildAction in _buildActions)
{
try
{
buildAction.Process(buildSession);
if (!buildSession.BuildResult.HasValue)
{
Log.WriteLine(LogLevel.Trace, () => string.Format("{0} has not built value", buildAction));
}
else
{
Log.WriteLine(LogLevel.Info, () => string.Format("redirected execution to {0}", buildAction));
_effectiveBuildActions.TryAdd(buildSession, buildAction);
break;
}
}
catch (ArmatureException exc)
{
LogException(exc);
exceptions.Add(exc);
// continue;
}
catch (Exception exc)
{
Log.WriteLine(LogLevel.Trace, () => string.Format("User exception was throw during executing {0}", buildAction));
LogException(exc);
for (var i = 0; i < exceptions.Count; i++)
{
exc.AddData(i, exceptions[i]);
}
throw;
}
}
if (!buildSession.BuildResult.HasValue && exceptions.Count > 0)
{
var exception = new ArmatureException("Multiply exceptions occured during processing build actions");
for (var i = 0; i < exceptions.Count; i++)
{
exception.AddData(i, exceptions[i]);
}
throw exception;
}
}
public void PostProcess(IBuildSession buildSession)
{
if (buildSession.BuildResult.HasValue)
{
var unit = buildSession.BuildResult.Value;
var type = unit.GetType();
var properties = buildSession.GetPropertiesToInject(type);
foreach (var property in properties)
{
var value = buildSession.GetValueForProperty(property);
property.SetValue(unit, value);
}
}
}
public static object?[] BuildArgumentsForMethod(this IBuildSession buildSession, ParameterInfo[] parameters)
{
if (buildSession is null)
{
throw new ArgumentNullException(nameof(buildSession));
}
if (parameters is null)
{
throw new ArgumentNullException(nameof(parameters));
}
if (parameters.Length == 0)
{
throw new ArgumentException("At least one parameter should be provided", nameof(parameters));
}
return((object?[])buildSession.BuildUnit(new UnitId(parameters, SpecialTag.Argument)).Value !);
}
public void Process(IBuildSession buildSession)
{
var propertyInfo = (PropertyInfo)buildSession.GetUnitUnderConstruction().Id;
var attribute = propertyInfo
.GetCustomAttributes <InjectAttribute>()
.SingleOrDefault();
if (attribute == null)
{
Log.WriteLine(LogLevel.Info, () => string.Format("{0}{{{1}}}", this, "No Property marked with InjectAttribute"));
}
else
{
var unitInfo = new UnitInfo(propertyInfo.PropertyType, attribute.InjectionPointId);
buildSession.BuildResult = buildSession.BuildUnit(unitInfo);
}
}
public object Get(Type pluginType, Instance instance, IBuildSession session)
{
object result;
var key = instance.InstanceKey(pluginType);
_lock.EnterUpgradeableReadLock();
try
{
if (_instances.Contains(instance))
{
throw new StructureMapBuildException("Bi-directional dependency relationship detected!" +
Environment.NewLine + "Check the StructureMap stacktrace below:");
}
if (_objects.ContainsKey(key))
{
result = _objects[key];
}
else
{
_lock.EnterWriteLock();
try
{
_instances.Add(instance);
result = buildWithSession(pluginType, instance, session);
_objects.Add(key, result);
}
finally
{
_instances.Remove(instance);
_lock.ExitWriteLock();
}
}
}
finally
{
_lock.ExitUpgradeableReadLock();
}
return result;
}
public object Get(Type pluginType, Instance instance, IBuildSession session)
{
return session.BuildNewInSession(pluginType, instance);
}
protected virtual object buildWithSession(Type pluginType, Instance instance, IBuildSession session)
{
return session.BuildNewInOriginalContext(pluginType, instance);
}
public object Build(IBuildSession session, IContext context)
{
try
{
return _func(session, context);
}
catch (StructureMapException e)
{
e.Instances.Add(_instance.Id);
throw;
}
}
protected override object buildWithSession(Type pluginType, Instance instance, IBuildSession session)
{
return session.BuildNewInSession(pluginType, instance);
}
public void SetUp()
{
theResolver = MockRepository.GenerateMock<IBuildSession>();
theCache = new SessionCache(theResolver);
thePipeline = MockRepository.GenerateMock<IPipelineGraph>();
}
