public String Render(IList<Object> args, IConnectionFactory factory) { if (args.Count != 2) throw new MappingException("cast() requires two arguments"); return "cast(" + args[0] + " as " + factory.Dialect.GetCastTypeName((String)args[1]) + ')'; }
public RdapConnectionListener() { sessionRegister = new SessionRegistrator(); publisherRegistrator = new PublisherRegistrator(); connectionFactory = new RdapConnectionFactory(sessionRegister, publisherRegistrator); connectionListener = new TcpConnectionListener(connectionFactory, sessionRegister); }
public Queue(MsgDeliveryMode mode = MsgDeliveryMode.NonPersistent) { Uri msgQueue = new Uri("activemq:tcp://localhost:61616"); _factory = new ConnectionFactory(msgQueue); try { _connection = _factory.CreateConnection(); } catch (NMSConnectionException ex) { Log.FatalException("Error connecting to MQ server", ex); throw; } // TODO check _connection for null _connection.RequestTimeout = TimeSpan.FromSeconds(60); Session = _connection.CreateSession(); // TODO need to find out if queue exists. // It creates a new queue if it doesn't exist. _destination = Session.GetDestination("queue://TwitterSearchStream"); _consumer = Session.CreateConsumer(_destination); _producer = Session.CreateProducer(_destination); _producer.RequestTimeout = TimeSpan.FromSeconds(60); _producer.DeliveryMode = mode; _connection.Start(); _connection.ExceptionListener += _connection_ExceptionListener; _connection.ConnectionInterruptedListener += _connection_ConnectionInterruptedListener; }
private static void ComposeConnectionFactory() { try { using (var catalog = new DirectoryCatalog(AppDomain.CurrentDomain.BaseDirectory)) using (var container = new CompositionContainer(catalog)) { var export = container.GetExportedValueOrDefault<IConnectionFactory>(); if (export != null) { Factory = export; Console.WriteLine("Using {0}", Factory.GetType()); } } } catch (ImportCardinalityMismatchException) { Console.WriteLine("More than one IConnectionFactory import was found."); } catch (Exception e) { Console.WriteLine(e); } if (Factory == null) { Factory = new DefaultConnectionFactory(); Console.WriteLine("Using default connection factory..."); } }
public void SetUp() { var configuration = new ConnectionConfiguration { Hosts = new List<IHostConfiguration> { new HostConfiguration { Host = "localhost", Port = 5672 } }, UserName = "******", Password = "******" }; configuration.Validate(); var typeNameSerializer = new TypeNameSerializer(); connectionFactory = new ConnectionFactoryWrapper(configuration, new DefaultClusterHostSelectionStrategy<ConnectionFactoryInfo>()); serializer = new JsonSerializer(typeNameSerializer); conventions = new Conventions(typeNameSerializer); consumerErrorStrategy = new DefaultConsumerErrorStrategy( connectionFactory, serializer, new ConsoleLogger(), conventions, typeNameSerializer); }
public SequenceFactory(IDocumentSchema schema, IConnectionFactory factory, StoreOptions options, IMartenLogger logger) { _schema = schema; _factory = factory; _options = options; _logger = logger; }
public VentanaPuja(ItemPuja ip, Usuario u) { factory = new NMSConnectionFactory(connecturi); user = u; itemPuja = ip; InitializeComponent(); }
// Verbindung zum Messaging-Server aktualisieren public void UpdateConnection() { try { // eventuell früher belegte Ressourcen freigeben CleanupResources(); // Verbindung / Session / MessageProducer und -Consumer instanziieren if (connectionFactory == null) { Console.WriteLine(brokerURL); connectionFactory = new ConnectionFactory(brokerURL); } connection = connectionFactory.CreateConnection(); session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge); messageProducer = session.CreateProducer(new ActiveMQTopic(topicName)); // Thread zum Empfang eingehender Nachrichten starten connection.Start(); Console.WriteLine("Connection geändert, Broker-URL ist " + brokerURL); } catch (Exception e) { Console.WriteLine("*** EXCEPTION in updateConnection(): " + e.Message); } }
private void CreateMocks() { mockConnectionFactory = (IConnectionFactory) mocks.CreateMock(typeof (IConnectionFactory)); mockConnection = (IConnection) mocks.CreateMock(typeof (IConnection)); mockSession = (ISession) mocks.CreateMock(typeof (ISession)); IQueue queue = (IQueue) mocks.CreateMock(typeof (IQueue)); Expect.Call(mockConnectionFactory.CreateConnection()).Return(mockConnection).Repeat.Once(); if (UseTransactedTemplate) { Expect.Call(mockConnection.CreateSession(AcknowledgementMode.Transactional)).Return(mockSession).Repeat. Once(); } else { Expect.Call(mockConnection.CreateSession(AcknowledgementMode.AutoAcknowledge)).Return(mockSession). Repeat. Once(); } Expect.Call(mockSession.Transacted).Return(true); mockDestinationResolver = (IDestinationResolver) mocks.CreateMock(typeof (IDestinationResolver)); mockDestinationResolver.ResolveDestinationName(mockSession, "testDestination", false); LastCall.Return(queue).Repeat.Any(); }
public SharedConnectionPoolFactory( IConnectionFactory connectionFactory, ConnectionPoolSettings connectionPoolSettings) { _connectionFactory = Ensure.IsNotNull(connectionFactory, "connectionFactory"); _connectionPoolSettings = Ensure.IsNotNull(connectionPoolSettings, "connectionPoolSettings"); }
public MQ() { producer = null; factory = null; connection = null; session = null; }
public RabbitResourceHolder(IConnectionFactory connectionFactory, IConnection connection, IModel channel) { this.connectionFactory = connectionFactory; AddConnection(connection); AddChannel(channel); this.frozen = true; }
// constructors public ExclusiveConnectionPool( ServerId serverId, EndPoint endPoint, ConnectionPoolSettings settings, IConnectionFactory connectionFactory, IEventSubscriber eventSubscriber) { _serverId = Ensure.IsNotNull(serverId, nameof(serverId)); _endPoint = Ensure.IsNotNull(endPoint, nameof(endPoint)); _settings = Ensure.IsNotNull(settings, nameof(settings)); _connectionFactory = Ensure.IsNotNull(connectionFactory, nameof(connectionFactory)); Ensure.IsNotNull(eventSubscriber, nameof(eventSubscriber)); _connectionHolder = new ListConnectionHolder(eventSubscriber); _poolQueue = new WaitQueue(settings.MaxConnections); _waitQueue = new SemaphoreSlim(settings.WaitQueueSize); _maintenanceCancellationTokenSource = new CancellationTokenSource(); _state = new InterlockedInt32(State.Initial); eventSubscriber.TryGetEventHandler(out _checkingOutConnectionEventHandler); eventSubscriber.TryGetEventHandler(out _checkedOutConnectionEventHandler); eventSubscriber.TryGetEventHandler(out _checkingOutConnectionFailedEventHandler); eventSubscriber.TryGetEventHandler(out _checkingInConnectionEventHandler); eventSubscriber.TryGetEventHandler(out _checkedInConnectionEventHandler); eventSubscriber.TryGetEventHandler(out _addingConnectionEventHandler); eventSubscriber.TryGetEventHandler(out _addedConnectionEventHandler); eventSubscriber.TryGetEventHandler(out _openingEventHandler); eventSubscriber.TryGetEventHandler(out _openedEventHandler); eventSubscriber.TryGetEventHandler(out _closingEventHandler); eventSubscriber.TryGetEventHandler(out _closedEventHandler); eventSubscriber.TryGetEventHandler(out _addingConnectionEventHandler); eventSubscriber.TryGetEventHandler(out _addedConnectionEventHandler); }
/// <summary> /// Instantiate Db with connectionString and a custom IConnectionFactory /// </summary> /// <param name="connectionString">the connection string</param> /// <param name="config"></param> /// <param name="connectionFactory">the connection factory</param> internal Db(string connectionString, DbConfig config, IConnectionFactory connectionFactory = null) { _connectionString = connectionString; _connectionFactory = connectionFactory ?? new AdoNetProviderFactory(config.ProviderName); _connection = new Lazy<IDbConnection>(CreateConnection); Config = config; }
/// <summary> /// Initializes a new instance of the <see cref="Connection"/> class. /// </summary> /// <param name="factory">The pool.</param> public Connection(IConnectionFactory factory) { if (factory == null) throw new ArgumentNullException ("factory"); _factory = factory; }
public PersistentConnection(IConnectionFactory connectionFactory, IEasyNetQLogger logger) { this.connectionFactory = connectionFactory; this.logger = logger; TryToConnect(null); }
public Repository( IConnectionFactory connectionFactory, IConfigurationStore configurationStore) { _connectionFactory = connectionFactory; _configurationStore = configurationStore; }
public ConnectionPool( RedisConfiguration configuration, IConnectionFactory connectionFactory ) { Configuration = configuration; ConnectionFactory = connectionFactory; AvailableConnections = new ConcurrentQueue<IConnection>(); ReservedConnections = new ConcurrentDictionary<IConnection, IConnection>(); }
public Entry() { Log = null; _loopContinue = true; rx = new Regex(@"([\d.]+):(\d+)", RegexOptions.IgnorePatternWhitespace | RegexOptions.IgnoreCase | RegexOptions.Compiled); try { var clientBootstrap = new ClientBootstrap() .SetTransport(TransportType.Udp) .OnConnect(ConnectionEstablishedCallback) .OnReceive(ReceivedDataCallback) .OnDisconnect(ConnectionTerminatedCallback) .OnError(ConnectionOnOnError); _connectionFactory = clientBootstrap.Build(); } catch (Exception) { throw; } _nodeDictionary = new Dictionary<string, INode>(); _connectionDictionary = new Dictionary<string, IConnection>(); }
public ActiveMQClient(string queueUrl, string queueName) { _queueUrl = queueUrl; _queueName = queueName; _connecturi = new Uri("activemq:tcp://" + queueUrl + "?keepAlive=true&randomize=false&wireFormat.maxInactivityDuration=0&nms.prefetchPolicy.all=10000"); _factory = new NMSConnectionFactory(_connecturi); }
public EventStoreAdmin(IDocumentSchema schema, IConnectionFactory connectionFactory, StoreOptions options, ISerializer serializer) { _schema = schema; _connectionFactory = connectionFactory; _options = options; _serializer = serializer; }
/// <summary> /// Releases the given connection, stopping it (if necessary) and eventually closing it. /// </summary> /// <remarks>Checks <see cref="ISmartConnectionFactory.ShouldStop"/>, if available. /// This is essentially a more sophisticated version of /// <see cref="NmsUtils.CloseConnection(IConnection, bool)"/> /// </remarks> /// <param name="connection">The connection to release. (if this is <code>null</code>, the call will be ignored)</param> /// <param name="cf">The ConnectionFactory that the Connection was obtained from. (may be <code>null</code>)</param> /// <param name="started">whether the Connection might have been started by the application.</param> public static void ReleaseConnection(IConnection connection, IConnectionFactory cf, bool started) { if (connection == null) { return; } if (started && cf is ISmartConnectionFactory && ((ISmartConnectionFactory)cf).ShouldStop(connection)) { try { connection.Stop(); } catch (Exception ex) { LOG.Debug("Could not stop NMS Connection before closing it", ex); } } try { connection.Close(); } catch (Exception ex) { LOG.Debug("Could not close NMS Connection", ex); } }
public CustomerAgent(IConnectionFactory ConnectionFactory, CustomerFactory Factory, CustomerAppService CustomerAppService) { this.Factory = Factory; this.ConnectionFactory = ConnectionFactory; this.CustomerAppService = CustomerAppService; }
private void CreateMocks() { mockConnectionFactory = (IConnectionFactory) mocks.CreateMock(typeof (IConnectionFactory)); mockConnection = (IConnection) mocks.CreateMock(typeof (IConnection)); mockSession = (ISession) mocks.CreateMock(typeof (ISession)); TIBCO.EMS.Queue queue = new TIBCO.EMS.Queue("test"); //(Queue) mocks.CreateMock(typeof (Queue)); Expect.Call(mockConnectionFactory.CreateConnection()).Return(mockConnection).Repeat.Once(); if (UseTransactedTemplate) { Expect.Call(mockConnection.CreateSession(true, Session.SESSION_TRANSACTED)).Return(mockSession).Repeat. Once(); } else { Expect.Call(mockConnection.CreateSession(false, Session.AUTO_ACKNOWLEDGE)).Return(mockSession). Repeat. Once(); } Expect.Call(mockSession.Transacted).Return(true); mockDestinationResolver = (IDestinationResolver) mocks.CreateMock(typeof (IDestinationResolver)); mockDestinationResolver.ResolveDestinationName(mockSession, "testDestination", false); LastCall.Return(queue).Repeat.Any(); }
public void Setup() { factory = A.Fake<IConnectionFactory>(); fakeHttp = A.Fake<ISimpleHttpGetRequest>(); fakeWebSocket = A.Fake<IWebSocket>(); heartBeatSignaler = A.Fake<IHeartBeatSignaler>(); A.CallTo(() => factory.CreateHttpRequest(A<string>._)).Returns(fakeHttp); A.CallTo(() => fakeHttp.Execute()).ReturnsLazily(() => handshakeResponse); A.CallTo(() => factory.CreateWebSocket(A<string>._)).Returns(fakeWebSocket); A.CallTo(() => fakeWebSocket.Connected).ReturnsLazily(() => isConnected); A.CallTo(() => fakeWebSocket.Open()).Invokes(() => { isConnected = true; fakeWebSocket.Opened += Raise.With(fakeWebSocket, EventArgs.Empty).Now; }); A.CallTo(() => fakeWebSocket.Close()).Invokes(() => { isConnected = false; fakeWebSocket.Closed += Raise.With(fakeWebSocket, EventArgs.Empty).Now; }); io = new SocketIOClient(factory, heartBeatSignaler); socket = io.Connect("http://localhost:3000"); }
public PersistentConnection(IConnectionFactory connectionFactory, TimeSpan retryDelay) { this.connectionFactory = connectionFactory; this.retryDelay = retryDelay; TryToConnect(null); }
public LinearBlockIdGenerator(IConnectionFactory connectionFactory, int range, string dimension, string tablePrefix) { _connectionFactory = connectionFactory; _range = range; _tablePrefix = tablePrefix; _dimension = dimension; }
public void SetUp() { connectionFactory = new ConnectionFactory("tcp://localhost:61616", GetType().Name); connection = connectionFactory.CreateConnection(); connection.Start(); session = connection.CreateSession(); }
public InheritedSqlPersistenceEngine( IConnectionFactory connectionFactory, ISqlDialect dialect, ISerialize serializer, TransactionScopeOption scopeOption, int pageSize) : base(connectionFactory, dialect, serializer, scopeOption, pageSize) {}
// constructors public ServerFactory(ServerSettings settings, IConnectionPoolFactory connectionPoolFactory, IConnectionFactory heartbeatConnectionFactory, IServerListener listener) { _settings = Ensure.IsNotNull(settings, "settings"); _connectionPoolFactory = Ensure.IsNotNull(connectionPoolFactory, "connectionPoolFactory"); _heartbeatConnectionFactory = Ensure.IsNotNull(heartbeatConnectionFactory, "heartbeatConnectionFactory"); _listener = listener; }
public RabbitMqConnection(ILogWriter logWriter, RabbitMQConfiguration rabbitConfig) { _logWriter = logWriter; _rabbitConfig = rabbitConfig; _connectionFactory = SetupConnection(rabbitConfig); }
public void Initialize() { _connectionFactory = new ConnectionFactory(); _sqlEmployeeRepository = new SQLEmployeeRepository(_connectionFactory, true); }
public DefaultRabbitMQPersistentConnection(IConnectionFactory connectionFactory, ILogger <DefaultRabbitMQPersistentConnection> logger, int retryCount = 5) { _connectionFactory = connectionFactory ?? throw new ArgumentNullException(nameof(connectionFactory)); _logger = logger ?? throw new ArgumentNullException(nameof(logger)); _retryCount = retryCount; }
public SQLAttributeRepository(IConnectionFactory connectionFactory, IConfiguration config) : base(connectionFactory, _tableName, false) { var connectionString = config["connectionString:DefaultConnection"]; connectionFactory.SetConnection(connectionString); }
public LanguagesRepository(IConnectionFactory connectionFactory, IMemoryCache memoryCache) { _connectionFactory = connectionFactory; _memoryCache = memoryCache; }
public AdoDistrictDao(IConnectionFactory connectionFactory) { this._template = new AdoTemplate(connectionFactory); }
public PlanoVooRepository(IConnectionFactory conn) { _conn = conn; }
public static IConfiguration SetConnectionFactory(this IConfiguration configuration, IConnectionFactory connectionFactory) { configuration.ConnectionFactory = connectionFactory; return(configuration); }
public DatabaseCreationUtil(IConnectionFactory connectionFactory) { _connectionFactory = connectionFactory; }
public static async Task UpsertRecordAsync(IConnectionFactory connFactory, ReplicationTable table, Dictionary <string, object> recordMap) { var conn = connFactory.GetConnection(); try { await conn.OpenAsync(); var primaryKey = table.Columns.Find(c => c.PrimaryKey); var primaryValue = recordMap[primaryKey.ColumnName]; if (primaryKey.Serialize) { primaryValue = JsonConvert.SerializeObject(primaryValue); } if (!await RecordExistsAsync(connFactory, table, primaryValue.ToString())) { // insert record var querySb = new StringBuilder( $"INSERT INTO {Utility.Utility.GetSafeName(table.SchemaName)}.{Utility.Utility.GetSafeName(table.TableName)}("); foreach (var column in table.Columns) { querySb.Append($"{Utility.Utility.GetSafeName(column.ColumnName)},"); } querySb.Length--; querySb.Append(") VALUES ("); foreach (var column in table.Columns) { if (recordMap.ContainsKey(column.ColumnName)) { var rawValue = recordMap[column.ColumnName]; if (column.Serialize) { rawValue = JsonConvert.SerializeObject(rawValue); } querySb.Append(rawValue != null ? $"'{Utility.Utility.GetSafeString(rawValue.ToString(), "'", "''")}'," : $"NULL,"); } else { querySb.Append($"NULL,"); } } querySb.Length--; querySb.Append(");"); var query = querySb.ToString(); Logger.Debug($"Insert record query: {query}"); var cmd = connFactory.GetCommand(query, conn); await cmd.ExecuteNonQueryAsync(); } else { // update record var querySb = new StringBuilder( $"UPDATE {Utility.Utility.GetSafeName(table.SchemaName)}.{Utility.Utility.GetSafeName(table.TableName)} SET "); foreach (var column in table.Columns) { if (!column.PrimaryKey) { if (recordMap.ContainsKey(column.ColumnName)) { var rawValue = recordMap[column.ColumnName]; if (column.Serialize) { rawValue = JsonConvert.SerializeObject(rawValue); } if (rawValue != null) { querySb.Append( $"{Utility.Utility.GetSafeName(column.ColumnName)}='{Utility.Utility.GetSafeString(rawValue.ToString(), "'", "''")}',"); } else { querySb.Append($"{Utility.Utility.GetSafeName(column.ColumnName)}=NULL,"); } } else { querySb.Append($"{Utility.Utility.GetSafeName(column.ColumnName)}=NULL,"); } } } querySb.Length--; querySb.Append($" WHERE {Utility.Utility.GetSafeName(primaryKey.ColumnName)} = '{primaryValue}'"); var query = querySb.ToString(); var cmd = connFactory.GetCommand(query, conn); await cmd.ExecuteNonQueryAsync(); } } catch (Exception e) { Logger.Error(e, $"Error Upsert Record: {e.Message}"); throw; } finally { await conn.CloseAsync(); } }
/// <summary> /// Initializes a new instance of the <see cref="SingleConnectionFactory"/> class /// that alwasy returns a single Connection. /// </summary> /// <param name="targetConnectionFactory">The target connection factory.</param> public SingleConnectionFactory(IConnectionFactory targetConnectionFactory) { AssertUtils.ArgumentNotNull(targetConnectionFactory, "targetConnectionFactory", "TargetSession ConnectionFactory must not be null"); this.targetConnectionFactory = targetConnectionFactory; }
public static async Task <ReplicationMetaData> GetPreviousReplicationMetaDataAsync( IConnectionFactory connFactory, string jobId, ReplicationTable table) { var conn = connFactory.GetConnection(); try { ReplicationMetaData replicationMetaData = null; // ensure replication metadata table await EnsureTableAsync(connFactory, table); // check if metadata exists await conn.OpenAsync(); var cmd = connFactory.GetCommand( string.Format(GetMetaDataQuery, Utility.Utility.GetSafeName(table.SchemaName, '`'), Utility.Utility.GetSafeName(table.TableName, '`'), Utility.Utility.GetSafeName(Constants.ReplicationMetaDataJobId), jobId), conn); var reader = await cmd.ExecuteReaderAsync(); if (reader.HasRows()) { // metadata exists await reader.ReadAsync(); var request = JsonConvert.DeserializeObject <PrepareWriteRequest>( reader.GetValueById(Constants.ReplicationMetaDataRequest).ToString()); var shapeName = reader.GetValueById(Constants.ReplicationMetaDataReplicatedShapeName) .ToString(); var shapeId = reader.GetValueById(Constants.ReplicationMetaDataReplicatedShapeId) .ToString(); var timestamp = DateTime.Parse(reader.GetValueById(Constants.ReplicationMetaDataTimestamp) .ToString()); replicationMetaData = new ReplicationMetaData { Request = request, ReplicatedShapeName = shapeName, ReplicatedShapeId = shapeId, Timestamp = timestamp }; } return(replicationMetaData); } catch (Exception e) { Logger.Error(e, e.Message); throw; } finally { await conn.CloseAsync(); } }
public MultimediaTypeRepository(IConnectionFactory connectionFactory) : base(connectionFactory) { }
public DefaultRabbitMQPersisterConnection(IConnectionFactory connectionFactory, ILogger <DefaultRabbitMQPersisterConnection> logger) { _connectionFactory = connectionFactory ?? throw new ArgumentNullException(nameof(connectionFactory)); _logger = logger ?? throw new ArgumentNullException(nameof(logger)); }
public JogoRepository(IConnectionFactory connection) { _connection = connection ?? throw new ArgumentNullException(nameof(connection)); }
public RabbitMQProvider(IConnectionFactory connectionFactory) { _connectionFactory = connectionFactory; }
public PostWriteService(IPostRepository postRepository, IConnectionFactory connectionFactory) { _postRepository = postRepository; _connectionFactory = connectionFactory; }
public CommonDependent(IConnectionFactory ConnectionFactory) { this.ConnectionFactory = ConnectionFactory; }
public AppAccessRepository(IConnectionFactory connectionFactory, ILogger <AppAccessRepository> logger) : base(connectionFactory, logger) { _logger = logger; }
public AccountRepository(IConnectionFactory factory) { _factory = factory; }
public ServiceQuery(IConnectionFactory connectionFactory) { _connectionFactory = connectionFactory; }
public ProxyConnectionFactory(IConnectionFactory innerFactory) { _innerFactory = innerFactory; }
public ReceiveProcessor(IConnectionFactory connectionFactory, string queueName) { _queueName = queueName; _utils = new Utils(); _connectionFactory = connectionFactory; }
public IServiceProvider CreateContainer(ShellSettings settings, ShellBlueprint blueprint) { var featureByType = blueprint.Dependencies.ToDictionary(x => x.Type, x => x.Feature); IServiceCollection tenantServiceCollection = _serviceProvider.CreateChildContainer(_applicationServices); tenantServiceCollection.AddInstance(settings); tenantServiceCollection.AddInstance(blueprint.Descriptor); tenantServiceCollection.AddInstance(blueprint); // Sure this is right? tenantServiceCollection.AddInstance(_loggerFactory); foreach (var dependency in blueprint.Dependencies .Where(t => !typeof(IModule).IsAssignableFrom(t.Type))) { foreach (var interfaceType in dependency.Type.GetInterfaces() .Where(itf => typeof(IDependency).IsAssignableFrom(itf))) { if (_logger.IsEnabled(LogLevel.Debug)) { _logger.LogDebug("Type: {0}, Interface Type: {1}", dependency.Type, interfaceType); } if (typeof(ISingletonDependency).IsAssignableFrom(interfaceType)) { tenantServiceCollection.AddSingleton(interfaceType, dependency.Type); } else if (typeof(ITransientDependency).IsAssignableFrom(interfaceType)) { tenantServiceCollection.AddTransient(interfaceType, dependency.Type); } else if (typeof(IDependency).IsAssignableFrom(interfaceType)) { tenantServiceCollection.AddScoped(interfaceType, dependency.Type); } } } // Register components foreach (var dependency in blueprint.Dependencies) { var serviceComponentAttribute = dependency.Type.GetTypeInfo().GetCustomAttribute <ServiceScopeAttribute>(); if (serviceComponentAttribute != null) { if (_logger.IsEnabled(LogLevel.Debug)) { _logger.LogDebug("Type: {0}, Interface Type: {1}", dependency.Type, serviceComponentAttribute.ServiceType); } serviceComponentAttribute.Register(tenantServiceCollection, dependency.Type); } } // Configure event handlers, they are not part of the blueprint, so they have // to be added manually. Or need to create a module for this. tenantServiceCollection.AddScoped <IEventBus, DefaultOrchardEventBus>(); tenantServiceCollection.AddSingleton <IEventBusState, EventBusState>(); //// Apply custom options for the tenant //var options = blueprint //.Dependencies //.Where(x => typeof(IConfigure).IsAssignableFrom(x.Type)) //.Select(x => x.Type).ToArray(); //// TODO: Group all options by type and reuse the same configuration object //// such that multiple feature can update the same configuration object. //foreach (var type in options) //{ // var optionType = type // .GetInterfaces() // .Where(x => typeof(IConfigure).IsAssignableFrom(x)) // .FirstOrDefault() // .GetGenericArguments() // .FirstOrDefault(); // if(optionType == null) // { // // Ignore non-generic implementation // continue; // } // var optionObject = Activator.CreateInstance(optionType); // var configureMethod = type.GetMethod("Configure"); // var optionHost = Activator.CreateInstance(type); // configureMethod.Invoke(optionHost, new[] { optionObject }); // tenantServiceCollection.ConfigureOptions(optionObject); //} // Configuring data access var indexes = blueprint .Dependencies .Where(x => typeof(IIndexProvider).IsAssignableFrom(x.Type)) .Select(x => x.Type).ToArray(); if (settings.DatabaseProvider != null) { var store = new Store(cfg => { // @"Data Source =.; Initial Catalog = test1; User Id=sa;Password=demo123!" IConnectionFactory connectionFactory = null; switch (settings.DatabaseProvider) { case "SqlConnection": connectionFactory = new DbConnectionFactory <SqlConnection>(settings.ConnectionString); break; //case "SqliteConnection": // connectionFactory = new DbConnectionFactory<SqliteConnection>(settings.ConnectionString); // break; default: throw new ArgumentException("Unknown database provider: " + settings.DatabaseProvider); } cfg.ConnectionFactory = connectionFactory; cfg.IsolationLevel = IsolationLevel.ReadUncommitted; if (!String.IsNullOrWhiteSpace(settings.TablePrefix)) { cfg.TablePrefix = settings.TablePrefix + "_"; } #if SQL var sqlFactory = new SqlDocumentStorageFactory(connectionFactory); sqlFactory.IsolationLevel = IsolationLevel.ReadUncommitted; sqlFactory.ConnectionFactory = connectionFactory; if (!String.IsNullOrWhiteSpace(settings.TablePrefix)) { sqlFactory.TablePrefix = settings.TablePrefix + "_"; } cfg.DocumentStorageFactory = sqlFactory; #else var storageFactory = new LightningDocumentStorageFactory(Path.Combine(_appDataFolderRoot.RootFolder, "Sites", settings.Name, "Documents")); cfg.DocumentStorageFactory = storageFactory; #endif //cfg.RunDefaultMigration(); } ); var idGenerator = new LinearBlockIdGenerator(store.Configuration.ConnectionFactory, 20, "contentitem", store.Configuration.TablePrefix); store.RegisterIndexes(indexes); tenantServiceCollection.AddInstance <IStore>(store); tenantServiceCollection.AddInstance <LinearBlockIdGenerator>(idGenerator); tenantServiceCollection.AddScoped <ISession>(serviceProvider => store.CreateSession() ); } tenantServiceCollection.AddInstance <ITypeFeatureProvider>(new TypeFeatureProvider(featureByType)); IServiceCollection moduleServiceCollection = _serviceProvider.CreateChildContainer(_applicationServices); foreach (var dependency in blueprint.Dependencies .Where(t => typeof(IModule).IsAssignableFrom(t.Type))) { moduleServiceCollection.AddScoped(typeof(IModule), dependency.Type); } var moduleServiceProvider = moduleServiceCollection.BuildServiceProvider(); // Let any module add custom service descriptors to the tenant foreach (var service in moduleServiceProvider.GetServices <IModule>()) { service.Configure(tenantServiceCollection); } // Register event handlers on the event bus var eventHandlers = tenantServiceCollection .Select(x => x.ImplementationType) .Distinct() .Where(t => t != null && typeof(IEventHandler).IsAssignableFrom(t) && t.GetTypeInfo().IsClass) .ToArray(); foreach (var handlerClass in eventHandlers) { tenantServiceCollection.AddScoped(handlerClass); // Register dynamic proxies to intercept direct calls if an IEventHandler is resolved, dispatching the call to // the event bus. foreach (var i in handlerClass.GetInterfaces().Where(t => typeof(IEventHandler).IsAssignableFrom(t))) { tenantServiceCollection.AddScoped(i, serviceProvider => { var proxy = DefaultOrchardEventBus.CreateProxy(i); proxy.EventBus = serviceProvider.GetService <IEventBus>(); return(proxy); }); } } var shellServiceProvider = tenantServiceCollection.BuildServiceProvider(); var eventBusState = shellServiceProvider.GetService <IEventBusState>(); // Register any IEventHandler method in the event bus foreach (var handlerClass in eventHandlers) { foreach (var handlerInterface in handlerClass.GetInterfaces().Where(x => typeof(IEventHandler).IsAssignableFrom(x) && typeof(IEventHandler) != x)) { foreach (var interfaceMethod in handlerInterface.GetMethods()) { if (_logger.IsEnabled(LogLevel.Debug)) { _logger.LogDebug($"{handlerClass.Name}/{handlerInterface.Name}.{interfaceMethod.Name}"); } //var classMethod = handlerClass.GetMethods().Where(x => x.Name == interfaceMethod.Name && x.GetParameters().Length == interfaceMethod.GetParameters().Length).FirstOrDefault(); Func <IServiceProvider, IDictionary <string, object>, Task> d = (sp, parameters) => DefaultOrchardEventBus.Invoke(sp, parameters, interfaceMethod, handlerClass); eventBusState.Add(handlerInterface.Name + "." + interfaceMethod.Name, d); } } } return(shellServiceProvider); }
public GetServices(IConnectionFactory connectionFactory) { _connectionFactory = connectionFactory; }
public AdoMeasurementTypeDao(IConnectionFactory connectionFactory) { this._template = new AdoTemplate(connectionFactory); }
public AbstractService(IConnectionFactory factory) { Factory = factory; Connection = Factory.GetConnection(); }
public RabbitmqChannelManagement(IConnectionFactory connectionFactory) { _connection = connectionFactory.CreateConnection(); }
public DefaultPersistentConnection(ILogger <DefaultPersistentConnection> logger, IConnectionFactory connectionFactory, int retryCount = 5) { _logger = logger; _connectionFactory = connectionFactory; _retryCount = retryCount; }
public DeviceReadingRepository(IConnectionFactory connectionFactory) { _connectionFactory = connectionFactory ?? throw new ArgumentNullException(nameof(connectionFactory)); }