def run(self, apache_config, timeout_tries=5, time_between_tries=2.0):
"""If you check whether apache is running just after it was (re)started, it may report that it
isn't running when it is infact running. This is because apache takes a few seconds before it writes
its pid file out. Thus, we need to use a timeout to see if apache could really be up when the status
command reports that it is down. If you haven't just started apache, you can probably reduce the
timeout duration. Note that time_between_tries is in seconds, so the default timeout is 10 seconds.
"""
controller_exe = apache_config.controller_exe
action._check_file_exists(controller_exe, self)
if controller_exe=='/opt/local/apache2/bin/apachectl':
"""The apachectl for macports is broken. We determine whether apache is
running by looking for the process
"""
return _macports_apache_is_running(controller_exe, self.ctx._get_sudo_password(self))
for i in range(timeout_tries):
try:
iuprocess.run_sudo_program([controller_exe, "status"],
self.ctx._get_sudo_password(self), self.ctx.logger)
self.ctx.logger.debug("Apache status is up")
return True
except iuprocess.SudoBadRc, e:
if e.rc == 1: # this means the server is down
self.ctx.logger.debug("Apache status is down")
if i != (timeout_tries-1): time.sleep(time_between_tries)
else:
exc_info = sys.exc_info()
self.ctx.logger.exception("Unexpected exception when checking for apache status occurred in resource %s" %
self.ctx.props.id)
raise convert_exc_to_user_error(exc_info, errors[ERR_APACHE_STATUS], nested_exc_info=e.get_nested_exc_info(),
msg_args={"id":self.ctx.props.id})
def run(self, package):
"""Run the load operation on the specified port(s).
Unfortunately, there's no way to query if a port is already loaded.
To get already this, we make the operation itempotent: we try the
port load. If it fails, we scan the results to see if we get the error
message indicating the port was already loaded. In that case, we ignore
the error.
"""
port_exe = self.ctx.props.input_ports.macports.macports_exe
action._check_file_exists(port_exe, self)
try:
re_map = {"already_loaded": concat(lit("Error: Target org.macports.load returned:"),
one_or_more(any_except_newline()),
line_ends_with(lit("Already loaded"))).get_value()}
(rc, result_map) = \
iuprocess.run_sudo_program_and_scan_results([port_exe, "load",
package],
re_map, self.ctx.logger,
self.ctx._get_sudo_password(self),
log_output=True,
cwd=os.path.dirname(port_exe),
env=ENV)
except iuprocess.SudoError, e:
self.ctx.logger.exception("Port load for %s failed, unexpected exception" % package)
exc_info = sys.exc_info()
sys.exc_clear()
raise convert_exc_to_user_error(exc_info, errors[ERR_MACPORTS_LOAD],
msg_args={"pkg":package, "id":self.ctx.props.id},
nested_exc_info=e.get_nested_exc_info())
def run(self):
p = self.ctx.props
_check_file_exists(p.mysql_install_db_script, self)
procutils.run_sudo_program([p.mysql_install_db_script],
self.ctx._get_sudo_password(self), logger,
cwd=os.path.dirname(p.mysql_install_db_script),
user=p.output_ports.mysql_admin.mysql_user)
def dry_run(self, password_file, username, password, apache_config):
htpasswd_exe = apache_config.htpasswd_exe
action._check_file_exists(htpasswd_exe, self)
if os.path.exists(password_file):
cmd = [htpasswd_exe, "-b", password_file, username, password]
else:
cmd = [htpasswd_exe, "-b", "-c", password_file, username, password]
self.ctx.logger.debug(" ".join(cmd))
def run(self, apache_config):
"""Stop the apache server. apache_config is the port
containing the apache config variables.
"""
controller_exe = apache_config.controller_exe
action._check_file_exists(controller_exe, self)
iuprocess.run_sudo_program([controller_exe, "stop"],
self.ctx._get_sudo_password(self),
self.ctx.logger)
def add_environment_vars_to_classpath(self, classpath_file, env_mapping):
_check_file_exists(classpath_file, self)
backup_file = classpath_file + ".orig"
if not os.path.exists(backup_file):
shutil.copyfile(classpath_file, backup_file)
assignments = ""
for (var, value) in env_mapping.items():
assignments += '%s="%s"\n' % (var, value)
with open(classpath_file, "a") as f:
f.write(assignments)
def run(self, src_config_file, apache_config, new_name=None):
action._check_file_exists(src_config_file, self)
(uid, gid, mode) = fileutils.get_file_permissions(apache_config.config_file)
if new_name:
target_path = os.path.join(apache_config.module_config_dir,
new_name)
else:
target_path = os.path.join(apache_config.module_config_dir,
os.path.basename(src_config_file))
iuprocess.sudo_copy([src_config_file, target_path], self.ctx._get_sudo_password(self), self.ctx.logger)
iuprocess.sudo_set_file_permissions(target_path, uid, gid, mode, self.ctx.logger, self.ctx._get_sudo_password(self))
def run(self, tomcat_port, app_path, warfile_path, admin_password,
update=False, tag=None):
_check_file_exists(warfile_path, self)
deploy_app_fn(self.ctx.props.id,
tomcat_port.hostname,
tomcat_port.manager_port,
app_path,
warfile_path,
tomcat_port.admin_user,
admin_password,
update=update, tag=tag)
def check_installed(self, package):
"""Validate that a macports package is installed (e.g. in a post-install check)
"""
port_exe = self.ctx.props.input_ports.macports.macports_exe
action._check_file_exists(port_exe, self)
(rc, map) = iuprocess.run_program_and_scan_results([port_exe, "installed", package],
{"found": re.escape(package) + ".*" + re.escape("(active)"),
'not_found': re.escape("None of the specified ports are installed.")},
self.ctx.logger,
log_output=True,
cwd=os.path.dirname(port_exe),
shell=True, env=ENV)
if rc==0 and map['found']:
return
else:
raise UserError(errors[ERR_POST_INSTALL],
msg_args={"pkg":package, "id":self.ctx.props.id})
def run(self, password_file, username, password, apache_config):
class LogProxy:
"""We need to wrap the logger and capture any action events, as those may
contain the password.
"""
def __init__(self, logger):
#Set attribute.
self._logger = logger
def __getattr__(self, attrib):
if attrib == "action":
return self.action
else:
return getattr(self._logger, attrib)
def action(self, msg):
pass
htpasswd_exe = apache_config.htpasswd_exe
action._check_file_exists(htpasswd_exe, self)
if os.path.exists(password_file):
cmd = [htpasswd_exe, "-b", password_file, username, password]
else:
cmd = [htpasswd_exe, "-b", "-c", password_file, username, password]
if self.ctx._get_sudo_password(self)==None or iuprocess.is_running_as_root():
self.ctx.logger.action("%s <password>" % " ".join(cmd[0:-1]))
rc = iuprocess.run_and_log_program(cmd, {}, LogProxy(self.ctx.logger))
if rc != 0:
raise UserError(errors[ERR_APACHE_HTPASSWD],
msg_args={"exe": htpasswd_exe,
"file": password_file,
"id":self.ctx.props.id},
developer_msg="return code was %d" % rc)
else:
try:
logger.action("sudo %s <password>" % " ".join(cmd[0:-1]))
iuprocess.run_sudo_program(cmd, self.ctx._get_sudo_password(self),
LogProxy(self.ctx.logger))
except Exception, e:
exc_info = sys.exc_info()
logger.exception("exception in htpasswd: %s, resource %s" % (e.__repr__(),
ctx.props.id))
raise convert_exc_to_user_error(exc_info, errors[ERR_APACHE_HTPASSWD],
msg_args={"exe": htpasswd_exe,
"file": password_file,
"id":self.ctx.props.id},
developer_msg="exception" % e.__repr__())
def run(self, apache_config):
"""Restart the apache server. apache_config is the port
containing the apache config variables.
"""
controller_exe = apache_config.controller_exe
action._check_file_exists(controller_exe, self)
## iuprocess.run_sudo_program([controller_exe, "restart"],
## self.ctx._get_sudo_password(self),
## self.ctx.logger)
# The restart command doesn't seem to work in some
# situations (see ticket #203). We do a real stop and start
# instead.
iuprocess.run_sudo_program([controller_exe, "stop"],
self.ctx._get_sudo_password(self),
self.ctx.logger)
iuprocess.run_sudo_program([controller_exe, "start"],
self.ctx._get_sudo_password(self),
self.ctx.logger)
def run(self, package):
port_exe = self.ctx.props.input_ports.macports.macports_exe
action._check_file_exists(port_exe, self)
logger.debug("PATH=%s, HOME=%s" % (ENV["PATH"], ENV["HOME"]))
(rc, map) = iuprocess.run_program_and_scan_results([port_exe, "installed", package],
{"found": re.escape(package) + ".*" + re.escape("(active)"),
'not_found': re.escape("None of the specified ports are installed.")},
self.ctx.logger,
log_output=True,
cwd=os.path.dirname(port_exe),
shell=True, env=ENV)
if rc==0 and map['found']:
return True
elif rc==0 and map['not_found']:
return False
else:
raise UserError(errors[ERR_MACPORTS_PKG_QUERY],
msg_args={"pkg":package, "id":self.ctx.props.id})
def run(self, package_list):
"""Install the specified port(s). If you have variants, include them in
the package list. Expects the context to have an input port "macports"
with a property "macports_exe".
"""
port_exe = self.ctx.props.input_ports.macports.macports_exe
action._check_file_exists(port_exe, self)
try:
iuprocess.run_sudo_program([port_exe, "install"]+package_list,
self.ctx._get_sudo_password(self),
self.ctx.logger,
cwd=os.path.dirname(port_exe),
env=ENV)
except iuprocess.SudoError, e:
exc_info = sys.exc_info()
self.ctx.logger.exception("Port install for %s failed, unexpected exception" % package_list)
sys.exc_clear()
raise convert_exc_to_user_error(exc_info, errors[ERR_MACPORTS_INSTALL],
msg_args={"pkg":package_list.__repr__(),
"id":self.ctx.props.id},
nested_exc_info=e.get_nested_exc_info())
def run(self, user, password, script_file, database=None):
p = self.ctx.props
_check_file_exists(script_file, self)
cmd = [p.input_ports.mysql_admin.mysql_client_exe, "-u", user,
"--password=%s" % password]
if database:
cmd.extend(["-D", database])
# make a version of cmd safe for logging
no_pw_cmd = copy.copy(cmd)
no_pw_cmd[3] = "--password=****"
self.ctx.logger.debug(' '.join(no_pw_cmd))
with open(script_file, "r") as sf:
input_data = sf.read()
rc = procutils.run_and_log_program(cmd, None, self.ctx.logger,
input=input_data,
hide_command=True,
hide_input=True)
if rc!=0:
raise UserError(errors[ERR_MYSQL_SCRIPT],
msg_args={"id":p.id,
"cmd":' '.join(cmd),
"script":script_file},
developer_msg="rc was %d, command was: '%s'" %
(rc, command_text))
def dry_run(self, package):
port_exe = self.ctx.props.input_ports.macports.macports_exe
action._check_file_exists(port_exe, self)
return None
def dry_run(self, package_list):
port_exe = self.ctx.props.input_ports.macports.macports_exe
action._check_file_exists(port_exe, self)
self.ctx.logger.action("sudo %s" % ([port_exe, "install"]+package_list).__repr__())
def dry_run(self, tomcat_port, app_path, warfile_path,
admin_password, update=False,
tag=None):
_check_file_exists(warfile_path, self)
def dry_run(self, apache_config, timeout_tries=5, time_between_tries=2.0):
controller_exe = apache_config.controller_exe
action._check_file_exists(controller_exe, self)
return False
def run(self, src, dest):
_check_file_exists(src, self)
shutil.copyfile(src, dest)
def dry_run(self, package_list):
_check_file_exists(APT_GET_PATH, self)
def is_database_installed(self, psql_exe, database_name, database_user):
_check_file_exists(psql_exe, self)
rc = procutils.run_and_log_program([psql_exe, '-d', database_name,
'-U', database_user, '-c', r'\d'], None,
self.ctx.logger, os.path.dirname(psql_exe))
return rc==0
def dry_run(self, apache_config):
controller_exe = apache_config.controller_exe
action._check_file_exists(controller_exe, self)
self.ctx.logger.debug("%s stop" % controller_exe)
