def test_command(self):
"""Test command invocation.
"""
subproc.call(['ls', '/tmp'])
subprocess.call.assert_called_with(['/bin/ls', '-al', '/tmp'],
env=mock.ANY,
close_fds=True)
def start_service(app_root, service, once=True):
"""Starts a service in the app_root/services/service directory."""
if once:
opt = '-o'
else:
opt = '-u'
subproc.call(['s6_svc', opt, os.path.join(app_root, service)])
def delete_chain(table, chain):
"""Delete a chain in the given table.
:param ``str`` table:
Name of the table where the chain resides.
:param ``str`` chain:
Name of the chain to delete
"""
subproc.call(['iptables', '-t', table, '-X', chain])
def flush_chain(table, chain):
"""Flush a chain in the given table.
:param ``str`` table:
Name of the table where the chain resides.
:param ``str`` chain:
Name of the chain to create
"""
subproc.call(['iptables', '-t', table, '-vF', chain])
def create_chain(table, chain):
"""Creates new chain in the given table.
:param ``str`` table:
Name of the table where the chain resides.
:param ``str`` chain:
Name of the chain to create
"""
subproc.call(['iptables', '-t', table, '-N', chain])
def kill_service(app_root, service, signal='TERM'):
"""Send the service the specified signal."""
signal_opts = dict([('STOP', '-p'), ('CONT', '-c'), ('HUP', '-h'),
('ALRM', '-a'), ('INT', '-i'), ('TERM', '-t'),
('KILL', '-k')])
if signal not in signal_opts:
utils.fatal('Unsupported signal: %s', signal)
opt = signal_opts[signal]
subproc.call(['s6_svc', opt, os.path.join(app_root, service)])
def monitor(manifest, container_dir, appevents_dir):
"""Monitor container services."""
app = yaml.load(manifest.read())
with lc.LogContext(_LOGGER, app['name'], lc.ContainerAdapter) as log:
svc_presence = presence.ServicePresence(
app,
container_dir,
appevents_dir,
)
sys_dir = os.path.join(container_dir, 'sys')
svc_sup_dir = os.path.join(sys_dir, 'start_container')
failed_svc = None
killed = False
# Check that start_container was not terminated. This fixed race
# condition if the presence exits and while restarted,
# start_container is terminated.
svc_sup_ran_once = os.path.exists(
os.path.join(svc_sup_dir, 'self.pid'))
log.info('services supervisor ran once: %s', svc_sup_ran_once)
svc_sup_down = presence.is_down(svc_sup_dir)
log.info('services supervisor down: %s', svc_sup_down)
if svc_sup_down and svc_sup_ran_once:
log.info('services supervisor was terminated, exiting.')
else:
svc_presence.ensure_supervisors_running()
# Try to start the service, taking into account number of
# restarts.
# If the number of restarts is more than specified, delete app
# from the model, which will trigger container shutdown.
#
# In case of container shutdown (application evicted from the
# server), exit_app will not be called.
while True:
success, failed_svc = svc_presence.start_all()
if not success:
break
svc_presence.wait_for_exit(svc_sup_dir)
if presence.is_down(svc_sup_dir):
log.info('Container services supervisor is down.')
failed_svc = None
killed = True
break
svc_presence.exit_app(failed_svc, killed=killed)
log.info('Shutting down sys supervisor.')
subproc.call(['s6-svscanctl', '-pi', sys_dir])
def _refresh_supervisor(self, instance_names=()):
"""Notify the supervisor of new instances to run."""
subproc.check_call(['s6_svscanctl', '-an', self.tm_env.running_dir])
for instance_name in instance_names:
with lc.LogContext(_LOGGER, instance_name):
_LOGGER.info('Starting')
instance_run_link = os.path.join(self.tm_env.running_dir,
instance_name)
# Wait for the supervisor to pick up the new instance.
for _ in range(10):
res = subproc.call([
's6_svok',
instance_run_link,
])
if res == 0:
break
else:
_LOGGER.warning('Supervisor has not picked it up yet')
time.sleep(0.5)
# Bring the instance up.
subproc.check_call([
's6_svc',
'-uO',
instance_run_link,
])
def _renew_tickets(tkt_spool_dir):
"""Try and renew all tickets that match a pattern."""
for tkt in glob.glob(os.path.join(tkt_spool_dir, '*')):
if tkt.startswith('.'):
continue
_LOGGER.info('Renew ticket: %s', tkt)
try:
subproc.check_call(
['kinit', '-R'],
environ={'KRB5CCNAME': 'FILE:' + tkt},
)
_LOGGER.info('Tickets renewed successfully.')
except subproc.CalledProcessError as err:
_LOGGER.info('Tickets not renewable, kinit rc: %s', err.returncode)
except OSError as os_err:
_LOGGER.warning('Error renewing tickets: %s', os_err)
subproc.call(['klist', '-e', '-5', tkt])
def wait_for_exit(self, container_svc_dir):
"""Waits for service to be down, reports status to zk."""
watched_dirs = [
os.path.join(self.services_dir, svc) for svc in self.services
]
if container_svc_dir:
watched_dirs.append(container_svc_dir)
_LOGGER.info('waiting for service exit: %r', watched_dirs)
# Wait for one of the services to come down.
# TODO: need to investigate why s6-svwait returns 111 rather
# than 0.
subproc.call(['s6_svwait', '-o', '-D'] + watched_dirs)
# Wait for the supervisor to report finished status.
time.sleep(1)
for service in self.services:
# If service is running, update_exit_status is noop.
self.update_exit_status(service)
def archive_filesystem(block_dev, rootdir, archive, files):
"""Archive the filesystem of an application
:param block_dev:
Block device from where to archive the new filesystem
:type block_dev:
``str``
:param rootdir:
Path to a directory where to mount the root device
:type rootdir:
``str``
:param archive:
Path to the archive file to create
:type archive:
``str``
:param files:
List of files and folders to include in the archive
relative to rootdir. This is input list of files to
tar.
:type list:
``str``
"""
if not files:
_LOGGER.info('Nothing to archive.')
return True
if not os.path.exists(rootdir):
_LOGGER.error('Root device directory does not exist: %s', rootdir)
return False
archive_cmd = '{tm_root}/sbin/archive_container.sh'.format(
tm_root=utils.rootdir())
arguments = [
'unshare',
'--mount',
archive_cmd,
block_dev,
# rootdir
os.path.realpath(rootdir),
# archive
os.path.realpath(archive)
]
# Make sure files are relative path.
safe_files = [filename.lstrip('/') for filename in files]
arguments.extend(safe_files)
result = subproc.call(arguments)
return result == 0
def benchmark(directory,
volume=BENCHMARK_VOLUME,
rw_type=BENCHMARK_RW_TYPE,
job_number=BENCHMARK_JOB_NUMBER,
thread_number=BENCHMARK_THREAD_NUMBER,
block_size=BENCHMARK_IOPS_BLOCK_SIZE,
max_seconds=BENCHMARK_MAX_SECONDS):
"""Use fio to do benchmark.
"""
result = {}
config_file = os.path.join(directory, _BENCHMARK_CONFIG_FILE)
result_file = os.path.join(directory, _BENCHMARK_RESULT_FILE)
# prepare fio config
config = configparser.SafeConfigParser()
global_section = 'global'
config.add_section(global_section)
config.set(global_section, 'group_reporting', '1')
config.set(global_section, 'unlink', '1')
config.set(global_section, 'time_based', '1')
config.set(global_section, 'direct', '1')
config.set(global_section, 'size', volume)
config.set(global_section, 'rw', rw_type)
config.set(global_section, 'numjobs', job_number)
config.set(global_section, 'iodepth', thread_number)
config.set(global_section, 'bs', block_size)
config.set(global_section, 'runtime', max_seconds)
drive_section = 'drive'
config.add_section(drive_section)
config.set(drive_section, 'directory', directory)
fs.write_safe(config_file, lambda f: config.write(EqualSpaceRemover(f)))
# start fio
ret = subproc.call([
'fio', config_file, '--norandommap', '--minimal', '--output',
result_file
])
# parse fio terse result
# http://fio.readthedocs.io/en/latest/fio_doc.html#terse-output
if ret == 0:
with io.open(result_file) as fp:
metric_list = fp.read().split(';')
result[Metrics.READ_BPS.value] = int(float(metric_list[6]) * 1024)
result[Metrics.READ_IOPS.value] = int(metric_list[7])
result[Metrics.WRITE_BPS.value] = int(
float(metric_list[47]) * 1024)
result[Metrics.WRITE_IOPS.value] = int(metric_list[48])
return result
def blk_fs_test(block_dev):
"""Test the existence of a filesystem on a given block device.
We essentially try to read the superblock and assume no filesystem if we
fail.
:param block_dev:
Block device where to create the new filesystem.
:type block_dev:
``str``
:returns ``bool``:
True if the block device contains a filesystem.
"""
res = subproc.call(['tune2fs', '-l', block_dev])
return bool(res == 0)
def _reforward_ticket(ticket_file, tkt_final_dir, endpoint):
"""Forward ticket to self, potentially correcting ticket enc type."""
_LOGGER.info('Reforwarding to: %s', endpoint)
_LOGGER.info('Before loopback forward: %s', ticket_file)
subproc.call(['klist', '-e', '-5', ticket_file])
host, port = endpoint.split(':')
subproc.call(['tkt_send_v2', '-h{}'.format(host), '-p{}'.format(port)],
environ={'KRB5CCNAME': 'FILE:' + ticket_file})
final_tkt_path = os.path.join(tkt_final_dir, os.path.basename(ticket_file))
_LOGGER.info('After loopback forward: %s', final_tkt_path)
subproc.call(['klist', '-e', '-5', final_tkt_path])
def stop_service(app_root, service):
"""Stops the service and do not restart it."""
subproc.call(['s6_svc', '-d', os.path.join(app_root, service)])
def exec_root_supervisor(directory):
"""Execs svscan in the directory."""
if os.name == 'nt':
subproc.call(['s6_svscan', directory])
else:
subproc.exec_pid1(['s6_svscan', directory])
