def ensure_jdbc_driver_installed(self, properties):
(result, msg) = self._prompt_jdbc_driver_install(properties)
if result == -1:
print_error_msg(msg)
raise FatalException(-1, msg)
if result != 1:
result = self._install_jdbc_driver(properties, result)
return cbool(result)
def ensure_jdbc_driver_installed(self, properties):
(result, msg) = self._prompt_jdbc_driver_install(properties)
if result == -1:
print_error_msg(msg)
raise FatalException(-1, msg)
if result != 1:
result = self._install_jdbc_driver(properties, result)
return cbool(result)
def install_packages(self, package_list):
"""
Actually install the packages using the package manager.
:param package_list: List of package names to install
:return: Returns 0 if no errors were found, and 1 otherwise.
"""
ret_code = 0
config = self.get_config()
agent_stack_retry_on_unavailability = cbool(config['hostLevelParams']['agent_stack_retry_on_unavailability'])
agent_stack_retry_count = cint(config['hostLevelParams']['agent_stack_retry_count'])
# Install packages
packages_were_checked = False
stack_selector_package = stack_tools.get_stack_tool_package(stack_tools.STACK_SELECTOR_NAME)
try:
Package(stack_selector_package,
action="upgrade",
retry_on_repo_unavailability=agent_stack_retry_on_unavailability,
retry_count=agent_stack_retry_count
)
packages_installed_before = []
allInstalledPackages(packages_installed_before)
packages_installed_before = [package[0] for package in packages_installed_before]
packages_were_checked = True
filtered_package_list = self.filter_package_list(package_list)
for package in filtered_package_list:
name = self.format_package_name(package['name'])
Package(name,
action="upgrade", # this enables upgrading non-versioned packages, despite the fact they exist. Needed by 'mahout' which is non-version but have to be updated
retry_on_repo_unavailability=agent_stack_retry_on_unavailability,
retry_count=agent_stack_retry_count
)
except Exception, err:
ret_code = 1
Logger.logger.exception("Package Manager failed to install packages. Error: {0}".format(str(err)))
# Remove already installed packages in case of fail
if packages_were_checked and packages_installed_before:
packages_installed_after = []
allInstalledPackages(packages_installed_after)
packages_installed_after = [package[0] for package in packages_installed_after]
packages_installed_before = set(packages_installed_before)
new_packages_installed = [package for package in packages_installed_after if package not in packages_installed_before]
if OSCheck.is_ubuntu_family():
package_version_string = self.repository_version.replace('.', '-')
else:
package_version_string = self.repository_version.replace('-', '_')
package_version_string = package_version_string.replace('.', '_')
for package in new_packages_installed:
if package_version_string and (package_version_string in package):
Package(package, action="remove")
def __init__(self, options, properties, storage_type):
super(SQLServerConfig, self).__init__(options, properties,
storage_type)
"""
#Just load the defaults. The derived classes will be able to modify them later
"""
self.dbms = DATABASE_DBMS_SQLSERVER
self.driver_class_name = DATABASE_DRIVER_NAME_SQLSERVER
self.JDBC_DRIVER_INSTALL_MSG = 'Before starting Ambari Server, you must install the SQL Server JDBC driver.'
# The values from options supersede the values from properties
self.database_host = DBMSConfig._init_member_with_prop_default(
options, "database_host", properties, self.dbPropKeys.server_key,
"")
try:
if not self.database_host:
self.database_host = options.default_database_host
else:
self.database_host = compress_backslashes(self.database_host)
except:
self.database_host = DATABASE_SERVER_SQLSERVER_DEFAULT
pass
self.database_port = DBMSConfig._init_member_with_prop_default(
options, "database_port", properties, self.dbPropKeys.port_key,
"1433")
self.database_name = DBMSConfig._init_member_with_prop_default(
options, "database_name", properties, self.dbPropKeys.db_name_key,
configDefaults.DEFAULT_DB_NAME)
self.use_windows_authentication = cbool(
DBMSConfig._init_member_with_prop_default(
options, "database_windows_auth", properties,
self.dbAuthKeys.integrated_auth_key, False))
self.database_username = DBMSConfig._init_member_with_prop_default(
options, "database_username", properties,
self.dbAuthKeys.user_name_key, DEFAULT_USERNAME)
self.database_password = DBMSConfig._init_member_with_default(
options, "database_password", "")
if not self.database_password:
self.database_password = DBMSConfig._read_password_from_properties(
properties)
self.database_url = self._build_sql_server_connection_string()
self.persistence_property = None
self.env_var_db_name = ""
self.env_var_db_log_name = ""
self.env_var_db_owner = ""
self.init_script_file = ""
self.drop_tables_script_file = ""
def __init__(self, options, properties, storage_type):
super(SQLServerConfig, self).__init__(options, properties, storage_type)
"""
#Just load the defaults. The derived classes will be able to modify them later
"""
self.dbms = DATABASE_DBMS_SQLSERVER
self.driver_class_name = DATABASE_DRIVER_NAME_SQLSERVER
self.JDBC_DRIVER_INSTALL_MSG = 'Before starting Ambari Server, you must install the SQL Server JDBC driver.'
# The values from options supersede the values from properties
self.database_host = DBMSConfig._init_member_with_prop_default(options, "database_host", properties, self.dbPropKeys.server_key, "")
try:
if not self.database_host:
self.database_host = options.default_database_host
else:
self.database_host = compress_backslashes(self.database_host)
except:
self.database_host = DATABASE_SERVER_SQLSERVER_DEFAULT
pass
self.database_port = DBMSConfig._init_member_with_prop_default(options, "database_port",
properties, self.dbPropKeys.port_key, "1433")
self.database_name = DBMSConfig._init_member_with_prop_default(options, "database_name",
properties, self.dbPropKeys.db_name_key, configDefaults.DEFAULT_DB_NAME)
self.use_windows_authentication = cbool(DBMSConfig._init_member_with_prop_default(options, "database_windows_auth",
properties, self.dbAuthKeys.integrated_auth_key, False))
self.database_username = DBMSConfig._init_member_with_prop_default(options, "database_username",
properties, self.dbAuthKeys.user_name_key, DEFAULT_USERNAME)
self.database_password = DBMSConfig._init_member_with_default(options, "database_password", "")
if not self.database_password:
self.database_password = DBMSConfig._read_password_from_properties(properties)
self.database_url = self._build_sql_server_connection_string()
self.persistence_property = None
self.env_var_db_name = ""
self.env_var_db_log_name = ""
self.env_var_db_owner = ""
self.init_script_file = ""
self.drop_tables_script_file = ""
from resource_management.libraries.functions.is_empty import is_empty
from resource_management.libraries.functions.version import format_stack_version
from resource_management.libraries.functions.copy_tarball import STACK_VERSION_PATTERN
from resource_management.libraries.functions import get_kinit_path
from resource_management.libraries.functions.get_not_managed_resources import get_not_managed_resources
from resource_management.libraries.script.script import Script
from resource_management.libraries.functions.get_port_from_url import get_port_from_url
from resource_management.libraries import functions
# server configurations
config = Script.get_config()
tmp_dir = Script.get_tmp_dir()
sudo = AMBARI_SUDO_BINARY
stack_name = default("/hostLevelParams/stack_name", None)
agent_stack_retry_on_unavailability = cbool(
config["hostLevelParams"]["agent_stack_retry_on_unavailability"])
agent_stack_retry_count = cint(
config["hostLevelParams"]["agent_stack_retry_count"])
# node hostname
hostname = config["hostname"]
# This is expected to be of the form #.#.#.#
stack_version_unformatted = str(config['hostLevelParams']['stack_version'])
stack_version_formatted_major = format_stack_version(stack_version_unformatted)
stack_is_hdp21 = Script.is_stack_less_than("2.2")
# this is not available on INSTALL action because hdp-select is not available
stack_version_formatted = functions.get_stack_version('hive-server2')
# New Cluster Stack Version that is defined during the RESTART of a Rolling Upgrade.
"""
from ambari_commons.constants import AMBARI_SUDO_BINARY
from ambari_commons.str_utils import cbool, cint
from resource_management.libraries.functions.version import format_stack_version, compare_versions
from resource_management.core.system import System
from resource_management.libraries.script.script import Script
from resource_management.libraries.functions import default, format
config = Script.get_config()
tmp_dir = Script.get_tmp_dir()
sudo = AMBARI_SUDO_BINARY
stack_version_unformatted = str(config['hostLevelParams']['stack_version'])
agent_stack_retry_on_unavailability = cbool(
default("/hostLevelParams/agent_stack_retry_on_unavailability", None))
agent_stack_retry_count = cint(
default("/hostLevelParams/agent_stack_retry_count", None))
stack_version_formatted = format_stack_version(stack_version_unformatted)
#users and groups
hbase_user = config['configurations']['hbase-env']['hbase_user']
smoke_user = config['configurations']['cluster-env']['smokeuser']
gmetad_user = config['configurations']['ganglia-env']["gmetad_user"]
gmond_user = config['configurations']['ganglia-env']["gmond_user"]
tez_user = config['configurations']['tez-env']["tez_user"]
user_group = config['configurations']['cluster-env']['user_group']
proxyuser_group = default("/configurations/hadoop-env/proxyuser_group",
"users")
def install_packages(self, package_list):
"""
Actually install the packages using the package manager.
:param package_list: List of package names to install
:return: Returns 0 if no errors were found, and 1 otherwise.
"""
ret_code = 0
config = self.get_config()
agent_stack_retry_on_unavailability = cbool(
config['ambariLevelParams']['agent_stack_retry_on_unavailability'])
agent_stack_retry_count = cint(
config['ambariLevelParams']['agent_stack_retry_count'])
# Install packages
packages_were_checked = False
packages_installed_before = []
stack_selector_package = stack_tools.get_stack_tool_package(
stack_tools.STACK_SELECTOR_NAME)
try:
# install the stack-selector; we need to supply the action as "upgrade" here since the normal
# install command will skip if the package is already installed in the system.
# This is required for non-versioned components, like stack-select, since each version of
# the stack comes with one. Also, scope the install by repository since we need to pick a
# specific repo that the stack-select tools are coming out of in case there are multiple
# patches installed
repositories = config['repositoryFile']['repositories']
command_repos = CommandRepository(config['repositoryFile'])
repository_ids = [
repository['repoId'] for repository in repositories
]
repos_to_use = {}
for repo_id in repository_ids:
if repo_id in self.repo_files:
repos_to_use[repo_id] = self.repo_files[repo_id]
self.repo_mgr.upgrade_package(
stack_selector_package,
RepoCallContext(ignore_errors=False,
use_repos=repos_to_use,
retry_on_repo_unavailability=
agent_stack_retry_on_unavailability,
retry_count=agent_stack_retry_count))
packages_installed_before = self.repo_mgr.installed_packages()
packages_installed_before = [
package[0] for package in packages_installed_before
]
packages_were_checked = True
filtered_package_list = self.filter_package_list(package_list)
try:
available_packages_in_repos = self.repo_mgr.get_available_packages_in_repos(
command_repos)
except Exception:
available_packages_in_repos = []
installation_context = RepoCallContext(
ignore_errors=False,
retry_on_repo_unavailability=
agent_stack_retry_on_unavailability,
retry_count=agent_stack_retry_count)
for package in filtered_package_list:
name = self.get_package_from_available(
package['name'], available_packages_in_repos)
# This enables upgrading non-versioned packages, despite the fact they exist.
# Needed by 'mahout' which is non-version but have to be updated
self.repo_mgr.upgrade_package(name, installation_context)
except Exception as err:
ret_code = 1
Logger.logger.error(
"Package Manager failed to install packages: {0}".format(
str(err)))
# Remove already installed packages in case of fail
if packages_were_checked and packages_installed_before:
packages_installed_after = self.repo_mgr.installed_packages()
packages_installed_after = [
package[0] for package in packages_installed_after
]
packages_installed_before = set(packages_installed_before)
new_packages_installed = [
package for package in packages_installed_after
if package not in packages_installed_before
]
if OSCheck.is_ubuntu_family():
package_version_string = self.repository_version.replace(
'.', '-')
else:
package_version_string = self.repository_version.replace(
'-', '_')
package_version_string = package_version_string.replace(
'.', '_')
for package in new_packages_installed:
if package_version_string and (package_version_string
in package):
self.repo_mgr.remove_package(package,
RepoCallContext())
if not self.repo_mgr.verify_dependencies():
ret_code = 1
Logger.logger.error("Failure while verifying dependencies")
Logger.logger.error(
"*******************************************************************************"
)
Logger.logger.error(
"Manually verify and fix package dependencies and then re-run install_packages"
)
Logger.logger.error(
"*******************************************************************************"
)
# Compute the actual version in order to save it in structured out
try:
if ret_code == 0:
self.compute_actual_version()
else:
self.check_partial_install()
except Fail as err:
ret_code = 1
Logger.logger.exception(
"Failure while computing actual version. Error: {0}".format(
str(err)))
return ret_code
def install_packages(self, package_list):
"""
Actually install the packages using the package manager.
:param package_list: List of package names to install
:return: Returns 0 if no errors were found, and 1 otherwise.
"""
ret_code = 0
config = self.get_config()
agent_stack_retry_on_unavailability = cbool(
config['hostLevelParams']['agent_stack_retry_on_unavailability'])
agent_stack_retry_count = cint(
config['hostLevelParams']['agent_stack_retry_count'])
# Install packages
packages_were_checked = False
stack_selector_package = stack_tools.get_stack_tool_package(
stack_tools.STACK_SELECTOR_NAME)
try:
Package(stack_selector_package,
action="upgrade",
retry_on_repo_unavailability=
agent_stack_retry_on_unavailability,
retry_count=agent_stack_retry_count)
packages_installed_before = []
allInstalledPackages(packages_installed_before)
packages_installed_before = [
package[0] for package in packages_installed_before
]
packages_were_checked = True
filtered_package_list = self.filter_package_list(package_list)
try:
available_packages_in_repos = packages_analyzer.get_available_packages_in_repos(
config['repositoryFile']['repositories'])
except Exception:
available_packages_in_repos = []
for package in filtered_package_list:
name = self.get_package_from_available(
package['name'], available_packages_in_repos)
Package(
name,
action=
"upgrade", # this enables upgrading non-versioned packages, despite the fact they exist. Needed by 'mahout' which is non-version but have to be updated
retry_on_repo_unavailability=
agent_stack_retry_on_unavailability,
retry_count=agent_stack_retry_count)
except Exception as err:
ret_code = 1
Logger.logger.exception(
"Package Manager failed to install packages. Error: {0}".
format(str(err)))
# Remove already installed packages in case of fail
if packages_were_checked and packages_installed_before:
packages_installed_after = []
allInstalledPackages(packages_installed_after)
packages_installed_after = [
package[0] for package in packages_installed_after
]
packages_installed_before = set(packages_installed_before)
new_packages_installed = [
package for package in packages_installed_after
if package not in packages_installed_before
]
if OSCheck.is_ubuntu_family():
package_version_string = self.repository_version.replace(
'.', '-')
else:
package_version_string = self.repository_version.replace(
'-', '_')
package_version_string = package_version_string.replace(
'.', '_')
for package in new_packages_installed:
if package_version_string and (package_version_string
in package):
Package(package, action="remove")
if not verifyDependencies():
ret_code = 1
Logger.logger.error("Failure while verifying dependencies")
Logger.logger.error(
"*******************************************************************************"
)
Logger.logger.error(
"Manually verify and fix package dependencies and then re-run install_packages"
)
Logger.logger.error(
"*******************************************************************************"
)
# Compute the actual version in order to save it in structured out
try:
if ret_code == 0:
self.compute_actual_version()
else:
self.check_partial_install()
except Fail as err:
ret_code = 1
Logger.logger.exception(
"Failure while computing actual version. Error: {0}".format(
str(err)))
return ret_code
def install_packages(self, package_list):
"""
Actually install the packages using the package manager.
:param package_list: List of package names to install
:return: Returns 0 if no errors were found, and 1 otherwise.
"""
ret_code = 0
# Clear cache of package manager right before installation of the packages
self._clear_package_manager_cache()
config = self.get_config()
agent_stack_retry_on_unavailability = cbool(
config['hostLevelParams']['agent_stack_retry_on_unavailability'])
agent_stack_retry_count = cint(
config['hostLevelParams']['agent_stack_retry_count'])
# Install packages
packages_were_checked = False
try:
Package(self.get_base_packages_to_install(),
retry_on_repo_unavailability=
agent_stack_retry_on_unavailability,
retry_count=agent_stack_retry_count)
packages_installed_before = []
allInstalledPackages(packages_installed_before)
packages_installed_before = [
package[0] for package in packages_installed_before
]
packages_were_checked = True
filtered_package_list = self.filter_package_list(package_list)
for package in filtered_package_list:
name = self.format_package_name(package['name'],
self.repository_version)
Package(
name,
use_repos=list(self.current_repo_files) if
OSCheck.is_ubuntu_family() else self.current_repositories,
skip_repos=[self.REPO_FILE_NAME_PREFIX +
"*"] if OSCheck.is_redhat_family() else [],
retry_on_repo_unavailability=
agent_stack_retry_on_unavailability,
retry_count=agent_stack_retry_count)
except Exception, err:
ret_code = 1
Logger.logger.exception(
"Package Manager failed to install packages. Error: {0}".
format(str(err)))
# Remove already installed packages in case of fail
if packages_were_checked and packages_installed_before:
packages_installed_after = []
allInstalledPackages(packages_installed_after)
packages_installed_after = [
package[0] for package in packages_installed_after
]
packages_installed_before = set(packages_installed_before)
new_packages_installed = [
package for package in packages_installed_after
if package not in packages_installed_before
]
if OSCheck.is_ubuntu_family():
package_version_string = self.repository_version.replace(
'.', '-')
else:
package_version_string = self.repository_version.replace(
'-', '_')
package_version_string = package_version_string.replace(
'.', '_')
for package in new_packages_installed:
if package_version_string and (package_version_string
in package):
Package(package, action="remove")
