/// <summary>
/// Retrieves the list of types available in the assemblies found by the <see cref="AssemblyFinder"/> specified in the constructor.
/// </summary>
/// <param name="baseType">The base type to match. Can be null.</param>
/// <param name="excludeGlobalTypes">Indicates whether types from all referenced assemblies should be checked.</param>
/// <returns>
/// A collection of types that match the criteria specified by baseType and excludeGlobalTypes.
/// </returns>
public ICollection GetTypes(Type baseType, bool excludeGlobalTypes)
{
var nonNullBaseType = baseType ?? typeof(object);
if (nonNullBaseType.IsSealed) // ValueTypes are also sealed
{
return new[] { nonNullBaseType }
}
;
if (!excludeGlobalTypes && AssemblyTypeCache.IsGacAssembly(nonNullBaseType.Assembly))
{
return(_globalTypesCache.GetOrAdd(
nonNullBaseType,
key =>
{
s_log.Value.DebugFormat("Discovering types derived from '{0}', including GAC...", key);
using (StopwatchScope.CreateScope(
s_log.Value,
LogLevel.Info,
string.Format("Discovered types derived from '{0}', including GAC. Time taken: {{elapsed}}", key)))
{
return GetTypesFromAllAssemblies(key, false).ToList().AsReadOnly();
}
}));
}
var baseTypeCache = _baseTypeCache.Value;
Assertion.IsTrue(_baseTypeCache.IsValueCreated);
return(baseTypeCache.GetTypes(nonNullBaseType));
}
public List <EnumValueInfo> GetAccessTypesFromAssembly(Assembly assembly, MetadataCache cache)
{
ArgumentUtility.CheckNotNull("assembly", assembly);
ArgumentUtility.CheckNotNull("cache", cache);
List <EnumValueInfo> accessTypes = new List <EnumValueInfo> ();
foreach (var type in AssemblyTypeCache.GetTypes(assembly))
{
if (type.IsEnum && Attribute.IsDefined(type, typeof(AccessTypeAttribute), false))
{
Dictionary <Enum, EnumValueInfo> values = _enumerationReflector.GetValues(type, cache);
foreach (KeyValuePair <Enum, EnumValueInfo> entry in values)
{
if (!cache.ContainsAccessType(entry.Key))
{
cache.AddAccessType(entry.Key, entry.Value);
}
accessTypes.Add(entry.Value);
}
}
}
return(accessTypes);
}
private IEnumerable <Type> GetTypesFromBaseType(_Assembly assembly, Type baseType)
{
ReadOnlyCollection <Type> allTypesInAssembly;
try
{
allTypesInAssembly = AssemblyTypeCache.GetTypes(assembly);
}
catch (ReflectionTypeLoadException ex)
{
string message = string.Format(
"The types from assembly '{0}' could not be loaded.{1}{2}",
assembly.GetName(),
Environment.NewLine,
string.Join(Environment.NewLine, ex.LoaderExceptions.Select(e => e.Message)));
throw new TypeLoadException(message, ex);
}
if (baseType == null)
{
return(allTypesInAssembly);
}
return(GetFilteredTypes(allTypesInAssembly, baseType));
}
private static void InstallDefaultRules(ValidatingVisitor visitor)
{
foreach (Type t in AssemblyTypeCache.GetTypes(Assembly.GetExecutingAssembly()))
{
if (!t.IsAbstract && typeof(IRuleSet).IsAssignableFrom(t) && t.Namespace == typeof(IRuleSet).Namespace)
{
IRuleSet ruleSet = (IRuleSet)Activator.CreateInstance(t);
ruleSet.Install(visitor);
}
}
}
/// <summary>
/// Adds all consumers in the specified assemblies
/// </summary>
/// <param name="configurator"></param>
/// <param name="assemblies">The assemblies to scan for consumers</param>
public static void AddConsumers(this IRegistrationConfigurator configurator, params Assembly[] assemblies)
{
if (assemblies.Length == 0)
{
assemblies = AppDomain.CurrentDomain.GetAssemblies();
}
var types = AssemblyTypeCache.FindTypes(assemblies, IsConsumerOrDefinition).GetAwaiter().GetResult();
AddConsumers(configurator, types.FindTypes(TypeClassification.Concrete | TypeClassification.Closed).ToArray());
}
/// <summary>
/// Adds SagaStateMachines to the registry, using the factory method, and updates the registrar prior to registering so that the default
/// saga registrar isn't notified.
/// </summary>
/// <param name="configurator"></param>
/// <param name="registrar"></param>
/// <param name="assemblies">The assemblies to scan for state machines</param>
public static void AddSagaStateMachines(this IRegistrationConfigurator configurator, ISagaStateMachineRegistrar registrar, params Assembly[] assemblies)
{
if (assemblies.Length == 0)
{
assemblies = AppDomain.CurrentDomain.GetAssemblies();
}
var types = AssemblyTypeCache.FindTypes(assemblies, IsSagaStateMachineOrDefinition).GetAwaiter().GetResult();
configurator.AddSagaStateMachines(registrar, types.FindTypes(TypeClassification.Concrete).ToArray());
}
public static void RegisterSagaStateMachines(this IContainerRegistrar registrar, params Assembly[] assemblies)
{
if (assemblies.Length == 0)
{
assemblies = AppDomain.CurrentDomain.GetAssemblies();
}
var types = AssemblyTypeCache.FindTypes(assemblies, x => x.HasInterface(typeof(SagaStateMachine <>))).GetAwaiter().GetResult();
registrar.RegisterSagaStateMachines(types.FindTypes(TypeClassification.Concrete | TypeClassification.Closed).ToArray());
}
/// <summary>
/// Adds all futures that match the given filter in the specified assemblies
/// </summary>
/// <param name="configurator"></param>
/// <param name="filter"></param>
/// <param name="assemblies">The assemblies to scan for futures</param>
public static void AddFutures(this IRegistrationConfigurator configurator, Func <Type, bool> filter, params Assembly[] assemblies)
{
if (assemblies.Length == 0)
{
assemblies = AppDomain.CurrentDomain.GetAssemblies();
}
var types = AssemblyTypeCache.FindTypes(assemblies, TypeMetadataCache.IsFutureOrDefinition).GetAwaiter().GetResult();
AddFutures(configurator, filter, types.FindTypes(TypeClassification.Concrete | TypeClassification.Closed).ToArray());
}
static IEnumerable <Type> FindTypesInNamespace(Type type, Func <Type, bool> typeFilter)
{
bool Filter(Type candidate)
{
return(typeFilter(candidate) &&
candidate.Namespace != null &&
candidate.Namespace.StartsWith(type.Namespace, StringComparison.OrdinalIgnoreCase));
}
return(AssemblyTypeCache.FindTypes(type.Assembly, TypeClassification.Concrete, Filter).GetAwaiter().GetResult());
}
/// <summary>
/// Adds SagaStateMachines to the registry, using the factory method, and updates the registrar prior to registering so that the default
/// saga registrar isn't notified.
/// </summary>
/// <param name="configurator"></param>
/// <param name="assemblies">The assemblies to scan for state machines</param>
public static void AddSagaStateMachines(this IRegistrationConfigurator configurator, params Assembly[] assemblies)
{
if (assemblies.Length == 0)
{
assemblies = AppDomain.CurrentDomain.GetAssemblies();
}
var types = AssemblyTypeCache.FindTypes(assemblies,
type => TypeMetadataCache.IsSagaStateMachineOrDefinition(type) && !TypeMetadataCache.IsFutureOrDefinition(type))
.GetAwaiter().GetResult();
configurator.AddSagaStateMachines(types.FindTypes(TypeClassification.Concrete | TypeClassification.Closed).ToArray());
}
static IList <Type> FindTypes <T>(IKernel kernel, Func <Type, bool> filter)
{
Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
TypeSet types = AssemblyTypeCache.FindTypes(assemblies, typeof(T).IsAssignableFrom).Result;
return(types.AllTypes()
.SelectMany(kernel.GetBindings)
.Select(x => x.Service)
.Distinct()
.Where(filter)
.ToList());
}
/// <summary>
/// Scans the given assembly for declarative mixin configuration information and stores the information for a later call to <see cref="BuildConfiguration"/>.
/// The mixin configuration information of types marked with the <see cref="IgnoreForMixinConfigurationAttribute"/> will be ignored.
/// </summary>
/// <param name="assembly">The assembly to be scanned.</param>
/// <returns>A reference to this <see cref="DeclarativeConfigurationBuilder"/> object.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="assembly"/> parameter is <see langword="null"/>.</exception>
public DeclarativeConfigurationBuilder AddAssembly(Assembly assembly)
{
ArgumentUtility.CheckNotNull("assembly", assembly);
s_log.DebugFormat("Adding assembly {0} to DeclarativeConfigurationBuilder.", assembly);
foreach (var t in AssemblyTypeCache.GetTypes(assembly))
{
if (!t.IsDefined(typeof(IgnoreForMixinConfigurationAttribute), false) && !MixinTypeUtility.IsGeneratedByMixinEngine(t))
{
AddType(t);
}
}
return(this);
}
static IServiceInstanceTransportConfigurator <TEndpointConfigurator> GetServiceInstanceTransportConfigurator()
{
var assembly = typeof(TEndpointConfigurator).Assembly;
var transportConfiguratorType = AssemblyTypeCache
.FindTypes(assembly, TypeClassification.Concrete, x => x.HasInterface <IServiceInstanceTransportConfigurator <TEndpointConfigurator> >())
.GetAwaiter().GetResult().FirstOrDefault();
if (transportConfiguratorType == null)
{
throw new ArgumentException($"Type not found: {TypeMetadataCache<IServiceInstanceTransportConfigurator<TEndpointConfigurator>>.ShortName}");
}
return((IServiceInstanceTransportConfigurator <TEndpointConfigurator>)Activator.CreateInstance(transportConfiguratorType));
}
TypeConverterCache()
{
_typeConverters = new ConcurrentDictionary <Type, object>();
_converters = new List <object>();
var assembly = typeof(BooleanTypeConverter).Assembly;
var ns = typeof(BooleanTypeConverter).Namespace;
var converterTypes = AssemblyTypeCache.FindTypes(assembly, TypeClassification.Concrete | TypeClassification.Closed,
x => x.Namespace.StartsWith(ns) && x.HasInterface(typeof(ITypeConverter <,>))).GetAwaiter().GetResult().ToArray();
foreach (var converterType in converterTypes)
{
AddSupportedTypes(converterType);
}
}
private void ConfigureLogging()
{
if (_parameters.Verbose)
{
LogManager.InitializeConsole();
}
else
{
var mixerLoggers = from t in AssemblyTypeCache.GetTypes(typeof(Mixer).Assembly)
where t.Namespace == typeof(Mixer).Namespace
select LogManager.GetLogger(t);
var logThresholds = from l in mixerLoggers
select new LogThreshold(l, LogLevel.Info);
LogManager.InitializeConsole(LogLevel.Warn, logThresholds.ToArray());
}
}
static IEnumerable <Type> FindTypesInNamespace(Type type, Func <Type, bool> typeFilter)
{
if (type.Namespace == null)
{
throw new ArgumentException("The type must have a valid namespace", nameof(type));
}
var dottedNamespace = type.Namespace + ".";
bool Filter(Type candidate)
{
return(typeFilter(candidate) &&
candidate.Namespace != null &&
(candidate.Namespace.StartsWith(dottedNamespace, StringComparison.OrdinalIgnoreCase) ||
candidate.Namespace.Equals(type.Namespace, StringComparison.OrdinalIgnoreCase)));
}
return(AssemblyTypeCache.FindTypes(type.Assembly, TypeClassification.Concrete | TypeClassification.Closed, Filter).GetAwaiter().GetResult());
}
public static async Task MapEndpointConventions(this IBusFactoryConfigurator cfg, params Assembly[] assemblies)
{
var types = await AssemblyTypeCache.FindTypes(assemblies, t =>
{
var info = t.GetTypeInfo();
return(!info.IsAbstract && !info.IsInterface && typeof(ICommand).IsAssignableFrom(t));
});
var allTypes = types.AllTypes();
var mapMethod = typeof(EndpointConvention)
.GetMethod("Map", BindingFlags.Static | BindingFlags.Public, null, new Type[] { typeof(Uri) }, null);
foreach (var type in allTypes)
{
var generic = mapMethod.MakeGenericMethod(type);
generic.Invoke(null, new object[] { new Uri($"queue:{type.Name}") });
}
}
public void GetMetadata(Assembly assembly, MetadataCache cache)
{
ArgumentUtility.CheckNotNull("assembly", assembly);
ArgumentUtility.CheckNotNull("cache", cache);
Assembly securityAssembly = GetType().Assembly;
_accessTypeReflector.GetAccessTypesFromAssembly(securityAssembly, cache);
_accessTypeReflector.GetAccessTypesFromAssembly(assembly, cache);
_abstractRoleReflector.GetAbstractRoles(securityAssembly, cache);
_abstractRoleReflector.GetAbstractRoles(assembly, cache);
foreach (Type type in AssemblyTypeCache.GetTypes(assembly))
{
if (typeof(ISecurableObject).IsAssignableFrom(type))
{
_classReflector.GetMetadata(type, cache);
}
}
}
public Task <TypeSet> ScanForTypes()
{
return(AssemblyTypeCache.FindTypes(_assemblies, _filter.Matches));
}
public static IServiceCollection ConfigureBus(this IServiceCollection services, IConfiguration configuration,
string apiResourceName, Assembly assembly,
Action <IServiceCollectionConfigurator <IExternalBus> > postAction = null)
{
var config = new MassTransitConfig();
configuration.Bind("MassTransitConfig", config);
// get referenced assemblies
var assemblies = new List <Assembly> {
assembly
};
assemblies.AddRange(assembly.GetProjectReferencedAssemblies());
// find consumers
var types = AssemblyTypeCache.FindTypes(assemblies, TypeMetadataCache.IsConsumerOrDefinition).GetAwaiter()
.GetResult();
var consumers = types.FindTypes(TypeClassification.Concrete | TypeClassification.Closed).ToArray();
var internals = new List <Type>();
var externals = new List <Type>();
foreach (var type in consumers)
{
if (type.HasInterface <IExternalConsumer>())
{
externals.Add(type);
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine($"{type.FullName} registered into External Bus");
}
else
{
internals.Add(type);
Console.ForegroundColor = ConsoleColor.Magenta;
Console.WriteLine($"{type.FullName} registered into Mediator");
}
}
services.AddMediator(x =>
{
x.AddConsumers(internals.ToArray());
});
//services.AddMassTransit(x =>
//{
// x.AddConsumers(internals.ToArray());
// x.AddMediator((provider, cfg) => { cfg.UseFluentValidation(); });
//});
services.AddMassTransit <IExternalBus>(x =>
{
x.AddConsumers(externals.ToArray());
x.AddBus(provider =>
{
switch (config.BusType)
{
case BusType.AzureServiceBus:
case BusType.ActiveMQ:
case BusType.AmazonSQS:
throw new NotImplementedException();
default:
var busControl = Bus.Factory.CreateUsingRabbitMq(cfg =>
{
cfg.Host(new Uri(config.RabbitMQ.Address), h =>
{
h.Username(config.RabbitMQ.Username);
h.Password(config.RabbitMQ.Password);
});
cfg.ReceiveEndpoint(apiResourceName, ep => { ep.ConfigureConsumers(provider); });
cfg.ConnectConsumerConfigurationObserver(
new FluentValidationConsumerConfigurationObserver(provider));
//cfg.UseFluentValidation();
});
return(busControl);
}
});
postAction?.Invoke(x);
});
services.AddMassTransitHostedService();
return(services);
}
/// <summary>
/// Gets the default service configuration for the types in the given assemblies.
/// </summary>
/// <param name="assemblies">The assemblies for whose types to get the default service configuration.</param>
/// <returns>A <see cref="ServiceConfigurationEntry"/> for each type that has the <see cref="ImplementationForAttribute"/> applied.
/// Types without the attribute are ignored.</returns>
public IEnumerable <ServiceConfigurationEntry> GetDefaultConfiguration(IEnumerable <Assembly> assemblies)
{
ArgumentUtility.CheckNotNull("assemblies", assemblies);
return(assemblies.SelectMany(a => GetDefaultConfiguration(AssemblyTypeCache.GetTypes(a))));
}
/// <summary>
/// Gets the default service configuration for the given types.
/// </summary>
/// <param name="serviceType">The type to get the default service configuration for.</param>
/// <returns>A <see cref="ServiceConfigurationEntry"/> for each serviceType that has implementations with a <see cref="ImplementationForAttribute"/> applied.
/// Types without the attribute are ignored.</returns>
public ServiceConfigurationEntry GetDefaultConfiguration(Type serviceType)
{
ArgumentUtility.CheckNotNull("serviceType", serviceType);
try
{
var excludeGlobalTypes = _excludeGlobalTypesForDefaultConfiguration || !AssemblyTypeCache.IsGacAssembly(serviceType.Assembly);
var implementingTypes = GetImplementingTypes(serviceType, excludeGlobalTypes);
var attributes = implementingTypes
.SelectMany(
implementingType => GetImplementationForAttributesFromCache(implementingType)
.Where(attribute => attribute.ServiceType == serviceType)
.Select(CloneAttribute)
.Select(attribute => Tuple.Create(implementingType, attribute)))
.ToLookup(a => a.Item2.RegistrationType);
if (attributes.Contains(RegistrationType.Compound) && attributes.Contains(RegistrationType.Single))
{
throw new InvalidOperationException("Registration types 'Compound' and 'Single' cannot be used together.");
}
if (attributes.Contains(RegistrationType.Single) && attributes.Contains(RegistrationType.Multiple))
{
throw new InvalidOperationException("Registration types 'Single' and 'Multiple' cannot be used together.");
}
return(ServiceConfigurationEntry.CreateFromAttributes(serviceType, FilterAttributes(attributes)));
}
catch (Exception ex)
{
var message = string.Format("Invalid configuration of service type '{0}'. {1}", serviceType, ex.Message);
throw new InvalidOperationException(message, ex);
}
}
