def f(x):
if (minimum is None or len(x) >= minimum) and (maximum is None
or len(x) <= maximum):
return x
if minimum is not None and minimum < 0:
new_minimum = 0
else:
new_minimum = minimum
if new_minimum is not None and maximum is not None:
if new_minimum == maximum:
raise InputFilterError(
'%s must be exactly %s character%s in length.' %
(field, maximum, '' if maximum == 1 else 's'))
if new_minimum < maximum:
raise InputFilterError(
'%s must be between %s and %s characters in length.' %
(field, new_minimum, maximum))
raise IrodsError(
'Minimum character count %s must not be greater than maximum character count %s.'
% (new_minimum, maximum))
if new_minimum is not None:
raise InputFilterError(
'%s must be at least %s character%s in length.' %
(field, new_minimum, '' if maximum == 1 else 's'))
raise InputFilterError('%s may be at most %s character%s in length.' %
(field, maximum, '' if maximum == 1 else 's'))
def test_put(irods_config):
l = logging.getLogger(__name__)
l.info(irods.lib.get_header('Running Post-Install Test'))
if 0 != irods.lib.execute_command_permissive(
irods.paths.test_put_get_executable())[2]:
raise IrodsError(
'Post-install test failed. Please check your configuration.')
l.info('Success')
def check_hostname():
l = logging.getLogger(__name__)
hostname = irods.lib.get_hostname()
try:
hostname.index('.')
except ValueError:
l.warning('Warning: Hostname `%s` should be a fully qualified domain name.' % (hostname))
if not irods.lib.hostname_resolves_to_local_address(hostname):
raise IrodsError('The hostname (%s) must resolve to the local machine.' % (hostname))
def get_next_object_id():
if irods_config.database_config['catalog_database_type'] == 'postgres':
return irods.database_connect.execute_sql_statement(
cursor, "select nextval('R_OBJECTID');").fetchone()[0]
elif irods_config.database_config['catalog_database_type'] == 'mysql':
return irods.database_connect.execute_sql_statement(
cursor, "select R_OBJECTID_nextval();").fetchone()[0]
elif irods_config.database_config['catalog_database_type'] == 'oracle':
return irods.database_connect.execute_sql_statement(
cursor, "select R_OBJECTID.nextval from DUAL;").fetchone()[0]
else:
raise IrodsError(
'no next object id function defined for %s' %
irods_config.database_config['catalog_database_type'])
def test_put(irods_config):
l = logging.getLogger(__name__)
l.info(irods.lib.get_header('Attempting test put'))
test_text = 'This is a test file written by the iRODS installation script.'
with tempfile.NamedTemporaryFile(mode='wt', suffix=irods_config.server_config['default_resource_name']) as f:
print(test_text, file=f, end='')
f.flush()
l.info('Putting the test file into iRODS...')
irods.lib.execute_command(['iput', f.name])
test_file_name = os.path.basename(f.name)
l.info('Getting the test file from iRODS...')
if irods.lib.execute_command(['iget', test_file_name, '-'])[0] != test_text:
raise IrodsError('The text retrieved from iRODS did not match the text in the file put into iRODS')
l.info('Removing the test file from iRODS...')
irods.lib.execute_command(['irm', '-f', test_file_name])
l.info('Success.')
def setup_server(irods_config, json_configuration_file=None):
l = logging.getLogger(__name__)
check_hostname()
if json_configuration_file is not None:
with open(json_configuration_file) as f:
json_configuration_dict = json.load(f)
else:
json_configuration_dict = None
if IrodsController().get_binary_to_pids_dict():
l.info(irods.lib.get_header('Stopping iRODS...'))
IrodsController(irods_config).stop()
if not os.path.exists(irods_config.version_path):
with open('.'.join([irods_config.version_path, 'dist'])) as f:
version_json = json.load(f)
version_json['installation_time'] = datetime.datetime.now().isoformat()
irods_config.commit(version_json, irods.paths.version_path())
if json_configuration_dict is not None:
irods_user = json_configuration_dict['host_system_information']['service_account_user_name']
irods_group = json_configuration_dict['host_system_information']['service_account_group_name']
else:
irods_user, irods_group = get_irods_user_and_group(irods_config)
setup_service_account(irods_config, irods_user, irods_group)
#Do the rest of the setup as the irods user
if os.getuid() == 0:
irods.lib.switch_user(irods_config.irods_user, irods_config.irods_group)
if json_configuration_dict is not None:
irods_config.commit(json_configuration_dict['server_config'], irods.paths.server_config_path())
if irods_config.is_catalog:
from irods import database_interface
if database_interface.database_already_in_use_by_irods(irods_config):
raise IrodsError('Database specified already in use by iRODS.')
irods_config.commit(json_configuration_dict['hosts_config'], irods.paths.hosts_config_path())
irods_config.commit(json_configuration_dict['host_access_control_config'], irods.paths.host_access_control_config_path())
if not os.path.exists(os.path.dirname(irods_config.client_environment_path)):
os.makedirs(os.path.dirname(irods_config.client_environment_path), mode=0o700)
irods_config.commit(json_configuration_dict['service_account_environment'], irods_config.client_environment_path)
irods_config.admin_password = json_configuration_dict['admin_password']
default_resource_directory = json_configuration_dict.get('default_resource_directory', os.path.join(irods_config.irods_directory, 'Vault'))
else:
determine_server_role(irods_config)
if irods_config.is_catalog:
from irods import database_interface
l.info(irods.lib.get_header('Configuring the database communications'))
database_interface.setup_database_config(irods_config)
setup_server_config(irods_config)
setup_client_environment(irods_config)
default_resource_directory = get_and_create_default_vault(irods_config)
if irods_config.is_catalog:
l.info(irods.lib.get_header('Setting up the database'))
database_interface.setup_catalog(irods_config, default_resource_directory=default_resource_directory)
l.info(irods.lib.get_header('Starting iRODS...'))
IrodsController(irods_config).start()
if irods_config.is_resource:
irods.lib.execute_command(['iadmin', 'mkresc', irods_config.server_config['default_resource_name'], 'unixfilesystem', ':'.join([irods.lib.get_hostname(), default_resource_directory]), ''])
test_put(irods_config)
l.info(irods.lib.get_header('iRODS is installed and running'))
def setup_server(irods_config, json_configuration_file=None, test_mode=False):
l = logging.getLogger(__name__)
check_hostname()
if json_configuration_file is not None:
with open(json_configuration_file) as f:
json_configuration_dict = json.load(f)
else:
json_configuration_dict = None
if IrodsController().get_binary_to_pids_dict():
l.info(irods.lib.get_header('Stopping iRODS...'))
IrodsController(irods_config).stop()
if not os.path.exists(irods_config.version_path):
with open('.'.join([irods_config.version_path, 'dist'])) as f:
version_json = json.load(f)
version_json['installation_time'] = datetime.datetime.now().isoformat()
irods_config.commit(version_json, irods.paths.version_path())
if json_configuration_dict is not None:
irods_user = json_configuration_dict['host_system_information'][
'service_account_user_name']
irods_group = json_configuration_dict['host_system_information'][
'service_account_group_name']
else:
irods_user, irods_group = get_irods_user_and_group(irods_config)
setup_service_account(irods_config, irods_user, irods_group)
setup_rsyslog_and_logrotate(register_tty=False)
# Do the rest of the setup as the irods user
if os.getuid() == 0:
irods.lib.switch_user(irods_config.irods_user,
irods_config.irods_group)
if json_configuration_dict is not None:
irods_config.commit(json_configuration_dict['server_config'],
irods.paths.server_config_path())
if irods_config.is_catalog:
from irods import database_interface
if database_interface.database_already_in_use_by_irods(
irods_config):
raise IrodsError('Database specified already in use by iRODS.')
irods_config.commit(json_configuration_dict['hosts_config'],
irods.paths.hosts_config_path())
irods_config.commit(
json_configuration_dict['host_access_control_config'],
irods.paths.host_access_control_config_path())
if not os.path.exists(
os.path.dirname(irods_config.client_environment_path)):
os.makedirs(os.path.dirname(irods_config.client_environment_path),
mode=0o700)
irods_config.commit(
json_configuration_dict['service_account_environment'],
irods_config.client_environment_path)
irods_config.admin_password = json_configuration_dict['admin_password']
default_resource_directory = json_configuration_dict.get(
'default_resource_directory',
os.path.join(irods_config.irods_directory, 'Vault'))
else:
determine_server_role(irods_config)
if irods_config.is_catalog:
from irods import database_interface
l.info(
irods.lib.get_header(
'Configuring the database communications'))
database_interface.setup_database_config(irods_config)
setup_server_config(irods_config)
setup_client_environment(irods_config)
default_resource_directory = get_and_create_default_vault(irods_config)
if irods_config.is_catalog:
l.info(irods.lib.get_header('Setting up the database'))
database_interface.setup_catalog(
irods_config,
default_resource_directory=default_resource_directory)
l.info(irods.lib.get_header('Starting iRODS...'))
IrodsController(irods_config).start(test_mode=test_mode)
if irods_config.is_resource:
irods.lib.execute_command([
'iadmin', 'mkresc',
irods_config.server_config['default_resource_name'],
'unixfilesystem',
':'.join([irods.lib.get_hostname(),
default_resource_directory]), ''
])
test_put(irods_config)
l.info(irods.lib.get_header('Log Configuration Notes'))
l.info((
'The iRODS log file is managed by rsyslog and logrotate.\n'
'The locations of the log file and configuration files are listed below.\n\n'
' Log File Path : ' + irods.paths.server_log_path() +
'\n'
' Rsyslog Configuration Path : ' + rsyslog_config_path() + '\n'
' Logrotate Configuration Path: ' + logrotate_config_path() + '\n\n'
'iRODS will never touch these configuration files again.\n'
'If you need to make adjustments, you must do so manually.'))
l.info(irods.lib.get_header('Stopping iRODS...'))
IrodsController(irods_config).stop()
l.info(irods.lib.get_header('iRODS is configured and ready to be started'))
def create_database_tables(irods_config,
cursor=None,
default_resource_directory=None):
if cursor is None:
with contextlib.closing(
irods_config.get_database_connection()) as connection:
with contextlib.closing(connection.cursor()) as cursor:
create_database_tables(irods_config, cursor)
return
l = logging.getLogger(__name__)
irods_table_names = irods_config.irods_tables_in_database()
if irods_table_names:
l.info(
'The following tables already exist in the database, table creation will be skipped:\n%s',
pprint.pformat(irods_table_names))
else:
if irods_config.database_config['catalog_database_type'] == 'mysql':
l.info('Defining mysql functions...')
with tempfile.NamedTemporaryFile() as f:
f.write('\n'.join([
'[client]', '='.join([
'user', irods_config.database_config['db_username']
]), '='.join([
'password', irods_config.database_config['db_password']
]), '='.join(
['port',
str(irods_config.database_config['db_port'])]),
'='.join(['host', irods_config.database_config['db_host']])
]))
f.flush()
with open(
os.path.join(irods_config.irods_directory, 'server',
'icat', 'src', 'mysql_functions.sql'),
'r') as sql_file:
irods.lib.execute_command([
'mysql', '='.join(['--defaults-file', f.name]),
irods_config.database_config['db_name']
],
stdin=sql_file)
l.info('Creating database tables...')
sql_files = [
os.path.join(irods_config.irods_directory, 'server', 'icat', 'src',
'icatSysTables.sql'),
os.path.join(irods_config.irods_directory, 'server', 'icat', 'src',
'icatSysInserts.sql')
]
for sql_file in sql_files:
try:
irods.database_connect.execute_sql_file(sql_file,
cursor,
by_line=True)
except IrodsError:
six.reraise(
IrodsError,
IrodsError('Database setup failed while running %s' %
(sql_file)),
sys.exc_info()[2])
setup_database_values(
irods_config,
cursor,
default_resource_directory=default_resource_directory)
def setup_database_config(irods_config):
l = logging.getLogger(__name__)
l.info(get_header('Configuring the database communications'))
if os.path.exists(
os.path.join(irods_config.top_level_directory, 'plugins',
'database', 'libpostgres.so')):
db_type = 'postgres'
elif os.path.exists(
os.path.join(irods_config.top_level_directory, 'plugins',
'database', 'libmysql.so')):
db_type = 'mysql'
elif os.path.exists(
os.path.join(irods_config.top_level_directory, 'plugins',
'database', 'liboracle.so')):
db_type = 'oracle'
else:
raise IrodsError(
'Database type must be one of postgres, mysql, or oracle.')
l.debug('setup_database_config has been called with database type \'%s\'.',
db_type)
try:
db_config = copy.deepcopy(irods_config.database_config)
except (OSError, ValueError):
db_config = {}
try:
server_config = copy.deepcopy(irods_config.server_config)
except (OSError, ValueError):
server_config = {}
l.info('You are configuring an iRODS database plugin. '
'The iRODS server cannot be started until its database '
'has been properly configured.\n')
db_config['catalog_database_type'] = db_type
while True:
odbc_drivers = irods.database_connect.get_odbc_drivers_for_db_type(
db_config['catalog_database_type'])
if odbc_drivers:
db_config['db_odbc_driver'] = default_prompt(
'ODBC driver for %s',
db_config['catalog_database_type'],
default=odbc_drivers)
else:
db_config['db_odbc_driver'] = default_prompt(
'No default ODBC drivers configured for %s; falling back to bare library paths',
db_config['catalog_database_type'],
default=irods.database_connect.get_odbc_driver_paths(
db_config['catalog_database_type'],
oracle_home=os.getenv('ORACLE_HOME', None)))
db_config['db_host'] = default_prompt(
'Database server\'s hostname or IP address',
default=[db_config.get('db_host', 'localhost')])
db_config['db_port'] = default_prompt(
'Database server\'s port',
default=[db_config.get('db_port', 5432)],
input_filter=int_filter(field='Port'))
if db_config['catalog_database_type'] == 'oracle':
db_config['db_name'] = default_prompt(
'Service name',
default=[db_config.get('db_name', 'ICAT.example.org')])
else:
db_config['db_name'] = default_prompt(
'Database name', default=[db_config.get('db_name', 'ICAT')])
db_config['db_username'] = default_prompt(
'Database username',
default=[db_config.get('db_username', 'irods')])
confirmation_message = ''.join([
'\n', '-------------------------------------------\n',
'Database Type: %s\n', 'ODBC Driver: %s\n',
'Database Host: %s\n', 'Database Port: %d\n', 'Database Name: %s\n'
if db_config['catalog_database_type'] != 'oracle' else
'Service Name: %s\n', 'Database User: %s\n',
'-------------------------------------------\n\n', 'Please confirm'
]) % (db_config['catalog_database_type'], db_config['db_odbc_driver'],
db_config['db_host'], db_config['db_port'], db_config['db_name'],
db_config['db_username'])
if default_prompt(confirmation_message,
default=['yes']) in ['', 'y', 'Y', 'yes', 'YES']:
break
db_config['db_password'] = prompt('Database password', echo=False)
irods_config.commit(db_config, irods_config.database_config_path)
if irods_config.irods_tables_in_database():
l.warning(
get_header('WARNING:\n'
'The database specified is an already-configured\n'
'iRODS database, so first-time database setup will\n'
'not be performed. Providing different inputs from\n'
'those provided the first time this script was run\n'
'will result in unspecified behavior, and may put\n'
'a previously working zone in a broken state. It\'s\n'
'recommended that you exit this script now if you\n'
'are running it manually. If you wish to wipe out\n'
'your current iRODS installation and associated data\n'
'catalog, drop the database and recreate it before\n'
're-running this script.'))
db_password_salt = prompt('Salt for passwords stored in the database',
echo=False)
if db_password_salt:
if 'environment_variables' not in server_config:
server_config['environment_variables'] = {}
server_config['environment_variables'][
'IRODS_DATABASE_USER_PASSWORD_SALT'] = db_password_salt
irods_config.commit(server_config, irods_config.server_config_path)
