示例#1
0
def delete_store(store_name, user=None):  # noqa: E501
    """Delete file store

     # noqa: E501

    :param store_name: Name of the store
    :type store_name: str

    :rtype: None
    """
    session = Database.get_session()
    try:
        # Check the store
        q = Database.get_session().query(RosbagStore).filter(
            RosbagStore.name == store_name)  # type: Query
        if q.count() == 1:
            session.delete(q.first())
            session.commit()
            return "", 204
        else:
            return Error(code=404, message="Store not found"), 404

    except Exception as e:
        logging.exception("User account deletion failed")
        session.rollback()

    return Error(code=500, message="Exception occurred"), 500
示例#2
0
def delete_bag_comment(store_name,
                       bag_name,
                       comment_id,
                       user=None):  # noqa: E501
    """Post a comment

     # noqa: E501

    :param store_name: Name of the store
    :type store_name: str
    :param bag_name: Name of the bag
    :type bag_name: str
    :param comment_id: Comment identifier
    :type comment_id: int

    :rtype: None
    """
    try:
        session = Database.get_session()
        bag, e = find_bag_in_database(session, store_name, bag_name)
        if e:
            return e, e.code

        q = session.query(RosbagComment).filter(
            RosbagComment.uid == comment_id)  # type: Query
        if q.count() != 1 or q.first().bag_id != bag.uid:
            return Error(code=404, message="Comment not found"), 404

        session.delete(q.first())
        session.commit()

        return "", 204

    except Exception as e:
        return handle_exception(e)
示例#3
0
def put_current_user(user, logged_in_user=None):
    """
    Change current user information


    :rtype: User
    """
    if connexion.request.is_json:
        user = SwaggerUser.from_dict(connexion.request.get_json())

    if logged_in_user.alias != user.alias:
        return Error(code=400, message="Alias cannot be changed"), 400

    session = Database.get_session()
    try:
        logged_in_user.from_swagger_model(user, user=logged_in_user)

        # Users are not allowed to change their own permissions...
        # if user.permissions is not None:
        #     update_user_permissions(logged_in_user, user.permissions)

        session.commit()

        q = session.query(User).filter(User.uid == logged_in_user.uid)
        swagger_user = q.first().to_swagger_model(user=logged_in_user)
        swagger_user.permissions = list_user_permissions(q.first())
        return swagger_user, 200

    except Exception as e:
        logging.exception("Current user put failed")
        session.rollback()

    return Error(code=500, message="Exception occurred"), 500
示例#4
0
def get_file_meta(store_name, uid, file_name, user=None):
    """
    Get file meta data
    
    :param store_name: Name of the store
    :type store_name: str
    :param uid: Unique identifier of the file
    :type uid: int
    :param file_name: Name of the file
    :type file_name: str

    :rtype: FileDetailed
    """
    try:
        q = Database.get_session().query(File).filter(
            and_(FileStore.name == store_name, File.uid == uid))  # type: Query
        if q.count():
            file = q[0]
            if file.name == file_name:
                return file.to_swagger_model_detailed(user=user)

        return Error(code=404, message="Store or file not found"), 404

    except Exception as e:
        if current_app.config['TESTING']:
            return Error(code=500, message="Exception: " + str(e)), 500
        else:
            return Error(code=500, message="Exception occurred"), 500
示例#5
0
def get_user_account(alias, logged_in_user=None):  # noqa: E501
    """Get user information

     # noqa: E501

    :param alias: Alias of the user
    :type alias: str

    :rtype: User
    """
    session = Database.get_session()
    try:
        # Check the store
        q = session.query(User).filter(User.alias == alias)  # type: Query
        if q.count() == 1:
            swagger_user = q.first().to_swagger_model(user=logged_in_user)
            swagger_user.permissions = list_user_permissions(q.first())
            return swagger_user, 200
        else:
            return Error(code=404, message="User not found"), 404

    except Exception as e:
        logging.exception("User account put failed")
        session.rollback()

    return Error(code=500, message="Exception occurred"), 500
