class RollbackAction(BaseAction):
def __init__(self, args):
super(RollbackAction, self).__init__(args)
self._set_alias = SetAliasAction(args)
def action(self):
func_name = self._config.get_function_name()
client = self.get_lambda_client()
remote_conf = client.get_function_conf(func_name)
alias_name = self._set_alias.get_alias_name()
if len(remote_conf) == 0:
raise Exception(
'"{}" function does not exist. Please `deploy` first.'.format(func_name))
pre_version = client.get_previous_version(func_name, alias_name)
if pre_version is None:
raise Exception(
'There is no previous version. ' +
'Please `deploy` with `publish` option or `versioning` configuration.')
self._logger.info(
'[Function] Previous version: {}'.format(pre_version))
self._set_alias._version = pre_version
self._set_alias.action()
def __init__(self, args):
super(DeployAction, self).__init__(args)
self._publish = args.publish
self._set_alias = SetAliasAction(args)
self._single_file = args.single_file
self._no_libs = args.no_libs
self._env = parse_env_args(args.env)
class RollbackAction(BaseAction):
def __init__(self, args):
super(RollbackAction, self).__init__(args)
self._set_alias = SetAliasAction(args)
def action(self):
func_name = self._config.get_function_name()
client = self.get_client()
remote_conf = client.get_function_conf(func_name)
alias_name = self._set_alias.get_alias_name()
if len(remote_conf) == 0:
raise Exception(
'"{}" function is not exists. Please `deploy` at first.'.format(func_name))
pre_version = client.get_previous_version(func_name, alias_name)
if pre_version is None:
raise Exception(
'There is no previous version. ' +
'Please `deploy` with `publish` option or `versioning` configuration.')
self._logger.info(
'[Function] Previous version: {}'.format(pre_version))
self._set_alias._version = pre_version
self._set_alias.action()
def test_get_version_target_not_exists(self):
c = Mock()
c.get_alias = Mock(return_value={})
args = default_args()
args.target = 'foo'
action = SetAliasAction(args)
action.get_lambda_client = Mock(return_value=c)
action.get_version('foo')
def test_get_version_target_not_exists(self):
c = Mock()
c.get_alias = Mock(return_value={})
args = default_args()
args.target = 'foo'
action = SetAliasAction(args)
action.get_lambda_client = Mock(return_value=c)
action.get_version('foo')
def test_get_version(self):
action = SetAliasAction(default_args())
eq_(action.get_version('foo'), '$LATEST')
args = default_args()
args.version = '1'
action = SetAliasAction(args)
eq_(action.get_version('foo'), '1')
c = Mock()
c.get_alias = Mock(return_value={'FunctionVersion': '2'})
args = default_args()
args.target = 'foo'
action = SetAliasAction(args)
action.get_lambda_client = Mock(return_value=c)
eq_(action.get_version('foo'), '2')
def test_get_version(self):
action = SetAliasAction(default_args())
eq_(action.get_version(), '$LATEST')
args = default_args()
args.version = '1'
action = SetAliasAction(args)
eq_(action.get_version(), '1')
def test_get_alias_name(self):
action = SetAliasAction(default_args())
eq_(action.get_alias_name(), 'test')
args = default_args()
args.alias = 'foo'
action = SetAliasAction(args)
eq_(action.get_alias_name(), 'foo')
def test_get_version(self):
action = SetAliasAction(default_args())
eq_(action.get_version('foo'), '$LATEST')
args = default_args()
args.version = '1'
action = SetAliasAction(args)
eq_(action.get_version('foo'), '1')
c = Mock()
c.get_alias = Mock(return_value={'FunctionVersion': '2'})
args = default_args()
args.target = 'foo'
action = SetAliasAction(args)
action.get_lambda_client = Mock(return_value=c)
eq_(action.get_version('foo'), '2')
class DeployAction(BaseAction):
def __init__(self, args):
super(DeployAction, self).__init__(args)
self._publish = args.publish
self._set_alias = SetAliasAction(args)
self._single_file = args.single_file
self._no_libs = args.no_libs
def action(self):
archive_name = self._config.get_archive_name()
function_filename = self._config.get_function_filename()
secret = self._config.generate_lambda_secret()
exclude = self._config.get_exclude()
archive = Archive(filename=archive_name,
function_filename=function_filename,
secret=secret,
single_file=self._single_file,
no_libs=self._no_libs,
exclude=exclude)
func_name = self._config.get_function_name()
local_conf = self._config.get_configuration()
zipfile = archive.create_zipfile()
client = self.get_client()
remote_conf = client.get_function_conf(func_name)
alias_name = self._set_alias.get_alias_name()
remote_size = client.calculate_capacity()
local_size = archive.get_size()
new_version = None
cur_version = None
if len(remote_conf) == 0:
self._logger.warn(
'[Function] Create new function "{}"'.format(func_name))
self._print_diff(prefix='[Function]',
remote=remote_conf,
local=local_conf,
keys=CONF_DIFF_KEYS)
if len(remote_conf) > 0:
if self._enable_versioning():
cur_version = client.get_alias(
func_name, alias_name).get('FunctionVersion')
else:
local_size -= remote_conf['CodeSize']
client.update_function_conf(local_conf)
self._print_capacity(remote=remote_size, local=local_size)
new_version = client.update_function_code(
zipfile, local_conf, self._enable_versioning())
else:
if self._enable_versioning():
local_size *= 2
self._print_capacity(remote=remote_size, local=local_size)
new_version = client.create_function(zipfile, local_conf,
self._enable_versioning())
zipfile.close()
if new_version is not None:
self._logger.info(
'[Function] Deployed version: {}'.format(new_version))
if cur_version is not None:
self._logger.info(
'[Function] Previous version: {}'.format(cur_version))
self._set_alias._alias = previous_alias(alias_name)
self._set_alias._version = cur_version
self._set_alias.action()
if alias_name is not None:
self._set_alias._alias = alias_name
self._set_alias._version = new_version
self._set_alias.action()
def _enable_versioning(self):
if self._publish:
return True
return self._config.enable_versioning()
def _print_capacity(self, remote, local):
self._logger.warn('[Function] Capacity: {r} Bytes -> {t} Bytes'.format(
r='{:,d}'.format(remote), t='{:,d}'.format(remote + local)))
def __init__(self, args):
super(RollbackAction, self).__init__(args)
self._set_alias = SetAliasAction(args)
def __init__(self, args):
super(DeployAction, self).__init__(args)
self._publish = args.publish
self._set_alias = SetAliasAction(args)
self._single_file = args.single_file
self._no_libs = args.no_libs
def test_print_alias_diff(self):
action = SetAliasAction(default_args())
action._print_alias_diff('name', {'FunctionVersion': 1}, 2)
def test_action(self, c):
# Dry run
args = default_args()
args.alias = 'foo'
action = SetAliasAction(args)
action.action()
# No dry run
args = default_args()
args.alias = 'foo'
args.dry_run = False
# New
with patch('lamvery.actions.base.Client') as c:
c.get_alias = Mock(return_value={})
action = SetAliasAction(args)
action.action()
# Update
with patch('lamvery.actions.base.Client') as c:
c.get_alias = Mock(return_value={'FunctionVersion': '1'})
action = SetAliasAction(args)
action.action()
def test_action_not_exists(self, c):
action = SetAliasAction(default_args())
action.get_alias_name = Mock(return_value=None)
action.action()
def __init__(self, args):
super(RollbackAction, self).__init__(args)
self._set_alias = SetAliasAction(args)
class DeployAction(BaseAction):
def __init__(self, args):
super(DeployAction, self).__init__(args)
self._publish = args.publish
self._set_alias = SetAliasAction(args)
self._single_file = args.single_file
self._no_libs = args.no_libs
def action(self):
archive_name = self._config.get_archive_name()
function_filename = self._config.get_function_filename()
secret = self._config.generate_lambda_secret()
exclude = self._config.get_exclude()
archive = Archive(filename=archive_name,
function_filename=function_filename,
secret=secret,
single_file=self._single_file,
no_libs=self._no_libs,
exclude=exclude)
func_name = self._config.get_function_name()
local_conf = self._config.get_configuration()
zipfile = archive.create_zipfile()
client = self.get_client()
remote_conf = client.get_function_conf(func_name)
alias_name = self._set_alias.get_alias_name()
remote_size = client.calculate_capacity()
local_size = archive.get_size()
new_version = None
cur_version = None
if len(remote_conf) == 0:
self._logger.warn(
'[Function] Create new function "{}"'.format(func_name))
self._print_diff(
prefix='[Function]',
remote=remote_conf, local=local_conf, keys=CONF_DIFF_KEYS)
if len(remote_conf) > 0:
if self._enable_versioning():
cur_version = client.get_alias(
func_name, alias_name).get('FunctionVersion')
else:
local_size -= remote_conf['CodeSize']
client.update_function_conf(local_conf)
self._print_capacity(remote=remote_size, local=local_size)
new_version = client.update_function_code(
zipfile, local_conf, self._enable_versioning())
else:
if self._enable_versioning():
local_size *= 2
self._print_capacity(
remote=remote_size, local=local_size)
new_version = client.create_function(
zipfile, local_conf, self._enable_versioning())
zipfile.close()
if new_version is not None:
self._logger.info(
'[Function] Deployed version: {}'.format(new_version))
if cur_version is not None:
self._logger.info(
'[Function] Previous version: {}'.format(cur_version))
self._set_alias._alias = previous_alias(alias_name)
self._set_alias._version = cur_version
self._set_alias.action()
if alias_name is not None:
self._set_alias._alias = alias_name
self._set_alias._version = new_version
self._set_alias.action()
def _enable_versioning(self):
if self._publish:
return True
return self._config.enable_versioning()
def _print_capacity(self, remote, local):
self._logger.warn(
'[Function] Capacity: {r} Bytes -> {t} Bytes'.format(
r='{:,d}'.format(remote), t='{:,d}'.format(remote + local)))
