def get_row_key_id(domain):
    counter_column, counter_lock = domain_counter_map[domain]
    
    ## acquire lock before getting value of 
    counter_lock.acquire()
    try:
        client = db_connection.get_client()
        cf = ColumnFamily(client, CONFIG_DOMAIN)
        
        ## get new key id
        id_key = cf.get(CONFIG_ROW, counter_column)[counter_column]
        
        ## increment value if not None
        if id_key:
            new_id_key = id_key + 1
            cf.insert(CONFIG_ROW, {counter_column: new_id_key}, write_consistency_level=ConsistencyLevel.ALL)
        
        return id_key
        
        """
        if id_key:
            str_id_key = str(id_key)
            str_id_key.zfill(MAX_PADDING_RANGE)
            return str_id_key
        else:
            return None
        """
        
    finally:
        ## release lock before returning from this function
        counter_lock.release()

 def __init__(self,keySpace):
     self.pool = ConnectionPool(keySpace, ['localhost:9160'])
     self.col_fam_page        = ColumnFamily(self.pool, 'Page')
     self.col_fam_publication = ColumnFamily(self.pool, 'Publication')
     self.col_fam_company     = ColumnFamily(self.pool, 'Company')
     self.col_fam_location    = ColumnFamily(self.pool, 'Location')
     self.col_fam_category    = ColumnFamily(self.pool, 'Category')

    def __init__(self, client, qname, trend=5):
        super(Buyer, self).__init__(client, uuid.uuid4().hex)
        self.holdings = {}
        self.cash = 100000.0
        self.history = {}
        self.trend = trend
        self.pool = ConnectionPool('example_consumer_Buyer')
        self.stored_holdings = ColumnFamily(self.pool, 'Holdings')
        self.quote_history = ColumnFamily(self.pool, 'Quotes')
        self.stored_cash = ColumnFamily(self.pool, 'Cash')

        try:
          cash = self.stored_cash.get('current')
          self.cash = cash['amount']
        except ttypes.NotFoundException:
          self.stored_cash.insert('current', { 'amount': self.cash })

        for symbol, columns in self.stored_holdings.get_range():
          self.holdings[symbol] = (columns['number_of_shares'], columns['price'], columns['cost'])

        date_expression = create_index_expression('timestamp', datetime.date.today(), GT)
        date_clause = create_index_clause([date_expression], count=1000)

        for key, columns in self.quote_history.get_range():
          symbol = columns['symbol']
          price = columns['price']
          self.add_quote(symbol, price)

def datatable():

    session = cassandra.connect()
    session.set_keyspace(settings['cluster_name'])
    cass_client = ConnectionPool(settings['cluster_name'],[settings['cass_cluster']+':'+settings['thrift_port']], timeout=60)
    col_fam = ColumnFamily(cass_client,'parsed_data')
    session.default_timeout = 100
    key1 = request.args.get('key')
    if key1 == None:
        key1=100
    key1= int(key1)
    query = "SELECT last_timeid FROM main_count"  # users contains 100 rows
    statement = session.execute(query)
    for x in statement:
        end_key = x[0]
    log_data = [[]for i in range(0,key1)]
    log_data_header,k = [], 0
    temp = end_key-key1
    for i in range(temp,end_key):
        expr2 = create_index_expression('logid',i)
        lause = create_index_clause([ expr2], count=1)
        test = list(col_fam.get_indexed_slices(lause, columns= ["timestamp", "host", "byte_transfer", "request_link", "request_details", "device_type", "operating_system", "request_type", "response_code", "response_time"]))[0][1]
        for m in test.values():
            log_data[k].append(m)
        k += 1
        if k == 1:
            for n in test.keys():
                log_data_header.append(n)
    return render_template('datatable.html', data= log_data, data_header = log_data_header,index = key1)

class CassandraRepository(object):
    def __init__(self, keyspace, column_family_name):
        self.pool = ConnectionPool(keyspace,
                                   cassandra_settings.NODE_POOL)

        self.cf = ColumnFamily(self.pool, column_family_name)

        self.batch = {}

    def add_batch(self, batch, start_time=None):
        """
        :param batch:
        """

        self.cf.batch_insert(batch)
        if start_time is not None:
            print 'time to  insert batch: %s ms' % (int(time.time() * 1000) - start_time)


    def get(self, timestamp):
        return self.cf.get(str(timestamp))

    def get_range(self, start, end):
        return list(self.cf.get_range(start=str(start), finish=str(end)))

    def close(self):
        self.sys.close()

