コード例 #1
0
ファイル: hbase_op.py プロジェクト: robrowill/roboearthDB
def delete_row(table, rowKey):
    """
    deletes a complete row (rowKey) from a given table
    """

    hasBinaryFiles = ["Elements"]
    hasGraphData = ["Elements"]

    transport = roboearth.openDBTransport()
    client = transport['client']
    try:
        client.deleteAllRow(table, rowKey)
        roboearth.closeDBTransport(transport)
        if table in hasBinaryFiles:
            hdfs.rm_dir(
                os.path.join(roboearth.UPLOAD_DIR, table.lower(),
                             rowKey.replace('.', '/')))
        if table in hasGraphData:
            sesame.rm(rowKey, table)

    except IOError, err:
        roboearth.closeDBTransport(transport)
        print table, rowKey
        raise roboearth.DBWriteErrorException("Can't delete data: " +
                                              err.__str__())
コード例 #2
0
ファイル: robots.py プロジェクト: robrowill/roboearthDB
def update(id_, environment, author):
    """

    id_ : robot identifier

    environment : reference to the related environment

    author : author who submitted the data
    """

    transport = roboearth.openDBTransport()
    client = transport['client']
    try:
        client.mutateRow("Elements", id_,
                          [Mutation(column="info:author", value=author)])

        # push update to subscribers
        scanner = client.scannerOpenWithPrefix("Elements", id_, [ ])
        res = client.scannerGet(scanner)
        for r in res[0].columns:
            if r.startswith("subscriber:"):
                client.mutateRow("Users", res[0].columns[r].value,
                                 [Mutation(column="news:", value="Robots#"+id_)])
        client.scannerClose(scanner)

        roboearth.closeDBTransport(transport)
        
        return {'id' : id_}
    except (IOError, IllegalArgument), err:
        raise roboearth.DBWriteErrorException("Can't write data to Robots table: " + err.__str__())
コード例 #3
0
def updateLocation(id_, posX, posY, posZ, delta, author):
    """
    update existing object location at the database

    id_ : complete identifier (primary key) of the data

    posX, posY, posZ : coordiantes which describes the exact location

    delta : impreciseness of position data

    author: author of the description
    """

    transport = roboearth.openDBTransport()
    client = transport['client']
    try:
        oldLocation = getLocation(id_)
        object_ = oldLocation[0]['object']
        environment = oldLocation[0]['environment']
        room_number = oldLocation[0]['room_number']
        newID = environment + '.' + room_number + '.' + posX + '.' + posY + '.' + posZ + '.' + delta

        client.mutateRow("ObjectLocations", newID, [
            Mutation(column="object:id", value=object_),
            Mutation(column="info:author", value=author),
            Mutation(column="environment:id", value=environment),
            Mutation(column="environment:room", value=room_number),
            Mutation(column="position:x", value=posX),
            Mutation(column="position:y", value=posY),
            Mutation(column="position:z", value=posZ),
            Mutation(column="position:delta", value=delta)
        ])

        roboearth.closeDBTransport(transport)

        hbase_op.delete_row("ObjectLocations", id_)

        return {
            'id': id_,
            'posX': posX,
            'posY': posY,
            'posZ': posZ,
            'delta': delta,
            'object': object_,
            'environment': environment,
            'room_number': room_number
        }
    except (IOError, IllegalArgument), err:
        raise roboearth.DBWriteErrorException(
            "Can't write data to Robots table: " + err.__str__())