示例#6
0
def new_bag_comment(store_name, bag_name, comment, user=None):  # noqa: E501
    """Delete a comment

     # noqa: E501

    :param store_name: Name of the store
    :type store_name: str
    :param bag_name: Name of the bag
    :type bag_name: str
    :param comment: Comment
    :type comment: dict | bytes

    :rtype: Comment
    """
    if connexion.request.is_json:
        comment = Comment.from_dict(connexion.request.get_json())  # noqa: E501

    try:
        session = Database.get_session()
        bag, e = find_bag_in_database(session, store_name, bag_name)
        if e:
            return e, e.code

        comment_model = RosbagComment()
        comment_model.from_swagger_model(comment)
        comment_model.user_id = user.uid
        comment_model.bag_id = bag.uid

        session.add(comment_model)
        session.commit()

        return comment_model.to_swagger_model()

    except Exception as e:
        return handle_exception(e)
示例#7
0
def delete_user_account(alias, user=None):  # noqa: E501
    """Delete user account

     # noqa: E501

    :param alias: Alias of the user
    :type alias: str

    :rtype: None
    """
    session = Database.get_session()
    try:
        # Check the store
        q = session.query(User).filter(User.alias == alias)  # type: Query
        if q.count() == 1:
            session.delete(q.first())
            session.commit()
            return "", 204
        else:
            return Error(code=404, message="User not found"), 404

    except Exception as e:
        logging.exception("User account deletion failed")
        session.rollback()

    return Error(code=500, message="Exception occurred"), 500
示例#8
0
def list_extraction_configurations(user=None):
    """List available configurations


    :rtype: List[BagExtractionConfiguration]
    """
    try:
        q = Database.get_session().query(RosbagExtractionConfiguration)
        return [p.to_swagger_model(user=user) for p in q]
    except Exception as e:
        return handle_exception(e)
示例#9
0
文件: auth.py 项目: xuchen27/rbb_core
def get_current_session():
    session_info = get_current_session_id_and_token()
    if not session_info:
        return None
    q = Database.get_session().query(Session).filter(Session.uid == session_info['id'])
    if q.count():
        session = q.first()
        if session.token == session_info['token']:
            return session

    return None
示例#10
0
def put_user_account(alias, user, block_on_existing=None, logged_in_user=None):  # noqa: E501
    """Change user information

     # noqa: E501

    :param alias: Alias of the user
    :type alias: str
    :param user: The user information
    :type user: dict | bytes

    :rtype: User
    """
    if connexion.request.is_json:
        user = SwaggerUser.from_dict(connexion.request.get_json())

    if alias != user.alias:
        return Error(code=400, message="URL and body aliases don't match"), 400

    if len(user.alias) < 4:
        return Error(code=400, message="Minimum alias length is 4 characters"), 400

    session = Database.get_session()
    try:
        # Check the store
        q = session.query(User).filter(User.alias == alias)  # type: Query

        # Create new store or use existing
        user_model = None
        if q.count() == 1:
            # Existing user
            if block_on_existing:
                return Error(code=1000, message="Already exists."), 400

            user_model = q.first()
        else:
            user_model = User()
            session.add(user_model)

        user_model.from_swagger_model(user, user=logged_in_user)
        if user.permissions is not None:
            update_user_permissions(user_model, user.permissions, session)
        session.commit()

        q = session.query(User).filter(User.uid == user_model.uid)

        swagger_user = q.first().to_swagger_model(user=logged_in_user)
        swagger_user.permissions = list_user_permissions(q.first())
        return swagger_user, 200

    except Exception as e:
        logging.exception("User account put failed")
        session.rollback()

    return Error(code=500, message="Exception occurred"), 500
示例#11
0
def bag_store_authorize_step_get(store_name, step, user=None):
    """
    Authorization step forwarded to storage plugin

    :param store_name: Name of the store
    :type store_name: str
    :param step: Step of the authorization procedure
    :type step: str

    :rtype: None
    """
    session = Database.get_session()
    try:
        q = session.query(RosbagStore).filter(
            RosbagStore.name == store_name)  # type: Query
        if q.count():
            store = q[0]
            storage_plugin = Storage.factory(store_name, store.store_type,
                                             store.store_data)

            link = url_for(
                "/api/v0.rbb_server_controllers_store_controller_bag_store_authorize_step_get",
                store_name=store_name,
                step="",
                _external=True)

            response = storage_plugin.authorize_get_step(
                step, flask_request, link)

            if storage_plugin.needs_saving():
                store.store_data = storage_plugin.get_data()
                flag_modified(store, 'store_data')
                Database.get_session().commit()

            return response

        return Error(code=404, message="Store not found"), 404

    except Exception as e:
        logging.exception(e)
        return Error(code=500, message="Exception occurred"), 500
