protected TimeOutException(ErrorCodes code, string message, ConsistencyLevel consistencyLevel, int received, int blockFor)
         : base(code, message)
 {
     ConsistencyLevel = consistencyLevel;
     Received = received;
     BlockFor = blockFor;
 }

 public UnavailableException(ConsistencyLevel consistency, int required, int alive)
     : base(string.Format("Not enough replica available for query at consistency {0} ({1} required but only {2} alive)", consistency, required, alive))
 {
     this.Consistency = consistency;
     this.RequiredReplicas = required;
     this.AliveReplicas = alive;
 }

        public static void RegisterComponents()
        {
            var container = new UnityContainer();

            var documentUri = ConfigurationManager.AppSettings["DocumentUri"];
            string authKey = ConfigurationManager.AppSettings["AuthorizationKey"];
            string redisConnection = ConfigurationManager.AppSettings["RedisConnection"];

            // register all your components with the container here
            // it is NOT necessary to register your controllers

            // e.g. container.RegisterType<ITestService, TestService>();
            Uri uri = new Uri(documentUri);
            ConnectionPolicy connectionPolicy = new ConnectionPolicy() { ConnectionMode = ConnectionMode.Direct, ConnectionProtocol = Protocol.Tcp };
            ConsistencyLevel consistencyLevel = new ConsistencyLevel();
            consistencyLevel = ConsistencyLevel.Session;

            container.RegisterType<IApplicationUserStore, ApplicatonUserStore>();
            container.RegisterType<DocumentClient>(new ContainerControlledLifetimeManager(), new InjectionConstructor(uri, authKey, connectionPolicy, consistencyLevel));

            ConnectionMultiplexer connectionMulp = ConnectionMultiplexer.Connect(redisConnection);
            container.RegisterInstance<IConnectionMultiplexer>(ConnectionMultiplexer.Connect(redisConnection));

            container.RegisterType<IRedisRepository, RedisRepository>();
            container.RegisterType<IUserRepository, UserRepository>();

            var repo = container.Resolve<IRedisRepository>();

            container.RegisterType<RefreshTokenProvider>(new InjectionConstructor(repo));

            GlobalConfiguration.Configuration.DependencyResolver = new UnityDependencyResolver(container);
        }

 public UnavailableException(string message, ConsistencyLevel consistencyLevel, int required, int alive)
         : base(ErrorCodes.Unavailable, message)
 {
     ConsistencyLevel = consistencyLevel;
     Required = required;
     Alive = alive;
 }

        public Task<IEnumerable<object>> Execute(ConsistencyLevel cl, IDataMapperFactory factory)
        {
            IConnection connection;
            if (null == (connection = _connection))
            {
                lock (_lock)
                {
                    if (null == (connection = _connection))
                    {
                        connection = _cluster.GetConnection(null);
                        connection.OnFailure += ConnectionOnOnFailure;

                        Action<IFrameWriter> writer = fw => CQLCommandHelpers.WritePrepareRequest(fw, _cql);
                        Func<IFrameReader, IEnumerable<object>> reader = fr => CQLCommandHelpers.ReadPreparedQuery(fr, connection);

                        connection.Execute(writer, reader).ContinueWith(ReadPreparedQueryInfo).Wait();

                        Thread.MemoryBarrier();

                        _connection = connection;
                    }
                }
            }

            Action<IFrameWriter> execWriter = fw => WriteExecuteRequest(fw, cl, factory);
            Func<IFrameReader, IEnumerable<object>> execReader = fr => CQLCommandHelpers.ReadRowSet(fr, factory);

            return connection.Execute(execWriter, execReader);
        }

 internal QueryProtocolOptions(ConsistencyLevel consistency,
                               object[] values,
                               bool skipMetadata,
                               int pageSize,
                               byte[] pagingState,
                               ConsistencyLevel serialConsistency)
 {
     Consistency = consistency;
     Values = values;
     _skipMetadata = skipMetadata;
     if (pageSize <= 0)
     {
         PageSize = QueryOptions.DefaultPageSize;
     }
     else if (pageSize == int.MaxValue)
     {
         PageSize = -1;
     }
     else
     {
         PageSize = pageSize;
     }
     PagingState = pagingState;
     SerialConsistency = serialConsistency;
 }

        public IAsyncResult BeginExecuteQuery(int _streamId, byte[] Id, string cql, RowSetMetadata Metadata, object[] values,
                                              AsyncCallback callback, object state, object owner,
                                              ConsistencyLevel consistency, bool isTracing)
        {
            var jar = SetupJob(_streamId, callback, state, owner, "EXECUTE");

            BeginJob(jar, SetupKeyspace(jar, SetupPreparedQuery(jar, Id, cql, () =>
               {
                   Evaluate(new ExecuteRequest(jar.StreamId, Id, Metadata, values, consistency, isTracing), jar.StreamId,
                            new Action<ResponseFrame>((frame2) =>
                                {
                                    var response = FrameParser.Parse(frame2);
                                    if (response is ResultResponse)
                                        JobFinished(jar, (response as ResultResponse).Output);
                                    else
                                        _protocolErrorHandlerAction(new ErrorActionParam()
                                            {
                                                AbstractResponse = response,
                                                Jar = jar
                                            });

                                }));
               })));

            return jar;
        }

        public IKeyspace Create(
			ICassandraClient client,
			string keyspaceName,
			IDictionary<string, Dictionary<string, string>> keyspaceDesc,
			ConsistencyLevel consistencyLevel,
			FailoverPolicy failoverPolicy,
			IKeyedObjectPool<Endpoint, ICassandraClient> pool)
        {
            switch (client.Version)
            {
                case CassandraVersion.v0_6_0_beta_3:
                    throw new NotImplementedException("Version 0.6.0 not implimented yet");

                default:
                case CassandraVersion.v0_5_1:
                    return new _051.Keyspace(
                        client,
                        keyspaceName,
                        keyspaceDesc,
                        consistencyLevel,
                        failoverPolicy,
                        pool,
                        monitor
                        );
            }
        }

 public QueryTimeoutException(string message, ConsistencyLevel consistencyLevel, int received, int required)
     : base(message)
 {
     ConsistencyLevel = consistencyLevel;
     ReceivedAcknowledgements = received;
     RequiredAcknowledgements = required;
 }

        public Task<IEnumerable<object>> Execute(ConsistencyLevel cl, IDataMapperFactory factory)
        {
            Action<IFrameWriter> writer = fw => WriteExecuteRequest(fw, cl, factory);
            Func<IFrameReader, IEnumerable<object>> reader = fr => CQLCommandHelpers.ReadRowSet(fr, factory);

            return _connection.Execute(writer, reader);
        }

        public Task<IEnumerable<object>> Execute(IDataMapperFactory factory, ConsistencyLevel cl)
        {
            IConnection connection;
            if (null == (connection = _connection))
            {
                lock (_lock)
                {
                    if (null == (connection = _connection))
                    {
                        connection = _cluster.GetConnection(null);
                        connection.OnFailure += ConnectionOnOnFailure;

                        Action<IFrameWriter> writer = fw => CQLCommandHelpers.WritePrepareRequest(fw, _cql);
                        Func<IFrameReader, IEnumerable<object>> reader = fr => CQLCommandHelpers.ReadPreparedQuery(fr, connection);

                        InstrumentationToken prepareToken = InstrumentationToken.Create(RequestType.Prepare, _executionFlags, _cql);
                        connection.Execute(writer, reader, _executionFlags, prepareToken).ContinueWith(ReadPreparedQueryInfo).Wait();
                        _connection = connection;
                    }
                }
            }

            Action<IFrameWriter> execWriter = fw => WriteExecuteRequest(fw, cl, factory);
            Func<IFrameReader, IEnumerable<object>> execReader = fr => CQLCommandHelpers.ReadRowSet(fr, factory);

            InstrumentationToken queryToken = InstrumentationToken.Create(RequestType.Query, _executionFlags, _cql);
            return connection.Execute(execWriter, execReader, _executionFlags, queryToken);
        }

 public Action GetInsertAction(ISession session, object bindableStatement, ConsistencyLevel consistency, int rowsPerId)
 {
     Action action = () =>
     {
         Trace.TraceInformation("Starting inserting from thread {0}", Thread.CurrentThread.ManagedThreadId);
         var id = Guid.NewGuid();
         for (var i = 0; i < rowsPerId; i++)
         {
             var paramsArray = new object[] { id, DateTime.Now, DateTime.Now.ToString() };
             IStatement statement = null;
             if (bindableStatement is SimpleStatement)
             {
                 statement = ((SimpleStatement)bindableStatement).Bind(paramsArray).SetConsistencyLevel(consistency);
             }
             else if (bindableStatement is PreparedStatement)
             {
                 statement = ((PreparedStatement)bindableStatement).Bind(paramsArray).SetConsistencyLevel(consistency);
             }
             else
             {
                 throw new Exception("Can not bind a statement of type " + bindableStatement.GetType().FullName);
             }
             session.Execute(statement);
         }
         Trace.TraceInformation("Finished inserting from thread {0}", Thread.CurrentThread.ManagedThreadId);
     };
     return action;
 }

 ///  Coordinator management/count
 public static void addCoordinator(IPAddress coordinator, ConsistencyLevel cl)
 {
     if (!coordinators.ContainsKey(coordinator))
         coordinators.Add(coordinator, 0);
     var n = coordinators[coordinator];
     coordinators[coordinator] = n + 1;
     achievedConsistencies.Add(cl);
 }

 public QueryRequest(int streamId, string cqlQuery, ConsistencyLevel consistency, bool tracingEnabled)
 {
     this._streamId = streamId;
     this._cqlQuery = cqlQuery;
     this._consistency = consistency;
     if (tracingEnabled)
         this._flags = 0x02;
 }

 public static void Reset()
 {
     ColumnWidth = 40;
     Formatter = OutputFormatter.Tab;
     DebugLog = false;
     Tracing = false;
     CL = ConsistencyLevel.QUORUM;
 }

 ///  Coordinator management/count
 public void AddCoordinator(string coordinator, ConsistencyLevel consistencyLevel)
 {
     if (!Coordinators.ContainsKey(coordinator))
         Coordinators.Add(coordinator, 0);
     int n = Coordinators[coordinator];
     Coordinators[coordinator] = n + 1;
     AchievedConsistencies.Add(consistencyLevel);
 }

 public WriteTimeoutException(ConsistencyLevel consistency, int received, int required,
                              string writeType)
     : base(string.Format("Cassandra timeout during write query at consitency {0} ({1} replica acknowledged the write over {2} required)", consistency.ToString().ToUpper(), received, required),
       consistency,
       received,
       required)
 {
     this.WriteType = writeType;
 }

 internal static void ExecutePreparedQuery(Session session, PreparedStatement prepared, object[] values, ConsistencyLevel consistency = ConsistencyLevel.Default, string messageInstead = null)
 {
     if (messageInstead != null)
         Console.WriteLine("CQL<\t" + messageInstead);
     else
         Console.WriteLine("CQL< Executing Prepared Query:\t");
     session.Execute(prepared.Bind(values).SetConsistencyLevel(consistency));
     Console.WriteLine("CQL> (OK).");
 }

 internal static IObservable<object> CreateQuery(IConnection connection, string cql, ConsistencyLevel cl, IDataMapperFactory factory,
                                                 ExecutionFlags executionFlags)
 {
     Action<IFrameWriter> writer = fw => WriteQueryRequest(fw, cql, cl, MessageOpcodes.Query);
     Func<IFrameReader, IEnumerable<object>> reader = fr => ReadRowSet(fr, factory);
     InstrumentationToken token = InstrumentationToken.Create(RequestType.Query, executionFlags, cql);
     Query query = new Query(writer, reader, token, connection);
     return query;
 }

 internal static void ExecuteSyncQuery(ISession session, string query, ConsistencyLevel consistency, List<object[]> expectedValues = null,
                                       string messageInstead = null)
 {   
     var ret = session.Execute(query, consistency);
     if (expectedValues != null)
     {
         valueComparator(ret, expectedValues);
     }
 }