def test_maximum_length_handling_ascii():
# Test that id secrets can be up to 56 characters long.
longest_id_secret = "m" * security.MAXIMUM_ID_SECRET_LENGTH
helper = security.SecurityHelper(id_secret=longest_id_secret)
helper.encode_id(1)
# Test that security helper will catch if the id secret is too long.
threw_exception = False
longer_id_secret = "m" * (security.MAXIMUM_ID_SECRET_LENGTH + 1)
try:
security.SecurityHelper(id_secret=longer_id_secret)
except Exception:
threw_exception = True
assert threw_exception
# Test that different kinds produce different keys even when id secret
# is very long.
e11 = helper.encode_id(1, kind="moo")
e12 = helper.encode_id(1, kind="moo2")
assert e11 != e12
# Test that long kinds are rejected because it uses up "too much" randomness
# from id_secret values. This isn't a strict requirement up but lets just enforce
# the best practice.
assertion_error_raised = False
try:
helper.encode_id(1, kind="this is a really long kind")
except AssertionError:
assertion_error_raised = True
assert assertion_error_raised
def setUp(self):
# Security helper
self.security = security.SecurityHelper(
id_secret='changethisinproductiontoo')
self.history_id = os.environ.get('GALAXY_TEST_HISTORY_ID', None)
self.host = os.environ.get('GALAXY_TEST_HOST')
self.port = os.environ.get('GALAXY_TEST_PORT')
default_url = "http://%s:%s" % (self.host, self.port)
self.url = os.environ.get('GALAXY_TEST_EXTERNAL', default_url)
self.test_data_resolver = TestDataResolver()
tool_shed_test_file = os.environ.get('GALAXY_TOOL_SHED_TEST_FILE',
None)
if tool_shed_test_file:
f = open(tool_shed_test_file, 'r')
text = f.read()
f.close()
self.shed_tools_dict = loads(text)
else:
self.shed_tools_dict = {}
self.keepOutdir = os.environ.get('GALAXY_TEST_SAVE', '')
if self.keepOutdir > '':
try:
os.makedirs(self.keepOutdir)
except Exception:
pass
def __init__(self, **kwargs):
print >> sys.stderr, "python path is: " + ", ".join(sys.path)
self.name = "reports"
# Read config file and check for errors
self.config = config.Configuration(**kwargs)
self.config.check()
config.configure_logging(self.config)
# Determine the database url
if self.config.database_connection:
db_url = self.config.database_connection
else:
db_url = "sqlite:///%s?isolation_level=IMMEDIATE" % self.config.database
# Setup the database engine and ORM
self.model = galaxy.model.mapping.init(
self.config.file_path,
db_url,
self.config.database_engine_options,
create_tables=True)
if not self.config.database_connection:
self.targets_mysql = False
else:
self.targets_mysql = 'mysql' in self.config.database_connection
# Security helper
self.security = security.SecurityHelper(
id_secret=self.config.id_secret)
# used for cachebusting -- refactor this into a *SINGLE* UniverseApplication base.
self.server_starttime = int(time.time())
def __init__(self, root=None, **kwargs):
Bunch.__init__(self, **kwargs)
root = root or '/tmp'
self.security = security.SecurityHelper(id_secret='bler')
self.use_remote_user = kwargs.get('use_remote_user', False)
self.file_path = '/tmp'
self.jobs_directory = '/tmp'
self.new_file_path = '/tmp'
self.tool_data_path = '/tmp'
self.object_store_config_file = ''
self.object_store = 'disk'
self.object_store_check_old_style = False
self.user_activation_on = False
self.new_user_dataset_access_role_default_private = False
self.expose_dataset_path = True
self.allow_user_dataset_purge = True
self.enable_old_display_applications = True
self.umask = 0o77
# Follow two required by GenomeBuilds
self.len_file_path = os.path.join('tool-data', 'shared', 'ucsc', 'chrom')
self.builds_file_path = os.path.join('tool-data', 'shared', 'ucsc', 'builds.txt.sample')
self.migrated_tools_config = "/tmp/migrated_tools_conf.xml"
self.preserve_python_environment = "always"
# set by MockDir
self.root = root
def __init__(self, **kwd):
print >> sys.stderr, "python path is: " + ", ".join(sys.path)
self.name = "tool_shed"
# Read the tool_shed.ini configuration file and check for errors.
self.config = config.Configuration(**kwd)
self.config.check()
config.configure_logging(self.config)
# Initialize the Galaxy datatypes registry.
self.datatypes_registry = galaxy.datatypes.registry.Registry()
self.datatypes_registry.load_datatypes(self.config.root,
self.config.datatypes_config)
# Initialize the Tool Shed repository_types registry.
self.repository_types_registry = tool_shed.repository_types.registry.Registry(
)
# Initialize the RepositoryGridFilterManager.
self.repository_grid_filter_manager = RepositoryGridFilterManager()
# Determine the Tool Shed database connection string.
if self.config.database_connection:
db_url = self.config.database_connection
else:
db_url = "sqlite:///%s?isolation_level=IMMEDIATE" % self.config.database
# Initialize the Tool Shed database and check for appropriate schema version.
from galaxy.webapps.tool_shed.model.migrate.check import create_or_verify_database
create_or_verify_database(db_url, self.config.database_engine_options)
# Set up the Tool Shed database engine and ORM.
from galaxy.webapps.tool_shed.model import mapping
self.model = mapping.init(self.config.file_path, db_url,
self.config.database_engine_options)
# Initialize the Tool Shed security helper.
self.security = security.SecurityHelper(
id_secret=self.config.id_secret)
# initialize the Tool Shed tag handler.
self.tag_handler = CommunityTagManager(self)
# Initialize the Tool Shed tool data tables. Never pass a configuration file here
# because the Tool Shed should always have an empty dictionary!
self.tool_data_tables = galaxy.tools.data.ToolDataTableManager(
self.config.tool_data_path)
self.genome_builds = GenomeBuilds(self)
# Citation manager needed to load tools.
from galaxy.managers.citations import CitationsManager
self.citations_manager = CitationsManager(self)
# The Tool Shed makes no use of a Galaxy toolbox, but this attribute is still required.
self.toolbox = tools.ToolBox([], self.config.tool_path, self)
# Initialize the Tool Shed security agent.
self.security_agent = self.model.security_agent
# The Tool Shed makes no use of a quota, but this attribute is still required.
self.quota_agent = galaxy.quota.NoQuotaAgent(self.model)
# TODO: Add OpenID support
self.openid_providers = OpenIDProviders()
# Initialize the baseline Tool Shed statistics component.
self.shed_counter = self.model.shed_counter
# Let the Tool Shed's HgwebConfigManager know where the hgweb.config file is located.
self.hgweb_config_manager = self.model.hgweb_config_manager
self.hgweb_config_manager.hgweb_config_dir = self.config.hgweb_config_dir
# Initialize the repository registry.
self.repository_registry = tool_shed.repository_registry.Registry(self)
# used for cachebusting -- refactor this into a *SINGLE* UniverseApplication base.
self.server_starttime = int(time.time())
print >> sys.stderr, "Tool shed hgweb.config file is: ", self.hgweb_config_manager.hgweb_config
def setUp(self):
# Security helper
self.security = security.SecurityHelper(
id_secret='changethisinproductiontoo')
self.history_id = os.environ.get('GALAXY_TEST_HISTORY_ID', None)
self.host, self.port, self.url = target_url_parts()
self.test_data_resolver = TestDataResolver()
self.keepOutdir = setup_keep_outdir()
def __init__( self, **kwargs ):
print >> sys.stderr, "python path is: " + ", ".join( sys.path )
# Read config file and check for errors
self.config = config.Configuration( **kwargs )
self.config.check()
config.configure_logging( self.config )
# Set up sequencer actions registry
self.sequencer_actions_registry = galaxy.webapps.demo_sequencer.registry.Registry( self.config.root, self.config.sequencer_actions_config )
# Security helper
self.security = security.SecurityHelper( id_secret=self.config.id_secret )
def __init__(self, config):
self.config = config
if not self.config.database_connection:
self.config.database_connection = \
"sqlite:///%s?isolation_level=IMMEDIATE" % str(config.database)
# Setup the database engine and ORM
self.model = mapping.init(self.config.file_path,
self.config.database_connection,
engine_options={},
create_tables=False)
self.security = security.SecurityHelper(id_secret=self.config.id_secret)
def test_maximum_length_handling_nonascii():
longest_id_secret = "◎◎◎◎◎◎◎◎◎◎◎◎◎◎◎◎◎◎"
helper = security.SecurityHelper(id_secret=longest_id_secret)
helper.encode_id(1)
# Test that security helper will catch if the id secret is too long.
threw_exception = False
longer_id_secret = "◎◎◎◎◎◎◎◎◎◎◎◎◎◎◎◎◎◎◎"
try:
security.SecurityHelper(id_secret=longer_id_secret)
except Exception:
threw_exception = True
assert threw_exception
# Test that different kinds produce different keys even when id secret
# is very long.
e11 = helper.encode_id(1, kind="moo")
e12 = helper.encode_id(1, kind="moo2")
assert e11 != e12
def __init__(self, config):
self.config = config
if not self.config.database_connection:
self.config.database_connection = "sqlite:///%s?isolation_level=IMMEDIATE" % str(config.database)
print 'Using database connection: ', self.config.database_connection
# Setup the database engine and ORM
self.model = mapping.init(self.config.file_path,
self.config.database_connection,
engine_options={},
create_tables=False)
self.security = security.SecurityHelper(id_secret=self.config.id_secret)
self.hgweb_config_manager = self.model.hgweb_config_manager
self.hgweb_config_manager.hgweb_config_dir = self.config.hgweb_config_dir
print 'Using hgweb.config file: ', self.hgweb_config_manager.hgweb_config
def __init__(self, **kwargs):
Bunch.__init__(self, **kwargs)
self.security = security.SecurityHelper(id_secret='bler')
self.file_path = '/tmp'
self.job_working_directory = '/tmp'
self.new_file_path = '/tmp'
self.object_store_config_file = ''
self.object_store = 'disk'
self.object_store_check_old_style = False
self.user_activation_on = False
self.new_user_dataset_access_role_default_private = False
self.allow_user_dataset_purge = True
def __init__( self, **kwargs ):
print >> sys.stderr, "python path is: " + ", ".join( sys.path )
# Read config file and check for errors
self.config = config.Configuration( **kwargs )
self.config.check()
config.configure_logging( self.config )
# Determine the database url
if self.config.database_connection:
db_url = self.config.database_connection
else:
db_url = "sqlite://%s?isolation_level=IMMEDIATE" % self.config.database
# Setup the database engine and ORM
self.model = galaxy.model.mapping.init( self.config.file_path,
db_url,
self.config.database_engine_options,
create_tables = True )
# Security helper
self.security = security.SecurityHelper( id_secret=self.config.id_secret )
def __init__(self, **kwargs):
print >> sys.stderr, "python path is: " + ", ".join(sys.path)
self.name = "community"
# Read config file and check for errors
self.config = config.Configuration(**kwargs)
self.config.check()
config.configure_logging(self.config)
# Set up datatypes registry
self.datatypes_registry = galaxy.datatypes.registry.Registry()
self.datatypes_registry.load_datatypes(self.config.root,
self.config.datatypes_config)
# Determine the database url
if self.config.database_connection:
db_url = self.config.database_connection
else:
db_url = "sqlite:///%s?isolation_level=IMMEDIATE" % self.config.database
# Initialize database / check for appropriate schema version
from galaxy.webapps.community.model.migrate.check import create_or_verify_database
create_or_verify_database(db_url, self.config.database_engine_options)
# Setup the database engine and ORM
from galaxy.webapps.community.model import mapping
self.model = mapping.init(self.config.file_path, db_url,
self.config.database_engine_options)
# Security helper
self.security = security.SecurityHelper(
id_secret=self.config.id_secret)
# Tag handler
self.tag_handler = CommunityTagHandler()
# Tool data tables - never pass a config file here because the tool shed should always have an empty dictionary!
self.tool_data_tables = galaxy.tools.data.ToolDataTableManager(
self.config.tool_data_path)
# The tool shed has no toolbox, but this attribute is still required.
self.toolbox = tools.ToolBox([], self.config.tool_path, self)
# Load security policy
self.security_agent = self.model.security_agent
self.quota_agent = galaxy.quota.NoQuotaAgent(self.model)
# TODO: Add OpenID support
self.openid_providers = OpenIDProviders()
self.shed_counter = self.model.shed_counter
# Let the HgwebConfigManager know where the hgweb.config file is located.
self.hgweb_config_manager = self.model.hgweb_config_manager
self.hgweb_config_manager.hgweb_config_dir = self.config.hgweb_config_dir
print >> sys.stderr, "Tool shed hgweb.config file is: ", self.hgweb_config_manager.hgweb_config
def __init__( self, root=None, **kwargs ):
Bunch.__init__( self, **kwargs )
self.security = security.SecurityHelper( id_secret='bler' )
self.file_path = '/tmp'
self.job_working_directory = '/tmp'
self.new_file_path = '/tmp'
self.object_store_config_file = ''
self.object_store = 'disk'
self.object_store_check_old_style = False
self.user_activation_on = False
self.new_user_dataset_access_role_default_private = False
self.expose_dataset_path = True
self.allow_user_dataset_purge = True
self.enable_old_display_applications = True
# set by MockDir
self.root = root
def setUp(self):
# Security helper
id_secret = os.environ.get('GALAXY_INSTALL_TEST_SECRET',
'changethisinproductiontoo')
self.security = security.SecurityHelper(id_secret=id_secret)
self.history_id = None
self.test_tmp_dir = os.environ.get('GALAXY_INSTALL_TEST_TMP_DIR', None)
self.host = os.environ.get('GALAXY_INSTALL_TEST_HOST')
self.port = os.environ.get('GALAXY_INSTALL_TEST_PORT')
self.url = "http://%s:%s" % (self.host, self.port)
self.shed_tool_data_table_conf = os.environ.get(
'GALAXY_INSTALL_TEST_SHED_TOOL_DATA_TABLE_CONF')
self.file_dir = os.environ.get('GALAXY_INSTALL_TEST_FILE_DIR', None)
self.tool_data_path = os.environ.get(
'GALAXY_INSTALL_TEST_TOOL_DATA_PATH')
self.shed_tool_conf = os.environ.get(
'GALAXY_INSTALL_TEST_SHED_TOOL_CONF')
# TODO: Figure out a way to alter these attributes during tests.
self.galaxy_tool_dependency_dir = os.environ.get(
'GALAXY_INSTALL_TEST_TOOL_DEPENDENCY_DIR')
self.shed_tools_dict = {}
def __init__( self, **kwargs ):
print >> sys.stderr, "python path is: " + ", ".join( sys.path )
# Read config file and check for errors
self.config = config.Configuration( **kwargs )
self.config.check()
config.configure_logging( self.config )
# Set up datatypes registry
self.datatypes_registry = galaxy.datatypes.registry.Registry()
# TODO: Handle datatypes included in repositories - the following will only load datatypes_conf.xml.
self.datatypes_registry.load_datatypes( self.config.root, self.config.datatypes_config )
# Determine the database url
if self.config.database_connection:
db_url = self.config.database_connection
else:
db_url = "sqlite://%s?isolation_level=IMMEDIATE" % self.config.database
# Initialize database / check for appropriate schema version
from galaxy.webapps.community.model.migrate.check import create_or_verify_database
create_or_verify_database( db_url, self.config.database_engine_options )
# Setup the database engine and ORM
from galaxy.webapps.community.model import mapping
self.model = mapping.init( self.config.file_path,
db_url,
self.config.database_engine_options )
# Security helper
self.security = security.SecurityHelper( id_secret=self.config.id_secret )
# Tag handler
self.tag_handler = CommunityTagHandler()
# Tool data tables
self.tool_data_tables = galaxy.tools.data.ToolDataTableManager( self.config.tool_data_table_config_path )
# The tool shed has no toolbox, but this attribute is still required.
self.toolbox = None
# Load security policy
self.security_agent = self.model.security_agent
self.quota_agent = galaxy.quota.NoQuotaAgent( self.model )
# TODO: Add OpenID support
self.openid_providers = OpenIDProviders()
self.shed_counter = self.model.shed_counter
def _configure_security(self):
from galaxy.web import security
self.security = security.SecurityHelper(
id_secret=self.config.id_secret)
def __init__( self, **kwargs ):
print >> sys.stderr, "python path is: " + ", ".join( sys.path )
self.new_installation = False
# Read config file and check for errors
self.config = config.Configuration( **kwargs )
self.config.check()
config.configure_logging( self.config )
# Determine the database url
if self.config.database_connection:
db_url = self.config.database_connection
else:
db_url = "sqlite:///%s?isolation_level=IMMEDIATE" % self.config.database
# Initialize database / check for appropriate schema version. # If this
# is a new installation, we'll restrict the tool migration messaging.
from galaxy.model.migrate.check import create_or_verify_database
create_or_verify_database( db_url, kwargs.get( 'global_conf', {} ).get( '__file__', None ), self.config.database_engine_options, app=self )
# Alert the Galaxy admin to tools that have been moved from the distribution to the tool shed.
from galaxy.tool_shed.migrate.check import verify_tools
verify_tools( self, db_url, kwargs.get( 'global_conf', {} ).get( '__file__', None ), self.config.database_engine_options )
# Object store manager
self.object_store = build_object_store_from_config(self.config)
# Setup the database engine and ORM
from galaxy.model import mapping
self.model = mapping.init( self.config.file_path,
db_url,
self.config.database_engine_options,
database_query_profiling_proxy = self.config.database_query_profiling_proxy,
object_store = self.object_store )
# Set up the tool sheds registry
if os.path.isfile( self.config.tool_sheds_config ):
self.tool_shed_registry = galaxy.tool_shed.tool_shed_registry.Registry( self.config.root, self.config.tool_sheds_config )
else:
self.tool_shed_registry = None
# Manage installed tool shed repositories.
self.installed_repository_manager = galaxy.tool_shed.InstalledRepositoryManager( self )
# Create an empty datatypes registry.
self.datatypes_registry = galaxy.datatypes.registry.Registry()
# Load proprietary datatypes defined in datatypes_conf.xml files in all installed tool shed repositories. We
# load proprietary datatypes before datatypes in the distribution because Galaxy's default sniffers include some
# generic sniffers (eg text,xml) which catch anything, so it's impossible for proprietary sniffers to be used.
# However, if there is a conflict (2 datatypes with the same extension) between a proprietary datatype and a datatype
# in the Galaxy distribution, the datatype in the Galaxy distribution will take precedence. If there is a conflict
# between 2 proprietary datatypes, the datatype from the repository that was installed earliest will take precedence.
# This will also load proprietary datatype converters and display applications.
self.installed_repository_manager.load_proprietary_datatypes()
# Load the data types in the Galaxy distribution, which are defined in self.config.datatypes_config.
self.datatypes_registry.load_datatypes( self.config.root, self.config.datatypes_config )
galaxy.model.set_datatypes_registry( self.datatypes_registry )
# Security helper
self.security = security.SecurityHelper( id_secret=self.config.id_secret )
# Tag handler
self.tag_handler = GalaxyTagHandler()
# Tool data tables
self.tool_data_tables = galaxy.tools.data.ToolDataTableManager( self.config.tool_data_table_config_path )
# Initialize the tools, making sure the list of tool configs includes the reserved migrated_tools_conf.xml file.
tool_configs = self.config.tool_configs
if self.config.migrated_tools_config not in tool_configs:
tool_configs.append( self.config.migrated_tools_config )
self.toolbox = tools.ToolBox( tool_configs, self.config.tool_path, self )
# Search support for tools
self.toolbox_search = galaxy.tools.search.ToolBoxSearch( self.toolbox )
# If enabled, poll respective tool sheds to see if updates are available for any installed tool shed repositories.
if self.config.get_bool( 'enable_tool_shed_check', False ):
from tool_shed import update_manager
self.update_manager = update_manager.UpdateManager( self )
# Load datatype display applications defined in local datatypes_conf.xml
self.datatypes_registry.load_display_applications()
# Load datatype converters defined in local datatypes_conf.xml
self.datatypes_registry.load_datatype_converters( self.toolbox )
# Load external metadata tool
self.datatypes_registry.load_external_metadata_tool( self.toolbox )
# Load history import/export tools.
load_history_imp_exp_tools( self.toolbox )
# Load genome indexer tool.
load_genome_index_tools( self.toolbox )
# Load security policy.
self.security_agent = self.model.security_agent
self.host_security_agent = galaxy.security.HostAgent( model=self.security_agent.model, permitted_actions=self.security_agent.permitted_actions )
# Load quota management.
if self.config.enable_quotas:
self.quota_agent = galaxy.quota.QuotaAgent( self.model )
else:
self.quota_agent = galaxy.quota.NoQuotaAgent( self.model )
# Heartbeat and memdump for thread / heap profiling
self.heartbeat = None
self.memdump = None
self.memory_usage = None
# Container for OpenID authentication routines
if self.config.enable_openid:
from galaxy.web.framework import openid_manager
self.openid_manager = openid_manager.OpenIDManager( self.config.openid_consumer_cache_path )
self.openid_providers = OpenIDProviders.from_file( self.config.openid_config )
else:
self.openid_providers = OpenIDProviders()
# Start the heartbeat process if configured and available
if self.config.use_heartbeat:
from galaxy.util import heartbeat
if heartbeat.Heartbeat:
self.heartbeat = heartbeat.Heartbeat( fname=self.config.heartbeat_log )
self.heartbeat.start()
# Enable the memdump signal catcher if configured and available
if self.config.use_memdump:
from galaxy.util import memdump
if memdump.Memdump:
self.memdump = memdump.Memdump()
# Transfer manager client
if self.config.get_bool( 'enable_beta_job_managers', False ):
from jobs import transfer_manager
self.transfer_manager = transfer_manager.TransferManager( self )
# Start the job manager
from jobs import manager
self.job_manager = manager.JobManager( self )
# FIXME: These are exposed directly for backward compatibility
self.job_queue = self.job_manager.job_queue
self.job_stop_queue = self.job_manager.job_stop_queue
# Initialize the external service types
self.external_service_types = external_service_types.ExternalServiceTypesCollection( self.config.external_service_type_config_file, self.config.external_service_type_path, self )
def __init__(self, tools_migration_config):
install_dependencies = 'install_dependencies' in sys.argv
galaxy_config_file = 'universe_wsgi.ini'
self.name = 'galaxy'
if '-c' in sys.argv:
pos = sys.argv.index('-c')
sys.argv.pop(pos)
galaxy_config_file = sys.argv.pop(pos)
if not os.path.exists(galaxy_config_file):
print "Galaxy config file does not exist (hint: use '-c config.ini' for non-standard locations): %s" % galaxy_config_file
sys.exit(1)
config_parser = ConfigParser.ConfigParser({'here': os.getcwd()})
config_parser.read(galaxy_config_file)
galaxy_config_dict = {}
for key, value in config_parser.items("app:main"):
galaxy_config_dict[key] = value
self.config = galaxy.config.Configuration(**galaxy_config_dict)
if not self.config.database_connection:
self.config.database_connection = "sqlite:///%s?isolation_level=IMMEDIATE" % self.config.database
self.config.update_integrated_tool_panel = True
self.object_store = build_object_store_from_config(self.config)
# Security helper
self.security = security.SecurityHelper(
id_secret=self.config.id_secret)
# Setup the database engine and ORM
self.model = galaxy.model.mapping.init(self.config.file_path,
self.config.database_connection,
engine_options={},
create_tables=False,
object_store=self.object_store)
# Create an empty datatypes registry.
self.datatypes_registry = galaxy.datatypes.registry.Registry()
# Load the data types in the Galaxy distribution, which are defined in self.config.datatypes_config.
self.datatypes_registry.load_datatypes(self.config.root,
self.config.datatypes_config)
# Initialize tool data tables using the config defined by self.config.tool_data_table_config_path.
self.tool_data_tables = ToolDataTableManager(
tool_data_path=self.config.tool_data_path,
config_filename=self.config.tool_data_table_config_path)
# Load additional entries defined by self.config.shed_tool_data_table_config into tool data tables.
self.tool_data_tables.load_from_config_file(
config_filename=self.config.shed_tool_data_table_config,
tool_data_path=self.tool_data_tables.tool_data_path,
from_shed_config=True)
# Initialize the tools, making sure the list of tool configs includes the reserved migrated_tools_conf.xml file.
tool_configs = self.config.tool_configs
if self.config.migrated_tools_config not in tool_configs:
tool_configs.append(self.config.migrated_tools_config)
self.toolbox = tools.ToolBox(tool_configs, self.config.tool_path, self)
# Search support for tools
self.toolbox_search = galaxy.tools.search.ToolBoxSearch(self.toolbox)
# Set up the tool sheds registry.
if os.path.isfile(self.config.tool_sheds_config):
self.tool_shed_registry = tool_shed.tool_shed_registry.Registry(
self.config.root, self.config.tool_sheds_config)
else:
self.tool_shed_registry = None
# Get the latest tool migration script number to send to the Install manager.
latest_migration_script_number = int(
tools_migration_config.split('_')[0])
# The value of migrated_tools_config is migrated_tools_conf.xml, and is reserved for containing only those tools that have been
# eliminated from the distribution and moved to the tool shed. A side-effect of instantiating the InstallManager is the automatic
# installation of all appropriate tool shed repositories.
self.install_manager = install_manager.InstallManager(
app=self,
latest_migration_script_number=latest_migration_script_number,
tool_shed_install_config=os.path.join(self.config.root, 'scripts',
'migrate_tools',
tools_migration_config),
migrated_tools_config=self.config.migrated_tools_config,
install_dependencies=install_dependencies)
def __init__(self, **kwargs):
self.name = kwargs.get('name', 'galaxy')
self.security = security.SecurityHelper(id_secret='bler')
def __init__( self, **kwargs ):
print >> sys.stderr, "python path is: " + ", ".join( sys.path )
# Read config file and check for errors
self.config = config.Configuration( **kwargs )
self.config.check()
config.configure_logging( self.config )
# Set up datatypes registry
self.datatypes_registry = galaxy.datatypes.registry.Registry( self.config.root, self.config.datatypes_config )
galaxy.model.set_datatypes_registry( self.datatypes_registry )
# Determine the database url
if self.config.database_connection:
db_url = self.config.database_connection
else:
db_url = "sqlite:///%s?isolation_level=IMMEDIATE" % self.config.database
# Initialize database / check for appropriate schema version
from galaxy.model.migrate.check import create_or_verify_database
create_or_verify_database( db_url, self.config.database_engine_options )
# Setup the database engine and ORM
from galaxy.model import mapping
self.model = mapping.init( self.config.file_path,
db_url,
self.config.database_engine_options )
# Security helper
self.security = security.SecurityHelper( id_secret=self.config.id_secret )
# Initialize the tools
self.toolbox = tools.ToolBox( self.config.tool_config, self.config.tool_path, self )
# Load datatype converters
self.datatypes_registry.load_datatype_converters( self.toolbox )
#load external metadata tool
self.datatypes_registry.load_external_metadata_tool( self.toolbox )
# Load datatype indexers
self.datatypes_registry.load_datatype_indexers( self.toolbox )
#Load security policy
self.security_agent = self.model.security_agent
self.host_security_agent = galaxy.security.HostAgent( model=self.security_agent.model, permitted_actions=self.security_agent.permitted_actions )
# Heartbeat and memdump for thread / heap profiling
self.heartbeat = None
self.memdump = None
self.memory_usage = None
# Start the heartbeat process if configured and available
if self.config.use_heartbeat:
from galaxy.util import heartbeat
if heartbeat.Heartbeat:
self.heartbeat = heartbeat.Heartbeat()
self.heartbeat.start()
# Enable the memdump signal catcher if configured and available
if self.config.use_memdump:
from galaxy.util import memdump
if memdump.Memdump:
self.memdump = memdump.Memdump()
# Enable memory_usage logging if configured
if self.config.log_memory_usage:
from galaxy.util import memory_usage
self.memory_usage = memory_usage
# Start the job queue
self.job_manager = jobs.JobManager( self )
# FIXME: These are exposed directly for backward compatibility
self.job_queue = self.job_manager.job_queue
self.job_stop_queue = self.job_manager.job_stop_queue
# Start the cloud manager
self.cloud_manager = cloud.CloudManager( self )
def __init__(self, **kwargs):
self.name = kwargs.get('name', 'galaxy')
self.security = security.SecurityHelper(
id_secret='6e46ed6483a833c100e68cc3f1d0dd76')
except:
parser.print_help()
sys.exit( 1 )
options.config = os.path.abspath( options.config )
sys.path.insert( 1, os.path.join( os.path.dirname( __file__ ), os.pardir, 'lib' ) )
config = ConfigParser( dict( file_path='database/files',
id_secret='USING THE DEFAULT IS NOT SECURE!',
database_connection='sqlite:///database/universe.sqlite?isolation_level=IMMEDIATE' ) )
config.read( options.config )
from galaxy.web import security
from galaxy.model import mapping
helper = security.SecurityHelper( id_secret=config.get( 'app:main', 'id_secret' ) )
model = mapping.init( config.get( 'app:main', 'file_path' ), config.get( 'app:main', 'database_connection' ), create_tables=False )
if options.encode_id:
print 'Encoded "%s": %s' % ( options.encode_id, helper.encode_id( options.encode_id ) )
if options.decode_id:
print 'Decoded "%s": %s' % ( options.decode_id, helper.decode_id( options.decode_id ) )
if options.hda_id:
try:
hda_id = int( options.hda_id )
except:
hda_id = int( helper.decode_id( options.hda_id ) )
hda = model.context.current.query( model.HistoryDatasetAssociation ).get( hda_id )
print 'HDA "%s" is Dataset "%s" at: %s' % ( hda.id, hda.dataset.id, hda.file_name )
# -*- coding: utf-8 -*-
from galaxy.web import security
test_helper_1 = security.SecurityHelper(id_secret="secu1")
test_helper_2 = security.SecurityHelper(id_secret="secu2")
def test_maximum_length_handling_ascii():
# Test that id secrets can be up to 56 characters long.
longest_id_secret = "m" * security.MAXIMUM_ID_SECRET_LENGTH
helper = security.SecurityHelper(id_secret=longest_id_secret)
helper.encode_id(1)
# Test that security helper will catch if the id secret is too long.
threw_exception = False
longer_id_secret = "m" * (security.MAXIMUM_ID_SECRET_LENGTH + 1)
try:
security.SecurityHelper(id_secret=longer_id_secret)
except Exception:
threw_exception = True
assert threw_exception
# Test that different kinds produce different keys even when id secret
# is very long.
e11 = helper.encode_id(1, kind="moo")
e12 = helper.encode_id(1, kind="moo2")
assert e11 != e12
parser = argparse.ArgumentParser()
populate_config_args(parser)
parser.add_argument('-e', '--encode-id', dest='encode_id', help='Encode an ID')
parser.add_argument('-d', '--decode-id', dest='decode_id', help='Decode an ID')
parser.add_argument('--hda',
dest='hda_id',
help='Display HistoryDatasetAssociation info')
parser.add_argument('--ldda',
dest='ldda_id',
help='Display LibraryDatasetDatasetAssociation info')
args = parser.parse_args()
app_properties = app_properties_from_args(args)
config = galaxy.config.Configuration(**app_properties)
helper = security.SecurityHelper(id_secret=app_properties.get('id_secret'))
model = galaxy.config.init_models_from_config(config)
if args.encode_id:
print('Encoded "%s": %s' %
(args.encode_id, helper.encode_id(args.encode_id)))
if args.decode_id:
print('Decoded "%s": %s' %
(args.decode_id, helper.decode_id(args.decode_id)))
if args.hda_id:
try:
hda_id = int(args.hda_id)
except Exception:
hda_id = int(helper.decode_id(args.hda_id))