def get():
#################### TEMP
  #userId = 'user-784b9158-5233-454e-8dcf-c229cdff12c6'
  print 'Getting result for userId: {0} between time {1} and {2}'.format(userId, startTime, startTime)
  con = util.getConnection()
  logCF = ColumnFamily(con, 'event_log_mux')
  
  rowKeys = ['{0}:{1}'.format(userId, i+1) for i in range(4)]
  rows = logCF.multiget(rowKeys)
  
  print 'Shows rows multiplexes into different rows each individually sorted in reverse cronological order:'
  merge = {}
  for row in rows:
    print '>> '+str(row) 
    merge = dict(merge.items() + rows[row].items())
    for col in rows[row]:
      colstr = rows[row][col]
      coljson = json.loads(colstr)
      print '\tInsertion Timestamp: {0}'.format(coljson['insert_time'])
  
  final = collections.OrderedDict(sorted(merge.items(), reverse=True))
  for k,v in final.iteritems():
    coljson = json.loads(v)
    print 'insertion timestamp: {0}'.format(coljson['insert_time'])

  """

    def __init__(self):
	err = ''
        self.pool = ConnectionPool('jobrun', server_list=options['hosts'])
        self.jl = ColumnFamily(self.pool, 'job_lookup')
        self.jr = ColumnFamily(self.pool, 'job_results')
        self.jd = ColumnFamily(self.pool, 'job_dashboard')
        self.jf = ColumnFamily(self.pool, 'job_failures')

 def colum_family_content(self, keyspace_name, column_family_name):
     """Returns content of column family of given keyspace """
     keyspace.cf_result = []
     keyspace.error = "Unknown error : May be one of node in your cluster is down please check?"
     if not self.keyspace_contains(keyspace.local_system, keyspace_name, column_family_name):
         keyspace.error = "Desired Keyspace,Column Family pair could not be found."
         return False
     try:
         pool = ConnectionPool(keyspace=keyspace_name, server_list=keyspace.server_ips, prefill=False)
     except Exception as e:
         print e
         return False
     try:
         col_fam = ColumnFamily(pool, column_family_name)
     except Exception as e:
         print e
         return False
     result = []
     try:
         tmp_result = col_fam.get_range(start='', finish='', buffer_size=10)
         for i in tmp_result:
             result.append(i)
     except Exception as e:
         print e
         return False
     keyspace.cf_result = result
     keyspace.tempks = keyspace_name
     keyspace.tempcf = column_family_name
     print result
     return result

	def colum_family_content(self,machine_id,keyspace_name,column_family_name):
		"""Returns content of column family of given keyspace """
		print "->>>in column family content function"
		pool = ConnectionPool(keyspace_name, [machine_id])
		col_fam = ColumnFamily(pool, column_family_name)
		result = col_fam.get_range(start='', finish='')
		return result

    def __init__(self, cls, pool, column_family, columns=None, raw_columns=False, **kwargs):
        """
        Maps an existing class to a column family.  Class fields become columns,
        and instances of that class can be represented as rows in standard column
        families or super columns in super column families.

        Instances of `cls` are returned from :meth:`get()`, :meth:`multiget()`,
        :meth:`get_range()` and :meth:`get_indexed_slices()`.
        
        `pool` is a :class:`~pycassa.pool.ConnectionPool` that will be used
        in the same way a :class:ColumnFamily uses one.

        `column_family` is the name of a column family to tie to `cls`.

        If `raw_columns` is ``True``, all columns will be fetched into the
        `raw_columns` field in requests.

        """
        ColumnFamily.__init__(self, pool, column_family, **kwargs)

        self.cls = cls
        self.autopack_names = False

        self.raw_columns = raw_columns
        self.dict_class = util.OrderedDict
        self.defaults = {}
        self.fields = []
        for name, val_type in self.cls.__dict__.iteritems():
            if isinstance(val_type, CassandraType):
                self.fields.append(name)
                self.column_validators[name] = val_type
                self.defaults[name] = val_type.default

    def load_slaves(self, o):
        cf = ColumnFamily(self._pool, 'slaves')
        with cf.batch() as batch:
            for slave_id, name in o.items():
                batch.insert(slave_id, {'name': name})

        return len(o)

 def get_builder(self, builder_id):
     """Obtain info about a builder from its ID."""
     cf = ColumnFamily(self.pool, 'builders')
     try:
         return cf.get(builder_id)
     except NotFoundException:
         return None

def loadData():
  con = util.getConnection()
  cf = ColumnFamily(con, 'videos_denorm')
  tagCF = ColumnFamily(con, 'tag_videos_composite')
  movies = util.readCSV('data/movies')
  for movie in movies:
    title = movie[0]
    uploader = movie[1]
    runtime = int(movie[2]) #convert to match column validator
    tags = movie[3]
    rowKey = title+":"+uploader


    print "Inserting in videos: {}.".format(str(movie))
    row = \
      {
        'title':title,
        'user_name':uploader,
        'runtime_in_sec':runtime,
      }

    for tag in tags.split(','):
      print 'adding tag: {0} for movie: {1}'.format(tag, title)
      row['tag:{}'.format(tag.strip().lower())] = tag.strip()

    print 'inserting denorm: {}'.format(row)
    cf.insert(rowKey, row)

  print 'finishished insertion.'    
  con.dispose()

def get_reverse(columnFamily, key) :
        "select values in a given column family"
        try :
	        column = ColumnFamily(pool, columnFamily)
	        return column.get(key,column_reversed=True)
	except:
		return {'status':0}

def remove_column(columnFamily, uid, columns) :
	"To remove columns from a key"
	try:
		column = ColumnFamily(pool, columnFamily)
		column.remove(uid,columns)
	except:
		return {'status':0}

 def build_from_id(self, build_id):
     """Obtain information about a build from its ID."""
     cf = ColumnFamily(self.pool, 'builds')
     try:
         return cf.get(build_id)
     except NotFoundException:
         return None

 def _update_analytics_start_time(self, start_times):
     try:
         col_family = ColumnFamily(self._pool, SYSTEM_OBJECT_TABLE)
         col_family.insert(SYSTEM_OBJECT_ANALYTICS, start_times)
     except Exception as e:
         self._logger.error("Exception: update_analytics_start_time "
             "Connection Failure %s" % e)

  def _check_cassandra(self, del_network_keyname, local_hostname, cassandra_listen_port):
	from pycassa.pool import ConnectionPool
	from pycassa.columnfamily import ColumnFamily

	pool1=ConnectionPool('config_db_uuid', [local_hostname+":"+cassandra_listen_port])
	col_fam=ColumnFamily(pool1, 'obj_fq_name_table')
        return col_fam.get_count('virtual_network', columns=[del_network_keyname])

    def load_builders(self, o):
        cf = ColumnFamily(self._pool, 'builders')
        indices = ColumnFamily(self._pool, 'indices')

        batch = cf.batch()
        i_batch = indices.batch()

        for builder_id, params in o.items():
            cat = params['category']
            columns = {
                'category': cat,
                'master': unicode(params['master_id']),
                'name': params['name'],
            }

            batch.insert(builder_id, columns)
            i_batch.insert('builder_category_to_builder_ids',
                {cat: {builder_id: ''}})
            i_batch.insert('master_id_to_slave_ids', {columns['master']: {
                builder_id: ''}})

            if len(params['slaves']):
                i_batch.insert('builder_id_to_slave_ids', {builder_id: {
                    unicode(slave_id): '' for slave_id in params['slaves']}})

        batch.send()
        i_batch.send()

        return len(o)

    def store_blob(self, key, content, chunk_size=DEFAULT_BLOB_CHUNK_SIZE):
        cf = ColumnFamily(self.pool, 'blobs')
        chunks = len(content) / chunk_size + 1

        sha1 = hashlib.sha1()
        sha1.update(content)

        offset = 0
        i = 1
        while True:
            b = content[offset:offset + chunk_size]
            # We prefix each part with "z" so the big chunks come at the end of
            # the row and our initial read for all the metadata doesn't span
            # excessive pages on disk.
            cf.insert(key, {'z:%04d' % i: b})

            if len(b) < chunk_size:
                break

            offset += chunk_size
            i += 1

        cf.insert(key, {
            'version': 1,
            'sha1': sha1.digest(),
            'size': len(content),
            'chunk_size': chunk_size,
            'chunk_count': chunks,
        })

        indices = ColumnFamily(self.pool, 'simple_indices')
        indices.insert('blobs', {key: ''})
        indices.insert('blob_size', {key: str(len(content))})

        return sha1.digest()