Esempio n. 1
0
 public RiakOnTheFlyConnection(
     IRiakNodeConfiguration nodeConfig,
     IRiakAuthenticationConfiguration authConfig,
     IRiakConnectionFactory connFactory)
 {
     this.nodeConfig  = nodeConfig;
     this.authConfig  = authConfig;
     this.connFactory = connFactory;
 }
Esempio n. 2
0
        public RiakCluster(IRiakClusterConfiguration clusterConfiguration, IRiakConnectionFactory connectionFactory)
        {
            _nodePollTime = clusterConfiguration.NodePollTime;
            _nodes        = clusterConfiguration.RiakNodes.Select(rn => new RiakNode(rn, connectionFactory)).Cast <IRiakNode>().ToList();
            _loadBalancer = new RoundRobinStrategy();
            _loadBalancer.Initialise(_nodes);
            _offlineNodes      = new ConcurrentQueue <IRiakNode>();
            _defaultRetryCount = clusterConfiguration.DefaultRetryCount;
            RetryWaitTime      = clusterConfiguration.DefaultRetryWaitTime;

            Task.Factory.StartNew(NodeMonitor);
        }
Esempio n. 3
0
        public RiakCluster(IRiakClusterConfiguration clusterConfiguration, IRiakConnectionFactory connectionFactory)
        {
            _nodePollTime = clusterConfiguration.NodePollTime;
            _nodes        = clusterConfiguration.RiakNodes.Select(rn => new RiakNode(rn, connectionFactory)).Cast <IRiakNode>().ToList();
            _loadBalancer = new RoundRobinStrategy();
            _loadBalancer.Initialise(_nodes);
            _offlineNodes      = new ConcurrentQueue <IRiakNode>();
            _defaultRetryCount = clusterConfiguration.DefaultRetryCount;
            RetryWaitTime      = clusterConfiguration.DefaultRetryWaitTime;

            // node monitor is now asynchronous, just triggered by timer!
            _nodePollTimer = new Timer(state => NodeMonitorCycle(), null, _nodePollTime, Timeout.Infinite);
        }
Esempio n. 4
0
 public RiakNode(IRiakNodeConfiguration nodeConfiguration, IRiakConnectionFactory connectionFactory)
 {
     // assume that if the node has a pool size of 0 then the intent is to have the connections
     // made on the fly
     if (nodeConfiguration.PoolSize == 0)
     {
         _connections = new RiakOnTheFlyConnection(nodeConfiguration, connectionFactory);
     }
     else
     {
         _connections = new RiakConnectionPool(nodeConfiguration, connectionFactory);
     }
 }
        public RiakConnectionPool(IRiakNodeConfiguration nodeConfig, IRiakConnectionFactory connFactory)
        {
            var poolSize = nodeConfig.PoolSize;

            _allResources = new List <IRiakConnection>();
            _resources    = new ConcurrentStack <IRiakConnection>();

            for (var i = 0; i < poolSize; ++i)
            {
                var conn = connFactory.CreateConnection(nodeConfig);
                _allResources.Add(conn);
                _resources.Push(conn);
            }
        }
Esempio n. 6
0
        public RiakConnectionPool(
            IRiakNodeConfiguration nodeConfig,
            IRiakAuthenticationConfiguration authConfig,
            IRiakConnectionFactory connFactory)
        {
            int poolSize = nodeConfig.PoolSize;

            for (var i = 0; i < poolSize; ++i)
            {
                var conn = connFactory.CreateConnection(nodeConfig, authConfig);
                allResources.Add(conn);
                resources.Push(conn);
            }
        }
Esempio n. 7
0
        /// <summary>
        /// Initializes a new instance of the <see cref="RiakCluster"/> class.
        /// </summary>
        /// <param name="clusterConfig">The <see cref="IRiakClusterConfiguration"/> to use for this RiakCluster.</param>
        /// <param name="connectionFactory">The <see cref="IRiakConnectionFactory"/> instance to use for this RiakCluster.</param>
        /// <exception cref="ArgumentNullException">If <paramref name="clusterConfig" /> contains no node information.</exception>
        public RiakCluster(IRiakClusterConfiguration clusterConfig, IRiakConnectionFactory connectionFactory)
        {
            nodePollTime      = clusterConfig.NodePollTime;
            defaultRetryCount = clusterConfig.DefaultRetryCount;
            RetryWaitTime     = clusterConfig.DefaultRetryWaitTime;

            nodes = clusterConfig.RiakNodes.Select(rn =>
                                                   new RiakNode(rn, clusterConfig.Authentication, connectionFactory)).Cast <IRiakNode>().ToList();

            loadBalancer = new RoundRobinStrategy();
            loadBalancer.Initialise(nodes);

            offlineNodes = new ConcurrentQueue <IRiakNode>();

            ct          = cts.Token;
            monitorTask = Task.Factory.StartNew(NodeMonitor, ct);
        }
Esempio n. 8
0
        public RiakNode(
            IRiakNodeConfiguration nodeConfig,
            IRiakAuthenticationConfiguration authConfig,
            IRiakConnectionFactory connectionFactory)
        {
            externalLoadBalancer = nodeConfig.ExternalLoadBalancer;

            // assume that if the node has a pool size of 0 then the intent is to have the connections
            // made on the fly
            if (nodeConfig.PoolSize == 0)
            {
                connections = new RiakOnTheFlyConnection(nodeConfig, authConfig, connectionFactory);
            }
            else
            {
                connections = new RiakConnectionPool(nodeConfig, authConfig, connectionFactory);
            }
        }
Esempio n. 9
0
 public RiakNode(IRiakNodeConfiguration nodeConfiguration, IRiakConnectionFactory connectionFactory)
 {
     _connections = new RiakConnectionPool(nodeConfiguration, connectionFactory);
 }
 public RiakOnTheFlyConnection(IRiakNodeConfiguration nodeConfig, IRiakConnectionFactory connFactory)
 {
     _nodeConfig  = nodeConfig;
     _connFactory = connFactory;
 }
 public RiakExternalLoadBalancer(IRiakExternalLoadBalancerConfiguration lbConfiguration, IRiakConnectionFactory connectionFactory)
 {
     _lbConfiguration = lbConfiguration;
     _node            = new RiakNode(_lbConfiguration.Target, connectionFactory);
 }