def configure_templates(storage, paths, logger):
code_path = paths.get('local.code')
for root, dirs, files in walk(code_path):
for name in files:
extension = name[-9:]
if extension != '.catapult':
continue
cleaned = name[:-9]
file_src = join(root, name)
file_dest = join(root, cleaned)
logger.info('configured template file "{}"'.format(file_src))
generated = render_path(file_src, {
'get': storage.get,
'storage': storage.get,
'paths': paths.get,
})
with codecs.open(file_dest, 'w', encoding='utf8') as open_file:
open_file.write(generated)
def configure_check(storage, paths, registers):
web_items = ''
if REGISTER_CHECK in registers and REGISTER_WEB in registers[
REGISTER_CHECK]:
web_items = '\n'.join(registers[REGISTER_CHECK][REGISTER_WEB])
bot_items = ''
if REGISTER_CHECK in registers and REGISTER_BOT in registers[
REGISTER_CHECK]:
bot_items = '\n'.join(registers[REGISTER_CHECK][REGISTER_BOT])
web_and_bot_items = ''
if REGISTER_CHECK in registers and REGISTER_WEB_AND_BOT in registers[
REGISTER_CHECK]:
web_and_bot_items = '\n'.join(
registers[REGISTER_CHECK][REGISTER_WEB_AND_BOT])
path = '{}/core/check.j2'.format(paths.get('catapult.templates'), )
generated = render_path(
path, {
'user': storage.get('config.deploy.user'),
'service_name': storage.get('release.service'),
'deploy_path': storage.get('config.deploy.deploy_path'),
'web_items': web_items,
'bot_items': bot_items,
'web_and_bot_items': web_and_bot_items,
})
file = '{}/check.sh'.format(paths.get('local.release'))
with open(file, 'w') as open_file:
open_file.write(generated)
chmod(file, 0o0766)
def render_check(self):
path = '{}/pm2/check.j2'.format(self.paths.get('catapult.templates'), )
generated = render_path(path, {
'storage': self.storage.get,
'paths': self.paths.get,
})
return generated
def render(demons, storage, paths):
items = []
path_item = '{}/supervisor/item.j2'.format(
paths.get('catapult.templates'), )
for demon in demons:
command = render_string(
demon['command'], {
'release_path': paths.get('remote.code'),
'storage': storage.get,
'paths': paths.get
})
numprocs = 1
if demon['type'] == BOT_MIRRORING:
numprocs = demon['instances']
item = render_path(
path_item, {
'program': demon['name'],
'process_name': '%(program_name)s_%(process_num)02d',
'command': command,
'user': storage.get('config.deploy.user'),
'numprocs': str(numprocs),
'storage': storage.get,
'paths': paths.get
})
items.append(item)
path_supervisor = '{}/supervisor/supervisor.j2'.format(
paths.get('catapult.templates'), )
generated = render_path(
path_supervisor, {
'items': '\n\n'.join(map(str, items)),
'storage': storage.get,
'paths': paths.get
})
return generated
def render_install_web(self):
path = '{}/nginx/install.j2'.format(
self.paths.get('catapult.templates'),
)
generated = render_path(path, {
'release_path': self.paths.get('remote.release'),
'file_name': 'catapult-{}'.format(self.storage.get('release.service')),
'storage': self.storage.get,
'paths': self.paths.get,
})
return generated
def render(crons, storage, paths):
items = []
path_item = '{}/crontab/item.j2'.format(paths.get('catapult.templates'), )
for cron in crons:
command = render_string(
cron['command'], {
'release_path': paths.get('remote.code'),
'storage': storage.get,
'paths': paths.get,
})
item = render_path(
path_item, {
'minutes': str(cron['planning']['minutes']),
'hours': str(cron['planning']['hours']),
'dom': str(cron['planning']['dom']),
'mon': str(cron['planning']['mon']),
'dow': str(cron['planning']['dow']),
'command': command,
'user': storage.get('config.deploy.user'),
'storage': storage.get,
'paths': paths.get,
})
items.append(item)
path_crontab = '{}/crontab/crontab.j2'.format(
paths.get('catapult.templates'), )
generated = render_path(
path_crontab, {
'items': '\n\n'.join(map(str, items)),
'storage': storage.get,
'paths': paths.get,
})
return generated
def render_install(self):
path = '{}/pm2/install.j2'.format(
self.paths.get('catapult.templates'), )
generated = render_path(
path, {
'release_path':
self.paths.get('remote.release'),
'user':
self.storage.get('config.deploy.user'),
'service_name':
'catapult-{}'.format(self.storage.get('release.service')),
'storage':
self.storage.get,
'paths':
self.paths.get,
})
return generated
def configure_install(storage, paths, registers):
web_items = ''
if REGISTER_INSTALL in registers and REGISTER_WEB in registers[
REGISTER_INSTALL]:
web_items = '\n'.join(registers[REGISTER_INSTALL][REGISTER_WEB])
bot_items = ''
if REGISTER_INSTALL in registers and REGISTER_BOT in registers[
REGISTER_INSTALL]:
bot_items = '\n'.join(registers[REGISTER_INSTALL][REGISTER_BOT])
web_and_bot_items = ''
if REGISTER_INSTALL in registers and REGISTER_WEB_AND_BOT in registers[
REGISTER_INSTALL]:
web_and_bot_items = '\n'.join(
registers[REGISTER_INSTALL][REGISTER_WEB_AND_BOT])
linked_paths = normalize_linked_paths(storage.get('place.linked'))
path = '{}/core/install.j2'.format(paths.get('catapult.templates'), )
generated = render_path(
path, {
'release_path': paths.get('remote.release'),
'release_name': storage.get('release.name'),
'user': storage.get('config.deploy.user'),
'service_name': storage.get('release.service'),
'file_name': 'catapult-{}'.format(storage.get('release.service')),
'deploy_path': storage.get('config.deploy.deploy_path'),
'linked_paths': linked_paths,
'web_items': web_items,
'bot_items': bot_items,
'web_and_bot_items': web_and_bot_items,
})
file = '{}/install.sh'.format(paths.get('local.release'))
with open(file, 'w') as open_file:
open_file.write(generated)
chmod(file, 0o0766)
def render(template_path, config, storage, paths):
path_parameter = '{}/nginx/parameter.j2'.format(
paths.get('catapult.templates'),
)
path_location = '{}/nginx/location.j2'.format(
paths.get('catapult.templates'),
)
locations = []
for location in config['locations']:
parameters = []
for key, value in location['configs'].items():
if type(value) is list:
for item in value:
generated = render_path(path_parameter, {
'key': key,
'value': item
})
parameters.append(generated)
else:
generated = render_path(path_parameter, {
'key': key,
'value': value
})
parameters.append(generated)
generated = render_path(path_location, {
'modifier': location['modifier'],
'match': location['match'],
'parameters': '\n'.join(parameters),
'storage': storage.get,
'paths': paths.get,
})
locations.append(generated)
index_files = config['index_files']
if type(index_files) is list:
index_files = ' '.join(index_files)
root = render_string(config['root'], {
'release_path': paths.get('remote.code'),
'storage': storage.get,
'paths': paths.get,
})
item = render_path(template_path, {
'root': root,
'index_files': index_files,
'locations': '\n'.join(locations),
'storage': storage.get,
'paths': paths.get,
})
path_nginx = '{}/nginx/nginx.j2'.format(
paths.get('catapult.templates'),
)
generated = render_path(path_nginx, {
'item': item,
'storage': storage.get,
'paths': paths.get,
})
return generated
def acquire_lock(self):
template_path = '{}/core/lock.j2'.format(
self.paths.get('catapult.templates')
)
generated = render_path(template_path, {
'service_folder': self.paths.get('remote.service_folder'),
'release_name': self.storage.get('release.name')
})
file = '{}/locker.sh'.format(self.paths.get('local.release'))
with open(file, 'w') as open_file:
open_file.write(generated)
os.chmod(file, 0o766)
self.logger.info('move lock file to all hosts')
self.ssh.move_on_hosts(
'{}/locker.sh'.format(self.paths.get('local.release')),
self.lock_path
)
self.ssh.execute_on_hosts('chmod +x {}'.format(self.lock_path))
self.logger.info('moving lock file to all hosts completed')
self.logger.info('start executing locking on hosts')
# if is force deploy
if self.storage.get('release.force'):
self.logger.info('release old lock because is force deploy')
self.release_lock()
locks = self.ssh.execute_on_hosts('{} acquire_lock'.format(self.lock_path))
self.logger.info('executing locking on hosts completed')
for host, result in locks.items():
if not result:
raise LockException(
'Can not get result about acquire lock. Stdout lock from host "{}" is empty'.format(host)
)
if result != 'true':
raise LockException(
'Can not obtain lock on host "{}", result is "{}"'.format(host, result)
)
# check equivalent releases on all hosts
# if is force deploy
if self.storage.get('release.force'):
return True
releases = self.ssh.execute_on_hosts('"{}" get_current_release'.format(self.lock_path))
release = None
for host, current_release in releases.items():
if not current_release:
raise LockException(
'Can not get current_release. Stdout lock from host "{}" is empty.'.format(host)
)
if release is None:
release = current_release
if release != current_release:
raise LockException(
'Release "{}" not compared for host "{}" release "{}"'.format(release, host, current_release)
)
