Exemple #1
0
def demo_client(host, port, is_framed_transport):

    # Make socket
    socket = TSocket.TSocket(host, port)

    # Make transport
    if is_framed_transport:
        transport = TTransport.TFramedTransport(socket)
    else:
        transport = TTransport.TBufferedTransport(socket)

    # Wrap in a protocol
    protocol = TBinaryProtocol.TBinaryProtocol(transport)

    # Create a client to use the protocol encoder
    client = Client(protocol)

    # Connect!
    transport.open()

    # Check Thrift Server Type
    serverType = client.getThriftServerType()
    if serverType != TThriftServerType.ONE:
        raise Exception(
            "Mismatch between client and server, server type is %s" %
            serverType)

    t = "demo_table"

    #
    # Scan all tables, look for the demo table and delete it.
    #
    print "scanning tables..."
    for table in client.getTableNames():
        print "  found: %s" % (table)
        if table == t:
            if client.isTableEnabled(table):
                print "    disabling table: %s" % (t)
                client.disableTable(table)
            print "    deleting table: %s" % (t)
            client.deleteTable(table)

    columns = []
    col = ColumnDescriptor()
    col.name = 'entry:'
    col.maxVersions = 10
    columns.append(col)
    col = ColumnDescriptor()
    col.name = 'unused:'
    columns.append(col)

    try:
        print "creating table: %s" % (t)
        client.createTable(t, columns)
    except AlreadyExists, ae:
        print "WARN: " + ae.message
Exemple #2
0
def demo_client(host, port, is_framed_transport):

  # Make socket
  socket = TSocket.TSocket(host, port)

  # Make transport
  if is_framed_transport:
    transport = TTransport.TFramedTransport(socket)
  else:
    transport = TTransport.TBufferedTransport(socket)

  # Wrap in a protocol
  protocol = TBinaryProtocol.TBinaryProtocol(transport)

  # Create a client to use the protocol encoder
  client = Client(protocol)

  # Connect!
  transport.open()

  t = "demo_table"

  #
  # Scan all tables, look for the demo table and delete it.
  #
  print "scanning tables..."
  for table in client.getTableNames():
    print "  found: %s" %(table)
    if table == t:
      if client.isTableEnabled(table):
        print "    disabling table: %s"  %(t)
        client.disableTable(table)
      print "    deleting table: %s"  %(t)
      client.deleteTable(table)

  columns = []
  col = ColumnDescriptor()
  col.name = 'entry:'
  col.maxVersions = 10
  columns.append(col)
  col = ColumnDescriptor()
  col.name = 'unused:'
  columns.append(col)

  try:
    print "creating table: %s" %(t)
    client.createTable(t, columns)
  except AlreadyExists, ae:
    print "WARN: " + ae.message
class HBaseClient:
    ''' Hbase client '''
    def __init__(self):
        transport = TSocket.TSocket('localhost', 9090)
        transport = TTransport.TBufferedTransport(transport)
        protocol = TBinaryProtocol.TBinaryProtocol(transport)

        self.__client = Client(protocol)
        transport.open()

    def getTableNames(self):
        ''' get table names '''
        return self.__client.getTableNames()

    def deleteTable(self, tName):
        ''' delete table name '''
        if self.__client.isTableEnabled(tName):
            self.__client.disableTable(tName)

        self.__client.deleteTable(tName)

    def createTable(self, tName, ColumnDescriptors):
        try:
            self.__client.createTable(tName, ColumnDescriptors)
        except ttypes.AlreadyExists as excp:
            raise UfException(Errors.HBASE_CREATE_ERROR,
                              "AlreadyExists Error when creating table %s with cols: %s): %s" % \
                              (tName, [col.name for col in ColumnDescriptors], excp.message))

    def getColumnDescriptors(self, tName):
        try:
            return self.__client.getColumnDescriptors(tName)
        except:
            raise UfException(Errors.UNKNOWN_ERROR,
                              "Error when getting column descriptors table %s" % tName)

    def updateRow(self, tName, rowName, mutations, timestamp=None):
        ''' add row to table '''
        try:
            if timestamp is None:
                self.__client.mutateRow(tName, rowName, mutations)
            else:
                self.__client.mutateRowTs(tName, rowName, mutations, timestamp)
        except Exception as excp:
            raise UfException(Errors.HBASE_UPDATE_ERROR,
                              "Error when updating table %s - rowName %s - mutations %s: %s" % \
                              (tName, rowName, mutations, excp))

    def getRow(self, tName, rowName):
        ''' get row '''
        result = self.__client.getRow(tName, rowName)
        if not result:
            return result
        else:
            return result[0]

    def scanTable(self, tName, columns, startRow="", endRow=None):
        ''' scan a table '''
        if endRow is None:
            scanner = self.__client.scannerOpen(tName, startRow, columns)
        else:
            scanner = self.__client.scannerOpenWithStop(tName, startRow, endRow, columns)
        ret = []

        row = self.__client.scannerGet(scanner)
        while row:
          ret.append(row[0])
          row = self.__client.scannerGet(scanner)

        return ret

    def getClient(self):
        ''' return client, in case low level api is needed '''
        return self.__client
Exemple #4
0
# Connect!
transport.open()

t = "demo_table"

#
# Scan all tables, look for the demo table and delete it.
#
print "scanning tables..."
for table in client.getTableNames():
    print "  found: %s" % (table)
    if table == t:
        if client.isTableEnabled(table):
            print "    disabling table: %s" % (t)
            client.disableTable(table)
        print "    deleting table: %s" % (t)
        client.deleteTable(table)

columns = []
col = ColumnDescriptor()
col.name = 'entry:'
col.maxVersions = 10
columns.append(col)
col = ColumnDescriptor()
col.name = 'unused:'
columns.append(col)

try:
    print "creating table: %s" % (t)
    client.createTable(t, columns)
Exemple #5
0
# Connect!
transport.open()

t = "demo_table"

#
# Scan all tables, look for the demo table and delete it.
#
print "scanning tables..."
for table in client.getTableNames():
    print "  found: %s" % (table)
    if table == t:
        if client.isTableEnabled(table):
            print "    disabling table: %s" % (t)
            client.disableTable(table)
        print "    deleting table: %s" % (t)
        client.deleteTable(table)

columns = []
col = ColumnDescriptor()
col.name = "entry:"
col.maxVersions = 10
columns.append(col)
col = ColumnDescriptor()
col.name = "unused:"
columns.append(col)

try:
    print "creating table: %s" % (t)
    client.createTable(t, columns)