示例#12
0
def setup_database_for_test():
    Database.init(debug=True)

    engine = Database.get_engine()
    connection = engine.connect()
    connection.execute("DROP SCHEMA IF EXISTS unittest CASCADE")
    connection.execute("CREATE SCHEMA unittest")
    connection.execute("SET search_path TO unittest, public")

    tx = connection.begin()
    try:
        # Create fresh schema
        with open(
                os.path.dirname(__file__) + "/../../src/rbb_server/schema.sql",
                'r') as sql_file:
            sql = sql_file.read()
        connection.execute(sql)

        # Insert all our testing data
        with open(os.path.dirname(__file__) + "/test-data.sql",
                  'r') as sql_file:
            sql = sql_file.read()

        statements = sql.split(";")
        for statement in statements:
            sql = statement.strip()
            if sql:
                connection.execute(sql)

        tx.commit()
    except Exception as e:
        tx.rollback()
        logging.error(e)
        print("ERROR: Cannot load unittest data into database!")
        raise e

    connection.close()

    # Make current session use the testing schema
    Database.get_session().execute("SET search_path TO unittest")
示例#13
0
    def test_get_bag_product_files(self):
        bag = Database.get_session().query(Rosbag).get(1) # type: Rosbag
        self.assertEqual(len(bag.products), 3)
        rviz_product = None
        for product in bag.products: #type: RosbagProduct
            if product.plugin == "RvizRecorder":
                rviz_product = product

        self.assertIsNotNone(rviz_product)
        self.assertEqual(len(rviz_product.files), 1)
        self.assertEqual(rviz_product.files[0].key, "video")
        self.assertEqual(rviz_product.files[0].file.name, "test.mp4")
        self.assertEqual(rviz_product.files[0].file.store.store_type, "google-cloud")
示例#14
0
def put_file_store(store_name,
                   store,
                   block_on_existing=None,
                   user=None):  # noqa: E501
    """Create/update store

     # noqa: E501

    :param store_name: Name of the store
    :type store_name: str
    :param store: Store information
    :type store: dict | bytes

    :rtype: FileStore
    """
    if connexion.request.is_json:
        store = SwaggerFileStore.from_dict(
            connexion.request.get_json())  # noqa: E501

    if store_name != store.name:
        return Error(code=400, message="URL and body names don't match"), 400

    session = Database.get_session()
    try:
        # Check the store
        q = session.query(FileStore).filter(
            FileStore.name == store_name)  # type: Query

        # Create new store or use existing
        model = None
        if q.first():
            # Existing store
            if block_on_existing:
                return Error(code=1000, message="Already exists."), 400

            model = q.first()
        else:
            model = FileStore()
            session.add(model)

        model.from_swagger_model(store, user=user)
        session.commit()

        q = session.query(FileStore).filter(FileStore.uid == model.uid)

        return q.first().to_swagger_model(user=user), 200
    except Exception as e:
        logging.exception("File store put failed")
        session.rollback()

    return Error(code=500, message="Exception occurred"), 500
示例#15
0
def patch_bag_meta(store_name,
                   bag_name,
                   bag,
                   trigger=None,
                   user=None):  # noqa: E501
    """Partial update of bag information (this only supports a few fields)

     # noqa: E501

    :param store_name: Name of the store
    :type store_name: str
    :param bag_name: Name of the bag
    :type bag_name: str
    :param bag: Bag to register
    :type bag: dict | bytes
    :param trigger: Hooks to trigger
    :type trigger: str

    :rtype: BagDetailed
    """
    if connexion.request.is_json:
        bag = connexion.request.get_json()

    try:
        session = Database.get_session()
        bag_model, e = find_bag_in_database(session, store_name, bag_name)
        if e:
            return e, e.code

        changed = False

        if 'comment' in bag and isinstance(bag['comment'], str):
            bag_model.comment = bag['comment']
            changed = True

        if 'extraction_failure' in bag:
            bag_model.extraction_failure = bag['extraction_failure']
            changed = True

        if 'in_trash' in bag:
            bag_model.in_trash = bag['in_trash']
            changed = True

        if changed:
            session.commit()

        return bag_model.to_swagger_model_detailed(user=user)

    except Exception as e:
        return handle_exception(e)
示例#16
0
def list_stores(user=None):
    """
    List available stores
    

    :rtype: List[BagStoreDetailed]
    """
    try:
        q = Database.get_session().query(RosbagStore)
        return [p.to_swagger_model_detailed(user=user) for p in q]
    except Exception as e:
        if current_app.config['TESTING']:
            return Error(code=500, message="Exception: " + str(e)), 500
        else:
            return Error(code=500, message="Exception occurred"), 500
