src, keep_last_versions,

config_file='config.yaml', profile_name=None,

):

"""Deletes old deployed versions of the function in AWS Lambda.

if keep_last_versions <= 0:

print("Won't delete all versions. Please do this manually")

else:

path_to_config_file = os.path.join(src, config_file)

cfg = read_cfg(path_to_config_file, profile_name)

profile_name = cfg.get('profile')

aws_access_key_id = cfg.get('aws_access_key_id')

aws_secret_access_key = cfg.get('aws_secret_access_key')

client = get_client(

'lambda', profile_name, aws_access_key_id, aws_secret_access_key,

cfg.get('region'),

)

response = client.list_versions_by_function(

FunctionName=cfg.get('function_name'),

)

versions = response.get('Versions')

if len(response.get('Versions')) < keep_last_versions:

print('Nothing to delete. (Too few versions published)')

else:

version_numbers = [elem.get('Version') for elem in

versions[1:-keep_last_versions]]

for version_number in version_numbers:

try:

client.delete_function(

FunctionName=cfg.get('function_name'),

Qualifier=version_number,

)

except botocore.exceptions.ClientError as e:

print('Skipping Version {}: {}'

src, requirements=None, local_package=None,

config_file='config.yaml', profile_name=None,

preserve_vpc=False

):

"""Deploys a new function to AWS Lambda.

# Load and parse the config file.

path_to_config_file = os.path.join(src, config_file)

cfg = read_cfg(path_to_config_file, profile_name)

# Copy all the pip dependencies required to run your code into a temporary

# folder then add the handler file in the root of this directory.

# Zip the contents of this folder into a single file and output to the dist

# directory.

path_to_zip_file = build(

src, config_file=config_file,

requirements=requirements,

local_package=local_package,

)

existing_config = get_function_config(cfg)

if existing_config:

update_function(cfg, path_to_zip_file, existing_config, preserve_vpc=preserve_vpc)

else:

src, requirements=None, local_package=None,

config_file='config.yaml', profile_name=None,

preserve_vpc=False

):

"""Deploys a new function via AWS S3.

# Load and parse the config file.

path_to_config_file = os.path.join(src, config_file)

cfg = read_cfg(path_to_config_file, profile_name)

# Copy all the pip dependencies required to run your code into a temporary

# folder then add the handler file in the root of this directory.

# Zip the contents of this folder into a single file and output to the dist

# directory.

path_to_zip_file = build(

src, config_file=config_file, requirements=requirements,

local_package=local_package,

)

use_s3 = True

s3_file = upload_s3(cfg, path_to_zip_file, use_s3)

existing_config = get_function_config(cfg)

if existing_config:

update_function(cfg, path_to_zip_file, existing_config, use_s3=use_s3,

s3_file=s3_file, preserve_vpc=preserve_vpc)

else:

src, requirements=None, local_package=None,

config_file='config.yaml', profile_name=None,

):

"""Uploads a new function to AWS S3.

# Load and parse the config file.

path_to_config_file = os.path.join(src, config_file)

cfg = read_cfg(path_to_config_file, profile_name)

# Copy all the pip dependencies required to run your code into a temporary

# folder then add the handler file in the root of this directory.

# Zip the contents of this folder into a single file and output to the dist

# directory.

path_to_zip_file = build(

src, config_file=config_file, requirements=requirements,

local_package=local_package,

)

src, event_file='event.json',

config_file='config.yaml', profile_name=None,

verbose=False,

):

"""Simulates a call to your function.

# Load and parse the config file.

path_to_config_file = os.path.join(src, config_file)

cfg = read_cfg(path_to_config_file, profile_name)

# Set AWS_PROFILE environment variable based on `--profile` option.

if profile_name:

os.environ['AWS_PROFILE'] = profile_name

# Load environment variables from the config file into the actual

# environment.

env_vars = cfg.get('environment_variables')

if env_vars:

for key, value in env_vars.items():

os.environ[key] = get_environment_variable_value(value)

# Load and parse event file.

path_to_event_file = os.path.join(src, event_file)

event = read(path_to_event_file, loader=json.loads)

# Tweak to allow module to import local modules

try:

sys.path.index(src)

except ValueError:

sys.path.append(src)

handler = cfg.get('handler')

# Inspect the handler string (<module>.<function name>) and translate it

# into a function we can execute.

fn = get_callable_handler_function(src, handler)

# TODO: look into mocking the ``context`` variable, currently being passed

# as None.

start = time.time()

results = fn(event, None)

end = time.time()

print('{0}'.format(results))

if verbose:

print('\nexecution time: {:.8f}s\nfunction execution '

"""Copies template files to a given directory.

