Commits

Nicola Soranzo  committed 2c6c797 Merge

Merge galaxy/galaxy-central default branch.

  • Participants
  • Parent commits 6e2eaa8, 5d666f5

Comments (0)

Files changed (77)

File lib/galaxy/exceptions/__init__.py

     status_code = 400
     err_code = error_codes.MALFORMED_ID
 
+class UnknownContentsType( MessageException ):
+    status_code = 400
+    err_code = error_codes.UNKNOWN_CONTENTS_TYPE
+
 class RequestParameterMissingException( MessageException ):
     status_code = 400
     err_code = error_codes.USER_REQUEST_MISSING_PARAMETER

File lib/galaxy/exceptions/error_codes.json

     "message": "The id of the resource is malformed."
     },
    {
+    "name": "UNKNOWN_CONTENTS_TYPE",
+    "code": 400010,
+    "message": "The request contains unknown type of contents."
+    },
+   {
     "name": "USER_NO_API_KEY",
     "code": 403001,
     "message": "API authentication required for this request"

File lib/galaxy/model/tool_shed_install/__init__.py

 from galaxy.util.bunch import Bunch
 from galaxy.util import asbool
 from tool_shed.util import common_util
+from urlparse import urljoin
 
 log = logging.getLogger( __name__ )
 
     def can_reinstall_or_activate( self ):
         return self.deleted
 
+    def get_sharable_url( self, app ):
+        tool_shed_url = common_util.get_tool_shed_url_from_tool_shed_registry( app, self.tool_shed )
+        if tool_shed_url:
+            return urljoin( tool_shed_url, 'view/%s/%s' % ( self.owner, self.name ) )
+        return tool_shed_url
+
     def get_shed_config_filename( self ):
         shed_config_filename = None
         if self.metadata:

File lib/galaxy/tools/errors.py

 -----------------------------------------------------------------------------
 job id: ${job_id}
 tool id: ${job_tool_id}
+tool version: ${tool_version}
 job pid or drm id: ${job_runner_external_id}
+job tool version: ${job_tool_version}
 -----------------------------------------------------------------------------
 job command line:
 ${job_command_line}
                               history_item_name=hda.get_display_name(),
                               history_view_link=history_view_link,
                               job_id=job.id,
+                              tool_version=job.tool_version,
                               job_tool_id=job.tool_id,
+                              job_tool_version=hda.tool_version,
                               job_runner_external_id=job.job_runner_external_id,
                               job_command_line=job.command_line,
                               job_stderr=util.unicodify( job.stderr ),

File lib/galaxy/tools/parameters/basic.py

                 if option[2]:
                     # Found selected option.
                     value = option[1]
-            d[ 'value' ] = options
+            d[ 'value' ] = value
 
         return d
 

File lib/galaxy/util/biostar.py

 def populate_tool_payload( payload=None, tool=None ):
     payload = populate_tag_payload( payload=payload, tool=tool )
     payload[ 'title' ] = 'Need help with "%s" tool' % ( tool.name )
-    payload[ 'content' ] = '<br /><hr /><p>Tool name: %s</br>Tool version: %s</br>Tool ID: %s</p>' % ( tool.name, tool.version, tool.id )
+    tool_url = None
+    if tool.tool_shed_repository:
+        tool_url = tool.tool_shed_repository.get_sharable_url( tool.app )
+        if tool_url:
+            tool_url = '</br>ToolShed URL: <a href="%s">%s</a>' % ( tool_url, tool_url )
+    if not tool_url:
+        tool_url = ''
+    payload[ 'content' ] = '<br /><hr /><p>Tool name: %s</br>Tool version: %s</br>Tool ID: %s%s</p></br>' % ( tool.name, tool.version, tool.id, tool_url )
     return payload
 
 def determine_cookie_domain( galaxy_hostname, biostar_hostname ):

File lib/galaxy/webapps/galaxy/api/folder_contents.py

 """
-API operations on the contents of a folder.
+API operations on the contents of a library folder.
 """
-import logging
 from galaxy import web
+from galaxy import exceptions
+from galaxy.web import _future_expose_api as expose_api
+from galaxy.web import _future_expose_api_anonymous as expose_api_anonymous
+from sqlalchemy.orm.exc import MultipleResultsFound
+from sqlalchemy.orm.exc import NoResultFound
 from galaxy.web.base.controller import BaseAPIController, UsesLibraryMixin, UsesLibraryMixinItems
 
+import logging
 log = logging.getLogger( __name__ )
 
 class FolderContentsController( BaseAPIController, UsesLibraryMixin, UsesLibraryMixinItems ):
     Class controls retrieval, creation and updating of folder contents.
     """
 
-    def load_folder_contents( self, trans, folder ):
+    @expose_api_anonymous
+    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.
+        """
+
+        if ( len( folder_id ) == 17 and folder_id.startswith( 'F' ) ):
+            try:
+                decoded_folder_id = trans.security.decode_id( folder_id[ 1: ] )
+            except TypeError:
+                raise exceptions.MalformedId( 'Malformed folder id ( %s ) specified, unable to decode.' % str( folder_id ) )
+        else:
+            raise exceptions.MalformedId( 'Malformed folder id ( %s ) specified, unable to decode.' % str( folder_id ) )
+
+        try:
+            folder = trans.sa_session.query( trans.app.model.LibraryFolder ).filter( trans.app.model.LibraryFolder.table.c.id == decoded_folder_id ).one()
+        except MultipleResultsFound:
+            raise exceptions.InconsistentDatabase( 'Multiple folders with same id found.' )
+        except NoResultFound:
+            raise exceptions.ObjectNotFound( 'Folder with the id provided ( %s ) was not found' % str( folder_id ) )
+        except Exception:
+            raise exceptions.InternalServerError( 'Error loading from the database.' )
+
+        current_user_roles = trans.get_current_user_roles()
+        can_add_library_item = trans.user_is_admin() or trans.app.security_agent.can_add_library_item( current_user_roles, folder )
+
+        if not ( trans.user_is_admin() or trans.app.security_agent.can_access_library_item( current_user_roles, folder, trans.user ) ):
+            if folder.parent_id == None:
+                try:
+                    library = trans.sa_session.query( trans.app.model.Library ).filter( trans.app.model.Library.table.c.root_folder_id == decoded_folder_id ).one()
+                except Exception:
+                    raise exceptions.InternalServerError( 'Error loading from the database.' )
+                if trans.app.security_agent.library_is_public( library, contents=False ):
+                    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 without proper access rights is trying to load folder with ID of %s" % ( decoded_folder_id ) )
+                    raise exceptions.ObjectNotFound( 'Folder with the id provided ( %s ) was not found' % str( folder_id ) ) 
+            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 without proper access rights is trying to load folder with ID of %s" % ( decoded_folder_id ) )
+                raise exceptions.ObjectNotFound( 'Folder with the id provided ( %s ) was not found' % str( folder_id ) )
+        
+        def build_path( folder ):
+            """
+            Search the path upwards recursively and load the whole route of names and ids for breadcrumb building purposes.
+            """
+            path_to_root = []
+            # We are almost in root
+            if folder.parent_id is None:
+                path_to_root.append( ( 'F' + trans.security.encode_id( folder.id ), folder.name ) )
+            else:
+            # We add the current folder and traverse up one folder.
+                path_to_root.append( ( 'F' + trans.security.encode_id( folder.id ), folder.name ) )
+                upper_folder = trans.sa_session.query( trans.app.model.LibraryFolder ).get( folder.parent_id )
+                path_to_root.extend( build_path( upper_folder ) )
+            return path_to_root
+            
+        # Return the reversed path so it starts with the library node.
+        full_path = build_path( folder )[::-1]
+
+        folder_contents = []
+        time_updated = ''
+        time_created = ''
+        # Go through every accessible item in the folder and include its meta-data.
+        for content_item in self._load_folder_contents( trans, folder ):
+            if trans.app.security_agent.can_access_library_item( current_user_roles, content_item, trans.user ):
+                return_item = {}
+                encoded_id = trans.security.encode_id( content_item.id )
+                time_updated = content_item.update_time.strftime( "%Y-%m-%d %I:%M %p" )
+                time_created = content_item.create_time.strftime( "%Y-%m-%d %I:%M %p" )
+
+                # For folder return also hierarchy values
+                if content_item.api_type == 'folder':
+                    encoded_id = 'F' + encoded_id
+                    return_item.update ( dict ( item_count = content_item.item_count ) )
+
+                if content_item.api_type == 'file':
+                    library_dataset_dict = content_item.to_dict()
+                    library_dataset_dict['data_type']
+                    library_dataset_dict['file_size']
+                    library_dataset_dict['date_uploaded']
+                    return_item.update ( dict ( data_type = library_dataset_dict['data_type'],
+                                                file_size = library_dataset_dict['file_size'],
+                                                date_uploaded = library_dataset_dict['date_uploaded'] ) )
+
+                # For every item return also the default meta-data
+                return_item.update( dict( id = encoded_id,
+                                   type = content_item.api_type,
+                                   name = content_item.name,
+                                   time_updated = time_updated,
+                                   time_created = time_created
+                                    ) )
+                folder_contents.append( return_item )
+
+        return { 'metadata' : { 'full_path' : full_path, 'can_add_library_item': can_add_library_item }, 'folder_contents' : folder_contents }
+
+    def _load_folder_contents( self, trans, folder ):
         """
         Loads all contents of the folder (folders and data sets) but only in the first level.
         """
         return content_items
 
     @web.expose_api
-    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 as a separate object in response providing data for breadcrumb path building.
-        """
-        folder_container = []
-        current_user_roles = trans.get_current_user_roles()
-
-        if ( folder_id.startswith( 'F' ) ):
-            try:
-                decoded_folder_id = trans.security.decode_id( folder_id[1:] )
-            except TypeError:
-                trans.response.status = 400
-                return "Malformed folder id ( %s ) specified, unable to decode." % str( folder_id )
-
-        try:
-            folder = trans.sa_session.query( trans.app.model.LibraryFolder ).get( decoded_folder_id )
-        except:
-            folder = None
-            log.error( "FolderContentsController.index: Unable to retrieve folder with ID: %s" % folder_id )
-
-        # We didn't find the folder or user does not have an access to it.
-        if not folder:
-            trans.response.status = 400
-            return "Invalid folder id ( %s ) specified." % str( folder_id )
-        
-        if not ( trans.user_is_admin() or trans.app.security_agent.can_access_library_item( current_user_roles, folder, trans.user ) ):
-            log.warning( "SECURITY: User (id: %s) without proper access rights is trying to load folder with ID of %s" % ( trans.user.id, folder.id ) )
-            trans.response.status = 400
-            return "Invalid folder id ( %s ) specified." % str( folder_id )
-        
-        def build_path( folder ):
-            """
-            Search the path upwards recursively and load the whole route of names and ids for breadcrumb purposes.
-            """
-            path_to_root = []
-            # We are almost in root
-            if folder.parent_id is None:
-                path_to_root.append( ( 'F' + trans.security.encode_id( folder.id ), folder.name ) )
-            else:
-            # We add the current folder and traverse up one folder.
-                path_to_root.append( ( 'F' + trans.security.encode_id( folder.id ), folder.name ) )
-                upper_folder = trans.sa_session.query( trans.app.model.LibraryFolder ).get( folder.parent_id )
-                path_to_root.extend( build_path( upper_folder ) )
-            return path_to_root
-            
-        # Return the reversed path so it starts with the library node.
-        full_path = build_path( folder )[::-1]
-        folder_container.append( dict( full_path = full_path ) )
-        
-        folder_contents = []
-        time_updated = ''
-        time_created = ''
-        # Go through every item in the folder and include its meta-data.
-        for content_item in self.load_folder_contents( trans, folder ):
-            return_item = {}
-            encoded_id = trans.security.encode_id( content_item.id )
-            time_updated = content_item.update_time.strftime( "%Y-%m-%d %I:%M %p" )
-            time_created = content_item.create_time.strftime( "%Y-%m-%d %I:%M %p" )
-            
-            # For folder return also hierarchy values
-            if content_item.api_type == 'folder':
-                encoded_id = 'F' + encoded_id
-                return_item.update ( dict ( item_count = content_item.item_count ) )
-
-            if content_item.api_type == 'file':
-                library_dataset_dict = content_item.to_dict()
-                library_dataset_dict['data_type']
-                library_dataset_dict['file_size']
-                library_dataset_dict['date_uploaded']
-                return_item.update ( dict ( data_type = library_dataset_dict['data_type'],
-                                            file_size = library_dataset_dict['file_size'],
-                                            date_uploaded = library_dataset_dict['date_uploaded'] ) )
-
-            # For every item return also the default meta-data
-            return_item.update( dict( id = encoded_id,
-                               type = content_item.api_type,
-                               name = content_item.name,
-                               time_updated = time_updated,
-                               time_created = time_created
-                                ) )
-            folder_contents.append( return_item )
-        # Put the data in the container
-        folder_container.append( dict( folder_contents = folder_contents ) )
-        return folder_container
-
-    @web.expose_api
     def show( self, trans, id, library_id, **kwd ):
         """
         GET /api/folders/{encoded_folder_id}/
         """
-        pass
+        raise exceptions.NotImplemented( 'Showing the library folder content is not implemented.' )
 
     @web.expose_api
     def create( self, trans, library_id, payload, **kwd ):
         Creates a new folder. This should be superseded by the
         LibraryController.
         """
-        pass
+        raise exceptions.NotImplemented( 'Creating the library folder content is not implemented.' )
 
     @web.expose_api
     def update( self, trans, id,  library_id, payload, **kwd ):
         """
         PUT /api/folders/{encoded_folder_id}/contents
         """
-        pass
+        raise exceptions.NotImplemented( 'Updating the library folder content is not implemented.' )

File lib/galaxy/webapps/galaxy/api/folders.py

 """
-API operations on folders
+API operations on library folders
 """
-import logging, os, string, shutil, urllib, re, socket, traceback
+import os, string, shutil, urllib, re, socket, traceback
 from galaxy import datatypes, jobs, web, security
+from galaxy.web import _future_expose_api as expose_api
+from galaxy.web import _future_expose_api_anonymous as expose_api_anonymous
 from galaxy.web.base.controller import BaseAPIController,UsesLibraryMixin,UsesLibraryMixinItems
 from galaxy.util.sanitize_html import sanitize_html
 
 from cgi import escape, FieldStorage
 from paste.httpexceptions import HTTPBadRequest
 
+import logging
 log = logging.getLogger( __name__ )
 
 class FoldersController( BaseAPIController, UsesLibraryMixin, UsesLibraryMixinItems ):
         """
         GET /api/folders/
         This would normally display a list of folders. However, that would
-        be across multiple libraries, so it's not implemented yet.
+        be across multiple libraries, so it's not implemented.
         """
-        pass
+        raise exceptions.NotImplemented( 'Listing all accessible library folders is not implemented.' )
 
     @web.expose_api
     def show( self, trans, id, **kwd ):

File lib/galaxy/webapps/galaxy/api/history_contents.py

         hda_dict[ 'display_apps' ] = self.get_display_apps( trans, hda )
         return hda_dict
 
-    #TODO: allow anon users to copy hdas, ldas
-    @expose_api
+    @expose_api_anonymous
     def create( self, trans, history_id, payload, **kwd ):
         """
         create( self, trans, history_id, payload, **kwd )
         return validated_payload
 
     def __handle_unknown_contents_type( self, trans, contents_type ):
-        # TODO: raise a message exception instead of setting status and returning dict.
-        trans.response.status = 400
-        return { 'error': 'Unknown contents type %s' % type }
-
+        raise exceptions.UnknownContentsType('Unknown contents type: %s' % type)
 
 class HDAManager( object ):
 

File lib/galaxy/webapps/galaxy/api/lda_datasets.py

 import urllib
 import urllib2
 import zipfile
-from paste.httpexceptions import HTTPBadRequest
-from galaxy import util, web
-from galaxy.exceptions import ItemAccessibilityException, MessageException, ItemDeletionException, ObjectNotFound
+from galaxy import exceptions
+from galaxy.web import _future_expose_api as expose_api
+from galaxy.web import _future_expose_api_anonymous as expose_api_anonymous
+# from paste.httpexceptions import HTTPBadRequest
+from galaxy import util
+from galaxy import web
+# from galaxy.exceptions import ItemAccessibilityException, MessageException, ItemDeletionException, ObjectNotFound
 from galaxy.security import Action
 from galaxy.util.streamball import StreamBall
 from galaxy.web.base.controller import BaseAPIController, UsesVisualizationMixin
 
 class LibraryDatasetsController( BaseAPIController, UsesVisualizationMixin ):
 
-    @web.expose_api
+    @expose_api_anonymous
     def show( self, trans, id, **kwd ):
         """
         show( self, trans, id, **kwd )
         try:
             dataset = self.get_library_dataset( trans, id = id, check_ownership=False, check_accessible=True )
         except Exception, e:
-            trans.response.status = 500
-            return str( e )
-        try:
-            rval = dataset.to_dict()
-        except Exception, e:
-            rval = "Error in dataset API at listing contents: " + str( e )
-            log.error( rval + ": %s" % str(e), exc_info=True )
-            trans.response.status = 500
-            return "Error in dataset API at listing contents: " + str( e )
+            raise exceptions.ObjectNotFound( 'Requested dataset was not found.' )
+            # trans.response.status = 500
+            # return str( e )
+        # try:
+        rval = dataset.to_dict()
+        # except Exception, e:
+        #     rval = "Error in dataset API at listing contents: " + str( e )
+        #     log.error( rval + ": %s" % str(e), exc_info=True )
+        #     trans.response.status = 500
+        #     return "Error in dataset API at listing contents: " + str( e )
 
         rval['id'] = trans.security.encode_id(rval['id']);
         rval['ldda_id'] = trans.security.encode_id(rval['ldda_id']);
-        rval['folder_id'] = 'f' + trans.security.encode_id(rval['folder_id'])
+        rval['folder_id'] = 'F' + trans.security.encode_id(rval['folder_id'])
         return rval
 
     @web.expose

File lib/galaxy/webapps/galaxy/api/libraries.py

 from galaxy.web import _future_expose_api as expose_api
 from galaxy.web import _future_expose_api_anonymous as expose_api_anonymous
 from galaxy.model.orm import and_, not_, or_
-from galaxy.web.base.controller import BaseAPIController, url_for
+from galaxy.web.base.controller import BaseAPIController
 
 import logging
 log = logging.getLogger( __name__ )
             if trans.app.security_agent.library_is_public( library, contents=False ):
                 item[ 'public' ] = True
             current_user_roles = trans.get_current_user_roles()
-            # can_user_add = trans.app.security_agent.can_add_library_item( current_user_roles, library.root_folder )
             if not trans.user_is_admin():
                 item['can_user_add'] = trans.app.security_agent.can_add_library_item( current_user_roles, library )
                 item['can_user_modify'] = trans.app.security_agent.can_modify_library_item( current_user_roles, library )
         deleted = util.string_as_bool( deleted )
         try:
             decoded_library_id = trans.security.decode_id( library_id )
-        except Exception:
+        except TypeError:
             raise exceptions.MalformedId( 'Malformed library id ( %s ) specified, unable to decode.' % id )
         try:
             library = trans.sa_session.query( trans.app.model.Library ).get( decoded_library_id )
         library.root_folder = root_folder
         trans.sa_session.add_all( ( library, root_folder ) )
         trans.sa_session.flush()
-        return library.to_dict( view='element', value_mapper={ 'id' : trans.security.encode_id , 'root_folder_id' : trans.security.encode_id } )
+
+        item = library.to_dict( view='element', value_mapper={ 'id' : trans.security.encode_id , 'root_folder_id' : trans.security.encode_id } )
+        item['can_user_add'] = True
+        item['can_user_modify'] = True
+        item['can_user_manage'] = True
+        if trans.app.security_agent.library_is_public( library, contents=False ):
+            item[ 'public' ] = True
+        return item
 
     @expose_api
     def update( self, trans, id, **kwd ):

File lib/galaxy/webapps/galaxy/api/library_contents.py

 log = logging.getLogger( __name__ )
 
 
-class LibraryContentsController( BaseAPIController, UsesLibraryMixin, UsesLibraryMixinItems,
-                                 UsesHistoryDatasetAssociationMixin ):
+class LibraryContentsController( BaseAPIController, UsesLibraryMixin, UsesLibraryMixinItems, UsesHistoryDatasetAssociationMixin ):
 
     @expose_api
     def index( self, trans, library_id, **kwd ):

File lib/galaxy/webapps/galaxy/buildapp.py

     # ====================
 
     # Handle displaying tool help images and README file images contained in repositories installed from the tool shed.
-    webapp.add_route( '/admin_toolshed/static/images/:repository_id/:image_file',
+    webapp.add_route( '/admin_toolshed/static/images/:repository_id/{image_file:.+?}',
                       controller='admin_toolshed',
                       action='display_image_in_repository',
                       repository_id=None,

File lib/galaxy/webapps/galaxy/controllers/admin_toolshed.py

 from tool_shed.util import data_manager_util
 from tool_shed.util import datatype_util
 from tool_shed.util import encoding_util
+from tool_shed.util import hg_util
 from tool_shed.util import metadata_util
 from tool_shed.util import readme_util
 from tool_shed.util import repository_dependency_util
                         repo_files_dir = os.path.abspath( os.path.join( tool_path, relative_install_dir, name ) )
                     else:
                         repo_files_dir = os.path.abspath( os.path.join( relative_install_dir, name ) )
-                    repo = hg.repository( suc.get_configured_ui(), path=repo_files_dir )
+                    repo = hg.repository( hg_util.get_configured_ui(), path=repo_files_dir )
                     repository_clone_url = os.path.join( tool_shed_url, 'repos', owner, name )
                     repository_util.pull_repository( repo, repository_clone_url, latest_ctx_rev )
                     suc.update_repository( repo, latest_ctx_rev )

File lib/galaxy/webapps/tool_shed/api/repositories.py

 import tool_shed.util.shed_util_common as suc
 from tool_shed.galaxy_install import repository_util
 from tool_shed.util import encoding_util
+from tool_shed.util import hg_util
 from tool_shed.util import import_util
 from tool_shed.util import metadata_util
 from tool_shed.util import repository_maintenance_util
                 log.debug( error_message )
                 return []
             repo_dir = repository.repo_path( trans.app )
-            repo = hg.repository( suc.get_configured_ui(), repo_dir )
+            repo = hg.repository( hg_util.get_configured_ui(), repo_dir )
             ordered_installable_revisions = suc.get_ordered_metadata_changeset_revisions( repository, repo, downloadable=True )
             return ordered_installable_revisions
         else:
                 # The changeset_revision column in the repository_metadata table has been updated with a new
                 # value value, so find the changeset_revision to which we need to update.
                 repo_dir = repository.repo_path( trans.app )
-                repo = hg.repository( suc.get_configured_ui(), repo_dir )
+                repo = hg.repository( hg_util.get_configured_ui(), repo_dir )
                 new_changeset_revision = suc.get_next_downloadable_changeset_revision( repository, repo, changeset_revision )
                 repository_metadata = suc.get_repository_metadata_by_changeset_revision( trans,
                                                                                          encoded_repository_id,

File lib/galaxy/webapps/tool_shed/api/repository_revisions.py

 from galaxy.model.orm import and_, not_, select
 from galaxy.web.base.controller import BaseAPIController, HTTPBadRequest
 from tool_shed.util import export_util
+from tool_shed.util import hg_util
 import tool_shed.util.shed_util_common as suc
 
 from galaxy import eggs
                     # The changeset_revision column in the repository_metadata table has been updated with a new
                     # value value, so find the changeset_revision to which we need to update.
                     repo_dir = repository_dependency.repo_path( trans.app )
-                    repo = hg.repository( suc.get_configured_ui(), repo_dir )
+                    repo = hg.repository( hg_util.get_configured_ui(), repo_dir )
                     new_changeset_revision = suc.get_next_downloadable_changeset_revision( repository_dependency,
                                                                                            repo,
                                                                                            changeset_revision )

File lib/galaxy/webapps/tool_shed/controllers/repository.py

 from tool_shed.util import container_util
 from tool_shed.util import encoding_util
 from tool_shed.util import export_util
+from tool_shed.util import hg_util
 from tool_shed.util import import_util
 from tool_shed.util import metadata_util
 from tool_shed.util import readme_util
         status = kwd.get( 'status', 'done' )
         commit_message = kwd.get( 'commit_message', 'Deleted selected files' )
         repository = suc.get_repository_in_tool_shed( trans, id )
-        repo = hg.repository( suc.get_configured_ui(), repository.repo_path( trans.app ) )
+        repo = hg.repository( hg_util.get_configured_ui(), repository.repo_path( trans.app ) )
         # Update repository files for browsing.
         suc.update_repository( repo )
         changeset_revision = repository.tip( trans.app )
         changeset_revision = kwd.get( 'changeset_revision', None )
         repository = suc.get_repository_by_name_and_owner( trans.app, name, owner )
         repo_dir = repository.repo_path( trans.app )
-        repo = hg.repository( suc.get_configured_ui(), repo_dir )
+        repo = hg.repository( hg_util.get_configured_ui(), repo_dir )
         # Default to the current changeset revision.
-        update_to_ctx = suc.get_changectx_for_changeset( repo, changeset_revision )
+        update_to_ctx = hg_util.get_changectx_for_changeset( repo, changeset_revision )
         latest_changeset_revision = changeset_revision
         from_update_manager = kwd.get( 'from_update_manager', False )
         if from_update_manager:
                 update_to_changeset_hash = None
                 for changeset in repo.changelog:
                     changeset_hash = str( repo.changectx( changeset ) )
-                    ctx = suc.get_changectx_for_changeset( repo, changeset_hash )
+                    ctx = hg_util.get_changectx_for_changeset( repo, changeset_hash )
                     if update_to_changeset_hash:
                         if changeset_hash == repository.tip( trans.app ):
-                            update_to_ctx = suc.get_changectx_for_changeset( repo, changeset_hash )
+                            update_to_ctx = hg_util.get_changectx_for_changeset( repo, changeset_hash )
                             latest_changeset_revision = changeset_hash
                             break
                         else:
                                                                                                      changeset_hash )
                             if repository_metadata:
                                 # We found a RepositoryMetadata record.
-                                update_to_ctx = suc.get_changectx_for_changeset( repo, changeset_hash )
+                                update_to_ctx = hg_util.get_changectx_for_changeset( repo, changeset_hash )
                                 latest_changeset_revision = changeset_hash
                                 break
                             else:
         else:
             containers_dict = None
             export_repository_dependencies_check_box = None
-        revision_label = suc.get_revision_label( trans, repository, changeset_revision, include_date=True )
+        revision_label = hg_util.get_revision_label( trans, repository, changeset_revision, include_date=True )
         return trans.fill_template( "/webapps/tool_shed/repository/export_repository.mako",
                                     changeset_revision=changeset_revision,
                                     containers_dict=containers_dict,
         has_repository_dependencies_only_if_compiling_contained_td = has_galaxy_utilities_dict[ 'has_repository_dependencies_only_if_compiling_contained_td' ]
         includes_workflows = has_galaxy_utilities_dict[ 'includes_workflows' ]
         repo_dir = repository.repo_path( trans.app )
-        repo = hg.repository( suc.get_configured_ui(), repo_dir )
+        repo = hg.repository( hg_util.get_configured_ui(), repo_dir )
         # Default to the received changeset revision and ctx_rev.
-        update_to_ctx = suc.get_changectx_for_changeset( repo, changeset_revision )
+        update_to_ctx = hg_util.get_changectx_for_changeset( repo, changeset_revision )
         ctx_rev = str( update_to_ctx.rev() )
         latest_changeset_revision = changeset_revision
         update_dict = dict( changeset_revision=changeset_revision,
                     has_repository_dependencies = False
                     has_repository_dependencies_only_if_compiling_contained_td = False
                     changeset_hash = str( repo.changectx( changeset ) )
-                    ctx = suc.get_changectx_for_changeset( repo, changeset_hash )
+                    ctx = hg_util.get_changectx_for_changeset( repo, changeset_hash )
                     if update_to_changeset_hash:
                         update_to_repository_metadata = suc.get_repository_metadata_by_changeset_revision( trans,
                                                                                                            trans.security.encode_id( repository.id ),
                             # We found a RepositoryMetadata record.
                             if changeset_hash == repository.tip( trans.app ):
                                 # The current ctx is the repository tip, so use it.
-                                update_to_ctx = suc.get_changectx_for_changeset( repo, changeset_hash )
+                                update_to_ctx = hg_util.get_changectx_for_changeset( repo, changeset_hash )
                                 latest_changeset_revision = changeset_hash
                             else:
-                                update_to_ctx = suc.get_changectx_for_changeset( repo, update_to_changeset_hash )
+                                update_to_ctx = hg_util.get_changectx_for_changeset( repo, update_to_changeset_hash )
                                 latest_changeset_revision = update_to_changeset_hash
                             break
                     elif not update_to_changeset_hash and changeset_hash == changeset_revision:
         changeset_revision = kwd[ 'changeset_revision' ]
         repository = suc.get_repository_by_name_and_owner( trans.app, repository_name, repository_owner )
         repo_dir = repository.repo_path( trans.app )
-        repo = hg.repository( suc.get_configured_ui(), repo_dir )
-        ctx = suc.get_changectx_for_changeset( repo, changeset_revision )
+        repo = hg.repository( hg_util.get_configured_ui(), repo_dir )
+        ctx = hg_util.get_changectx_for_changeset( repo, changeset_revision )
         if ctx:
             return str( ctx.rev() )
         return ''
     def get_file_from_changeset_revision( self, repo_files_dir, changeset_revision, file_name, dir ):
         """Return file_name from the received changeset_revision of the repository manifest."""
         stripped_file_name = suc.strip_path( file_name )
-        repo = hg.repository( suc.get_configured_ui(), repo_files_dir )
-        ctx = suc.get_changectx_for_changeset( repo, changeset_revision )
+        repo = hg.repository( hg_util.get_configured_ui(), repo_files_dir )
+        ctx = hg_util.get_changectx_for_changeset( repo, changeset_revision )
         named_tmp_file = suc.get_named_tmpfile_from_ctx( ctx, file_name, dir )
         return named_tmp_file
 
                                                            trans.model.Repository.table.c.user_id == user.id ) ):
             repository = repository_metadata.repository
             repo_dir = repository.repo_path( trans.app )
-            repo = hg.repository( suc.get_configured_ui(), repo_dir )
+            repo = hg.repository( hg_util.get_configured_ui(), repo_dir )
             latest_downloadable_changeset_revsion = suc.get_latest_downloadable_changeset_revision( trans, repository, repo )
             if repository_metadata.changeset_revision == latest_downloadable_changeset_revsion:
                 # We'll display only the test run for the latest installable revision in the rss feed.
         if repository_name is not None and repository_owner is not None:
             repository = suc.get_repository_by_name_and_owner( trans.app, repository_name, repository_owner )
             if repository:
-                repo = hg.repository( suc.get_configured_ui(), repository.repo_path( trans.app ) )
+                repo = hg.repository( hg_util.get_configured_ui(), repository.repo_path( trans.app ) )
                 return suc.get_latest_downloadable_changeset_revision( trans, repository, repo )
         return suc.INITIAL_CHANGELOG_HASH
 
         changeset_revision = kwd[ 'changeset_revision' ]
         repository = suc.get_repository_by_name_and_owner( trans.app, name, owner )
         repo_dir = repository.repo_path( trans.app )
-        repo = hg.repository( suc.get_configured_ui(), repo_dir )
+        repo = hg.repository( hg_util.get_configured_ui(), repo_dir )
         tool_version_dicts = []
         for changeset in repo.changelog:
             current_changeset_revision = str( repo.changectx( changeset ) )
         repository_id = trans.security.encode_id( repository.id )
         repository_clone_url = common_util.generate_clone_url_for_repository_in_tool_shed( trans, repository )
         repo_dir = repository.repo_path( trans.app )
-        repo = hg.repository( suc.get_configured_ui(), repo_dir )
+        repo = hg.repository( hg_util.get_configured_ui(), repo_dir )
         repository_metadata = suc.get_repository_metadata_by_changeset_revision( trans, repository_id, changeset_revision )
         if not repository_metadata:
             # The received changeset_revision is no longer associated with metadata, so get the next changeset_revision in the repository
                                                                                repo,
                                                                                after_changeset_revision=changeset_revision )
             repository_metadata = suc.get_repository_metadata_by_changeset_revision( trans, repository_id, changeset_revision )
-        ctx = suc.get_changectx_for_changeset( repo, changeset_revision )
+        ctx = hg_util.get_changectx_for_changeset( repo, changeset_revision )
         repo_info_dict = repository_util.create_repo_info_dict( trans=trans,
                                                                 repository_clone_url=repository_clone_url,
                                                                 changeset_revision=changeset_revision,
         repository = suc.get_repository_in_tool_shed( trans, id )
         repository_type = kwd.get( 'repository_type', str( repository.type ) )
         repo_dir = repository.repo_path( trans.app )
-        repo = hg.repository( suc.get_configured_ui(), repo_dir )
+        repo = hg.repository( hg_util.get_configured_ui(), repo_dir )
         repo_name = kwd.get( 'repo_name', repository.name )
         changeset_revision = kwd.get( 'changeset_revision', repository.tip( trans.app ) )
         description = kwd.get( 'description', repository.description )
                                                                                             selected_value=changeset_revision,
                                                                                             add_id_to_name=False,
                                                                                             downloadable=False )
-        revision_label = suc.get_revision_label( trans, repository, repository.tip( trans.app ), include_date=False )
+        revision_label = hg_util.get_revision_label( trans, repository, repository.tip( trans.app ), include_date=False )
         repository_metadata = None
         metadata = None
         is_malicious = False
         if changeset_revision != suc.INITIAL_CHANGELOG_HASH:
             repository_metadata = suc.get_repository_metadata_by_changeset_revision( trans, id, changeset_revision )
             if repository_metadata:
-                revision_label = suc.get_revision_label( trans, repository, changeset_revision, include_date=False )
+                revision_label = hg_util.get_revision_label( trans, repository, changeset_revision, include_date=False )
                 metadata = repository_metadata.metadata
                 is_malicious = repository_metadata.malicious
             else:
                 if previous_changeset_revision != suc.INITIAL_CHANGELOG_HASH:
                     repository_metadata = suc.get_repository_metadata_by_changeset_revision( trans, id, previous_changeset_revision )
                     if repository_metadata:
-                        revision_label = suc.get_revision_label( trans, repository, previous_changeset_revision, include_date=False )
+                        revision_label = hg_util.get_revision_label( trans, repository, previous_changeset_revision, include_date=False )
                         metadata = repository_metadata.metadata
                         is_malicious = repository_metadata.malicious
                         changeset_revision = previous_changeset_revision
                 # There is no repository_metadata defined for the changeset_revision, so see if it was defined
                 # in a previous changeset in the changelog.
                 repo_dir = repository.repo_path( trans.app )
-                repo = hg.repository( suc.get_configured_ui(), repo_dir )
+                repo = hg.repository( hg_util.get_configured_ui(), repo_dir )
                 previous_changeset_revision = \
                     suc.get_previous_metadata_changeset_revision( repository,
                                                                   repo,
         changeset_revision = kwd.get( 'changeset_revision', None )
         repository = suc.get_repository_by_name_and_owner( trans.app, name, owner )
         repo_dir = repository.repo_path( trans.app )
-        repo = hg.repository( suc.get_configured_ui(), repo_dir )
+        repo = hg.repository( hg_util.get_configured_ui(), repo_dir )
         # Get the next installable changeset_revision beyond the received changeset_revision.
         changeset_revision = suc.get_next_downloadable_changeset_revision( repository, repo, changeset_revision )
         if changeset_revision:
         status = kwd.get( 'status', 'done' )
         repository = suc.get_repository_in_tool_shed( trans, repository_id )
         repo_dir = repository.repo_path( trans.app )
-        repo = hg.repository( suc.get_configured_ui(), repo_dir )
+        repo = hg.repository( hg_util.get_configured_ui(), repo_dir )
         changeset_revision = kwd.get( 'changeset_revision', repository.tip( trans.app ) )
         repository_metadata = suc.get_repository_metadata_by_changeset_revision( trans, repository_id, changeset_revision )
         if repository_metadata:
             repository_metadata_id = None
             metadata = None
             repository_dependencies = None
-        revision_label = suc.get_revision_label( trans, repository, changeset_revision, include_date=True )
+        revision_label = hg_util.get_revision_label( trans, repository, changeset_revision, include_date=True )
         changeset_revision_select_field = grids_util.build_changeset_revision_select_field( trans,
                                                                                             repository,
                                                                                             selected_value=changeset_revision,
         changeset_revision = kwd.get( 'changeset_revision', None )
         repository = suc.get_repository_by_name_and_owner( trans.app, name, owner )
         repo_dir = repository.repo_path( trans.app )
-        repo = hg.repository( suc.get_configured_ui(), repo_dir )
+        repo = hg.repository( hg_util.get_configured_ui(), repo_dir )
         # Get the lower bound changeset revision.
         lower_bound_changeset_revision = suc.get_previous_metadata_changeset_revision( repository, repo, changeset_revision, downloadable=True )
         # Build the list of changeset revision hashes.
                                                               status='error' ) )
         repository = suc.get_repository_in_tool_shed( trans, id )
         changeset_revision = repository.tip( trans.app )
-        repo = hg.repository( suc.get_configured_ui(), repository.repo_path( trans.app ) )
+        repo = hg.repository( hg_util.get_configured_ui(), repository.repo_path( trans.app ) )
         if repository.user == trans.user:
             return trans.response.send_redirect( web.url_for( controller='repository',
                                                               action='browse_repositories',
                                                                                               changeset_revision,
                                                                                               metadata_only=True )
         repository_type_select_field = rt_util.build_repository_type_select_field( trans, repository=repository )
-        revision_label = suc.get_revision_label( trans, repository, changeset_revision, include_date=True )
+        revision_label = hg_util.get_revision_label( trans, repository, changeset_revision, include_date=True )
         return trans.fill_template( '/webapps/tool_shed/repository/rate_repository.mako',
                                     repository=repository,
                                     metadata=metadata,
         commit_message = kwd.get( 'commit_message', 'Deleted selected files' )
         repository = suc.get_repository_in_tool_shed( trans, id )
         repo_dir = repository.repo_path( trans.app )
-        repo = hg.repository( suc.get_configured_ui(), repo_dir )
+        repo = hg.repository( hg_util.get_configured_ui(), repo_dir )
         selected_files_to_delete = kwd.get( 'selected_files_to_delete', '' )
         if kwd.get( 'select_files_to_delete_button', False ):
             if selected_files_to_delete:
                 # Update the repository files for browsing.
                 suc.update_repository( repo )
                 # Get the new repository tip.
-                repo = hg.repository( suc.get_configured_ui(), repo_dir )
+                repo = hg.repository( hg_util.get_configured_ui(), repo_dir )
                 if tip == repository.tip( trans.app ):
                     message += 'No changes to repository.  '
                     kwd[ 'message' ] = message
             if not repository_metadata:
                 # Get updates to the received changeset_revision if any exist.
                 repo_dir = repository.repo_path( trans.app )
-                repo = hg.repository( suc.get_configured_ui(), repo_dir )
+                repo = hg.repository( hg_util.get_configured_ui(), repo_dir )
                 upper_bound_changeset_revision = suc.get_next_downloadable_changeset_revision( repository, repo, changeset_revision )
                 if upper_bound_changeset_revision:
                     changeset_revision = upper_bound_changeset_revision
                                                                                      trans.security.encode_id( repository.id ),
                                                                                      changeset_revision )
             repo_dir = repository.repo_path( trans.app )
-            repo = hg.repository( suc.get_configured_ui(), repo_dir )
+            repo = hg.repository( hg_util.get_configured_ui(), repo_dir )
             tool_shed_status_dict = {}
             # Handle repository deprecation.
             tool_shed_status_dict[ 'repository_deprecated' ] = str( repository.deprecated )
         message = kwd.get( 'message', ''  )
         status = kwd.get( 'status', 'done' )
         repository = suc.get_repository_in_tool_shed( trans, id )
-        repo = hg.repository( suc.get_configured_ui(), repository.repo_path( trans.app ) )
+        repo = hg.repository( hg_util.get_configured_ui(), repository.repo_path( trans.app ) )
         changesets = []
         for changeset in repo.changelog:
             ctx = repo.changectx( changeset )
             change_dict = { 'ctx' : ctx,
                             'rev' : str( ctx.rev() ),
                             'date' : date,
-                            'display_date' : suc.get_readable_ctx_date( ctx ),
+                            'display_date' : hg_util.get_readable_ctx_date( ctx ),
                             'description' : ctx.description(),
                             'files' : ctx.files(),
                             'user' : ctx.user(),
         message = kwd.get( 'message', ''  )
         status = kwd.get( 'status', 'done' )
         repository = suc.get_repository_in_tool_shed( trans, id )
-        repo = hg.repository( suc.get_configured_ui(), repository.repo_path( trans.app ) )
-        ctx = suc.get_changectx_for_changeset( repo, ctx_str )
+        repo = hg.repository( hg_util.get_configured_ui(), repository.repo_path( trans.app ) )
+        ctx = hg_util.get_changectx_for_changeset( repo, ctx_str )
         if ctx is None:
             message = "Repository does not include changeset revision '%s'." % str( ctx_str )
             status = 'error'
         metadata = metadata_util.get_repository_metadata_by_repository_id_changeset_revision( trans, id, ctx_str, metadata_only=True )
         # For rendering the prev button.
         if ctx_parent:
-            ctx_parent_date = suc.get_readable_ctx_date( ctx_parent )
+            ctx_parent_date = hg_util.get_readable_ctx_date( ctx_parent )
             ctx_parent_rev = ctx_parent.rev()
             if ctx_parent_rev < 0:
                  prev = None
         else:
            prev = None
         if ctx_child:
-            ctx_child_date = suc.get_readable_ctx_date( ctx_child )
+            ctx_child_date = hg_util.get_readable_ctx_date( ctx_child )
             ctx_child_rev = ctx_child.rev()
             next = "<b>%s:%s</b> <i>(%s)</i>" % ( ctx_child_rev, ctx_child, ctx_child_date )
         else:
         message = kwd.get( 'message', ''  )
         status = kwd.get( 'status', 'done' )
         repository = suc.get_repository_in_tool_shed( trans, id )
-        repo = hg.repository( suc.get_configured_ui(), repository.repo_path( trans.app ) )
+        repo = hg.repository( hg_util.get_configured_ui(), repository.repo_path( trans.app ) )
         avg_rating, num_ratings = self.get_ave_item_rating_data( trans.sa_session, repository, webapp_model=trans.model )
         changeset_revision = kwd.get( 'changeset_revision', repository.tip( trans.app ) )
         display_reviews = kwd.get( 'display_reviews', False )
                                                                                             selected_value=changeset_revision,
                                                                                             add_id_to_name=False,
                                                                                             downloadable=False )
-        revision_label = suc.get_revision_label( trans, repository, changeset_revision, include_date=False )
+        revision_label = hg_util.get_revision_label( trans, repository, changeset_revision, include_date=False )
         repository_metadata = suc.get_repository_metadata_by_changeset_revision( trans, id, changeset_revision )
         if repository_metadata:
             metadata = repository_metadata.metadata
         render_repository_actions_for = kwd.get( 'render_repository_actions_for', 'tool_shed' )
         repository = suc.get_repository_in_tool_shed( trans, repository_id )
         repo_files_dir = repository.repo_path( trans.app )
-        repo = hg.repository( suc.get_configured_ui(), repo_files_dir )
+        repo = hg.repository( hg_util.get_configured_ui(), repo_files_dir )
         tool_metadata_dict = {}
         tool_lineage = []
         tool = None
         guid = None
         original_tool_data_path = trans.app.config.tool_data_path
-        revision_label = suc.get_revision_label( trans, repository, changeset_revision, include_date=False )
+        revision_label = hg_util.get_revision_label( trans, repository, changeset_revision, include_date=False )
         repository_metadata = suc.get_repository_metadata_by_changeset_revision( trans, repository_id, changeset_revision )
         if repository_metadata:
             repository_metadata_id = trans.security.encode_id( repository_metadata.id )

File lib/galaxy/webapps/tool_shed/controllers/repository_review.py

 from galaxy.webapps.tool_shed.util import ratings_util
 from tool_shed.util.container_util import STRSEP
 import tool_shed.util.shed_util_common as suc
+from tool_shed.util import hg_util
 from tool_shed.util import review_util
 from galaxy.util.odict import odict
 import tool_shed.grids.repository_review_grids as repository_review_grids
         status = kwd.get( 'status', 'done' )
         review = review_util.get_review( trans, kwd[ 'id' ] )
         repository = review.repository
-        repo = hg.repository( suc.get_configured_ui(), repository.repo_path( trans.app ) )
-        rev, changeset_revision_label = suc.get_rev_label_from_changeset_revision( repo, review.changeset_revision )
+        repo = hg.repository( hg_util.get_configured_ui(), repository.repo_path( trans.app ) )
+        rev, changeset_revision_label = hg_util.get_rev_label_from_changeset_revision( repo, review.changeset_revision )
         return trans.fill_template( '/webapps/tool_shed/repository_review/browse_review.mako',
                                     repository=repository,
                                     changeset_revision_label=changeset_revision_label,
         for component in review_util.get_components( trans ):
             components_dict[ component.name ] = dict( component=component, component_review=None )
         repository = review.repository
-        repo = hg.repository( suc.get_configured_ui(), repository.repo_path( trans.app ) )
+        repo = hg.repository( hg_util.get_configured_ui(), repository.repo_path( trans.app ) )
         for component_review in review.component_reviews:
             if component_review and component_review.component:
                 component_name = component_review.component.name
                                                                                  name='revision_approved',
                                                                                  selected_value=selected_value,
                                                                                  for_component=False )
-        rev, changeset_revision_label = suc.get_rev_label_from_changeset_revision( repo, review.changeset_revision )
+        rev, changeset_revision_label = hg_util.get_rev_label_from_changeset_revision( repo, review.changeset_revision )
         return trans.fill_template( '/webapps/tool_shed/repository_review/edit_review.mako',
                                     repository=repository,
                                     review=review,
         if repository_id:
             repository = suc.get_repository_in_tool_shed( trans, repository_id )
             repo_dir = repository.repo_path( trans.app )
-            repo = hg.repository( suc.get_configured_ui(), repo_dir )
+            repo = hg.repository( hg_util.get_configured_ui(), repo_dir )
             metadata_revision_hashes = [ metadata_revision.changeset_revision for metadata_revision in repository.metadata_revisions ]
             reviewed_revision_hashes = [ review.changeset_revision for review in repository.reviews ]
             reviews_dict = odict()
                 ctx = repo.changectx( changeset )
                 changeset_revision = str( ctx )
                 if changeset_revision in metadata_revision_hashes or changeset_revision in reviewed_revision_hashes:
-                    rev, changeset_revision_label = suc.get_rev_label_from_changeset_revision( repo, changeset_revision )
+                    rev, changeset_revision_label = hg_util.get_rev_label_from_changeset_revision( repo, changeset_revision )
                     if changeset_revision in reviewed_revision_hashes:
                         # Find the review for this changeset_revision
                         repository_reviews = review_util.get_reviews_by_repository_id_changeset_revision( trans, repository_id, changeset_revision )
         changeset_revision = kwd.get( 'changeset_revision', None )
         repository = suc.get_repository_in_tool_shed( trans, repository_id )
         repo_dir = repository.repo_path( trans.app )
-        repo = hg.repository( suc.get_configured_ui(), repo_dir )
+        repo = hg.repository( hg_util.get_configured_ui(), repo_dir )
         installable = changeset_revision in [ metadata_revision.changeset_revision for metadata_revision in repository.metadata_revisions ]
-        rev, changeset_revision_label = suc.get_rev_label_from_changeset_revision( repo, changeset_revision )
+        rev, changeset_revision_label = hg_util.get_rev_label_from_changeset_revision( repo, changeset_revision )
         reviews = review_util.get_reviews_by_repository_id_changeset_revision( trans, repository_id, changeset_revision )
         return trans.fill_template( '/webapps/tool_shed/repository_review/reviews_of_changeset_revision.mako',
                                     repository=repository,
         status = kwd.get( 'status', 'done' )
         repository = suc.get_repository_in_tool_shed( trans, kwd[ 'id' ] )
         changeset_revision = kwd.get( 'changeset_revision', None )
-        repo = hg.repository( suc.get_configured_ui(), repository.repo_path( trans.app ) )
+        repo = hg.repository( hg_util.get_configured_ui(), repository.repo_path( trans.app ) )
         previous_reviews_dict = review_util.get_previous_repository_reviews( trans, repository, changeset_revision )
-        rev, changeset_revision_label = suc.get_rev_label_from_changeset_revision( repo, changeset_revision )
+        rev, changeset_revision_label = hg_util.get_rev_label_from_changeset_revision( repo, changeset_revision )
         return trans.fill_template( '/webapps/tool_shed/repository_review/select_previous_review.mako',
                                     repository=repository,
                                     changeset_revision=changeset_revision,

File lib/galaxy/webapps/tool_shed/controllers/upload.py

 import tool_shed.repository_types.util as rt_util
 import tool_shed.util.shed_util_common as suc
 from tool_shed.util import commit_util
+from tool_shed.util import hg_util
 from tool_shed.util import metadata_util
 from tool_shed.util import repository_dependency_util
 from tool_shed.util import tool_dependency_util
         repository_id = kwd.get( 'repository_id', '' )
         repository = suc.get_repository_in_tool_shed( trans, repository_id )
         repo_dir = repository.repo_path( trans.app )
-        repo = hg.repository( suc.get_configured_ui(), repo_dir )
+        repo = hg.repository( hg_util.get_configured_ui(), repo_dir )
         uncompress_file = util.string_as_bool( kwd.get( 'uncompress_file', 'true' ) )
         remove_repo_files_not_in_tar = util.string_as_bool( kwd.get( 'remove_repo_files_not_in_tar', 'true' ) )
         uploaded_file = None
                 repo_url = 'http%s' % url[ len( 'hg' ): ]
                 repo_url = repo_url.encode( 'ascii', 'replace' )
                 try:
-                    commands.clone( suc.get_configured_ui(), repo_url, uploaded_directory )
+                    commands.clone( hg_util.get_configured_ui(), repo_url, uploaded_directory )
                 except Exception, e:
                     message = 'Error uploading via mercurial clone: %s' % suc.to_html_string( str( e ) )
                     status = 'error'
     def upload_directory( self, trans, repository, uploaded_directory, upload_point, remove_repo_files_not_in_tar,
                           commit_message, new_repo_alert ):
         repo_dir = repository.repo_path( trans.app )
-        repo = hg.repository( suc.get_configured_ui(), repo_dir )
+        repo = hg.repository( hg_util.get_configured_ui(), repo_dir )
         undesirable_dirs_removed = 0
         undesirable_files_removed = 0
         if upload_point is not None:
     def upload_tar( self, trans, repository, tar, uploaded_file, upload_point, remove_repo_files_not_in_tar, commit_message, new_repo_alert ):
         # Upload a tar archive of files.
         repo_dir = repository.repo_path( trans.app )
-        repo = hg.repository( suc.get_configured_ui(), repo_dir )
+        repo = hg.repository( hg_util.get_configured_ui(), repo_dir )
         undesirable_dirs_removed = 0
         undesirable_files_removed = 0
         ok, message = commit_util.check_archive( repository, tar )

File lib/tool_shed/galaxy_install/repository_util.py

 from tool_shed.util import data_manager_util
 from tool_shed.util import datatype_util
 from tool_shed.util import encoding_util
+from tool_shed.util import hg_util
 from tool_shed.util import repository_dependency_util
 from tool_shed.util import metadata_util
 from tool_shed.util import tool_dependency_util
 def get_repo_info_dict( trans, repository_id, changeset_revision ):
     repository = suc.get_repository_in_tool_shed( trans, repository_id )
     repo_dir = repository.repo_path( trans.app )
-    repo = hg.repository( suc.get_configured_ui(), repo_dir )
+    repo = hg.repository( hg_util.get_configured_ui(), repo_dir )
     repository_clone_url = common_util.generate_clone_url_for_repository_in_tool_shed( trans, repository )
     repository_metadata = suc.get_repository_metadata_by_changeset_revision( trans,
                                                                              repository_id,
         has_repository_dependencies_only_if_compiling_contained_td = False
         includes_tool_dependencies = False
         includes_tools_for_display_in_tool_panel = False
-    ctx = suc.get_changectx_for_changeset( repo, changeset_revision )
+    ctx = hg_util.get_changectx_for_changeset( repo, changeset_revision )
     repo_info_dict = create_repo_info_dict( trans=trans,
                                             repository_clone_url=repository_clone_url,
                                             changeset_revision=changeset_revision,
             current_changeset_revision = changeset_revision_dict.get( 'changeset_revision', None )
             current_ctx_rev = changeset_revision_dict.get( 'ctx_rev', None )
             if current_ctx_rev != ctx_rev:
-                repo = hg.repository( suc.get_configured_ui(), path=os.path.abspath( install_dir ) )
+                repo = hg.repository( hg_util.get_configured_ui(), path=os.path.abspath( install_dir ) )
                 pull_repository( repo, repository_clone_url, current_changeset_revision )
                 suc.update_repository( repo, ctx_rev=current_ctx_rev )
         handle_repository_contents( trans,
 
 def pull_repository( repo, repository_clone_url, ctx_rev ):
     """Pull changes from a remote repository to a local one."""
-    commands.pull( suc.get_configured_ui(), repo, source=repository_clone_url, rev=[ ctx_rev ] )
+    commands.pull( hg_util.get_configured_ui(), repo, source=repository_clone_url, rev=[ ctx_rev ] )
 
 def repair_tool_shed_repository( trans, repository, repo_info_dict ):
 

File lib/tool_shed/grids/admin_grids.py

 from galaxy.webapps.tool_shed import model
 from galaxy.model.orm import and_
 import tool_shed.util.shed_util_common as suc
+from tool_shed.util import hg_util
 from tool_shed.grids.repository_grids import CategoryGrid
 from tool_shed.grids.repository_grids import RepositoryGrid
 
 
         def get_value( self, trans, grid, repository_metadata ):
             repository = repository_metadata.repository
-            repo = hg.repository( suc.get_configured_ui(), repository.repo_path( trans.app ) )
-            ctx = suc.get_changectx_for_changeset( repo, repository_metadata.changeset_revision )
-            return suc.get_revision_label( trans, repository, repository_metadata.changeset_revision, include_date=True )
+            return hg_util.get_revision_label( trans,
+                                               repository,
+                                               repository_metadata.changeset_revision,
+                                               include_date=True,
+                                               include_hash=True )
 
 
     class ToolsColumn( grids.TextColumn ):

File lib/tool_shed/grids/repository_grids.py

 from galaxy.model.orm import or_
 from galaxy.util import json
 from galaxy.util import listify
+from tool_shed.util import hg_util
 import tool_shed.util.shed_util_common as suc
 import tool_shed.grids.util as grids_util
 import tool_shed.repository_types.util as rt_util
         def get_value( self, trans, grid, repository ):
             """Display the current repository heads."""
             repo_dir = repository.repo_path( trans.app )
-            repo = hg.repository( suc.get_configured_ui(), repo_dir )
+            repo = hg.repository( hg_util.get_configured_ui(), repo_dir )
             heads = suc.get_repository_heads( repo )
             multiple_heads = len( heads ) > 1
             if multiple_heads:
             else:
                 heads_str = ''
             for ctx in heads:
-                heads_str += '%s<br/>' % suc.get_revision_label_from_ctx( ctx, include_date=True )
+                heads_str += '%s<br/>' % hg_util.get_revision_label_from_ctx( ctx, include_date=True )
             heads_str.rstrip( '<br/>' )
             if multiple_heads:
                 heads_str += '</font>'
         def get_value( self, trans, grid, repository_metadata ):
             repository = repository_metadata.repository
             changeset_revision = repository_metadata.changeset_revision
-            changeset_revision_label = suc.get_revision_label( trans, repository, changeset_revision, include_date=True )
+            changeset_revision_label = hg_util.get_revision_label( trans, repository, changeset_revision, include_date=True )
             return changeset_revision_label
 
 
                                                                                                                                           changeset_revision )
                                 if not required_repository_metadata:
                                     repo_dir = required_repository.repo_path( trans.app )
-                                    repo = hg.repository( suc.get_configured_ui(), repo_dir )
+                                    repo = hg.repository( hg_util.get_configured_ui(), repo_dir )
                                     updated_changeset_revision = suc.get_next_downloadable_changeset_revision( required_repository, repo, changeset_revision )
                                     required_repository_metadata = metadata_util.get_repository_metadata_by_repository_id_changeset_revision( trans,
                                                                                                                                               required_repository_id,
      tool_dependency_definition.
     """
     encoded_repository_id = trans.security.encode_id( repository.id )
-    repo = hg.repository( suc.get_configured_ui(), repository.repo_path( trans.app ) )
+    repo = hg.repository( hg_util.get_configured_ui(), repository.repo_path( trans.app ) )
     tip_ctx = str( repo.changectx( repo.changelog.tip() ) )
     repository_metadata = None
     try:
      tool_dependency_definition.
     """
     encoded_repository_id = trans.security.encode_id( repository.id )
-    repo = hg.repository( suc.get_configured_ui(), repository.repo_path( trans.app ) )
+    repo = hg.repository( hg_util.get_configured_ui(), repository.repo_path( trans.app ) )
     tip_ctx = str( repo.changectx( repo.changelog.tip() ) )
     try:
         repository_metadata = suc.get_repository_metadata_by_changeset_revision( trans, encoded_repository_id, tip_ctx )

File lib/tool_shed/grids/repository_review_grids.py

 from galaxy.model.orm import or_
 from tool_shed.grids.repository_grids import RepositoryGrid
 import tool_shed.util.shed_util_common as suc
+from tool_shed.util import hg_util
 from tool_shed.util import metadata_util
 
 from galaxy import eggs
             # Restrict to revisions that have been reviewed.
             if repository.reviews:
                 rval = ''
-                repo = hg.repository( suc.get_configured_ui(), repository.repo_path( trans.app ) )
+                repo = hg.repository( hg_util.get_configured_ui(), repository.repo_path( trans.app ) )
                 for review in repository.reviews:
                     changeset_revision = review.changeset_revision
-                    rev, label = suc.get_rev_label_from_changeset_revision( repo, changeset_revision )
+                    rev, label = hg_util.get_rev_label_from_changeset_revision( repo, changeset_revision )
                     rval += '<a href="manage_repository_reviews_of_revision?id=%s&changeset_revision=%s">%s</a><br/>' % \
                         ( trans.security.encode_id( repository.id ), changeset_revision, label )
                 return rval
                 rval = ''
                 for repository_metadata in repository_metadata_revisions:
                     rev, label, changeset_revision = \
-                        metadata_util.get_rev_label_changeset_revision_from_repository_metadata( trans,
-                                                                                                 repository_metadata,
-                                                                                                 repository=repository )
+                        hg_util.get_rev_label_changeset_revision_from_repository_metadata( trans,
+                                                                                           repository_metadata,
+                                                                                           repository=repository,
+                                                                                           include_date=True,
+                                                                                           include_hash=False )
                     rval += '<a href="manage_repository_reviews_of_revision?id=%s&changeset_revision=%s">%s</a><br/>' % \
                         ( trans.security.encode_id( repository.id ), changeset_revision, label )
                 return rval
                 rval += 'edit_review'
             else:
                 rval +='browse_review'
-            revision_label = suc.get_revision_label( trans, review.repository, review.changeset_revision, include_date=True )
+            revision_label = hg_util.get_revision_label( trans,
+                                                         review.repository,
+                                                         review.changeset_revision,
+                                                         include_date=True,
+                                                         include_hash=False )
             rval += '?id=%s">%s</a>' % ( encoded_review_id, revision_label )
             return rval
 

File lib/tool_shed/grids/util.py

 import logging
 import os
 import tool_shed.util.shed_util_common as suc
-import tool_shed.util.metadata_util as metadata_util
+from tool_shed.util import hg_util
 from galaxy.web.form_builder import SelectField
 from galaxy.util.bunch import Bunch
 
         repository_metadata_revisions = repository.metadata_revisions
     for repository_metadata in repository_metadata_revisions:
         rev, label, changeset_revision = \
-            metadata_util.get_rev_label_changeset_revision_from_repository_metadata( trans,
-                                                                                     repository_metadata,
-                                                                                     repository=repository )
+            hg_util.get_rev_label_changeset_revision_from_repository_metadata( trans,
+                                                                               repository_metadata,
+                                                                               repository=repository,
+                                                                               include_date=True,
+                                                                               include_hash=False )
         changeset_tups.append( ( rev, label, changeset_revision ) )
         refresh_on_change_values.append( changeset_revision )
     # Sort options by the revision label.  Even though the downloadable_revisions query sorts by update_time,

File lib/tool_shed/scripts/check_repositories_for_functional_tests.py

 
 import ConfigParser
 import galaxy.webapps.tool_shed.config as tool_shed_config
+from tool_shed.util import hg_util
 import tool_shed.util.shed_util_common as suc
 import logging
 import shutil
         if tool_dicts is not None:
             # Clone the repository up to the changeset revision we're checking.
             repo_dir = repository.repo_path( app )
-            repo = hg.repository( suc.get_configured_ui(), repo_dir )
+            repo = hg.repository( hg_util.get_configured_ui(), repo_dir )
             work_dir = tempfile.mkdtemp( prefix="tmp-toolshed-cafr"  )
             cloned_ok, error_message = suc.clone_repository( repo_dir, work_dir, changeset_revision )
             if cloned_ok:
     """
     if not testable_revision:
         repo_dir = repository.repo_path( app )
-        repo = hg.repository( suc.get_configured_ui(), repo_dir )
+        repo = hg.repository( hg_util.get_configured_ui(), repo_dir )
         changeset_revisions = suc.get_ordered_metadata_changeset_revisions( repository, repo, downloadable=True )
         if len( changeset_revisions ) > 1:
             latest_downloadable_revision = changeset_revisions[ -1 ]

File lib/tool_shed/util/commit_util.py

 from galaxy.util.odict import odict
 from galaxy.web import url_for
 import tool_shed.util.shed_util_common as suc
+from tool_shed.util import hg_util
 from tool_shed.util import tool_util
 from tool_shed.util import xml_util
 import tool_shed.repository_types.util as rt_util
 def handle_directory_changes( trans, repository, full_path, filenames_in_archive, remove_repo_files_not_in_tar, new_repo_alert,
                               commit_message, undesirable_dirs_removed, undesirable_files_removed ):
     repo_dir = repository.repo_path( trans.app )
-    repo = hg.repository( suc.get_configured_ui(), repo_dir )
+    repo = hg.repository( hg_util.get_configured_ui(), repo_dir )
     content_alert_str = ''
     files_to_remove = []
     filenames_in_archive = [ os.path.join( full_path, name ) for name in filenames_in_archive ]
         repository = suc.get_repository_by_name_and_owner( trans.app, name, owner )
         if repository:
             repo_dir = repository.repo_path( trans.app )
-            repo = hg.repository( suc.get_configured_ui(), repo_dir )
+            repo = hg.repository( hg_util.get_configured_ui(), repo_dir )
             lastest_installable_changeset_revision = suc.get_latest_downloadable_changeset_revision( trans, repository, repo )
             if lastest_installable_changeset_revision != suc.INITIAL_CHANGELOG_HASH:
                 elem.attrib[ 'changeset_revision' ] = lastest_installable_changeset_revision

File lib/tool_shed/util/export_util.py

 from tool_shed.util import common_install_util
 from tool_shed.util import common_util
 from tool_shed.util import encoding_util
+from tool_shed.util import hg_util
 from tool_shed.util import repository_dependency_util
 from tool_shed.util import xml_util
 
 
 def archive_repository_revision( trans, ui, repository, archive_dir, changeset_revision ):
     '''Create an un-versioned archive of a repository.'''
-    repo = hg.repository( suc.get_configured_ui(), repository.repo_path( trans.app ) )
+    repo = hg.repository( hg_util.get_configured_ui(), repository.repo_path( trans.app ) )
     options_dict = suc.get_mercurial_default_options_dict( 'archive' )
     options_dict[ 'rev' ] = changeset_revision
     error_message = ''
                                                                                        key_rd_dicts_to_be_processed=None,
                                                                                        all_repository_dependencies=None,
                                                                                        handled_key_rd_dicts=None )
-    repo = hg.repository( suc.get_configured_ui(), repository.repo_path( trans.app ) )
-    ctx = suc.get_changectx_for_changeset( repo, changeset_revision )
+    repo = hg.repository( hg_util.get_configured_ui(), repository.repo_path( trans.app ) )
+    ctx = hg_util.get_changectx_for_changeset( repo, changeset_revision )
     repo_info_dict = {}
     # Cast unicode to string.
     repo_info_dict[ str( repository.name ) ] = ( str( repository.description ),

File lib/tool_shed/util/hg_util.py

+import logging
+from datetime import datetime
+from time import gmtime
+from time import strftime
+
+from galaxy import eggs
+eggs.require( 'mercurial' )
+
+from mercurial import cmdutil
+from mercurial import commands
+from mercurial import hg
+from mercurial import ui
+
+def get_changectx_for_changeset( repo, changeset_revision, **kwd ):
+    """Retrieve a specified changectx from a repository."""
+    for changeset in repo.changelog:
+        ctx = repo.changectx( changeset )
+        if str( ctx ) == changeset_revision:
+            return ctx
+    return None
+
+def get_configured_ui():
+    """Configure any desired ui settings."""
+    _ui = ui.ui()
+    # The following will suppress all messages.  This is
+    # the same as adding the following setting to the repo
+    # hgrc file' [ui] section:
+    # quiet = True
+    _ui.setconfig( 'ui', 'quiet', True )
+    return _ui
+    
+def get_readable_ctx_date( ctx ):
+    """Convert the date of the changeset (the received ctx) to a human-readable date."""
+    t, tz = ctx.date()
+    date = datetime( *gmtime( float( t ) - tz )[ :6 ] )
+    ctx_date = date.strftime( "%Y-%m-%d" )
+    return ctx_date
+
+def get_revision_label( trans, repository, changeset_revision, include_date=True, include_hash=True ):
+    """
+    Return a string consisting of the human read-able changeset rev and the changeset revision string
+    which includes the revision date if the receive include_date is True.
+    """
+    repo = hg.repository( get_configured_ui(), repository.repo_path( trans.app ) )
+    ctx = get_changectx_for_changeset( repo, changeset_revision )
+    if ctx:
+        return get_revision_label_from_ctx( ctx, include_date=include_date, include_hash=include_hash )
+    else:
+        if include_hash:
+            return "-1:%s" % changeset_revision
+        else:
+            return "-1"
+
+def get_rev_label_changeset_revision_from_repository_metadata( trans, repository_metadata, repository=None,
+                                                               include_date=True, include_hash=True ):
+    if repository is None:
+        repository = repository_metadata.repository
+    repo = hg.repository( get_configured_ui(), repository.repo_path( trans.app ) )
+    changeset_revision = repository_metadata.changeset_revision
+    ctx = get_changectx_for_changeset( repo, changeset_revision )
+    if ctx:
+        rev = '%04d' % ctx.rev()
+        if include_date:
+            changeset_revision_date = get_readable_ctx_date( ctx )
+            if include_hash:
+                label = "%s:%s (%s)" % ( str( ctx.rev() ), changeset_revision, changeset_revision_date )
+            else:
+                label = "%s (%s)" % ( str( ctx.rev() ), changeset_revision_date )
+        else:
+            if include_hash:
+                label = "%s:%s" % ( str( ctx.rev() ), changeset_revision )
+            else:
+                label = "%s" % str( ctx.rev() )
+    else:
+        rev = '-1'
+        if include_hash:
+            label = "-1:%s" % changeset_revision
+        else:
+            label = "-1"
+    return rev, label, changeset_revision
+
+def get_revision_label_from_ctx( ctx, include_date=True, include_hash=True ):
+    if include_date:
+        if include_hash:
+            return '%s:%s <i><font color="#666666">(%s)</font></i>' % \
+                ( str( ctx.rev() ), str( ctx ), str( get_readable_ctx_date( ctx ) ) )
+        else:
+            return '%s <i><font color="#666666">(%s)</font></i>' % \
+                ( str( ctx.rev() ), str( get_readable_ctx_date( ctx ) ) )
+    else:
+        if include_hash:
+            return '%s:%s' % ( str( ctx.rev() ), str( ctx ) )
+        else:
+            return '%s' % str( ctx.rev() )
+
+def get_rev_label_from_changeset_revision( repo, changeset_revision, include_date=True, include_hash=True ):
+    """
+    Given a changeset revision hash, return two strings, the changeset rev and the changeset revision hash
+    which includes the revision date if the receive include_date is True.
+    """
+    ctx = get_changectx_for_changeset( repo, changeset_revision )
+    if ctx:
+        rev = '%04d' % ctx.rev()
+        label = get_revision_label_from_ctx( ctx, include_date=include_date )
+    else:
+        rev = '-1'
+        label = "-1:%s" % changeset_revision
+    return rev, label

File lib/tool_shed/util/import_util.py

 from galaxy.datatypes import checkers
 from tool_shed.util import commit_util
 from tool_shed.util import encoding_util
+from tool_shed.util import hg_util
 from tool_shed.util import metadata_util
 from tool_shed.util import xml_util
 import tool_shed.util.shed_util_common as suc
     archive_file_path = os.path.join( file_path, archive_file_name )
     archive = tarfile.open( archive_file_path, 'r:*' )
     repo_dir = repository.repo_path( trans.app )
-    repo = hg.repository( suc.get_configured_ui(), repo_dir )
+    repo = hg.repository( hg_util.get_configured_ui(), repo_dir )
     undesirable_dirs_removed = 0
     undesirable_files_removed = 0
     ok, error_message = commit_util.check_archive( repository, archive )

File lib/tool_shed/util/metadata_util.py

 from tool_shed.util import common_util
 from tool_shed.util import common_install_util
 from tool_shed.util import container_util
+from tool_shed.util import hg_util
 from tool_shed.util import readme_util
 from tool_shed.util import tool_dependency_util
 from tool_shed.util import tool_util
         # changeset revision in the received repository's changelog (up to the received changeset revision) to see if it is contained in the
         # skip_tool_test table.  If it is, but is not associated with a repository_metadata record, reset that skip_tool_test record to the
         # newly created repository_metadata record.
-        repo = hg.repository( suc.get_configured_ui(), repository.repo_path( trans.app ) )
+        repo = hg.repository( hg_util.get_configured_ui(), repository.repo_path( trans.app ) )
         for changeset in repo.changelog:
             changeset_hash = str( repo.changectx( changeset ) )
             skip_tool_test = suc.get_skip_tool_test_by_changeset_revision( trans, changeset_hash )
 def get_latest_repository_metadata( trans, decoded_repository_id, downloadable=False ):
     """Get last metadata defined for a specified repository from the database."""
     repository = trans.sa_session.query( trans.model.Repository ).get( decoded_repository_id )
-    repo = hg.repository( suc.get_configured_ui(), repository.repo_path( trans.app ) )
+    repo = hg.repository( hg_util.get_configured_ui(), repository.repo_path( trans.app ) )
     if downloadable:
         changeset_revision = suc.get_latest_downloadable_changeset_revision( trans, repository, repo )
     else:
                 repository_metadata_revisions.append( metadata_revision )
     return repository_metadata_revisions
 
-def get_rev_label_changeset_revision_from_repository_metadata( trans, repository_metadata, repository=None ):
-    if repository is None:
-        repository = repository_metadata.repository
-    repo = hg.repository( suc.get_configured_ui(), repository.repo_path( trans.app ) )
-    changeset_revision = repository_metadata.changeset_revision
-    ctx = suc.get_changectx_for_changeset( repo, changeset_revision )
-    if ctx:
-        changeset_revision_date = suc.get_readable_ctx_date( ctx )
-        rev = '%04d' % ctx.rev()
-        label = "%s:%s (%s)" % ( str( ctx.rev() ), changeset_revision, changeset_revision_date )
-    else:
-        rev = '-1'
-        label = "-1:%s" % changeset_revision
-    return rev, label, changeset_revision
-
 def get_sample_files_from_disk( repository_files_dir, tool_path=None, relative_install_dir=None,
                                 resetting_all_metadata_on_repository=False ):
     if resetting_all_metadata_on_repository:
                 log.debug( error_message )
                 is_valid = False
                 return repository_dependency_tup, is_valid, error_message
-            repo = hg.repository( suc.get_configured_ui(), repository.repo_path( app ) )
+            repo = hg.repository( hg_util.get_configured_ui(), repository.repo_path( app ) )
             # The received changeset_revision may be None since defining it in the dependency definition is optional.
             # If this is the case, the default will be to set it's value to the repository dependency tip revision.
             # This probably occurs only when handling circular dependency definitions.
     """
     if repository.deleted:
         return ( None, False )
-    repo = hg.repository( suc.get_configured_ui(), repository.repo_path( trans.app ) )
+    repo = hg.repository( hg_util.get_configured_ui(), repository.repo_path( trans.app ) )
     # Get the latest installable changeset revision since that is all that is currently configured for testing.
     latest_installable_changeset_revision = suc.get_latest_downloadable_changeset_revision( trans, repository, repo )
     if latest_installable_changeset_revision not in [ None, suc.INITIAL_CHANGELOG_HASH ]:
     repository = suc.get_repository_in_tool_shed( trans, id )
     log.debug( "Resetting all metadata on repository: %s" % repository.name )
     repo_dir = repository.repo_path( trans.app )
-    repo = hg.repository( suc.get_configured_ui(), repo_dir )
+    repo = hg.repository( hg_util.get_configured_ui(), repo_dir )
     repository_clone_url = common_util.generate_clone_url_for_repository_in_tool_shed( trans, repository )
     # The list of changeset_revisions refers to repository_metadata records that have been created or updated.  When the following loop
     # completes, we'll delete all repository_metadata records for this repository that do not have a changeset_revision value in this list.
     encoded_id = trans.security.encode_id( repository.id )
     repository_clone_url = common_util.generate_clone_url_for_repository_in_tool_shed( trans, repository )
     repo_dir = repository.repo_path( trans.app )
-    repo = hg.repository( suc.get_configured_ui(), repo_dir )
+    repo = hg.repository( hg_util.get_configured_ui(), repo_dir )
     metadata_dict, invalid_file_tups = generate_metadata_for_changeset_revision( app=trans.app,
                                                                                  repository=repository,
                                                                                  changeset_revision=repository.tip( trans.app ),

File lib/tool_shed/util/readme_util.py

 from galaxy.util import unicodify
 import tool_shed.util.shed_util_common as suc
 from tool_shed.util import common_util
+from tool_shed.util import hg_util
 
 eggs.require( 'mercurial' )
 
     if trans.webapp.name == 'galaxy':
         can_use_disk_files = True
     else:
-        repo = hg.repository( suc.get_configured_ui(), repository.repo_path( trans.app ) )
+        repo = hg.repository( hg_util.get_configured_ui(), repository.repo_path( trans.app ) )
         latest_downloadable_changeset_revision = suc.get_latest_downloadable_changeset_revision( trans, repository, repo )
         can_use_disk_files = changeset_revision == latest_downloadable_changeset_revision
     readme_files_dict = {}
                         readme_files_dict[ readme_file_name ] = text_of_reasonable_length
                 else:
                     # We must be in the tool shed and have an old changeset_revision, so we need to retrieve the file contents from the repository manifest.
-                    ctx = suc.get_changectx_for_changeset( repo, changeset_revision )
+                    ctx = hg_util.get_changectx_for_changeset( repo, changeset_revision )
                     if ctx:
                         fctx = suc.get_file_context_from_ctx( ctx, readme_file_name )
                         if fctx and fctx not in [ 'DELETED' ]:

File lib/tool_shed/util/repository_dependency_util.py

 from tool_shed.util import common_install_util
 from tool_shed.util import container_util
 from tool_shed.util import encoding_util
+from tool_shed.util import hg_util
 from tool_shed.util import metadata_util
 from tool_shed.util import tool_util
 
                 else:
                     # The repository changeset_revision is no longer installable, so see if there's been an update.
                     repo_dir = repository.repo_path( trans.app )
-                    repo = hg.repository( suc.get_configured_ui(), repo_dir )
+                    repo = hg.repository( hg_util.get_configured_ui(), repo_dir )
                     changeset_revision = suc.get_next_downloadable_changeset_revision( repository, repo, rd_changeset_revision )
                     repository_metadata = metadata_util.get_repository_metadata_by_repository_id_changeset_revision( trans,
                                                                                                                      trans.security.encode_id( repository.id ),

File lib/tool_shed/util/repository_maintenance_util.py

 import os
 import re
 import tool_shed.util.shed_util_common as suc
+from tool_shed.util import hg_util
 from tool_shed.util import import_util
 from galaxy import util
 from galaxy.web.form_builder import build_select_field
     # Since we support both http and https, we set push_ssl to False to override the default (which is True) in the mercurial api.  The hg
     # purge extension purges all files and directories not being tracked by mercurial in the current repository.  It'll remove unknown files
     # and empty directories.  This is not currently used because it is not supported in the mercurial API.
-    repo = hg.repository( suc.get_configured_ui(), path=repository.repo_path( trans.app ) )
+    repo = hg.repository( hg_util.get_configured_ui(), path=repository.repo_path( trans.app ) )
     fp = repo.opener( 'hgrc', 'wb' )
     fp.write( '[paths]\n' )
     fp.write( 'default = .\n' )
     if not os.path.exists( repository_path ):
         os.makedirs( repository_path )
     # Create the local repository.
-    repo = hg.repository( suc.get_configured_ui(), repository_path, create=True )
+    repo = hg.repository( hg_util.get_configured_ui(), repository_path, create=True )
     # Add an entry in the hgweb.config file for the local repository.
     lhs = "repos/%s/%s" % ( repository.user.username, repository.name )
     trans.app.hgweb_config_manager.add_entry( lhs, repository_path )

File lib/tool_shed/util/review_util.py

 from galaxy import eggs
 from galaxy.model.orm import and_
 from galaxy.util.odict import odict
+from tool_shed.util import hg_util
 import tool_shed.util.shed_util_common as suc
 
 eggs.require( 'mercurial' )
 
 def get_previous_repository_reviews( trans, repository, changeset_revision ):
     """Return an ordered dictionary of repository reviews up to and including the received changeset revision."""
-    repo = hg.repository( suc.get_configured_ui(), repository.repo_path( trans.app ) )
+    repo = hg.repository( hg_util.get_configured_ui(), repository.repo_path( trans.app ) )
     reviewed_revision_hashes = [ review.changeset_revision for review in repository.reviews ]
     previous_reviews_dict = odict()
     for changeset in suc.reversed_upper_bounded_changelog( repo, changeset_revision ):
         previous_changeset_revision = str( repo.changectx( changeset ) )
         if previous_changeset_revision in reviewed_revision_hashes:
-            previous_rev, previous_changeset_revision_label = suc.get_rev_label_from_changeset_revision( repo, previous_changeset_revision )