Ejemplo n.º 1
0
        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);
 }
Ejemplo n.º 3
0
        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;
        }
Ejemplo n.º 4
0
		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);
         
        }
Ejemplo n.º 6
0
 public SequenceFactory(IDocumentSchema schema, IConnectionFactory factory, StoreOptions options, IMartenLogger logger)
 {
     _schema = schema;
     _factory = factory;
     _options = options;
     _logger = logger;
 }
Ejemplo n.º 7
0
 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);
            }
        }
Ejemplo n.º 9
0
        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");
 }
Ejemplo n.º 11
0
 public MQ()
 {
     producer = null;
     factory = null;
     connection = null;
     session = null;
 }
Ejemplo n.º 12
0
 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);
        }
Ejemplo n.º 14
0
Archivo: Db.cs Proyecto: jhgbrt/yadal
 /// <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;
 }
Ejemplo n.º 15
0
        /// <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;
        }
Ejemplo n.º 16
0
        public PersistentConnection(IConnectionFactory connectionFactory, IEasyNetQLogger logger)
        {
            this.connectionFactory = connectionFactory;
            this.logger = logger;

            TryToConnect(null);
        }
Ejemplo n.º 17
0
 public Repository(
     IConnectionFactory connectionFactory,
     IConfigurationStore configurationStore)
 {
     _connectionFactory = connectionFactory;
     _configurationStore = configurationStore;
 }
Ejemplo n.º 18
0
 public ConnectionPool( RedisConfiguration configuration, IConnectionFactory connectionFactory )
 {
     Configuration = configuration;
     ConnectionFactory = connectionFactory;
     AvailableConnections = new ConcurrentQueue<IConnection>();
     ReservedConnections = new ConcurrentDictionary<IConnection, IConnection>();
 }
Ejemplo n.º 19
0
        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>();
        }
Ejemplo n.º 20
0
 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);
 }
Ejemplo n.º 21
0
 public EventStoreAdmin(IDocumentSchema schema, IConnectionFactory connectionFactory, StoreOptions options, ISerializer serializer)
 {
     _schema = schema;
     _connectionFactory = connectionFactory;
     _options = options;
     _serializer = serializer;
 }
Ejemplo n.º 22
0
        /// <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);
            }           
        }
Ejemplo n.º 23
0
 public CustomerAgent(IConnectionFactory ConnectionFactory,
     CustomerFactory Factory, CustomerAppService CustomerAppService)
 {
     this.Factory = Factory;
     this.ConnectionFactory = ConnectionFactory;
     this.CustomerAppService = CustomerAppService;
 }
Ejemplo n.º 24
0
        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();
        }
Ejemplo n.º 25
0
      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);
        }
Ejemplo n.º 27
0
 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)
 {}
Ejemplo n.º 30
0
 // 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;
 }
Ejemplo n.º 31
0
 public RabbitMqConnection(ILogWriter logWriter, RabbitMQConfiguration rabbitConfig)
 {
     _logWriter         = logWriter;
     _rabbitConfig      = rabbitConfig;
     _connectionFactory = SetupConnection(rabbitConfig);
 }
Ejemplo n.º 32
0
 public void Initialize()
 {
     _connectionFactory     = new ConnectionFactory();
     _sqlEmployeeRepository = new SQLEmployeeRepository(_connectionFactory, true);
 }
Ejemplo n.º 33
0
 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);
        }
Ejemplo n.º 35
0
 public LanguagesRepository(IConnectionFactory connectionFactory, IMemoryCache memoryCache)
 {
     _connectionFactory = connectionFactory;
     _memoryCache       = memoryCache;
 }
Ejemplo n.º 36
0
 public AdoDistrictDao(IConnectionFactory connectionFactory)
 {
     this._template = new AdoTemplate(connectionFactory);
 }
Ejemplo n.º 37
0
 public PlanoVooRepository(IConnectionFactory conn)
 {
     _conn = conn;
 }
Ejemplo n.º 38
0
 public static IConfiguration SetConnectionFactory(this IConfiguration configuration, IConnectionFactory connectionFactory)
 {
     configuration.ConnectionFactory = connectionFactory;
     return(configuration);
 }
Ejemplo n.º 39
0
 public DatabaseCreationUtil(IConnectionFactory connectionFactory)
 {
     _connectionFactory = connectionFactory;
 }
Ejemplo n.º 40
0
        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;
 }
Ejemplo n.º 42
0
        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();
            }
        }
Ejemplo n.º 43
0
 public MultimediaTypeRepository(IConnectionFactory connectionFactory) : base(connectionFactory)
 {
 }
Ejemplo n.º 44
0
 public DefaultRabbitMQPersisterConnection(IConnectionFactory connectionFactory, ILogger <DefaultRabbitMQPersisterConnection> logger)
 {
     _connectionFactory = connectionFactory ?? throw new ArgumentNullException(nameof(connectionFactory));
     _logger            = logger ?? throw new ArgumentNullException(nameof(logger));
 }
Ejemplo n.º 45
0
 public JogoRepository(IConnectionFactory connection)
 {
     _connection = connection ?? throw new ArgumentNullException(nameof(connection));
 }
Ejemplo n.º 46
0
 public RabbitMQProvider(IConnectionFactory connectionFactory)
 {
     _connectionFactory = connectionFactory;
 }
Ejemplo n.º 47
0
 public PostWriteService(IPostRepository postRepository,
                         IConnectionFactory connectionFactory)
 {
     _postRepository    = postRepository;
     _connectionFactory = connectionFactory;
 }
Ejemplo n.º 48
0
 public CommonDependent(IConnectionFactory ConnectionFactory)
 {
     this.ConnectionFactory = ConnectionFactory;
 }
Ejemplo n.º 49
0
 public AppAccessRepository(IConnectionFactory connectionFactory,
                            ILogger <AppAccessRepository> logger) : base(connectionFactory, logger)
 {
     _logger = logger;
 }
Ejemplo n.º 50
0
 public AccountRepository(IConnectionFactory factory)
 {
     _factory = factory;
 }
Ejemplo n.º 51
0
 public ServiceQuery(IConnectionFactory connectionFactory)
 {
     _connectionFactory = connectionFactory;
 }
Ejemplo n.º 52
0
 public ProxyConnectionFactory(IConnectionFactory innerFactory)
 {
     _innerFactory = innerFactory;
 }
Ejemplo n.º 53
0
 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);
        }
Ejemplo n.º 55
0
 public GetServices(IConnectionFactory connectionFactory)
 {
     _connectionFactory = connectionFactory;
 }
Ejemplo n.º 56
0
 public AdoMeasurementTypeDao(IConnectionFactory connectionFactory)
 {
     this._template = new AdoTemplate(connectionFactory);
 }
Ejemplo n.º 57
0
 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));
 }