def __init__(self):
super(JDKSetupLinux, self).__init__()
self.JDK_DEFAULT_CONFIGS = [
JDKRelease("jdk1.8", "Oracle JDK 1.8 + Java Cryptography Extension (JCE) Policy Files 8",
"http://public-repo-1.hortonworks.com/ARTIFACTS/jdk-8u112-linux-x64.tar.gz", "jdk-8u112-linux-x64.tar.gz",
"http://public-repo-1.hortonworks.com/ARTIFACTS/jce_policy-8.zip", "jce_policy-8.zip",
AmbariPath.get("/usr/jdk64/jdk1.8.0_112"),
"(jdk.*)/jre")
]
self.jdks = self.JDK_DEFAULT_CONFIGS
self.custom_jdk_number = len(self.jdks)
self.JAVA_BIN = "java"
self.CREATE_JDK_DIR_CMD = "/bin/mkdir -p {0}"
self.CHMOD_JDK_DIR_CMD = "chmod a+x {0}"
self.SET_JCE_PERMISSIONS = "chown {0} {1}/{2}/*"
self.SET_JCE_JAR_MODE = "chmod 664 {0}/{1}/{2}"
self.SET_JCE_FILE_MODE = "chmod 644 {0}/{1}/{2}"
# use --no-same-owner when running as root to prevent uucp as the user (AMBARI-6478)
self.UNTAR_JDK_ARCHIVE = "tar --no-same-owner -xvf {0}"
SERVER_PING_ATTEMPTS_WINDOWS = 4
SERVER_SEARCH_PATTERN = "org.apache.ambari.server.controller.AmbariServer"
EXITCODE_NAME = "ambari-server.exitcode"
CHECK_DATABASE_SKIPPED_PROPERTY = "check_database_skipped"
AMBARI_SERVER_DIE_MSG = "Ambari Server java process died with exitcode {0}. Check {1} for more information."
AMBARI_SERVER_NOT_STARTED_MSG = "Ambari Server java process hasn't been started or can't be determined."
# linux open-file limit
ULIMIT_OPEN_FILES_KEY = 'ulimit.open.files'
ULIMIT_OPEN_FILES_DEFAULT = 10000
AMBARI_ENV_FILE = AmbariPath.get("/var/lib/ambari-server/ambari-env.sh")
@OsFamilyFuncImpl(OSConst.WINSRV_FAMILY)
def ensure_server_security_is_configured():
pass
@OsFamilyFuncImpl(OsFamilyImpl.DEFAULT)
def ensure_server_security_is_configured():
if not is_root():
print "Unable to check firewall status when starting without root privileges."
print "Please do not forget to disable or adjust firewall if needed"
def get_ulimit_open_files(properties):
class PGConfig(LinuxDBMSConfig):
# PostgreSQL settings
SETUP_DB_CMD = [AMBARI_SUDO_BINARY, 'su', 'postgres', '-',
'--command=psql -f {0} -v username=\'"{1}"\' -v password="******" -v dbname="{3}"']
UPGRADE_STACK_CMD = [AMBARI_SUDO_BINARY, 'su', 'postgres',
'--command=psql -f {0} -v stack_name="\'{1}\'" -v stack_version="\'{2}\'" -v dbname="{3}"']
CHANGE_OWNER_COMMAND = [AMBARI_SUDO_BINARY, 'su', 'postgres', '-',
'--command=' + AmbariPath.get("/var/lib/ambari-server/resources/scripts/change_owner.sh") + ' -d {0} -s {1} -o {2}']
PG_ERROR_BLOCKED = "is being accessed by other users"
PG_STATUS_RUNNING = None
SERVICE_CMD = "/usr/bin/env service"
PG_SERVICE_NAME = "postgresql"
PG_HBA_DIR = None
PG_ST_CMD = "%s %s status" % (SERVICE_CMD, PG_SERVICE_NAME)
if os.path.isfile("/usr/bin/postgresql-setup"):
PG_INITDB_CMD = "/usr/bin/postgresql-setup initdb"
else:
PG_INITDB_CMD = "%s %s initdb" % (SERVICE_CMD, PG_SERVICE_NAME)
PG_START_CMD = "%s %s start" % (SERVICE_CMD, PG_SERVICE_NAME)
PG_RESTART_CMD = "%s %s restart" % (SERVICE_CMD, PG_SERVICE_NAME)
PG_HBA_RELOAD_CMD = AMBARI_SUDO_BINARY + " su postgres -l -c '%s %s reload'" % (SERVICE_CMD, PG_SERVICE_NAME)
PG_HBA_CONF_FILE = None
PG_HBA_CONF_FILE_BACKUP = None
POSTGRESQL_CONF_FILE = None
POSTGRES_EMBEDDED_INIT_FILE = AmbariPath.get("/var/lib/ambari-server/resources/Ambari-DDL-Postgres-EMBEDDED-CREATE.sql")
POSTGRES_EMBEDDED_DROP_FILE = AmbariPath.get("/var/lib/ambari-server/resources/Ambari-DDL-Postgres-EMBEDDED-DROP.sql")
POSTGRES_INIT_FILE = AmbariPath.get("/var/lib/ambari-server/resources/Ambari-DDL-Postgres-CREATE.sql")
POSTGRES_DROP_FILE = AmbariPath.get("/var/lib/ambari-server/resources/Ambari-DDL-Postgres-DROP.sql")
def __init__(self, options, properties, storage_type):
super(PGConfig, self).__init__(options, properties, storage_type)
#Init the database configuration data here, if any
self.dbms = "postgres"
self.dbms_full_name = "PostgreSQL"
self.driver_class_name = "org.postgresql.Driver"
self.driver_file_name = "postgresql-jdbc.jar"
self.database_storage_name = "Database"
# PostgreSQL seems to require additional schema coordinates
self.postgres_schema = DBMSConfig._init_member_with_prop_default(options, "postgres_schema",
properties, JDBC_POSTGRES_SCHEMA_PROPERTY, self.database_name)
self.database_port = DBMSConfig._init_member_with_prop_default(options, "database_port",
properties, JDBC_PORT_PROPERTY, "5432")
self.database_url_pattern = "jdbc:postgresql://{0}:{1}/{2}"
self.database_url_pattern_alt = "jdbc:postgresql://{0}:{1}/{2}"
self.JDBC_DRIVER_INSTALL_MSG = 'Before starting Ambari Server, ' \
'you must copy the {0} JDBC driver JAR file to {1}.'.format(
self.dbms_full_name, configDefaults.JAVA_SHARE_PATH)
self._is_user_changed = False
if self.persistence_type == STORAGE_TYPE_LOCAL:
PGConfig.PG_STATUS_RUNNING = get_postgre_running_status()
PGConfig.PG_HBA_DIR = get_postgre_hba_dir(OS_FAMILY)
PGConfig.PG_HBA_CONF_FILE = os.path.join(PGConfig.PG_HBA_DIR, "pg_hba.conf")
PGConfig.PG_HBA_CONF_FILE_BACKUP = os.path.join(PGConfig.PG_HBA_DIR, "pg_hba_bak.conf.old")
PGConfig.POSTGRESQL_CONF_FILE = os.path.join(PGConfig.PG_HBA_DIR, "postgresql.conf")
postgres_init_file_default = PGConfig.POSTGRES_EMBEDDED_INIT_FILE
postgres_drop_file_default = PGConfig.POSTGRES_EMBEDDED_DROP_FILE
else:
postgres_init_file_default = PGConfig.POSTGRES_INIT_FILE
postgres_drop_file_default = PGConfig.POSTGRES_DROP_FILE
self.init_script_file = DBMSConfig._init_member_with_default(options, "init_script_file",
postgres_init_file_default)
self.drop_tables_script_file = DBMSConfig._init_member_with_default(options, "drop_script_file",
postgres_drop_file_default)
self.client_tool_usage_pattern = 'su -postgres --command=psql -f {0} -v username=\'"{1}"\' -v password="******"'
#
# Public methods
#
def ensure_dbms_is_running(self, options, properties, scmStatus=None):
if self._is_local_database():
if is_root():
(pg_status, retcode, out, err) = PGConfig._check_postgre_up()
if not retcode == 0:
err = 'Unable to start PostgreSQL server. Status {0}. {1}. Exiting'.format(pg_status, err)
raise FatalException(retcode, err)
else:
print "Unable to check PostgreSQL server status when starting " \
"without root privileges."
print "Please do not forget to start PostgreSQL server."
#
# Private implementation
#
# Supporting remote server for all the DB types. Supporting local server only for PostgreSQL.
def _setup_local_server(self, properties):
# check if jdbc user is changed
self._is_user_changed = PGConfig._is_jdbc_user_changed(self.database_username)
print 'Default properties detected. Using built-in database.'
self._store_local_properties(properties)
def _create_postgres_lock_directory(self):
postgres_user_uid = None
try:
postgres_user_uid = pwd.getpwnam("postgres").pw_uid
except KeyError:
print "WARNING: Unable to create /var/run/postgresql directory, because user [postgres] doesn't exist. Potentially," \
" postgresql service start can be failed."
return
try:
if not os.path.isdir("/var/run/postgresql"):
os.mkdir("/var/run/postgresql")
except Exception as e:
print "WARNING: Unable to create /var/run/postgresql directory. Potentially," \
" postgresql service start can be failed."
print "Unexpected error: " + str(e)
return
if postgres_user_uid:
os.chown("/var/run/postgresql", postgres_user_uid, -1)
def _setup_local_database(self):
print 'Checking PostgreSQL...'
(pg_status, retcode, out, err) = PGConfig._check_postgre_up()
if not retcode == 0:
err = 'Unable to start PostgreSQL server. Exiting'
raise FatalException(retcode, err)
print 'Configuring local database...'
retcode, out, err = self._setup_db()
if not retcode == 0:
err = 'Running database init script failed. Exiting.'
raise FatalException(retcode, err)
if self._is_user_changed:
#remove backup for pg_hba in order to reconfigure postgres
remove_file(PGConfig.PG_HBA_CONF_FILE_BACKUP)
print 'Configuring PostgreSQL...'
retcode, out, err = self._configure_postgres()
if not retcode == 0:
err = 'Unable to configure PostgreSQL server. Exiting'
raise FatalException(retcode, err)
def _reset_local_database(self):
#force reset if silent option provided
if get_silent():
default = "yes"
else:
default = "no"
# Run automatic reset only for embedded DB
okToRun = get_YN_input("Confirm server reset [yes/no]({0})? ".format(default), get_silent())
if not okToRun:
err = "Ambari Server 'reset' cancelled"
raise FatalException(1, err)
print "Resetting the Server database..."
dbname = self.database_name
filename = self.drop_tables_script_file
username = self.database_username
password = self.database_password
command = PGConfig.SETUP_DB_CMD[:]
command[-1] = command[-1].format(filename, username, password, dbname)
drop_retcode, drop_outdata, drop_errdata = run_os_command(command)
if not drop_retcode == 0:
raise FatalException(1, drop_errdata)
if drop_errdata and PGConfig.PG_ERROR_BLOCKED in drop_errdata:
raise FatalException(1, "Database is in use. Please, make sure all connections to the database are closed")
if drop_errdata and get_verbose():
print_warning_msg(drop_errdata)
print_info_msg("About to run database setup")
retcode, outdata, errdata = self._setup_db()
if errdata and get_verbose():
print_warning_msg(errdata)
if (errdata and 'ERROR' in errdata.upper()) or (drop_errdata and 'ERROR' in drop_errdata.upper()):
err = "Non critical error in DDL"
if not get_verbose():
err += ", use --verbose for more information"
raise NonFatalException(err)
def _reset_remote_database(self):
super(PGConfig, self)._reset_remote_database()
raise NonFatalException("Please set DB password to PGPASSWORD env variable before running DDL`s!")
def _is_jdbc_driver_installed(self, properties):
return 0
def _configure_database_name(self):
self.database_name = LinuxDBMSConfig._get_validated_db_name(self.database_storage_name, self.database_name)
self.postgres_schema = PGConfig._get_validated_db_schema(self.postgres_schema)
return True
def _get_remote_script_line(self, scriptFile):
os.environ["PGPASSWORD"] = self.database_password
return "psql -h {0} -p {1} -d {2} -U {3} -f {4} -v username='******'".format(
self.database_host,
self.database_port,
self.database_name,
self.database_username,
scriptFile
)
@staticmethod
def _get_validated_db_schema(postgres_schema):
return get_validated_string_input(
"Postgres schema (" + postgres_schema + "): ",
postgres_schema,
"^[a-zA-Z0-9_\-]*$",
"Invalid schema name.",
False, allowEmpty=True
)
# Check if jdbc user is changed
@staticmethod
def _is_jdbc_user_changed(database_username):
properties = get_ambari_properties()
if properties == -1:
print_error_msg("Error getting ambari properties")
return None
previos_user = get_value_from_properties(properties, JDBC_USER_NAME_PROPERTY, "")
if previos_user and database_username:
if previos_user != database_username:
return True
else:
return False
return None
# Store local database connection properties
def _store_local_properties(self, properties):
properties.removeOldProp(JDBC_DATABASE_PROPERTY)
properties.removeOldProp(JDBC_DATABASE_NAME_PROPERTY)
properties.removeOldProp(JDBC_POSTGRES_SCHEMA_PROPERTY)
properties.removeOldProp(JDBC_HOSTNAME_PROPERTY)
properties.removeOldProp(JDBC_RCA_DRIVER_PROPERTY)
properties.removeOldProp(JDBC_RCA_URL_PROPERTY)
properties.removeOldProp(JDBC_PORT_PROPERTY)
properties.removeOldProp(JDBC_DRIVER_PROPERTY)
properties.removeOldProp(JDBC_URL_PROPERTY)
# Store the properties
properties.process_pair(PERSISTENCE_TYPE_PROPERTY, self.persistence_type)
properties.process_pair(JDBC_DATABASE_PROPERTY, self.dbms)
properties.process_pair(JDBC_DATABASE_NAME_PROPERTY, self.database_name)
properties.process_pair(JDBC_POSTGRES_SCHEMA_PROPERTY, self.postgres_schema)
properties.process_pair(JDBC_USER_NAME_PROPERTY, self.database_username)
# connection pooling (internal JPA by default)
properties.process_pair(JDBC_CONNECTION_POOL_TYPE, "internal")
self._store_password_property(properties, JDBC_PASSWORD_PROPERTY)
@staticmethod
def _get_postgre_status():
retcode, out, err = run_os_command(PGConfig.PG_ST_CMD)
# on RHEL and SUSE PG_ST_COMD returns RC 0 for running and 3 for stoppped
if retcode == 0:
pg_status = PGConfig.PG_STATUS_RUNNING
else:
if retcode == 3:
pg_status = "stopped"
else:
pg_status = None
return pg_status, retcode, out, err
@staticmethod
def _check_postgre_up():
pg_status, retcode, out, err = PGConfig._get_postgre_status()
if pg_status == PGConfig.PG_STATUS_RUNNING:
print_info_msg("PostgreSQL is running")
return pg_status, 0, out, err
else:
# run initdb only on non ubuntu systems as ubuntu does not have initdb cmd.
if not OSCheck.is_ubuntu_family():
print "Running initdb: This may take up to a minute."
retcode, out, err = run_os_command(PGConfig.PG_INITDB_CMD)
if retcode == 0:
print out
print "About to start PostgreSQL"
try:
process = subprocess.Popen(PGConfig.PG_START_CMD.split(' '),
stdout=subprocess.PIPE,
stdin=subprocess.PIPE,
stderr=subprocess.PIPE
)
if OSCheck.is_suse_family():
time.sleep(20)
result = process.poll()
print_info_msg("Result of postgres start cmd: " + str(result))
if result is None:
process.kill()
pg_status, retcode, out, err = PGConfig._get_postgre_status()
else:
retcode = result
else:
out, err = process.communicate()
retcode = process.returncode
pg_status, retcode, out, err = PGConfig._get_postgre_status()
if pg_status == PGConfig.PG_STATUS_RUNNING:
print_info_msg("Postgres process is running. Returning...")
return pg_status, 0, out, err
except (Exception), e:
pg_status, retcode, out, err = PGConfig._get_postgre_status()
if pg_status == PGConfig.PG_STATUS_RUNNING:
return pg_status, 0, out, err
else:
print_error_msg("Postgres start failed. " + str(e))
return pg_status, retcode, out, err
def init_parser_options(parser):
parser.add_option('-f', '--init-script-file', default=None,
help="File with setup script")
parser.add_option('-r', '--drop-script-file', default=None,
help="File with drop script")
parser.add_option('-u', '--upgrade-script-file', default=AmbariPath.get("/var/lib/"
"ambari-server/resources/upgrade/ddl/"
"Ambari-DDL-Postgres-UPGRADE-1.3.0.sql"),
help="File with upgrade script")
parser.add_option('-t', '--upgrade-stack-script-file', default=AmbariPath.get("/var/lib/"
"ambari-server/resources/upgrade/dml/"
"Ambari-DML-Postgres-UPGRADE_STACK.sql"),
help="File with stack upgrade script")
parser.add_option('-j', '--java-home', default=None,
help="Use specified java_home. Must be valid on all hosts")
parser.add_option("-v", "--verbose",
action="store_true", dest="verbose", default=False,
help="Print verbose status messages")
parser.add_option("-s", "--silent",
action="store_true", dest="silent", default=False,
help="Silently accepts default prompt values")
parser.add_option('-g', '--debug', action="store_true", dest='debug', default=False,
help="Start ambari-server in debug mode")
parser.add_option('-y', '--suspend-start', action="store_true", dest='suspend_start', default=False,
help="Freeze ambari-server Java process at startup in debug mode")
parser.add_option('--all', action="store_true", default=False, help="LDAP sync all option. Synchronize all LDAP users and groups.",
dest="ldap_sync_all")
parser.add_option('--existing', action="store_true", default=False,
help="LDAP sync existing option. Synchronize existing Ambari users and groups only.", dest="ldap_sync_existing")
parser.add_option('--users', default=None, help="LDAP sync users option. Specifies the path to a CSV file of user names to be synchronized.",
dest="ldap_sync_users")
parser.add_option('--groups', default=None, help="LDAP sync groups option. Specifies the path to a CSV file of group names to be synchronized.",
dest="ldap_sync_groups")
parser.add_option('--database', default=None, help="Database to use embedded|oracle|mysql|mssql|postgres|sqlanywhere", dest="dbms")
parser.add_option('--databasehost', default=None, help="Hostname of database server", dest="database_host")
parser.add_option('--databaseport', default=None, help="Database port", dest="database_port")
parser.add_option('--databasename', default=None, help="Database/Service name or ServiceID",
dest="database_name")
parser.add_option('--postgresschema', default=None, help="Postgres database schema name",
dest="postgres_schema")
parser.add_option('--databaseusername', default=None, help="Database user login", dest="database_username")
parser.add_option('--databasepassword', default=None, help="Database user password", dest="database_password")
parser.add_option('--sidorsname', default="sname", help="Oracle database identifier type, Service ID/Service "
"Name sid|sname", dest="sid_or_sname")
parser.add_option('--sqla-server-name', default=None, help="SQL Anywhere server name", dest="sqla_server_name")
parser.add_option('--jdbc-driver', default=None, help="Specifies the path to the JDBC driver JAR file or archive " \
"with all required files(jdbc jar, libraries and etc), for the " \
"database type specified with the --jdbc-db option. " \
"Used only with --jdbc-db option. Archive is supported only for" \
" sqlanywhere database." ,
dest="jdbc_driver")
parser.add_option('--jdbc-db', default=None, help="Specifies the database type [postgres|mysql|mssql|oracle|hsqldb|sqlanywhere] for the " \
"JDBC driver specified with the --jdbc-driver option. Used only with --jdbc-driver option.",
dest="jdbc_db")
parser.add_option('--cluster-name', default=None, help="Cluster name", dest="cluster_name")
parser.add_option('--version-display-name', default=None, help="Display name of desired repo version", dest="desired_repo_version")
parser.add_option('--skip-properties-validation', action="store_true", default=False, help="Skip properties file validation", dest="skip_properties_validation")
parser.add_option('--skip-database-check', action="store_true", default=False, help="Skip database consistency check", dest="skip_database_check")
parser.add_option('--force-version', action="store_true", default=False, help="Force version to current", dest="force_repo_version")
parser.add_option('--version', dest="stack_versions", default=None, action="append", type="string",
help="Specify stack version that needs to be enabled. All other stacks versions will be disabled")
parser.add_option('--stack', dest="stack_name", default=None, type="string",
help="Specify stack name for the stack versions that needs to be enabled")
parser.add_option("-d", "--from-date", dest="cleanup_from_date", default=None, type="string", help="Specify date for the cleanup process in 'yyyy-MM-dd' format")
parser.add_option('--mpack', default=None,
help="Specified the path for management pack to be installed/upgraded",
dest="mpack_path")
parser.add_option('--purge', action="store_true", default=False,
help="Purge existing resources specified in purge-list",
dest="purge")
purge_resources = ",".join([STACK_DEFINITIONS_RESOURCE_NAME, SERVICE_DEFINITIONS_RESOURCE_NAME, MPACKS_RESOURCE_NAME])
default_purge_resources = ",".join([STACK_DEFINITIONS_RESOURCE_NAME, MPACKS_RESOURCE_NAME])
parser.add_option('--purge-list', default=default_purge_resources,
help="Comma separated list of resources to purge ({0}). By default ({1}) will be purged.".format(purge_resources, default_purge_resources),
dest="purge_list")
parser.add_option('--force', action="store_true", default=False, help="Force install management pack", dest="force")
parser.add_option('--ldap-url', default=None, help="Primary url for LDAP", dest="ldap_url")
parser.add_option('--ldap-secondary-url', default=None, help="Secondary url for LDAP", dest="ldap_secondary_url")
parser.add_option('--ldap-ssl', default=None, help="Use SSL [true/false] for LDAP", dest="ldap_ssl")
parser.add_option('--ldap-user-class', default=None, help="User Attribute Object Class for LDAP", dest="ldap_user_class")
parser.add_option('--ldap-user-attr', default=None, help="User Attribute Name for LDAP", dest="ldap_user_attr")
parser.add_option('--ldap-group-class', default=None, help="Group Attribute Object Class for LDAP", dest="ldap_group_class")
parser.add_option('--ldap-group-attr', default=None, help="Group Attribute Name for LDAP", dest="ldap_group_attr")
parser.add_option('--ldap-member-attr', default=None, help="Group Membership Attribute Name for LDAP", dest="ldap_member_attr")
parser.add_option('--ldap-dn', default=None, help="Distinguished name attribute for LDAP", dest="ldap_dn")
parser.add_option('--ldap-base-dn', default=None, help="Base DN for LDAP", dest="ldap_base_dn")
parser.add_option('--ldap-manager-dn', default=None, help="Manager DN for LDAP", dest="ldap_manager_dn")
parser.add_option('--ldap-manager-password', default=None, help="Manager Password For LDAP", dest="ldap_manager_password")
parser.add_option('--ldap-save-settings', action="store_true", default=None, help="Save without review for LDAP", dest="ldap_save_settings")
parser.add_option('--ldap-referral', default=None, help="Referral method [follow/ignore] for LDAP", dest="ldap_referral")
parser.add_option('--ldap-bind-anonym', default=None, help="Bind anonymously [true/false] for LDAP", dest="ldap_bind_anonym")
parser.add_option('--ldap-sync-admin-name', default=None, help="Username for LDAP sync", dest="ldap_sync_admin_name")
parser.add_option('--ldap-sync-admin-password', default=None, help="Password for LDAP sync", dest="ldap_sync_admin_password")
parser.add_option('--truststore-type', default=None, help="Type of TrustStore (jks|jceks|pkcs12)", dest="trust_store_type")
parser.add_option('--truststore-path', default=None, help="Path of TrustStore", dest="trust_store_path")
parser.add_option('--truststore-password', default=None, help="Password for TrustStore", dest="trust_store_password")
parser.add_option('--truststore-reconfigure', action="store_true", default=None, help="Force to reconfigure TrustStore if exits", dest="trust_store_reconfigure")
parser.add_option('--security-option', default=None,
help="Setup security option (setup-https|encrypt-password|setup-kerberos-jaas|setup-truststore|import-certificate)",
dest="security_option")
parser.add_option('--api-ssl', default=None, help="Enable SSL for Ambari API [true/false]", dest="api_ssl")
parser.add_option('--api-ssl-port', default=None, help="Client API SSL port", dest="api_ssl_port")
parser.add_option('--import-cert-path', default=None, help="Path to Certificate (import)", dest="import_cert_path")
parser.add_option('--import-cert-alias', default=None, help="Alias for the imported certificate", dest="import_cert_alias")
parser.add_option('--import-key-path', default=None, help="Path to Private Key (import)", dest="import_key_path")
parser.add_option('--pem-password', default=None, help="Password for Private Key", dest="pem_password")
parser.add_option('--master-key', default=None, help="Master key for encrypting passwords", dest="master_key")
parser.add_option('--master-key-persist', default=None, help="Persist master key [true/false]", dest="master_key_persist")
parser.add_option('--jaas-principal', default=None, help="Kerberos principal for ambari server", dest="jaas_principal")
parser.add_option('--jaas-keytab', default=None, help="Keytab path for Kerberos principal", dest="jaas_keytab")
def __init__(self, options):
super(AmbariUserChecksLinux, self).__init__()
self.NR_USER_CHANGE_PROMPT = "Ambari-server daemon is configured to run under user '{0}'. Change this setting [y/n] ({1})? "
self.NR_USER_CUSTOMIZE_PROMPT = "Customize user account for ambari-server daemon [y/n] ({0})? "
self.NR_DEFAULT_USER = getpass.getuser()
self.NR_USERADD_CMD = 'useradd -M --comment "{1}" ' \
'--shell %s ' % locate_file('nologin', '/sbin') + '-d ' + AmbariPath.get('/var/lib/ambari-server/keys/') + ' {0}'
limitations under the License.
'''
import sys
import zipfile
import os
from ambari_server.ambariPath import AmbariPath
# Default values are hardcoded here
BACKUP_PROCESS = 'backup'
RESTORE_PROCESS = 'restore'
SUPPORTED_PROCESSES = [BACKUP_PROCESS, RESTORE_PROCESS]
# The list of files where the ambari server state is kept on the filesystem
AMBARI_FILESYSTEM_STATE = [
AmbariPath.get("/etc/ambari-server/conf"),
AmbariPath.get("/var/lib/ambari-server/resources"),
AmbariPath.get("/var/run/ambari-server/bootstrap/"),
AmbariPath.get("/var/run/ambari-server/stack-recommendations")
]
# What to use when no path/archive is specified
DEFAULT_ARCHIVE = AmbariPath.get(
"/var/lib/ambari-server/Ambari_State_Backup.zip")
# Responsible for managing the Backup/Restore process
class BackupRestore:
def __init__(self, state_file_list, zipname, zip_folder_path):
"""
Zip file creator
def init_parser_options(parser):
parser.add_option('-f',
'--init-script-file',
default=AmbariPath.get(
'/var/lib/ambari-server/'
'resources/Ambari-DDL-Postgres-EMBEDDED-CREATE.sql'),
help="File with setup script")
parser.add_option('-r',
'--drop-script-file',
default=AmbariPath.get(
"/var/lib/"
"ambari-server/resources/"
"Ambari-DDL-Postgres-EMBEDDED-DROP.sql"),
help="File with drop script")
parser.add_option('-u',
'--upgrade-script-file',
default=AmbariPath.get(
"/var/lib/"
"ambari-server/resources/upgrade/ddl/"
"Ambari-DDL-Postgres-UPGRADE-1.3.0.sql"),
help="File with upgrade script")
parser.add_option('-t',
'--upgrade-stack-script-file',
default=AmbariPath.get(
"/var/lib/"
"ambari-server/resources/upgrade/dml/"
"Ambari-DML-Postgres-UPGRADE_STACK.sql"),
help="File with stack upgrade script")
parser.add_option(
'-j',
'--java-home',
default=None,
help="Use specified java_home. Must be valid on all hosts")
parser.add_option("-v",
"--verbose",
action="store_true",
dest="verbose",
default=False,
help="Print verbose status messages")
parser.add_option("-s",
"--silent",
action="store_true",
dest="silent",
default=False,
help="Silently accepts default prompt values")
parser.add_option('-g',
'--debug',
action="store_true",
dest='debug',
default=False,
help="Start ambari-server in debug mode")
parser.add_option(
'-y',
'--suspend-start',
action="store_true",
dest='suspend_start',
default=False,
help="Freeze ambari-server Java process at startup in debug mode")
parser.add_option(
'--all',
action="store_true",
default=False,
help="LDAP sync all option. Synchronize all LDAP users and groups.",
dest="ldap_sync_all")
parser.add_option(
'--existing',
action="store_true",
default=False,
help=
"LDAP sync existing option. Synchronize existing Ambari users and groups only.",
dest="ldap_sync_existing")
parser.add_option(
'--users',
default=None,
help=
"LDAP sync users option. Specifies the path to a CSV file of user names to be synchronized.",
dest="ldap_sync_users")
parser.add_option(
'--groups',
default=None,
help=
"LDAP sync groups option. Specifies the path to a CSV file of group names to be synchronized.",
dest="ldap_sync_groups")
parser.add_option(
'--database',
default=None,
help="Database to use embedded|oracle|mysql|mssql|postgres|sqlanywhere",
dest="dbms")
parser.add_option('--databasehost',
default=None,
help="Hostname of database server",
dest="database_host")
parser.add_option('--databaseport',
default=None,
help="Database port",
dest="database_port")
parser.add_option('--databasename',
default=None,
help="Database/Service name or ServiceID",
dest="database_name")
parser.add_option('--postgresschema',
default=None,
help="Postgres database schema name",
dest="postgres_schema")
parser.add_option('--databaseusername',
default=None,
help="Database user login",
dest="database_username")
parser.add_option('--databasepassword',
default=None,
help="Database user password",
dest="database_password")
parser.add_option(
'--sidorsname',
default="sname",
help="Oracle database identifier type, Service ID/Service "
"Name sid|sname",
dest="sid_or_sname")
parser.add_option('--sqla-server-name',
default=None,
help="SQL Anywhere server name",
dest="sqla_server_name")
parser.add_option('--jdbc-driver', default=None, help="Specifies the path to the JDBC driver JAR file or archive " \
"with all required files(jdbc jar, libraries and etc), for the " \
"database type specified with the --jdbc-db option. " \
"Used only with --jdbc-db option. Archive is supported only for" \
" sqlanywhere database." ,
dest="jdbc_driver")
parser.add_option('--jdbc-db', default=None, help="Specifies the database type [postgres|mysql|mssql|oracle|hsqldb|sqlanywhere] for the " \
"JDBC driver specified with the --jdbc-driver option. Used only with --jdbc-driver option.",
dest="jdbc_db")
parser.add_option('--cluster-name',
default=None,
help="Cluster name",
dest="cluster_name")
parser.add_option('--version-display-name',
default=None,
help="Display name of desired repo version",
dest="desired_repo_version")
parser.add_option('--skip-properties-validation',
action="store_true",
default=False,
help="Skip properties file validation",
dest="skip_properties_validation")
parser.add_option('--skip-database-validation',
action="store_true",
default=False,
help="Skip database consistency validation",
dest="skip_database_validation")
parser.add_option('--force-version',
action="store_true",
default=False,
help="Force version to current",
dest="force_repo_version")
parser.add_option(
'--version',
dest="stack_versions",
default=None,
action="append",
type="string",
help=
"Specify stack version that needs to be enabled. All other stacks versions will be disabled"
)
parser.add_option(
'--stack',
dest="stack_name",
default=None,
type="string",
help=
"Specify stack name for the stack versions that needs to be enabled")