示例#17
0
def list_tags(user=None):
    """List all tags

     # noqa: E501


    :rtype: List[Tag]
    """
    try:
        session = Database.get_session()
        q = session.query(Tag)  #type: Query
        return [p.to_swagger_model(user=user) for p in q]

    except Exception as e:
        return handle_exception(e)
示例#18
0
文件: auth.py 项目: xuchen27/rbb_core
def check_auth(username, password):
    """This function is called to check if a username /
    password combination is valid.
    """
    try:
        q = Database.get_session().query(User).filter(User.alias == username)
        if q.count():
            user = q.first()
            if user.check_password(password):
                return user

    except Exception as e:
        logging.exception(e)

    return False
示例#19
0
 def test_insert_store(self):
     test_store = RosbagStore(
         name="some-test-store",
         description="test",
         store_type="dropbox",
         store_data="{}"
     )
     Database.get_session().add(test_store)
     Database.get_session().flush()
     self.assertIsNotNone(test_store.uid, "UID assigned after flush/commit")
     Database.get_session().commit()
示例#20
0
def get_store_extraction_configs(store_name, user=None):
    """Get list of auto extraction configs

    :param store_name: Name of the store
    :type store_name: str

    :rtype: List[BagExtractionConfiguration]
    """
    try:
        q = Database.get_session().query(RosbagStore).filter(RosbagStore.name == store_name) #type: Query
        if q.count():
            return [x.to_swagger_model(user=user) for x in q.first().auto_extraction_configs]
        else:
            return Error(code=404, message="Store not found"), 404

    except Exception as e:
        return handle_exception(e)
示例#21
0
def get_extraction_config(config_name, user=None):
    """Get configuration details

    :param config_name: Name of the configuration
    :type config_name: str

    :rtype: BagExtractionConfiguration
    """
    try:
        q = Database.get_session().query(RosbagExtractionConfiguration).\
            filter(RosbagExtractionConfiguration.name == config_name) #type: Query
        if q.count():
            return q[0].to_swagger_model(user=user)
        else:
            return Error(code=404, message="Configuration not found"), 404

    except Exception as e:
        return handle_exception(e)
示例#22
0
def read_bags_into_map(store, plugin):
    bags = {}
    bags_full_path = {}
    q = Database.get_session().query(Rosbag).filter(
        Rosbag.store_id == store.uid)
    for bag in q:
        file_info = plugin.list_file(bag.store_data)
        bag_basename = file_info.get_name()
        bag_fullname = file_info.get_path()

        if bag_basename in bags:
            logging.warning("Duplicate bag '{}' in store '{}'".format(
                bag_basename, store.name))

        bags[bag_basename] = bag
        bags_full_path[bag_fullname] = bag

    return bags, bags_full_path
示例#23
0
def put_bag_tags(store_name, bag_name, tags, auto_create=None, user=None):
    """Change bag tags

     # noqa: E501

    :param store_name: Name of the store
    :type store_name: str
    :param bag_name: Name of the bag
    :type bag_name: str
    :param tags: List of tags
    :type tags: List[]
    :param auto_create: Create non existing tags
    :type auto_create: bool

    :rtype: List[Tag]
    """
    try:
        session = Database.get_session()
        bag, e = find_bag_in_database(session, store_name, bag_name)
        if e:
            return e, e.code

        tag_models = []

        tags_unique = list(set([x.strip().lower() for x in tags]))
        for tag in tags_unique:
            q = session.query(Tag).filter(Tag.tag == tag)  # type: Query
            if q.count() == 1:
                tag_models.append(q.first())
            else:
                if auto_create:
                    tag_models.append(Tag(tag=tag, color=""))
                else:
                    return Error(code=400,
                                 message="Tag '" + tag +
                                 "' does not exist"), 400

        bag.tags = tag_models
        session.commit()

        return get_bag_tags(store_name, bag_name)

    except Exception as e:
        return handle_exception(e)
示例#24
0
def list_user_accounts(user=None):  # noqa: E501
    """List user acounts

     # noqa: E501


    :rtype: List[User]
    """
    session = Database.get_session()
    try:
        # Check the store
        q = session.query(User)  # type: Query
        return [x.to_swagger_model(user=user) for x in q], 200

    except Exception as e:
        logging.exception("List user accounts")
        session.rollback()

    return Error(code=500, message="Exception occurred"), 500
