'BRANCH_NAME': '',

'BUILD_ID': 'abcdef12-3456-7890-abcd-ef0123456789',

'COMMIT_SHA': '',

'PROJECT_ID': 'dummy-project-id',

'REPO_NAME': '',

'REVISION_ID': '',

'TAG_NAME': '',

"""Return a shell-escaped, variable substituted, version of the string s.

def sub(match):

"""Perform a single substitution."""

variable_name = match.group(1)

if variable_name[0] == '{':

# Strip curly brackets

variable_name = variable_name[1:-1]

if variable_name == '$':

value = '$'

elif variable_name not in substitutions:

# Variables must be set

raise ValueError(

'Variable "{}" used without being defined. Try adding '

'it to the --substitutions flag'.format(variable_name))

else:

value = substitutions.get(variable_name)

substitutions_used.add(variable_name)

return value

substituted_s = re.sub(SUBSTITUTION_REGEX, sub, s)

quoted_s = shlex.quote(substituted_s)

"""Read and validate a cloudbuild recipe

if not isinstance(raw_config, dict):

raise ValueError(

'Expected {} contents to be of type "dict", but found type "{}"'.

format(args.config, type(raw_config)))

raw_steps = validation_utils.get_field_value(raw_config, 'steps', list)

if not raw_steps:

raise ValueError('No steps defined in {}'.format(args.config))

steps = [get_step(raw_step) for raw_step in raw_steps]

return CloudBuild(

output_script=args.output_script,

run=args.run,

steps=steps,

substitutions=args.substitutions,

"""Read and validate a single cloudbuild step

if not isinstance(raw_step, dict):

raise ValueError(

'Expected step to be of type "dict", but found type "{}"'.

format(type(raw_step)))

raw_args = validation_utils.get_field_value(raw_step, 'args', list)

args = [validation_utils.get_field_value(raw_args, index, str)

for index in range(len(raw_args))]

dir_ = validation_utils.get_field_value(raw_step, 'dir', str)

raw_env = validation_utils.get_field_value(raw_step, 'env', list)

env = [validation_utils.get_field_value(raw_env, index, str)

for index in range(len(raw_env))]

name = validation_utils.get_field_value(raw_step, 'name', str)

return Step(

args=args,

dir_=dir_,

env=env,

name=name,

"""Generate a single shell command to run for a single cloudbuild step

quoted_args = [sub_and_quote(arg, substitutions, substitutions_used)

for arg in step.args]

quoted_env = []

for env in step.env:

quoted_env.extend(['--env', sub_and_quote(env, substitutions,

substitutions_used)])

quoted_name = sub_and_quote(step.name, substitutions, substitutions_used)

workdir = '/workspace'

if step.dir_:

workdir = os.path.join(workdir, sub_and_quote(step.dir_, substitutions,

substitutions_used))

process_args = [

'docker',

'run',

'--volume',

'/var/run/docker.sock:/var/run/docker.sock',

'--volume',

'/root/.docker:/root/.docker',

'--volume',

'${HOST_WORKSPACE}:/workspace',

'--workdir',

workdir,

] + quoted_env + [quoted_name] + quoted_args

"""Generate the contents of a shell script

# This deletes everything in /workspace including hidden files,

# but not /workspace itself

cleanup_step = Step(

args=['rm', '-rf', '/workspace'],

dir_='',

env=[],

name=DEBIAN_IMAGE,

)

cleanup_command = generate_command(cleanup_step, {}, set())

subs_used = set()

docker_commands = [

generate_command(step, cloudbuild.substitutions, subs_used)

for step in cloudbuild.steps]

# Check that all user variables were referenced at least once

user_subs_unused = [name for name in cloudbuild.substitutions.keys()

if name not in subs_used and name[0] == '_']

if user_subs_unused:

nice_list = '"' + '", "'.join(sorted(user_subs_unused)) + '"'

raise ValueError(

'User substitution variables {} were defined in the '

'--substitution flag but never used in the cloudbuild file.'.

format(nice_list))

cleanup_str = ' '.join(cleanup_command)

docker_lines = []

for docker_command in docker_commands:

line = ' '.join(docker_command) + '\n\n'

docker_lines.append(line)

docker_str = ''.join(docker_lines)

s = BUILD_SCRIPT_TEMPLATE.format(cleanup_str=cleanup_str,

docker_str=docker_str)

"""Set executable bit(s) on file"""

# http://stackoverflow.com/questions/12791997

mode = os.stat(path).st_mode

mode |= (mode & 0o444) >> 2 # copy R bits to X

"""Write a shell script to a file."""

print('Writing build script to {}'.format(cloudbuild.output_script))

with io.open(cloudbuild.output_script, 'w', encoding='utf8') as outfile:

outfile.write(contents)

"""Execute the steps of a cloudbuild.yaml locally

# Load and parse cloudbuild.yaml

with io.open(args.config, 'r', encoding='utf8') as cloudbuild_file:

raw_config = yaml.safe_load(cloudbuild_file)

# Determine configuration

cloudbuild = get_cloudbuild(raw_config, args)

# Create shell script

contents = generate_script(cloudbuild)

write_script(cloudbuild, contents)

# Run shell script

if cloudbuild.run:

print('Running {}'.format(cloudbuild.output_script))

args = [os.path.abspath(cloudbuild.output_script)]

"""Parse and validate command line flags"""

parser = argparse.ArgumentParser(

description='Process cloudbuild.yaml locally to build Docker images')

parser.add_argument(

'--config',

type=functools.partial(

validation_utils.validate_arg_regex, flag_regex=PRINTABLE_REGEX),

default='cloudbuild.yaml',

help='Path to cloudbuild.yaml file'

)

parser.add_argument(

'--output_script',

type=functools.partial(

validation_utils.validate_arg_regex, flag_regex=PRINTABLE_REGEX),

help='Filename to write shell script to',

)

parser.add_argument(

'--no-run',

action='store_false',

help='Create shell script but don\'t execute it',

dest='run',

)

parser.add_argument(

'--substitutions',

type=validation_utils.validate_arg_dict,

default={},

help='Parameters to be substituted in the build specification',

)

args = parser.parse_args(argv[1:])

if not args.output_script:

args.output_script = args.config + "_local.sh"