def _apt_get_dry_run(action, pkgs):
apt_args = _apt_args()
logger = LogCatcher(package_logger)
success = call_process(['/usr/bin/apt-get'] + apt_args + [action, '-s'] +
pkgs,
logger=logger).returncode == 0
install, remove, broken = [], [], []
install_regex = re.compile('^(Inst) ([^ ]*?) \((.*?) ')
upgrade_remove_regex = re.compile('^(Remv|Inst) ([^ ]*?) \[(.*?)\]')
for line in logger.stdout():
for regex in [install_regex, upgrade_remove_regex]:
match = regex.match(line)
if match:
operation, pkg_name, version = match.groups()
if operation == 'Inst':
install.append(pkg_name)
elif operation == 'Remv':
remove.append(pkg_name)
break
if not success:
for pkg in pkgs:
if action == 'install' and pkg not in install:
broken.append(pkg)
if action == 'remove' and pkg not in remove:
broken.append(pkg)
return dict(zip(['install', 'remove', 'broken'],
[install, remove, broken]))
def _update_converter_service(self, app):
listener_file = '/usr/lib/univention-directory-listener/system/%s.py' % app.id
if os.path.exists(listener_file):
logger = LogCatcher()
self._subprocess([
'systemctl', 'is-enabled',
'univention-appcenter-listener-converter@%s.service' % app.id
], logger)
if list(logger.stdout()) == ['enabled']:
self._subprocess([
'systemctl', 'restart',
'univention-appcenter-listener-converter@%s.service' %
app.id
])
else:
self._subprocess([
'systemctl', 'enable',
'univention-appcenter-listener-converter@%s.service' %
app.id
])
self._subprocess([
'systemctl', 'start',
'univention-appcenter-listener-converter@%s.service' %
app.id
])
else:
self._subprocess([
'systemctl', 'stop',
'univention-appcenter-listener-converter@%s.service' % app.id
])
self._subprocess([
'systemctl', 'disable',
'univention-appcenter-listener-converter@%s.service' % app.id
])
def execute(self, query):
logger = LogCatcher()
process = call_process_as('postgres', ['/usr/bin/psql', '-tc', query], logger=logger)
if process.returncode:
for level, msg in logger.logs:
if level == 'OUT':
database_logger.info(msg)
elif level == 'ERR':
database_logger.warn(msg)
raise DatabaseError('Returncode %s for query' % process.returncode)
return list(logger.stdout())
def start(self, attempts=2):
service_name = self._get_service_name()
if service_name:
if call_process(['service', service_name, 'start'], database_logger).returncode:
if attempts > 1:
# try again. sometimes, under heavy load, mysql seems to fail to
# start although it is just slow
database_logger.info('Starting %s failed. Retrying...' % service_name)
return self.start(attempts=attempts - 1)
catcher = LogCatcher(database_logger)
call_process(['service', service_name, 'status'], catcher)
details = '\n'.join(catcher.stdstream())
raise DatabaseCreationFailed('Could not start %s' % service_name, details=details)
def _setup_docker_image(self, app, args):
self._execute_container_script(app, 'restore_data_before_setup', credentials=False)
if app.docker_script_setup:
logger = LogCatcher(self.logger)
try:
process = self._execute_container_script(app, 'setup', args, cmd_kwargs={'_logger': logger})
if not process or process.returncode != 0:
code = -1
if process:
code = process.returncode
raise InstallSetupFailed(code=code, stderr=list(logger.stderr()))
finally:
del logger
self._execute_container_script(app, 'restore_data_after_setup', credentials=False)
def _execute_container_script(self,
app,
interface,
args=None,
credentials=True,
output=False,
cmd_args=None,
cmd_kwargs=None):
cmd_args = cmd_args or []
cmd_kwargs = cmd_kwargs or {}
self.log('Executing interface %s for %s' % (interface, app.id))
docker = self._get_docker(app)
interface_file = getattr(app, 'docker_script_%s' % interface)
if not interface_file:
self.log('No interface defined')
return None
remote_interface_script = app.get_cache_file(interface)
container_interface_script = docker.path(interface_file)
if os.path.exists(remote_interface_script):
self.log('Copying App Center\'s %s to container\'s %s' %
(interface, interface_file))
mkdir(os.path.dirname(container_interface_script))
shutil.copy2(remote_interface_script, container_interface_script)
os.chmod(container_interface_script, 0o755) # -rwxr-xr-x
if not os.path.exists(container_interface_script):
self.warn('Interface script %s not found!' % interface_file)
return None
with docker.tmp_file() as error_file:
with docker.tmp_file() as password_file:
if credentials:
self._get_ldap_connection(
args,
allow_machine_connection=False,
allow_admin_connection=False
) # to get a working username/password
username = self._get_username(args)
password = self._get_password(args)
with open(password_file.name, 'w') as f:
f.write(password)
cmd_kwargs['username'] = username
cmd_kwargs['password_file'] = password_file.container_path
cmd_kwargs['error_file'] = error_file.container_path
cmd_kwargs['app'] = app.id
cmd_kwargs['app_version'] = app.version
# locale = get_locale()
# if locale:
# cmd_kwargs['locale'] = locale
cmd_kwargs['_tty'] = False
if output:
logger = LogCatcher(self.logger)
cmd_kwargs['_logger'] = logger
process = docker.execute(interface_file, *cmd_args,
**cmd_kwargs)
if process.returncode != 0:
with open(error_file.name, 'r+b') as error_handle:
for line in error_handle:
self.fatal(line)
if output:
return process, logger
return process
def main(self, args):
lo, pos = self._get_ldap_connection(args, allow_machine_connection=True)
first = True
localhost = ucr_get('hostname')
username = '******' % localhost
pwdfile = '/etc/machine.secret'
for obj in self.get_appcenter_hosts(lo, pos):
if not first:
self.log('')
fqdn = obj.info.get('fqdn')
self.log('%s:' % fqdn)
logger = LogCatcher()
output = self.manage(username % fqdn, pwdfile, logger, 'info')
if output.has_stdout():
for line in output.stdout():
self.log(line)
else:
self.warn('Failed to get info')
if output.has_stderr():
for line in output.stderr():
self.warn(line)
first = False