コード例 #4
0
def set(id_, class_, description, recipe, author):
    """
    write recipe to the database

    id_ : recipe identifier

    class_: recipe class

    description: human readable description

    recipe: owl description

    author: author of the description
    """

    transport = roboearth.openDBTransport()
    client = transport['client']
    recipeName = class_.replace(' ',
                                '').lower().strip('.') + '.' + id_.replace(
                                    ' ', '').lower().strip('.')
    try:
        # recipe already exist
        if get(query=recipeName, exact=True):
            return None

        #write data to hbase
        client.mutateRow("Elements", recipeName, [
            Mutation(column="info:description", value=description),
            Mutation(column="info:author", value=author),
            Mutation(column="info:rating", value="1"),
            Mutation(column="info:type", value="recipe"),
            Mutation(column="owl:description", value=recipe)
        ])

        #write data to sesame
        sesame_ret = sesame.set(recipe, recipeName, "elements")
        if sesame_ret != "0":
            hbase_op.delete_row("Elements", recipeName)
            raise IllegalArgument(sesame_ret)

        client.mutateRow("Users", author,
                         [Mutation(column="element:" + recipeName, value="")])

        roboearth.closeDBTransport(transport)

        return {'id': recipeName, 'description': description, 'recipe': recipe}
    except (IOError, IllegalArgument), err:
        raise roboearth.DBWriteErrorException(
            "Can't write data to Action Recipe table: " + err.__str__())
コード例 #5
0
def update(id_, data, author):
    """
    update an existing object description at the database

    id_ : complete identifier (primary key) of the object

    data: dictionary with the updated data ('description' (human readable) and
    'object_description' (OWL))

    author: author of the description
    """

    transport = roboearth.openDBTransport()
    client = transport['client']
    try:
        mutation_list = []
        if data.has_key('description'):
            mutation_list.append(
                Mutation(column="info:description", value=data['description']))
        if data.has_key('object_description'):
            mutation_list.append(
                Mutation(column="owl:description",
                         value=data['object_description']))

        client.mutateRow("Elements", id_,
                         [Mutation(column="info:modified_by", value=author)] +
                         mutation_list)

        if data.has_key('object_description'):
            sesame.rm(id_, "Elements")
            sesame.set(data['object_description'], id_, "Elements")

        # push update to subscribers
        scanner = client.scannerOpenWithPrefix("Elements", id_, [])
        res = client.scannerGet(scanner)
        for r in res[0].columns:
            if r.startswith("subscriber:"):
                client.mutateRow(
                    "Users", res[0].columns[r].value,
                    [Mutation(column="news:", value="Objects#" + id_)])

        client.scannerClose(scanner)
        roboearth.closeDBTransport(transport)

        return True
    except (IOError, IllegalArgument), err:
        raise roboearth.DBWriteErrorException(
            "Can't write data to Elements table: " + err.__str__())
コード例 #6
0
def create(user_name):
    """
    create hbase table for a new user

    user_name : user name of the new user
    """

    transport = roboearth.openDBTransport()
    client = transport['client']

    try:
        client.mutateRow("Users", user_name, [])

        roboearth.closeDBTransport(transport)

    except (IOError, IllegalArgument), err:
        raise roboearth.DBWriteErrorException(
            "Can't write data to users table: " + err.__str__())
コード例 #7
0
ファイル: robots.py プロジェクト: robrowill/roboearthDB
def set(id_, author, description, srdl, picture):
    """
    write a robot location to the database

    id_ : robot identifier

    author : author who submitted the data

    description : description of the reobot
    
    srdl: Semantic Robot Description of the robot

    picture: picture of the robot

    
    """

    transport = roboearth.openDBTransport()
    client = transport['client']

    if get(query=id_, exact=True):
        return None
    
    try:
        #create paths
        path = id_.replace(' ', '').lower().strip('.') +  '.' +id_.replace(' ', '').lower().strip('.')
        wwwPath = roboearth.DOMAIN + os.path.join("data/", 'elements/', id_.replace(' ', '').lower().strip('.'), picture.name)
        hdfs.upload_file(picture, os.path.join(roboearth.UPLOAD_DIR, 'elements/', id_.replace(' ', '').lower().strip('.')))
        
        client.mutateRow("Elements", id_.lower(),
                             [Mutation(column="info:author", value=author),
                              Mutation(column="info:description", value=description),
                              Mutation(column="owl:description", value=srdl),
                              Mutation(column="info:picture", value=wwwPath),
                              Mutation(column="info:type", value='robot')])
        client.mutateRow("Users", author,
                         [Mutation(column="element:"+id_, value="")])

        roboearth.closeDBTransport(transport)
        return {'id' : id_, 'description' : description, 'srdl' : srdl}
    except (IOError, IllegalArgument), err:
        raise roboearth.DBWriteErrorException("Can't write data to Robot table: " + err.__str__())
