def __init__(self, config=None, **kwargs): self.config = config or MockAppConfig(**kwargs) self.security = self.config.security self.name = kwargs.get('name', 'galaxy') self.object_store = objectstore.build_object_store_from_config( self.config) self.model = mapping.init("/tmp", self.config.database_connection, create_tables=True, object_store=self.object_store) self.security_agent = self.model.security_agent self.visualizations_registry = MockVisualizationsRegistry() self.tag_handler = tags.GalaxyTagHandler(self.model.context) self.quota_agent = quota.DatabaseQuotaAgent(self.model) self.init_datatypes() self.job_config = Bunch(dynamic_params=None, destinations={}) self.tool_data_tables = {} self.dataset_collections_service = None self.container_finder = NullContainerFinder() self._toolbox_lock = MockLock() self.tool_shed_registry = Bunch(tool_sheds={}) self.genome_builds = GenomeBuilds(self) self.job_manager = NoopManager() self.application_stack = ApplicationStack() self.auth_manager = AuthManager(self) self.user_manager = UserManager(self) self.execution_timer_factory = Bunch( get_timer=StructuredExecutionTimer) def url_for(*args, **kwds): return "/mock/url" self.url_for = url_for
def __init__(self, app): self.type_registry = DATASET_COLLECTION_TYPES_REGISTRY self.collection_type_descriptions = COLLECTION_TYPE_DESCRIPTION_FACTORY self.model = app.model self.security = app.security self.hda_manager = hdas.HDAManager(app) self.history_manager = histories.HistoryManager(app) self.tag_handler = tags.GalaxyTagHandler(app.model.context) self.ldda_manager = lddas.LDDAManager(app)
def show(self, trans, id, library_id, **kwd): """ GET /api/libraries/{library_id}/contents/{id} Returns information about library file or folder. :param id: the encoded id of the library item to return :type id: str :param library_id: the encoded id of the library that contains this item :type library_id: str :returns: detailed library item information :rtype: dict .. seealso:: :func:`galaxy.model.LibraryDataset.to_dict` and :attr:`galaxy.model.LibraryFolder.dict_element_visible_keys` """ class_name, content_id = self._decode_library_content_id(id) if class_name == 'LibraryFolder': content = self.get_library_folder(trans, content_id, check_ownership=False, check_accessible=True) rval = content.to_dict( view='element', value_mapper={'id': trans.security.encode_id}) rval['id'] = 'F' + str(rval['id']) if rval['parent_id'] is not None: # This can happen for root folders. rval['parent_id'] = 'F' + str( trans.security.encode_id(rval['parent_id'])) rval['parent_library_id'] = trans.security.encode_id( rval['parent_library_id']) else: content = self.get_library_dataset(trans, content_id, check_ownership=False, check_accessible=True) rval = content.to_dict(view='element') rval['id'] = trans.security.encode_id(rval['id']) rval['ldda_id'] = trans.security.encode_id(rval['ldda_id']) rval['folder_id'] = 'F' + str( trans.security.encode_id(rval['folder_id'])) rval['parent_library_id'] = trans.security.encode_id( rval['parent_library_id']) tag_manager = tags.GalaxyTagHandler(trans.sa_session) rval['tags'] = tag_manager.get_tags_str( content.library_dataset_dataset_association.tags) return rval
def __init__(self, config=None, **kwargs): super().__init__() self[BasicApp] = self self[MinimalManagerApp] = self self[StructuredApp] = self self.config = config or MockAppConfig(**kwargs) self.security = self.config.security self[idencoding.IdEncodingHelper] = self.security self.name = kwargs.get('name', 'galaxy') self.object_store = objectstore.build_object_store_from_config( self.config) self.model = mapping.init("/tmp", self.config.database_connection, create_tables=True, object_store=self.object_store) self[SharedModelMapping] = self.model self[GalaxyModelMapping] = self.model self[scoped_session] = self.model.context self.security_agent = self.model.security_agent self.visualizations_registry = MockVisualizationsRegistry() self.tag_handler = tags.GalaxyTagHandler(self.model.context) self[tags.GalaxyTagHandler] = self.tag_handler self.quota_agent = quota.DatabaseQuotaAgent(self.model) self.init_datatypes() self.job_config = Bunch(dynamic_params=None, destinations={}, use_messaging=False, assign_handler=lambda *args, **kwargs: None) self.tool_data_tables = {} self.dataset_collections_service = None self.container_finder = NullContainerFinder() self._toolbox_lock = MockLock() self.tool_shed_registry = Bunch(tool_sheds={}) self.genome_builds = GenomeBuilds(self) self.job_manager = NoopManager() self.application_stack = ApplicationStack() self.auth_manager = AuthManager(self.config) self.user_manager = UserManager(self) self.execution_timer_factory = Bunch( get_timer=StructuredExecutionTimer) self.is_job_handler = False rebind_container_to_task(self) def url_for(*args, **kwds): return "/mock/url" self.url_for = url_for
def __init__(self, config=None, **kwargs): super().__init__() config = config or MockAppConfig(**kwargs) GalaxyDataTestApp.__init__(self, config=config, **kwargs) self[BasicSharedApp] = self self[MinimalManagerApp] = self self[StructuredApp] = self self[idencoding.IdEncodingHelper] = self.security self.name = kwargs.get('name', 'galaxy') self[SharedModelMapping] = self.model self[GalaxyModelMapping] = self.model self[galaxy_scoped_session] = self.model.context self.visualizations_registry = MockVisualizationsRegistry() self.tag_handler = tags.GalaxyTagHandler(self.model.context) self[tags.GalaxyTagHandler] = self.tag_handler self.quota_agent = quota.DatabaseQuotaAgent(self.model) self.job_config = Bunch( dynamic_params=None, destinations={}, use_messaging=False, assign_handler=lambda *args, **kwargs: None ) self.tool_data_tables = ToolDataTableManager(tool_data_path=self.config.tool_data_path) self.dataset_collections_service = None self.container_finder = NullContainerFinder() self._toolbox_lock = MockLock() self.tool_shed_registry = Bunch(tool_sheds={}) self.genome_builds = GenomeBuilds(self) self.job_manager = NoopManager() self.application_stack = ApplicationStack() self.auth_manager = AuthManager(self.config) self.user_manager = UserManager(self) self.execution_timer_factory = Bunch(get_timer=StructuredExecutionTimer) self.file_sources = Bunch(to_dict=lambda *args, **kwargs: {}) self.interactivetool_manager = Bunch(create_interactivetool=lambda *args, **kwargs: None) self.is_job_handler = False self.biotools_metadata_source = None rebind_container_to_task(self) def url_for(*args, **kwds): return "/mock/url" self.url_for = url_for
def index(self, trans, folder_id, limit=None, offset=None, search_text=None, include_deleted=False): """ Displays a collection (list) of a folder's contents (files and folders). Encoded folder ID is prepended with 'F' if it is a folder as opposed to a data set which does not have it. Full path is provided in response as a separate object providing data for breadcrumb path building. ..example: limit and offset can be combined. Skip the first two and return five: '?offset=2&limit=5' :param folder_id: encoded ID of the folder which contents should be library_dataset_dict :type folder_id: encoded string :param offset: number of folder contents to skip :type offset: optional int :param limit: maximum number of folder contents to return :type limit: optional int :param include_deleted: whether to include deleted items in the results :type include_deleted: optional bool (default False) :returns: dictionary containing all items and metadata :type: dict :raises: MalformedId, InconsistentDatabase, ObjectNotFound, InternalServerError """ is_admin = trans.user_is_admin current_user_roles = trans.get_current_user_roles() decoded_folder_id = self.folder_manager.cut_and_decode( trans, folder_id) folder = self.folder_manager.get(trans, decoded_folder_id) # Special level of security on top of libraries. if trans.app.security_agent.can_access_library( current_user_roles, folder.parent_library) or is_admin: pass else: if trans.user: log.warning( f"SECURITY: User (id: {trans.user.id}) without proper access rights is trying to load folder with ID of {decoded_folder_id}" ) else: log.warning( f"SECURITY: Anonymous user is trying to load restricted folder with ID of {decoded_folder_id}" ) raise exceptions.ObjectNotFound( f'Folder with the id provided ( {folder_id} ) was not found') folder_contents = [] update_time = '' create_time = '' folders, datasets = self._apply_preferences(folder, include_deleted, search_text) # Go through every accessible item (folders, datasets) in the folder and include its metadata. for content_item in self._load_folder_contents(trans, folders, datasets, offset, limit): return_item = {} encoded_id = trans.security.encode_id(content_item.id) create_time = content_item.create_time.strftime(TIME_FORMAT) if content_item.api_type == FOLDER_TYPE_NAME: encoded_id = f'F{encoded_id}' can_modify = is_admin or ( trans.user and trans.app.security_agent.can_modify_library_item( current_user_roles, folder)) can_manage = is_admin or ( trans.user and trans.app.security_agent.can_manage_library_item( current_user_roles, folder)) update_time = content_item.update_time.strftime(TIME_FORMAT) return_item.update( dict(can_modify=can_modify, can_manage=can_manage)) if content_item.description: return_item.update( dict(description=content_item.description)) elif content_item.api_type == FILE_TYPE_NAME: # Is the dataset public or private? # When both are False the dataset is 'restricted' # Access rights are checked on the dataset level, not on the ld or ldda level to maintain consistency dataset = content_item.library_dataset_dataset_association.dataset is_unrestricted = trans.app.security_agent.dataset_is_public( dataset) is_private = not is_unrestricted and trans.user and trans.app.security_agent.dataset_is_private_to_user( trans, dataset) # Can user manage the permissions on the dataset? can_manage = is_admin or ( trans.user and trans.app.security_agent.can_manage_dataset( current_user_roles, content_item. library_dataset_dataset_association.dataset)) raw_size = int(content_item. library_dataset_dataset_association.get_size()) nice_size = util.nice_size(raw_size) update_time = content_item.library_dataset_dataset_association.update_time.strftime( TIME_FORMAT) library_dataset_dict = content_item.to_dict() encoded_ldda_id = trans.security.encode_id( content_item.library_dataset_dataset_association.id) tag_manager = tags.GalaxyTagHandler(trans.sa_session) ldda_tags = tag_manager.get_tags_str( content_item.library_dataset_dataset_association.tags) return_item.update( dict(file_ext=library_dataset_dict['file_ext'], date_uploaded=library_dataset_dict['date_uploaded'], update_time=update_time, is_unrestricted=is_unrestricted, is_private=is_private, can_manage=can_manage, state=library_dataset_dict['state'], file_size=nice_size, raw_size=raw_size, ldda_id=encoded_ldda_id, tags=ldda_tags)) if content_item.library_dataset_dataset_association.message: return_item.update( dict(message=content_item. library_dataset_dataset_association.message)) elif content_item.library_dataset_dataset_association.info: # There is no message but ldda info contains something so we display that instead. return_item.update( dict(message=content_item. library_dataset_dataset_association.info)) # For every item include the default metadata return_item.update( dict(id=encoded_id, type=content_item.api_type, name=content_item.name, update_time=update_time, create_time=create_time, deleted=content_item.deleted)) folder_contents.append(return_item) # Return the reversed path so it starts with the library node. full_path = self._build_path(trans, folder)[::-1] user_can_add_library_item = is_admin or trans.app.security_agent.can_add_library_item( current_user_roles, folder) user_can_modify_folder = is_admin or trans.app.security_agent.can_modify_library_item( current_user_roles, folder) parent_library_id = None if folder.parent_library is not None: parent_library_id = trans.security.encode_id( folder.parent_library.id) total_rows = len(folders) + len(datasets) metadata = dict(full_path=full_path, total_rows=total_rows, can_add_library_item=user_can_add_library_item, can_modify_folder=user_can_modify_folder, folder_name=folder.name, folder_description=folder.description, parent_library_id=parent_library_id) folder_container = dict(metadata=metadata, folder_contents=folder_contents) return folder_container
def __init__(self, app): self.app = app self.tag_handler = tags.GalaxyTagHandler(app.model.context)
def __new_library_upload(trans, cntrller, uploaded_dataset, library_bunch, state=None): current_user_roles = trans.get_current_user_roles() if not ((trans.user_is_admin and cntrller in ['library_admin', 'api']) or trans.app.security_agent.can_add_library_item( current_user_roles, library_bunch.folder)): # This doesn't have to be pretty - the only time this should happen is if someone's being malicious. raise Exception( "User is not authorized to add datasets to this library.") folder = library_bunch.folder if uploaded_dataset.get('in_folder', False): # Create subfolders if desired for name in uploaded_dataset.in_folder.split(os.path.sep): trans.sa_session.refresh(folder) matches = [ x for x in active_folders(trans, folder) if x.name == name ] if matches: folder = matches[0] else: new_folder = trans.app.model.LibraryFolder( name=name, description='Automatically created by upload tool') new_folder.genome_build = trans.app.genome_builds.default_value folder.add_folder(new_folder) trans.sa_session.add(new_folder) trans.sa_session.flush() trans.app.security_agent.copy_library_permissions( trans, folder, new_folder) folder = new_folder if library_bunch.replace_dataset: ld = library_bunch.replace_dataset else: ld = trans.app.model.LibraryDataset(folder=folder, name=uploaded_dataset.name) trans.sa_session.add(ld) trans.sa_session.flush() trans.app.security_agent.copy_library_permissions(trans, folder, ld) ldda = trans.app.model.LibraryDatasetDatasetAssociation( name=uploaded_dataset.name, extension=uploaded_dataset.file_type, dbkey=uploaded_dataset.dbkey, library_dataset=ld, user=trans.user, create_dataset=True, sa_session=trans.sa_session) if uploaded_dataset.get('tag_using_filenames', False): tag_from_filename = os.path.splitext( os.path.basename(uploaded_dataset.name))[0] tag_manager = tags.GalaxyTagHandler(trans.sa_session) tag_manager.apply_item_tag(item=ldda, user=trans.user, name='name', value=tag_from_filename) trans.sa_session.add(ldda) if state: ldda.state = state else: ldda.state = ldda.states.QUEUED ldda.message = library_bunch.message trans.sa_session.flush() # Permissions must be the same on the LibraryDatasetDatasetAssociation and the associated LibraryDataset trans.app.security_agent.copy_library_permissions(trans, ld, ldda) if library_bunch.replace_dataset: # Copy the Dataset level permissions from replace_dataset to the new LibraryDatasetDatasetAssociation.dataset trans.app.security_agent.copy_dataset_permissions( library_bunch.replace_dataset.library_dataset_dataset_association. dataset, ldda.dataset) else: # Copy the current user's DefaultUserPermissions to the new LibraryDatasetDatasetAssociation.dataset trans.app.security_agent.set_all_dataset_permissions( ldda.dataset, trans.app.security_agent.user_get_default_permissions(trans.user)) folder.add_library_dataset(ld, genome_build=uploaded_dataset.dbkey) trans.sa_session.add(folder) trans.sa_session.flush() ld.library_dataset_dataset_association_id = ldda.id trans.sa_session.add(ld) trans.sa_session.flush() # Handle template included in the upload form, if any. If the upload is not asynchronous ( e.g., URL paste ), # then the template and contents will be included in the library_bunch at this point. If the upload is # asynchronous ( e.g., uploading a file ), then the template and contents will be included in the library_bunch # in the get_uploaded_datasets() method below. if library_bunch.template and library_bunch.template_field_contents: # Since information templates are inherited, the template fields can be displayed on the upload form. # If the user has added field contents, we'll need to create a new form_values and info_association # for the new library_dataset_dataset_association object. # Create a new FormValues object, using the template we previously retrieved form_values = trans.app.model.FormValues( library_bunch.template, library_bunch.template_field_contents) trans.sa_session.add(form_values) trans.sa_session.flush() # Create a new info_association between the current ldda and form_values # TODO: Currently info_associations at the ldda level are not inheritable to the associated LibraryDataset, # we need to figure out if this is optimal info_association = trans.app.model.LibraryDatasetDatasetInfoAssociation( ldda, library_bunch.template, form_values) trans.sa_session.add(info_association) trans.sa_session.flush() # If roles were selected upon upload, restrict access to the Dataset to those roles if library_bunch.roles: for role in library_bunch.roles: dp = trans.app.model.DatasetPermissions( trans.app.security_agent.permitted_actions.DATASET_ACCESS. action, ldda.dataset, role) trans.sa_session.add(dp) trans.sa_session.flush() return ldda
def index(self, trans, folder_id, **kwd): """ GET /api/folders/{encoded_folder_id}/contents Displays a collection (list) of a folder's contents (files and folders). Encoded folder ID is prepended with 'F' if it is a folder as opposed to a data set which does not have it. Full path is provided in response as a separate object providing data for breadcrumb path building. :param folder_id: encoded ID of the folder which contents should be library_dataset_dict :type folder_id: encoded string :param kwd: keyword dictionary with other params :type kwd: dict :returns: dictionary containing all items and metadata :type: dict :raises: MalformedId, InconsistentDatabase, ObjectNotFound, InternalServerError """ is_admin = trans.user_is_admin deleted = kwd.get('include_deleted', 'missing') current_user_roles = trans.get_current_user_roles() try: deleted = util.asbool(deleted) except ValueError: deleted = False decoded_folder_id = self.folder_manager.cut_and_decode( trans, folder_id) folder = self.folder_manager.get(trans, decoded_folder_id) # Special level of security on top of libraries. if trans.app.security_agent.can_access_library( current_user_roles, folder.parent_library) or is_admin: pass else: if trans.user: log.warning( "SECURITY: User (id: %s) without proper access rights is trying to load folder with ID of %s" % (trans.user.id, decoded_folder_id)) else: log.warning( "SECURITY: Anonymous user is trying to load restricted folder with ID of %s" % (decoded_folder_id)) raise exceptions.ObjectNotFound( 'Folder with the id provided ( %s ) was not found' % str(folder_id)) folder_contents = [] update_time = '' create_time = '' # Go through every accessible item (folders, datasets) in the folder and include its metadata. for content_item in self._load_folder_contents(trans, folder, deleted): return_item = {} encoded_id = trans.security.encode_id(content_item.id) create_time = content_item.create_time.strftime( "%Y-%m-%d %I:%M %p") if content_item.api_type == 'folder': encoded_id = 'F' + encoded_id can_modify = is_admin or ( trans.user and trans.app.security_agent.can_modify_library_item( current_user_roles, folder)) can_manage = is_admin or ( trans.user and trans.app.security_agent.can_manage_library_item( current_user_roles, folder)) update_time = content_item.update_time.strftime( "%Y-%m-%d %I:%M %p") return_item.update( dict(can_modify=can_modify, can_manage=can_manage)) if content_item.description: return_item.update( dict(description=content_item.description)) elif content_item.api_type == 'file': # Is the dataset public or private? # When both are False the dataset is 'restricted' # Access rights are checked on the dataset level, not on the ld or ldda level to maintain consistency dataset = content_item.library_dataset_dataset_association.dataset is_unrestricted = trans.app.security_agent.dataset_is_public( dataset) if not is_unrestricted and trans.user and trans.app.security_agent.dataset_is_private_to_user( trans, dataset): is_private = True else: is_private = False # Can user manage the permissions on the dataset? can_manage = is_admin or ( trans.user and trans.app.security_agent.can_manage_dataset( current_user_roles, content_item. library_dataset_dataset_association.dataset)) raw_size = int(content_item. library_dataset_dataset_association.get_size()) nice_size = util.nice_size(raw_size) update_time = content_item.library_dataset_dataset_association.update_time.strftime( "%Y-%m-%d %I:%M %p") library_dataset_dict = content_item.to_dict() encoded_ldda_id = trans.security.encode_id( content_item.library_dataset_dataset_association.id) tag_manager = tags.GalaxyTagHandler(trans.sa_session) ldda_tags = tag_manager.get_tags_str( content_item.library_dataset_dataset_association.tags) return_item.update( dict(file_ext=library_dataset_dict['file_ext'], date_uploaded=library_dataset_dict['date_uploaded'], update_time=update_time, is_unrestricted=is_unrestricted, is_private=is_private, can_manage=can_manage, state=library_dataset_dict['state'], file_size=nice_size, raw_size=raw_size, ldda_id=encoded_ldda_id, tags=ldda_tags)) if content_item.library_dataset_dataset_association.message: return_item.update( dict(message=content_item. library_dataset_dataset_association.message)) elif content_item.library_dataset_dataset_association.info: # There is no message but ldda info contains something so we display that instead. return_item.update( dict(message=content_item. library_dataset_dataset_association.info)) # For every item include the default metadata return_item.update( dict(id=encoded_id, type=content_item.api_type, name=content_item.name, update_time=update_time, create_time=create_time, deleted=content_item.deleted)) folder_contents.append(return_item) # Return the reversed path so it starts with the library node. full_path = self.build_path(trans, folder)[::-1] # Check whether user can add items to the current folder can_add_library_item = is_admin or trans.app.security_agent.can_add_library_item( current_user_roles, folder) # Check whether user can modify the current folder can_modify_folder = is_admin or trans.app.security_agent.can_modify_library_item( current_user_roles, folder) parent_library_id = None if folder.parent_library is not None: parent_library_id = trans.security.encode_id( folder.parent_library.id) metadata = dict(full_path=full_path, can_add_library_item=can_add_library_item, can_modify_folder=can_modify_folder, folder_name=folder.name, folder_description=folder.description, parent_library_id=parent_library_id) folder_container = dict(metadata=metadata, folder_contents=folder_contents) return folder_container