public RabbitMQMessageBus(IDependencyResolver resolver, string rabbitMqExchangeName, IModel rabbitMqChannel) : base(resolver)
{
_rabbitmqchannel = rabbitMqChannel;
_rabbitmqExchangeName = rabbitMqExchangeName;
EnsureConnection();
}
/// <summary>
/// Initialize's the MVC Controller Factory, using Sitecore's Controller Factory as the inner factory.
/// http://www.superstarcoders.com/blogs/posts/using-castle-windsor-with-sitecore-mvc-for-dependency-injection.aspx
/// </summary>
public void SetupMvcControllerFactory(IDependencyResolver resolver)
{
IControllerFactory controllerFactory = new WindsorControllerFactory(resolver);
SCSitecoreControllerFactory scSitecoreControllerFactory = new SCSitecoreControllerFactory(controllerFactory);
ControllerBuilder.Current.SetControllerFactory(scSitecoreControllerFactory);
}
public RequestEntityReaderHydrator(IDependencyResolver resolver, IRequest request)
{
this.Log = NullLogger<CodecLogSource>.Instance;
this.ErrorCollector = NullErrorCollector.Instance;
this.resolver = resolver;
this.request = request;
}
private static Filter CreateFilter(FilterAttributeMetadata filterMetadata,
IDependencyResolver dependencyResolver)
{
var filter = dependencyResolver.GetService(filterMetadata.Attribute.FilterType);
filterMetadata.Attribute.InitializeFilter(filter);
return new Filter(filter, filterMetadata.Scope, GetFilterOrder(filter));
}
public Dispatcher(IDependencyResolver dependencyResolver,
IJobCoordinator jobCoordinator, IErrorHandlingPolicy errorHandlingPolicy,
IMethodBinder methodBinder,
IEventStream eventStream,
IRecoverableAction recoverableAction,
IStatusChanger statusChanger,
IContinuationLiveness continuationLiveness,
IExceptionFilterDispatcher exceptionFilterDispatcher,
IJobRootValidator jobRootValidator)
{
if (jobCoordinator == null) throw new ArgumentNullException("jobCoordinator");
if (dependencyResolver == null) throw new ArgumentNullException("dependencyResolver");
if (errorHandlingPolicy == null) throw new ArgumentNullException("errorHandlingPolicy");
if (methodBinder == null) throw new ArgumentNullException("methodBinder");
if (eventStream == null) throw new ArgumentNullException("eventStream");
if (recoverableAction == null) throw new ArgumentNullException("recoverableAction");
if (statusChanger == null) throw new ArgumentNullException("statusChanger");
if (continuationLiveness == null) throw new ArgumentNullException("continuationLiveness");
if (exceptionFilterDispatcher == null) throw new ArgumentNullException("exceptionFilterDispatcher");
if (jobRootValidator == null) throw new ArgumentNullException("jobRootValidator");
_jobCoordinator = jobCoordinator;
_dependencyResolver = dependencyResolver;
_errorHandlingPolicy = errorHandlingPolicy;
_methodBinder = methodBinder;
_eventStream = eventStream;
_recoverableAction = recoverableAction;
_statusChanger = statusChanger;
_continuationLiveness = continuationLiveness;
_exceptionFilterDispatcher = exceptionFilterDispatcher;
_jobRootValidator = jobRootValidator;
}
public HubDispatcherRouteHandler(string url, IDependencyResolver resolver)
{
_url = VirtualPathUtility.ToAbsolute(url);
overrideUrlWithPublished();
_resolver = resolver;
}
private HttpConfiguration(HttpConfiguration configuration, HttpControllerSettings settings)
{
_routes = configuration.Routes;
_filters = configuration.Filters;
_messageHandlers = configuration.MessageHandlers;
_properties = configuration.Properties;
_dependencyResolver = configuration.DependencyResolver;
IncludeErrorDetailPolicy = configuration.IncludeErrorDetailPolicy;
// per-controller settings
Services = settings.IsServiceCollectionInitialized ? settings.Services : configuration.Services;
_formatters = settings.IsFormatterCollectionInitialized ? settings.Formatters : configuration.Formatters;
ParameterBindingRules = settings.IsParameterBindingRuleCollectionInitialized ? settings.ParameterBindingRules : configuration.ParameterBindingRules;
// Use the original configuration's initializer so that its Initialize()
// will perform the same logic on this clone as on the original.
Initializer = configuration.Initializer;
// create a new validator cache if the validator providers have changed
if (settings.IsServiceCollectionInitialized &&
!settings.Services.GetModelValidatorProviders().SequenceEqual(configuration.Services.GetModelValidatorProviders()))
{
ModelValidatorCache validatorCache = new ModelValidatorCache(new Lazy<IEnumerable<ModelValidatorProvider>>(() => Services.GetModelValidatorProviders()));
RegisterForDispose(validatorCache);
settings.Services.Replace(typeof(IModelValidatorCache), validatorCache);
}
}
protected void UseMessageBus(MessageBusType type, IDependencyResolver resolver, int streams = 1)
{
IMessageBus bus = null;
switch (type)
{
case MessageBusType.Default:
break;
case MessageBusType.Fake:
case MessageBusType.FakeMultiStream:
bus = new FakeScaleoutBus(resolver, streams);
break;
case MessageBusType.SqlServer:
break;
case MessageBusType.ServiceBus:
break;
case MessageBusType.Redis:
break;
default:
break;
}
if (bus != null)
{
resolver.Register(typeof(IMessageBus), () => bus);
}
}
public virtual void Initialize(IDependencyResolver resolver)
{
if (resolver == null)
{
throw new ArgumentNullException("resolver");
}
if (_initialized)
{
return;
}
MessageBus = resolver.Resolve<IMessageBus>();
JsonSerializer = resolver.Resolve<JsonSerializer>();
TraceManager = resolver.Resolve<ITraceManager>();
Counters = resolver.Resolve<IPerformanceCounterManager>();
AckHandler = resolver.Resolve<IAckHandler>();
ProtectedData = resolver.Resolve<IProtectedData>();
UserIdProvider = resolver.Resolve<IUserIdProvider>();
_configurationManager = resolver.Resolve<IConfigurationManager>();
_transportManager = resolver.Resolve<ITransportManager>();
_initialized = true;
}
public ForeverTransport(HostContext context, IDependencyResolver resolver)
: this(context,
resolver.Resolve<IJsonSerializer>(),
resolver.Resolve<ITransportHeartBeat>(),
resolver.Resolve<IPerformanceCounterManager>())
{
}
private void AddSignalRInjection(IContainer container,IDependencyResolver resolver)
{
var updater = new ContainerBuilder();
updater.RegisterInstance(resolver.Resolve<IConnectionManager>());
updater.Update(container);
}
/// <summary>
///
/// </summary>
/// <param name="resolver"></param>
public MessageBus(IDependencyResolver resolver)
: this(resolver.Resolve<IStringMinifier>(),
resolver.Resolve<ITraceManager>(),
resolver.Resolve<IPerformanceCounterManager>(),
resolver.Resolve<IConfigurationManager>())
{
}
public MyOpenRastaDependencyResolverAccessor()
{
var resolver = new InternalDependencyResolver();
resolver.AddDependency<OwinCommunicationContext>(DependencyLifetime.PerRequest);
resolver.AddDependency<IValidator<Widget>, RulesForWidgetRequests>(DependencyLifetime.PerRequest);
_resolver = resolver;
}
public PersistentConnectionHandler(AppFunc app, string path, Type connectionType, IDependencyResolver resolver)
{
_app = app;
_path = path;
_connectionType = connectionType;
_resolver = resolver;
}
public ComparisonService(IRectangleIntersectionService rectangleIntersectionService, IAdjacencyService adjacencyService, IDependencyResolver resolver, IShapeFactory shapeFactory)
{
_rectangleIntersectionService = rectangleIntersectionService;
_adjacencyService = adjacencyService;
_resolver = resolver;
_shapeFactory = shapeFactory;
}
public RedisMessageBus(string server, int port, string password, int db, IEnumerable<string> keys, IDependencyResolver resolver)
: base(resolver)
{
_db = db;
_keys = keys.ToArray();
_connection = new RedisConnection(host: server, port: port, password: password);
_connection.Closed += OnConnectionClosed;
_connection.Error += OnConnectionError;
// Start the connection
_connectTask = _connection.Open().Then(() => {
// Create a subscription channel in redis
_channel = _connection.GetOpenSubscriberChannel();
// Subscribe to the registered connections
_channel.Subscribe(_keys, OnMessage);
// Dirty hack but it seems like subscribe returns before the actual
// subscription is properly setup in some cases
while (_channel.SubscriptionCount == 0) {
Thread.Sleep(500);
}
});
}
/// <summary>
/// Registers a dependency resolver with a given actor system.
/// </summary>
/// <param name="system">The actor system in which to register the given dependency resolver.</param>
/// <param name="dependencyResolver">The dependency resolver being registered to the actor system.</param>
/// <exception cref="ArgumentNullException">
/// Either the <paramref name="system"/> or the <paramref name="dependencyResolver"/> was null.
/// </exception>
public static void AddDependencyResolver(this ActorSystem system, IDependencyResolver dependencyResolver)
{
if (system == null) throw new ArgumentNullException("system");
if (dependencyResolver == null) throw new ArgumentNullException("dependencyResolver");
system.RegisterExtension(DIExtension.DIExtensionProvider);
DIExtension.DIExtensionProvider.Get(system).Initialize(dependencyResolver);
}
public RabbitMqMessageBus( IDependencyResolver resolver,
RabbitMqScaleoutConfiguration configuration,
RabbitConnectionBase advancedConnectionInstance = null)
: base(resolver, configuration)
{
if (configuration == null)
{
throw new ArgumentNullException("configuration");
}
_rabbitConnectionBase = advancedConnectionInstance ?? new EasyNetQRabbitConnection(configuration);
_rabbitConnectionBase.OnDisconnectionAction = OnConnectionLost;
_rabbitConnectionBase.OnReconnectionAction = ConnectToRabbit;
_rabbitConnectionBase.OnMessageReceived = wrapper => Receivingbuffer.Add(wrapper);
ConnectToRabbit();
Task.Factory.StartNew(()=>
{
while (true)
{
foreach (var message in Receivingbuffer.GetConsumingEnumerable())
{
try
{
OnReceived(0, message.Id, message.ScaleoutMessage);
}
catch
{
OnConnectionLost();
}
}
}
});
}
/// <summary>
/// Initializes a new instance of the <see cref="JobRunner"/> class.
/// </summary>
public JobRunner(IJobConfiguration configuration, Type jobType, JobLockProvider jobLockProvider, JobHistoryProvider jobHistoryProvider, IDependencyResolver dependencyResolver)
{
_id = Guid.NewGuid().ToString("N").Substring(0, 10).ToLower();
_isBusy = new Synchronized<bool>();
_lastResult = new Synchronized<string>();
_lastRunStartTime = new Synchronized<DateTime>();
_lastRunFinishTime = new Synchronized<DateTime>();
_lastStatus = new Synchronized<JobStatus>();
_nextRunTime = new Synchronized<DateTime>();
_status = new Synchronized<JobStatus>();
_runLock = new object();
_name = configuration.Name;
_description = configuration.Description;
_group = configuration.Group;
_interval = configuration.Interval;
_isTimeOfDay = configuration.IsTimeOfDay;
_keepAlive = configuration.KeepAlive;
_arguments = configuration.Arguments;
_jobType = jobType;
_jobLockProvider = jobLockProvider ?? new DefaultJobLockProvider();
_dependencyResolver = dependencyResolver ?? new DefaultDependencyResolver();
_jobHistoryProvider = jobHistoryProvider;
_instance = null;
_timer = new Timer(OnTimerCallback);
if (_jobHistoryProvider != null)
_jobHistoryProvider.RestoreHistory(this);
Trace.TraceInformation("Job {0} created on {1}.", Name, Environment.MachineName);
}
public MemoryHost(IDependencyResolver resolver)
: base(resolver)
{
resolver.InitializePerformanceCounters(Process.GetCurrentProcess().GetUniqueInstanceName(_shutDownToken.Token), _shutDownToken.Token);
User = Thread.CurrentPrincipal;
}
/// <summary>
/// Initializes a new instance of <see cref="TransportManager"/> class.
/// </summary>
/// <param name="resolver">The default <see cref="IDependencyResolver"/>.</param>
public TransportManager(IDependencyResolver resolver)
{
Register("foreverFrame", context => new ForeverFrameTransport(context, resolver));
Register("serverSentEvents", context => new ServerSentEventsTransport(context, resolver));
Register("longPolling", context => new LongPollingTransport(context, resolver));
Register("webSockets", context => new WebSocketTransport(context, resolver));
}
internal BuildManagerViewEngine(IViewPageActivator viewPageActivator, IResolver<IViewPageActivator> activatorResolver,
IDependencyResolver dependencyResolver, VirtualPathProvider pathProvider)
{
if (viewPageActivator != null)
{
_viewPageActivator = viewPageActivator;
}
else
{
_activatorResolver = activatorResolver ?? new SingleServiceResolver<IViewPageActivator>(
() => null,
new DefaultViewPageActivator(dependencyResolver),
"BuildManagerViewEngine constructor");
}
if (pathProvider != null)
{
Func<VirtualPathProvider> providerFunc = () => pathProvider;
_fileExistsCache = new FileExistenceCache(providerFunc);
VirtualPathProviderFunc = providerFunc;
}
else
{
if (_sharedFileExistsCache == null)
{
// Startup initialization race is OK providing service remains read-only
_sharedFileExistsCache = new FileExistenceCache(() => HostingEnvironment.VirtualPathProvider);
}
_fileExistsCache = _sharedFileExistsCache;
}
}
public ServerCommandHandler(IDependencyResolver resolver) :
this(resolver.Resolve<IMessageBus>(),
resolver.Resolve<IServerIdManager>(),
resolver.Resolve<JsonSerializer>())
{
}
public ApplicationOAuthProvider(string publicClientId, IDependencyResolver dependencyResolver)
{
Requires.NotNull(dependencyResolver, "dependencyResolver");
_dependencyResolver = dependencyResolver;
_publicClientId = publicClientId;
}
/// <summary>
/// Initializes new instance of <see cref="Server"/>.
/// </summary>
/// <param name="url">The url to host the server on.</param>
/// <param name="resolver">The dependency resolver for the server.</param>
public Server(string url, IDependencyResolver resolver)
: base(resolver)
{
_url = url.Replace("*", @".*?");
_listener = new HttpListener();
_listener.Prefixes.Add(url);
}
public LongPollingTransport(HostContext context, IDependencyResolver resolver)
: this(context,
resolver.Resolve<IJsonSerializer>(),
resolver.Resolve<ITransportHeartBeat>(),
resolver.Resolve<IPerformanceCounterWriter>())
{
}
public ConfiguradorDeDependencias(IDependencyResolver container)
{
this.container = container;
repositorioFactory = new RepositorioFactory(GerenciadorSinais.CaminhoDoArquivoDoRepositorio);
caracteristicasFactory = new CaracteristicasFactory();
algoritmoFactory = new AlgoritmoClassificacaoSinalFactory(caracteristicasFactory);
}
internal RedisMessageBus(IDependencyResolver resolver, RedisScaleoutConfiguration configuration, IRedisConnection connection, bool connectAutomatically)
: base(resolver, configuration)
{
if (configuration == null)
{
throw new ArgumentNullException("configuration");
}
_connection = connection;
_connectionString = configuration.ConnectionString;
_db = configuration.Database;
_key = configuration.EventKey;
var traceManager = resolver.Resolve<ITraceManager>();
_trace = traceManager["SignalR." + typeof(RedisMessageBus).Name];
ReconnectDelay = TimeSpan.FromSeconds(2);
if (connectAutomatically)
{
ThreadPool.QueueUserWorkItem(_ =>
{
var ignore = ConnectWithRetry();
});
}
}
public DefaultViewPageActivator(IDependencyResolver resolver)
{
if (resolver == null)
_resolverThunk = () => DependencyResolver.Current;
else
_resolverThunk = () => resolver;
}
public UnityBasedDependencyResolver(
IDependencyResolver baseResolver,
IUnityContainer unityContainer)
{
_baseResolver = baseResolver;
_unityContainer = unityContainer;
}
public MediatorPlan(Type handlerTypeTemplate, string handlerMethodName, Type messageType, IDependencyResolver dependencyResolver)
{
var handlerType = handlerTypeTemplate.MakeGenericType(messageType, typeof(TResult));
HandleMethod = GetHandlerMethod(handlerType, handlerMethodName, messageType);
HandlerInstanceBuilder = () => dependencyResolver.GetInstance(handlerType);
}
/*
* In previous practice. We refactored InvokeAction method. Now we have
* renamed its name from "InvokeAction" to "InvokeActionInternal". The
* InvokeAction method will no longer accept ActionDescriptor instance.
* Instead, it will create the ActionDescriptor instance from a matching
* route and an IDependencyResolver instance.
*
* The matched route contains the type of the controller, the name of the
* action and the method constraint. It should use a resolver to create
* controller from its type.
*/
public static HttpResponseMessage InvokeAction(HttpRoute matchedRoute, IDependencyResolver resolver)
{
return(InvokeActionInternal(new ActionDescriptor(null, matchedRoute.ActionName, matchedRoute.MethodConstraint)));
}
public ServerSentEventsTransport(HostContext context, IDependencyResolver resolver)
: base(context, resolver)
{
}
public OrderSchema(OrdersQuery query, OrdersMutation mutation, IDependencyResolver resolver)
{
Query = query;
Mutation = mutation;
DependencyResolver = resolver;
}
public CardapioCategoriaSchema(IDependencyResolver resolver)
: base(resolver)
{
Query = resolver.Resolve <CardapioCategoriaQuery>();
Mutation = resolver.Resolve <CardapioCategoriaMutation>();
}
public abstract bool TryResolve(IDependencyResolver resolver, out object value);
public abstract object Resolve(IDependencyResolver resolver);
public HubDispatcherHandler(AppFunc app, string path, IDependencyResolver resolver)
{
_app = app;
_path = path;
_resolver = () => resolver;
}
public RootSchema(IDependencyResolver resolver)
: base(resolver)
{
Query = resolver.Resolve <RootQuery>();
Mutation = resolver.Resolve <RootMutation>();
}
public static T Resolve <T>(this IDependencyResolver resolver) => (T)resolver.Resolve(typeof(T));
public ScaleoutMessageBus(IDependencyResolver resolver)
: base(resolver)
{
}
public abstract void inject(object instance, IDependencyResolver dependencyResolver, IDependencyResolver explicitDependencies);
internal SingleServiceResolver(Func <TService> staticAccessor, TService defaultValue, IDependencyResolver resolver, string callerMethodName)
: this(staticAccessor, defaultValue, callerMethodName)
{
if (resolver != null)
{
_resolverThunk = () => resolver;
}
}
public Mediator(IDependencyResolver dependencyResolver)
{
_dependencyResolver = dependencyResolver;
}
public MyStateSchema(IDependencyResolver resolver) : base(resolver)
{
Query = resolver.Resolve <MyStateQuery>();
}
public static void RegisterOverrides(IDependencyResolver resolver)
{
resolver.GetContainer();
}
/// <summary>
/// Allows setting the dependency resolver.
/// </summary>
/// <param name="dependencyResolver">The dependency resolver to set.</param>
public static void SetLocator(IDependencyResolver dependencyResolver)
{
InternalLocator.SetLocator(dependencyResolver);
}
/// <summary>
/// Sets the DependencyResolver to use throughout Trout
/// </summary>
/// <param name="dependencyResolver"></param>
public static void SetDependencyResolver(IDependencyResolver dependencyResolver)
{
CurrentResolver = dependencyResolver;
}
public RestoreHandler(IConfigProvider configProvider, IDependencyResolver dependencyResolver)
{
this.configProvider = configProvider;
this.dependencyResolver = dependencyResolver;
}
public static IDependencyResolver UseSqlServer(this IDependencyResolver resolver, string connectionString)
{
return(UseSqlServer(resolver, connectionString, 1));
}
/// <summary>
/// Initializes a new instance of the <see cref="ShellService" /> class.
/// </summary>
/// <param name="typeFactory">The type factory.</param>
/// <param name="keyboardMappingsService">The keyboard mappings service.</param>
/// <param name="commandManager">The command manager.</param>
/// <param name="splashScreenService">The splash screen service.</param>
/// <param name="ensureStartupService">The ensure startup service.</param>
/// <param name="applicationInitializationService">The application initialization service.</param>
/// <param name="dependencyResolver">The dependency resolver.</param>
/// <exception cref="ArgumentNullException">The <paramref name="typeFactory" /> is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">The <paramref name="keyboardMappingsService" /> is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">The <paramref name="commandManager" /> is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">The <paramref name="splashScreenService" /> is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">The <paramref name="applicationInitializationService" /> is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">The <paramref name="dependencyResolver" /> is <c>null</c>.</exception>
public ShellService(ITypeFactory typeFactory, IKeyboardMappingsService keyboardMappingsService, ICommandManager commandManager,
ISplashScreenService splashScreenService, IEnsureStartupService ensureStartupService, IApplicationInitializationService applicationInitializationService, IDependencyResolver dependencyResolver)
{
Argument.IsNotNull(() => typeFactory);
Argument.IsNotNull(() => keyboardMappingsService);
Argument.IsNotNull(() => commandManager);
Argument.IsNotNull(() => splashScreenService);
Argument.IsNotNull(() => ensureStartupService);
Argument.IsNotNull(() => applicationInitializationService);
Argument.IsNotNull(() => dependencyResolver);
_typeFactory = typeFactory;
_keyboardMappingsService = keyboardMappingsService;
_commandManager = commandManager;
_splashScreenService = splashScreenService;
_ensureStartupService = ensureStartupService;
_applicationInitializationService = applicationInitializationService;
_dependencyResolver = dependencyResolver;
var entryAssembly = Catel.Reflection.AssemblyHelper.GetEntryAssembly();
Log.Info("Starting {0} v{1} ({2})", entryAssembly.Title(), entryAssembly.Version(), entryAssembly.InformationalVersion());
// Initialize (now we have an application)
DotNetPatchHelper.Initialize();
}
public DependencyResolverFactory(IDependencyResolver resolver)
{
Checks.Argument.IsNotNull(resolver, "resolver");
_resolver = resolver;
}
public void Create(TSubject subject, IDependencyResolver resolver)
{
ResolvedDependencies = m_ResolveDependedncies(resolver.GetService).ToList();
Create(subject);
}
public WriteCommand(IDependencyResolver resolver)
{
this.resolver = resolver;
}
public WithdrawFundsFromAtmCommandHandler(IUnitOfWork <Cqrs.Authentication.ISingleSignOnToken> unitOfWork, IDependencyResolver dependencyResolver, ILogger logger)
{
UnitOfWork = unitOfWork;
DependencyResolver = dependencyResolver;
Logger = logger;
}
public SystemAndAttributesOperationInterceptorProvider(IDependencyResolver resolver)
: this(resolver.ResolveAll <IOperationInterceptor>)
{
}
public StateMachineActivator(IModelRepository modelRepo, IDependencyResolver resolver)
{
_modelRepo = modelRepo;
_resolver = resolver;
}
public AppSchema(IDependencyResolver resolver)
: base(resolver)
{
Query = resolver.Resolve <AppQuery>();
Mutation = resolver.Resolve <AppMutation>();
}
public RedisMessageBus(IDependencyResolver resolver, RedisScaleoutConfiguration configuration, IRedisConnection connection)
: this(resolver, configuration, connection, true)
{
}
public AngularWriter(IDependencyResolver resolver)
{
this.resolver = resolver;
}