コード例 #8
0
def update_rating(id_, rating):
    """
    update the rating of an existing recipe at the database

    id_ : complete identifier (primary key) of the recipe

    rating : new rating
    """

    transport = roboearth.openDBTransport()
    client = transport['client']
    try:
        client.mutateRow("Elements", id_,
                         [Mutation(column="info:rating", value=str(rating))])

        roboearth.closeDBTransport(transport)

        return True
    except (IOError, IllegalArgument), err:
        raise roboearth.DBWriteErrorException(
            "Can't update Action Recipe rating: " + err.__str__())
コード例 #9
0
ファイル: hdfs_op.py プロジェクト: robrowill/roboearthDB
def upload_file(f, path):
    """
    write file to hdfs

    f : file

    path : hdfs location of the file
    """
    try:
        # write file to hdfs
        filename = os.path.join(path, f.name)
        if not os.path.exists(path):
            os.makedirs(path)
        if os.path.exists(filename):
            raise roboearth.DBWriteErrorException
            #os.remove(filename)
        destination = open(filename, 'w')
        for chunk in f.chunks():
            destination.write(chunk)
        destination.close()

    except:
        raise roboearth.DBWriteErrorException("Can't write" + os.path.join(path, f.name) + " to hdfs")
コード例 #10
0
ファイル: hbase_op.py プロジェクト: robrowill/roboearthDB
def delete_column(table, rowKey, column):
    """
    deletes a column from a given row (rowKey) in a specific table
    """
    transport = roboearth.openDBTransport()
    client = transport['client']

    scanner = client.scannerOpenWithPrefix(table, rowKey, [])
    res = client.scannerGet(scanner)

    for i in res[0].columns:
        if i == column:
            break

    client.scannerClose(scanner)

    try:
        client.deleteAll(table, rowKey, column)
        roboearth.closeDBTransport(transport)

    except IOError, err:
        roboearth.closeDBTransport(transport)
        raise roboearth.DBWriteErrorException("Can't delete column: " +
                                              err.__str__())
コード例 #11
0
ファイル: environments.py プロジェクト: robrowill/roboearthDB
            raise IllegalArgument(sesame_ret + 'bug' + envName + ' ' +
                                  environment)

        client.mutateRow("Users", author,
                         [Mutation(column="element:" + envName, value="")])

        roboearth.closeDBTransport(transport)

        return {
            'id': envName,
            'description': description,
            'environment': environment
        }

    except (IOError, IllegalArgument), err:
        raise roboearth.DBWriteErrorException(
            "Can't write data to Environment table: " + err.__str__())


def update(id_, data, author):
    """
    update an existing recipe at the database

    id_ : complete identifier (primary key) of the recipe

    data: dictionary with the updated data

    author: author of the description
    """

    transport = roboearth.openDBTransport()
    client = transport['client']