示例#25
0
def put_tag(tag, tag_obj, user=None):
    """Create/update tag

     # noqa: E501

    :param tag: Name of the tag
    :type tag: str
    :param tag_obj: Tag information
    :type tag_obj: dict | bytes

    :rtype: Tag
    """
    tag = tag.strip().lower()

    if connexion.request.is_json:
        tag_obj = SwaggerTag.from_dict(connexion.request.get_json())

    # We do allow renaming tags
    # if tag_obj.tag != tag:
    #     return Error(code=400, message="Path and body tag are not the same"), 400

    try:
        session = Database.get_session()
        q = session.query(Tag).filter(Tag.tag == tag)  # type: Query

        model = Tag()
        if q.count() == 1:
            model = q.first()
        else:
            if tag_obj.tag != tag:
                return Error(
                    code=400,
                    message="Path and body tag have to be equal for a new tag"
                ), 400
            session.add(model)

        model.from_swagger_model(tag_obj)
        session.commit()

        return model.to_swagger_model(user=user)

    except Exception as e:
        return handle_exception(e)
示例#26
0
    def test_insert_bag(self):
        bag = Rosbag(
            store=Database.get_session().query(RosbagStore).get(1),
            store_data={'test':'est'},
            name="Testbag",
            is_extracted=False,
            meta_available=False,
            size=100,
            start_time=datetime.datetime.now(),
            end_time=datetime.datetime.now(),
            duration=10.4,
            messages=10000,
            comment="Lalalalala"
        )
        Database.get_session().add(bag)
        Database.get_session().flush()
        self.assertIsNotNone(bag.uid, "UID assigned after flush/commit")
        Database.get_session().commit()

        bag = Database.get_session().query(Rosbag).get(bag.uid)
        self.assertEqual(bag.store_data['test'], 'est')
示例#27
0
def put_extraction_configuration(config_name, configuration_obj, block_on_existing=None, user=None):
    """Create/update configuration

    :param config_name: Name of the configuration
    :type config_name: str
    :param configuration: Configuration information
    :type configuration: dict | bytes

    :rtype: BagExtractionConfiguration
    """
    if connexion.request.is_json:
        configuration_obj = BagExtractionConfiguration.from_dict(connexion.request.get_json())

    if config_name != configuration_obj.name:
        return Error(code=400, message="URL and body names don't match"), 400

    session = Database.get_session()
    try:
        # Check the store
        q = session.query(RosbagExtractionConfiguration).filter(RosbagExtractionConfiguration.name == config_name)  # type: Query

        # Create new store or use existing
        model = None
        if q.count() == 1:
            # Existing configuration
            if block_on_existing:
                return Error(code=1000, message="Already exists."), 400

            model = q.first()
        else:
            model = RosbagExtractionConfiguration()
            session.add(model)

        model.from_swagger_model(configuration_obj, user=user)
        session.commit()

        q = session.query(RosbagExtractionConfiguration).filter(RosbagExtractionConfiguration.uid == model.uid)

        return q.first().to_swagger_model(user=user), 200

    except Exception as e:
        session.rollback()
        return handle_exception(e)
示例#28
0
def get_tag(tag, user=None):
    """Get tag info

     # noqa: E501

    :param tag: Name of the tag
    :type tag: str

    :rtype: Tag
    """
    try:
        session = Database.get_session()
        q = session.query(Tag).filter(Tag.tag == tag)  # type: Query

        if q.count() == 0:
            return Error(code=404, message="Tag not found"), 404

        return q[0].to_swagger_model(user=user)

    except Exception as e:
        return handle_exception(e)
示例#29
0
def list_sessions(user=None):
    """
    List current session


    :rtype: List[Session]
    """
    try:
        q = Database.get_session().query(Session).filter(
            Session.user_uid == user.uid)

        models = []
        for session in q:
            model = session.to_swagger_model()
            model.token = ""
            models.append(model)

        return models

    except Exception as e:
        return error_helper.handle_exception(e)
示例#30
0
def get_bag_meta(store_name, bag_name, user=None):
    """
    List products from bag
    
    :param store_name: Name of the store
    :type store_name: str
    :param bag_name: Name of the bag
    :type bag_name: str

    :rtype: BagDetailed
    """
    try:
        session = Database.get_session()
        bag_model, e = find_bag_in_database(session, store_name, bag_name)
        if e:
            return e, e.code

        return bag_model.to_swagger_model_detailed(user=user)

    except Exception as e:
        return handle_exception(e)