templates_path = os.path.join(

os.path.dirname(os.path.abspath(__file__)), 'project_templates',

)

for filename in os.listdir(templates_path):

if (minimal and filename == 'event.json') or filename.endswith('.pyc'):

continue

dest_path = os.path.join(templates_path, filename)

if not os.path.isdir(dest_path):

src, requirements=None, local_package=None,

config_file='config.yaml', profile_name=None,

):

"""Builds the file bundle.

# Load and parse the config file.

path_to_config_file = os.path.join(src, config_file)

cfg = read_cfg(path_to_config_file, profile_name)

# Get the absolute path to the output directory and create it if it doesn't

# already exist.

dist_directory = cfg.get('dist_directory', 'dist')

path_to_dist = os.path.join(src, dist_directory)

mkdir(path_to_dist)

# Combine the name of the Lambda function with the current timestamp to use

# for the output filename.

function_name = cfg.get('function_name')

output_filename = '{0}-{1}.zip'.format(timestamp(), function_name)

path_to_temp = mkdtemp(prefix='aws-lambda')

pip_install_to_target(

path_to_temp,

requirements=requirements,

local_package=local_package,

)

# Hack for Zope.

if 'zope' in os.listdir(path_to_temp):

print(

'Zope packages detected; fixing Zope package paths to '

'make them importable.',

)

# Touch.

with open(os.path.join(path_to_temp, 'zope/__init__.py'), 'wb'):

pass

# Gracefully handle whether ".zip" was included in the filename or not.

output_filename = (

'{0}.zip'.format(output_filename)

if not output_filename.endswith('.zip')

else output_filename

)

# Allow definition of source code directories we want to build into our

# zipped package.

build_config = defaultdict(**cfg.get('build', {}))

build_source_directories = build_config.get('source_directories', '')

build_source_directories = (

build_source_directories

if build_source_directories is not None

else ''

)

source_directories = [

d.strip() for d in build_source_directories.split(',')

]

files = []

for filename in os.listdir(src):

if os.path.isfile(filename):

if filename == '.DS_Store':

continue

if filename == config_file:

continue

print('Bundling: %r' % filename)

files.append(os.path.join(src, filename))

elif os.path.isdir(filename) and filename in source_directories:

print('Bundling directory: %r' % filename)

files.append(os.path.join(src, filename))

# "cd" into `temp_path` directory.

os.chdir(path_to_temp)

for f in files:

if os.path.isfile(f):

_, filename = os.path.split(f)

# Copy handler file into root of the packages folder.

copyfile(f, os.path.join(path_to_temp, filename))

elif os.path.isdir(f):

destination_folder = os.path.join(path_to_temp, f[len(src) + 1:])

copytree(f, destination_folder)

# Zip them together into a single file.

# TODO: Delete temp directory created once the archive has been compiled.

path_to_zip_file = archive('./', path_to_dist, output_filename)

"""Tranlate a string of the form "module.function" into a callable

# "cd" into `src` directory.

os.chdir(src)

module_name, function_name = handler.split('.')

filename = get_handler_filename(handler)

path_to_module_file = os.path.join(src, filename)

module = load_source(module_name, path_to_module_file)

"""Shortcut to get the filename from the handler string.

module_name, _ = handler.split('.')

"""Install all packages listed to the target directory.

def _filter_blacklist(package):

blacklist = ['-i', '#', 'Python==', 'python-lambda==']

return all(package.startswith(entry) is False for entry in blacklist)

filtered_packages = filter(_filter_blacklist, packages)

for package in filtered_packages:

if package.startswith('-e '):

package = package.replace('-e ', '')

print('Installing {package}'.format(package=package))

pip_major_version = [int(v) for v in pip.__version__.split('.')][0]

if pip_major_version >= 10:

from pip._internal import main

main(['install', package, '-t', path, '--ignore-installed'])

else:

"""For a given active virtualenv, gather all installed pip packages then

packages = []

if not requirements:

print('Gathering pip packages')

pip_major_version = [int(v) for v in pip.__version__.split('.')][0]

if pip_major_version >= 10:

from pip._internal import operations

packages.extend(operations.freeze.freeze())

else:

packages.extend(pip.operations.freeze.freeze())

else:

if os.path.exists(requirements):

print('Gathering requirement packages')

data = read(requirements)

packages.extend(data.splitlines())

if not packages:

print('No dependency packages installed!')

if local_package is not None:

if not isinstance(local_package, (list, tuple)):

local_package = [local_package]

for l_package in local_package:

packages.append(l_package)

profile_name, aws_access_key_id, aws_secret_access_key,

region=None,

):

"""Query STS for a users' account_id"""

client = get_client(

'sts', profile_name, aws_access_key_id, aws_secret_access_key,

region,

)

client, profile_name, aws_access_key_id, aws_secret_access_key,

region=None,

):

"""Shortcut for getting an initialized instance of the boto3 client."""

boto3.setup_default_session(

profile_name=profile_name,

aws_access_key_id=aws_access_key_id,

aws_secret_access_key=aws_secret_access_key,

region_name=region,

)

"""Register and upload a function to AWS Lambda."""

print('Creating your new Lambda function')

byte_stream = read(path_to_zip_file, binary_file=True)

profile_name = cfg.get('profile')

aws_access_key_id = cfg.get('aws_access_key_id')

aws_secret_access_key = cfg.get('aws_secret_access_key')

account_id = get_account_id(

profile_name, aws_access_key_id, aws_secret_access_key, cfg.get(

'region',

),

)

role = get_role_name(

cfg.get('region'), account_id,

cfg.get('role', 'lambda_basic_execution'),

)

client = get_client(

'lambda', profile_name, aws_access_key_id, aws_secret_access_key,

cfg.get('region'),

)

# Do we prefer development variable over config?

buck_name = (

os.environ.get('S3_BUCKET_NAME') or cfg.get('bucket_name')

)

func_name = (

os.environ.get('LAMBDA_FUNCTION_NAME') or cfg.get('function_name')

)

print('Creating lambda function with name: {}'.format(func_name))

if use_s3:

kwargs = {

'FunctionName': func_name,

'Runtime': cfg.get('runtime', 'python2.7'),

'Role': role,

'Handler': cfg.get('handler'),

'Code': {

'S3Bucket': '{}'.format(buck_name),

'S3Key': '{}'.format(s3_file),

},

'Description': cfg.get('description'),

'Timeout': cfg.get('timeout', 15),

'MemorySize': cfg.get('memory_size', 512),

'VpcConfig': {

'SubnetIds': cfg.get('subnet_ids', []),

'SecurityGroupIds': cfg.get('security_group_ids', []),

},

'Publish': True,

}

else:

kwargs = {

'FunctionName': func_name,

'Runtime': cfg.get('runtime', 'python2.7'),

'Role': role,

'Handler': cfg.get('handler'),

'Code': {'ZipFile': byte_stream},

'Description': cfg.get('description'),

'Timeout': cfg.get('timeout', 15),

'MemorySize': cfg.get('memory_size', 512),

'VpcConfig': {

'SubnetIds': cfg.get('subnet_ids', []),

'SecurityGroupIds': cfg.get('security_group_ids', []),

},

'Publish': True,

}

if 'tags' in cfg:

kwargs.update(

Tags={

key: str(value)

for key, value in cfg.get('tags').items()

}

)

if 'environment_variables' in cfg:

kwargs.update(

Environment={

'Variables': {

key: get_environment_variable_value(value)

for key, value

in cfg.get('environment_variables').items()

},

},

)

cfg, path_to_zip_file, existing_cfg, use_s3=False, s3_file=None, preserve_vpc=False

):

"""Updates the code of an existing Lambda function"""

print('Updating your Lambda function')

byte_stream = read(path_to_zip_file, binary_file=True)

profile_name = cfg.get('profile')

aws_access_key_id = cfg.get('aws_access_key_id')

aws_secret_access_key = cfg.get('aws_secret_access_key')

account_id = get_account_id(

profile_name, aws_access_key_id, aws_secret_access_key, cfg.get(

'region',

),

)