コード例 #12
0
def set(id_, class_, description, object_description, author, files=None):
    """
    write a object description to the database

    id_ : object identifier

    class_: object class

    description: human readable description

    object_description: owl description

    author: author of the description

    files: dictionary of binary files (file identifier : file)
    """
    logging.basicConfig(filename='example.log', level=logging.DEBUG)
    transport = roboearth.openDBTransport()
    client = transport['client']

    identifier = class_.replace(' ',
                                '').lower().strip('.') + '.' + id_.replace(
                                    ' ', '').lower().strip('.')

    #create paths
    path = class_.replace(' ', '').lower().strip('.') + '.' + id_.replace(
        ' ', '').lower().strip('.')
    wwwPath = roboearth.DOMAIN + os.path.join("data/", 'elements/',
                                              path.replace('.', '/'))
    path = os.path.join(roboearth.UPLOAD_DIR, 'elements/',
                        path.replace('.', '/'))

    try:
        # object already exists
        if get(query=identifier, exact=True):
            return None

        # upload files and build file mutation list for hbase operation
        file_mutation_list = []
        if files:
            for file_ID, file_ in files.items():
                hdfs.upload_file(file_, path)
                file_mutation_list.append(
                    Mutation(column="file:" + file_ID,
                             value=wwwPath + "/" + file_.name))

        # now write to hbase
        client.mutateRow("Elements", identifier, [
            Mutation(column="info:description", value=description),
            Mutation(column="info:author", value=author),
            Mutation(column="info:rating", value="1"),
            Mutation(column="info:type", value="object"),
            Mutation(column="owl:description", value=object_description)
        ] + file_mutation_list)

        #write data to sesame
        sesame_ret = sesame.set(object_description, identifier, "elements")
        if sesame_ret != "0":
            hbase_op.delete_row("Elements", identifier)
            print 'raising shit'
            raise IllegalArgument(sesame_ret)

        client.mutateRow("Users", author,
                         [Mutation(column="element:" + identifier, value="")])

        roboearth.closeDBTransport(transport)

        #if not roboearth.local_installation:
        #    roboearth.send_twitter_message("upload", "Object", identifier, author)

        return {
            'id': identifier,
            'description': description,
            'object_description': object_description
        }

    except (IOError, IllegalArgument), err:
        try:  # try clean up
            hdfs.rm_dir(path)
            hbase_op.delete_row("Elements", identifier)
            sesame.rm(identifier, "Elements")
        except:
            sys.exc_clear()
        import traceback
        logging.info(traceback.format_exc())
        raise roboearth.DBWriteErrorException(
            "Can't write data to Object table: HEREEEEE " + err.__str__())
コード例 #13
0
def setLocation(environment, room_number, object_, posX, posY, posZ, delta,
                author):
    """
    write a object location to the database

    environment : reference to an environment, stored at the database

    room_number: the room where the object is located

    object : reference to the object description

    posX, posY, posZ : coordiantes which describes the exact location

    delta : impreciseness of position data

    author : author of the description
    """

    transport = roboearth.openDBTransport()
    client = transport['client']

    try:
        scanner = client.scannerOpenWithPrefix("Objects", object_.lower(), [])
        if not client.scannerGet(scanner):
            raise roboearth.NoDBEntryFoundException(
                "Couldn't connect location with the named object. Object doesn't exits in database"
            )
        scanner = client.scannerOpenWithPrefix("Environments",
                                               environment.lower(), [])
        if not client.scannerGet(scanner):
            raise roboearth.NoDBEntryFoundException(
                "Couldn't connect location with the named environment. Environment doesn't exits in database"
            )

        id_ = environment + '.' + room_number + '.' + posX + '.' + posY + '.' + posZ + '.' + delta

        if getLocation(query=id_, exact=True):
            return None

        client.mutateRow("ObjectLocations", id_, [
            Mutation(column="object:id", value=object_),
            Mutation(column="info:author", value=author),
            Mutation(column="environment:id", value=environment),
            Mutation(column="environment:room", value=room_number),
            Mutation(column="position:x", value=posX),
            Mutation(column="position:y", value=posY),
            Mutation(column="position:z", value=posZ),
            Mutation(column="position:delta", value=delta)
        ])
        roboearth.closeDBTransport(transport)
        return {
            'id': id_,
            'posX': posX,
            'posY': posY,
            'posZ': posZ,
            'delta': delta,
            'object': object_,
            'environment': environment,
            'room_number': room_number
        }
    except (IOError, IllegalArgument), err:
        raise roboearth.DBWriteErrorException(
            "Can't write dataop to Object table: " + err.__str__())