.dodo.py.template

import os
import uuid
import sys
import zipfile
from datetime import date, timedelta
from pathlib import *
from hx.dodo_helpers import MarkerFile, DockerContext, DockerImage, rglobfiles, YarnNodeModules, fileAge
from hx.dodo_infrastructure import run_dockerized_terraform, update_camus2, lambdazip_file_task, lambdazip_pydir_task

# Use helix's packaged terraform and associated tools
# from the image helixta/terraform at this version:
TERRAFORM_IMAGE = 'helixta/terraform:2019-03-11'

HERE = Path('.')

es_tool_build_file = (HERE/'typescript/build/hx-terraform/tools/es-tool.js')

provisioning_tools = HERE / 'generate/.stack-work/install/x86_64-linux/lts-10.10/8.2.2/bin/hx-provisioning-tools'

local_lambda_zip_sources = HERE/'lambdas'
lambda_zip_sources = HERE/'typescript/hx-terraform/aws/lambdas'
lambda_es_tool = HERE/'typescript/build/hx-terraform/tools/es-tool.js'

lambda_source_files = (list(local_lambda_zip_sources.glob("*")) + list(lambda_zip_sources.glob("*")) + [ lambda_es_tool ])

tfplan = HERE / 'terraform/tfplan'

# These are actually symlinked so they share package.json
nodemodules = YarnNodeModules(HERE / 'typescript')
hxtnodemodules = YarnNodeModules(HERE / 'typescript'/'hx-terraform')

def dockerized_terraform(cmd):
    return run_dockerized_terraform(TERRAFORM_IMAGE, cmd)

def task_node_modules():
    yield nodemodules.task()
    yield hxtnodemodules.task()

def generate_providers():
    return '(cd typescript; ./node_modules/.bin/ts-node hx-terraform/tools/gen-providers.ts)'

def generate_tf():
    return '(cd typescript; ./node_modules/.bin/ts-node main.ts)'

def yarn_build():
    return '(cd typescript; yarn build)'

def confirm_apply():
    print("You are about to apply changes to live infrastructure.")
    print("Please confirm you have checked the plan and wish to proceed")
    print("by entering yes: ", end='')
    s = input().strip()
    if s != "yes":
        print("terraform apply aborted")
        sys.exit(1)

def check_plan():
    """ Ensure the plan is not too old """

    if not tfplan.exists():
        print("Error - no plan file found - Run 'doit plan' first.")
        exit(1)

    ageThresholdSeconds = 2 * 60
    if fileAge(tfplan) > ageThresholdSeconds:
        print("Plan has expired - please try again.")
        expire_plan()
        exit(1)

def expire_plan():
    tfplan.unlink()

def task_lambda_zips():
    # Required for compiling typescript
    yield {
        'name': 'yarn build',
        'actions': [ yarn_build() ],
        'targets': [ es_tool_build_file ],
        'file_dep': [ (HERE/'typescript/hx-terraform/tools/es-tool.ts') ]
    }
    for f in lambda_source_files:
        zipfile = (HERE/'build/lambdas/'/f.stem).with_suffix('.zip')
        if f.suffix == '.py':
            yield lambdazip_file_task(zipfile, f)
        elif f.suffix == '.js':
            yield {
                **lambdazip_file_task(zipfile, f),
                'file_dep': [ es_tool_build_file ],
            }
        elif f.is_dir() and (f/'requirements.txt').is_file():
            yield lambdazip_pydir_task(zipfile, f)

def task_generate_providers():
    return {
        'doc' : 'Generate typescript for providers',
        'actions' : [generate_providers()],
        'file_dep': [
            HERE/'typescript/hx-terraform/tools/gen-helpers.ts',
            HERE/'typescript/hx-terraform/tools/gen-providers.ts'] +
            [f for f in rglobfiles(HERE/'typescript/hx-terraform/providers') if not f.name == 'resources.ts'] +
            nodemodules.file_dep() +
            hxtnodemodules.file_dep(),
        'targets': [
            HERE/'typescript/hx-terraform/providers/aws/resources.ts',
            HERE/'typescript/hx-terraform/providers/random/resources.ts',
        ]
    }

def task_generate_terraform():
    return {
        'doc' : 'Generate terraform files from the terraform EDSL',
        'actions' : [
            generate_tf()
        ],
        'task_dep': ['generate_providers'],
        'file_dep': [f for f in rglobfiles(HERE/'typescript') if not 'node_modules' in f.parts] +
            nodemodules.file_dep() +
            hxtnodemodules.file_dep(),
        'targets': [
            HERE/'terraform'/'.manifest.adhoc',
            HERE/'terraform'/'.manifest.backend',
            HERE/'terraform'/'.manifest.providers',
            HERE/'terraform'/'.manifest.resources'
        ],
        'verbosity':2
    }
def task_generate():
    return {
        'doc' : '(alias of generate_terraform)',
        'task_dep': ['generate_terraform'],
        'actions': [],
        'uptodate': [False],
    }

def task_terraform_init():
    return {
        'doc' : '(Re)Initialize terraform on initial setup and/or changes to backend/provider',
        'actions': [ dockerized_terraform(['init', '--force-copy']) ],
        'file_dep': [
            HERE/'terraform'/'.manifest.backend',
            HERE/'terraform'/'.manifest.providers'
        ],
        'verbosity' : 2
    }

def task_plan():
    return {
        'doc' : 'Execute terraform plan to show pending infrastructure changes and save the plan',
        'actions': [
            dockerized_terraform(['plan', '-parallelism=20', '-out=tfplan']) +
                "| grep --line-buffered -v 'This plan was saved to'" +
                "| grep --line-buffered -v 'To perform exactly these actions'" +
                "| grep --line-buffered -v 'terraform apply'",
            'echo "Review the above plan and run:\n  doit apply"'
        ],
        'task_dep': [ 'terraform_init', ],
        'file_dep':
            lambda_zipfiles() +
            [
                HERE/'terraform'/'.manifest.adhoc',
                HERE/'terraform'/'.manifest.backend',
                HERE/'terraform'/'.manifest.providers',
                HERE/'terraform'/'.manifest.resources'
            ] +
            [ f for f in rglobfiles(HERE/"terraform") if f.name != 'tfplan' and '.terraform' not in f.parts ],
        'targets': [
            HERE/"terraform/tfplan"
        ],
        'verbosity' : 2,
        'uptodate': [False]  # always run
    }

def task_apply():
  return {
      'doc' : 'Execute terraform apply to make any pending infrastructure changes according to the plan',
      'actions': [
          check_plan,
          confirm_apply,
          dockerized_terraform(['apply', 'tfplan']),
          expire_plan   # invalidate the plan after using it
        ],
      'file_dep': lambda_zipfiles(),       # no doit dependency back into tfplan - you have to run "doit plan" explicitly
      'verbosity' : 2,
      'uptodate': [False],
  }



def task_refresh():
    return {
        'doc' : 'Run terraform refresh to update state from current deployed resources',
        'actions': [ dockerized_terraform(['refresh']) ],
        'verbosity' : 2,
        'uptodate': [False],
    }

def task_output():
    return {
        'doc' : 'Run terraform to show terraform outputs',
        'actions': [ dockerized_terraform(['output']) ],
        'verbosity' : 2,
        'uptodate': [False],
    }

def task_update_camus2():
    return update_camus2(HERE)

def lambda_zipfiles():
    zipfiles = []
    for f in lambda_source_files:
        zipfile = (HERE/'build/lambdas/'/f.stem).with_suffix('.zip')
        zipfiles.append(zipfile)
    return zipfiles