role = get_role_name(

cfg.get('region'), account_id,

cfg.get('role', 'lambda_basic_execution'),

)

client = get_client(

'lambda', profile_name, aws_access_key_id, aws_secret_access_key,

cfg.get('region'),

)

# Do we prefer development variable over config?

buck_name = (

os.environ.get('S3_BUCKET_NAME') or cfg.get('bucket_name')

)

if use_s3:

client.update_function_code(

FunctionName=cfg.get('function_name'),

S3Bucket='{}'.format(buck_name),

S3Key='{}'.format(s3_file),

Publish=True,

)

else:

client.update_function_code(

FunctionName=cfg.get('function_name'),

ZipFile=byte_stream,

Publish=True,

)

kwargs = {

'FunctionName': cfg.get('function_name'),

'Role': role,

'Runtime': cfg.get('runtime'),

'Handler': cfg.get('handler'),

'Description': cfg.get('description'),

'Timeout': cfg.get('timeout', 15),

'MemorySize': cfg.get('memory_size', 512),

}

if preserve_vpc:

kwargs['VpcConfig'] = existing_cfg.get('Configuration', {}).get('VpcConfig')

if kwargs['VpcConfig'] is None:

kwargs['VpcConfig'] = {

'SubnetIds': cfg.get('subnet_ids', []),

'SecurityGroupIds': cfg.get('security_group_ids', []),

}

else:

del kwargs['VpcConfig']['VpcId']

else:

kwargs['VpcConfig'] = {

'SubnetIds': cfg.get('subnet_ids', []),

'SecurityGroupIds': cfg.get('security_group_ids', []),

}

if 'environment_variables' in cfg:

kwargs.update(

Environment={

'Variables': {

key: str(get_environment_variable_value(value))

for key, value

in cfg.get('environment_variables').items()

},

},

)

ret = client.update_function_configuration(**kwargs)

if 'tags' in cfg:

tags = {

key: str(value)

for key, value in cfg.get('tags').items()

}

if tags != existing_cfg.get('Tags'):

if existing_cfg.get('Tags'):

client.untag_resource(Resource=ret['FunctionArn'],

TagKeys=list(existing_cfg['Tags'].keys()))

"""Upload a function to AWS S3."""

print('Uploading your new Lambda function')

profile_name = cfg.get('profile')

aws_access_key_id = cfg.get('aws_access_key_id')

aws_secret_access_key = cfg.get('aws_secret_access_key')

client = get_client(

's3', profile_name, aws_access_key_id, aws_secret_access_key,

cfg.get('region'),

)

byte_stream = b''

with open(path_to_zip_file, mode='rb') as fh:

byte_stream = fh.read()

s3_key_prefix = cfg.get('s3_key_prefix', '/dist')

checksum = hashlib.new('md5', byte_stream).hexdigest()

timestamp = str(time.time())

filename = '{prefix}{checksum}-{ts}.zip'.format(

prefix=s3_key_prefix, checksum=checksum, ts=timestamp,

)

# Do we prefer development variable over config?

buck_name = (

os.environ.get('S3_BUCKET_NAME') or cfg.get('bucket_name')

)

func_name = (

os.environ.get('LAMBDA_FUNCTION_NAME') or cfg.get('function_name')

)

kwargs = {

'Bucket': '{}'.format(buck_name),

'Key': '{}'.format(filename),

'Body': byte_stream,

}

client.put_object(**kwargs)

print('Finished uploading {} to S3 bucket {}'.format(func_name, buck_name))

if use_s3:

"""Check whether a function exists or not and return its config"""

function_name = cfg.get('function_name')

profile_name = cfg.get('profile')

aws_access_key_id = cfg.get('aws_access_key_id')

aws_secret_access_key = cfg.get('aws_secret_access_key')

client = get_client(

'lambda', profile_name, aws_access_key_id, aws_secret_access_key,

cfg.get('region'),

)

try:

return client.get_function(FunctionName=function_name)

except client.exceptions.ResourceNotFoundException as e:

if 'Function not found' in str(e):

cfg = read(path_to_config_file, loader=yaml.load)

if profile_name is not None:

cfg['profile'] = profile_name

elif 'AWS_PROFILE' in os.environ:

cfg['profile'] = os.environ['AWS_PROFILE']