text: #!/usr/bin/python
  import argparse
  import ConfigParser
  import os
  import sys
  
  sys.path.insert(1, os.path.join( os.path.dirname( __file__ ), os.pardir, os.pardir, os.pardir ) )
  
  from galaxy import eggs
  eggs.require( "SQLAlchemy >= 0.4" )
  from sqlalchemy.exc import OperationalError, ProgrammingError
  
  import galaxy.webapps.tool_shed.model.mapping as tool_shed_model
  from tool_shed.util import xml_util
  
  
  def check_db( config_parser ):
      dburi = None
  
      if config_parser.has_option( 'app:main', 'database_connection' ):
          dburi = config_parser.get( 'app:main', 'database_connection' )
      elif config_parser.has_option( 'app:main', 'database_file' ):
          db_file = config_parser.get( 'app:main', 'database_file' )
          dburi = "sqlite:///%s?isolation_level=IMMEDIATE" % db_file
      else:
          sys.exit('The database configuration setting is missing from the tool_shed.ini file.  Add this setting before attempting to bootstrap.')
  
      sa_session = None
  
      database_exists_message = 'The database configured for this Tool Shed is not new, so bootstrapping is not allowed.  '
      database_exists_message += 'Create a new database that has not been migrated before attempting to bootstrap.'
  
      try:
          model = tool_shed_model.init( config_parser.get( 'app:main', 'file_path' ), dburi, engine_options={}, create_tables=False )
          sa_session = model.context.current
          sys.exit(database_exists_message)
      except ProgrammingError:
          pass
      except OperationalError:
          pass
  
      try:
          if sa_session is not None:
              result = sa_session.execute( 'SELECT version FROM migrate_version' ).first()
              if result[0] >= 2:
                  sys.exit(database_exists_message)
              else:
                  pass
      except ProgrammingError:
          pass
  
      if config_parser.has_option( 'app:main', 'hgweb_config_dir' ):
          hgweb_config_parser = ConfigParser.ConfigParser()
          hgweb_dir = config_parser.get( 'app:main', 'hgweb_config_dir' )
          hgweb_config_file = os.path.join( hgweb_dir, 'hgweb.config' )
          if not os.path.exists( hgweb_config_file ):
              sys.exit(0)
          hgweb_config_parser.read( hgweb_config_file )
          configured_repos = hgweb_config_parser.items( 'paths' )
          if len( configured_repos ) >= 1:
              message = "This Tool Shed's hgweb.config file contains entries, so bootstrapping is not allowed.  Delete"
              message += " the current hgweb.config file along with all associated repositories in the configured "
              message += "location before attempting to boostrap."
              sys.exit(message)
          else:
              sys.exit(0)
      else:
          sys.exit(0)
  
      sys.exit(0)
  
  
  def admin_user_info( ):
      user_info_config = os.path.abspath( os.path.join( os.getcwd(), 'lib/tool_shed/scripts/bootstrap_tool_shed', 'user_info.xml' ) )
      tree, error_message = xml_util.parse_xml( user_info_config )
      username = None
      email = None
      password = None
      if tree is None:
          print "The XML file ", user_info_config, " seems to be invalid, using defaults."
          email = 'admin@test.org'
          password = 'testuser'
          username = 'admin'
      else:
          root = tree.getroot()
          for elem in root:
              if elem.tag == 'email':
                  email = elem.text
              elif elem.tag == 'password':
                  password = elem.text
              elif elem.tag == 'username':
                  username = elem.text
      return (username, email, password)
  
  
  def get_local_tool_shed_url( config_parser ):
      port = '9009'
      if config_parser.has_section( 'server:main' ):
          if config_parser.has_option( 'server:main', 'port' ):
              port = config_parser.get( 'server:main', 'port' )
      host = '127.0.0.1'
      print 'http://%s:%s' % ( host, port )
      return 0
  
  
  def main( args ):
      config_parser = ConfigParser.ConfigParser()
  
      if os.path.exists( args.config ):
          config_parser.read( args.config )
      else:
          return 1
  
      if args.method == 'check_db':
          return check_db( config_parser )
      elif args.method == 'admin_user_info':
          (username, email, password) = admin_user_info()
          print '%s__SEP__%s__SEP__%s' % ( username, email, password )
          return 0
      elif args.method == 'get_url':
          return get_local_tool_shed_url( config_parser )
      else:
          return 1
  
  parser = argparse.ArgumentParser()
  parser.add_argument( '-c', '--config_file', dest='config', action='store', default='config/tool_shed.ini.sample' )
  parser.add_argument( '-e', '--execute', dest='method', action='store', default='check_db' )
  args = parser.parse_args()
  
  if __name__ == '__main__':
      sys.exit( main( args ) )
  