def env_update(env_name, target=None, config=None, aws_key=None, aws_secret=None):
settings = get_project_settings()
report_async({"command": f"dg env update"}, settings=settings, status="start")
projectName = settings["project"]["name"]
envDetails = api.get_environment_details(projectName, env_name)
envPk = envDetails["pk"]
data = {}
if target is not None:
data["target"] = target
if config is not None:
data["config_options"] = parse_env_config_options(config)
cliOptions = parse_env_config_options(config)
try:
configOptions = read_env_config_from_file(env_name, overrideOptions=cliOptions)
except yaml.YAMLError as ex:
print(f"Could not parse config file: {exc}")
return
data["config_options"] = configOptions
data["config_options"] = data["config_options"]
if aws_key is not None:
data["aws_key"] = aws_key
if aws_secret is not None:
data["aws_secret"] = aws_secret
response = api.update_environment(projectName, envPk, data)
Bcolors.okgreen("environment udpated succesfully")
report_async({"command": f"dg env update"}, settings=settings, status="stop")
def fetch_github_token():
webbrowser.open(GITHUB_LOGIN_ENDPOINT)
token = ""
while len(token) < 1:
Bcolors.warn("Please follow browser and paste token here")
token = input()
save_github_token(token)
Bcolors.okgreen("Authentication successful!")
def sync():
"""
Sync all current services with backend
"""
settings = get_project_settings()
projectName = settings["project"]["name"]
services = settings["services"]
for key, service in services.items():
service["name"] = service["service_name"]
servicesList = json.dumps(list(services.values()))
api.sync_services(projectName, {"services": servicesList})
Bcolors.okgreen("digger.yml services synced with backend successfully")
def env_cost(env_name):
settings = get_project_settings()
report_async({"command": f"dg env cost"}, settings=settings, status="start")
projectName = settings["project"]["name"]
envDetails = api.get_environment_details(projectName, env_name)
envPk = envDetails["pk"]
spinner = Halo(text="Estimating environment costs ...", spinner="dots")
spinner.start()
response = api.estimate_cost(projectName, envPk)
spinner.stop()
Bcolors.okgreen("Your cost estimates are shown below")
print("--------------------------------")
pprint(response.content)
report_async({"command": f"dg env cost"}, settings=settings, status="complete")
def env_plan(env_name):
settings = get_project_settings()
report_async({"command": f"dg env plan"}, settings=settings, status="start")
projectName = settings["project"]["name"]
envDetails = api.get_environment_details(projectName, env_name)
envPk = envDetails["pk"]
spinner = Halo(text="Planning environment ...", spinner="dots")
spinner.start()
response = api.plan_environment(projectName, envPk)
spinner.stop()
Bcolors.okgreen("Your environment plan is shown below")
print("--------------------------------")
data = json.loads(response.content)
pprint(data["output"])
report_async({"command": f"dg env plan"}, settings=settings, status="complete")
def env_sync_tform(env_name):
settings = get_project_settings()
report_async({"command": f"dg env sync-tform"}, settings=settings, status="start")
project_name = settings["project"]["name"]
services = settings["services"]
env_path = f"digger-master/{env_name}"
tform_path = f"{env_path}/terraform"
target = settings["environments"][env_name]["target"]
region = settings["environments"][env_name]["region"]
Path(env_path).mkdir(parents=True, exist_ok=True)
Path(tform_path).mkdir(parents=True, exist_ok=True)
shutil.rmtree(tform_path)
# tform generation
spinner = Halo(text="Updating terraform ...", spinner="dots")
spinner.start()
download_terraform_files(project_name, env_name, region, target, services, tform_path)
spinner.stop()
Bcolors.okgreen("Terraform updated successfully")
report_async({"command": f"dg env sync-tform"}, settings=settings, status="complete")
def detect_service(self, path):
Bcolors.warn("... Searching for digger.yml")
dgtest = self.digger_test(path)
if dgtest != False:
Bcolors.okgreen("digger.yml file found .. loading settings")
return dgtest
Bcolors.warn("[x] digger.yml not found")
Bcolors.warn("... Searching for dockerfile")
dockertest = self.docker_test(path)
if dockertest != False:
return dockertest
Bcolors.warn("[x] dockerfile not found")
Bcolors.warn("... Searching for package.json")
jstest = self.javascript_test(path)
if jstest != False:
return jstest
Bcolors.warn("[x] package.json not found")
return Service(self.UNKNOWN, None)
def perform_release(settings, env_name, service_key):
project_name = settings["project"]["name"]
service_name = settings["services"][service_key]["service_name"]
service_type = settings["services"][service_key]["service_type"]
service_path = settings["services"][service_key]["path"]
service_runtime = settings["services"][service_key]["lambda_runtime"]
envDetails = api.get_environment_details(project_name, env_name)
envId = envDetails["pk"]
region = envDetails["region"]
# nextjs service doesn't have infra deployment stage
if service_type != ServiceType.NEXTJS:
response = api.get_last_infra_deployment_info(project_name, envId)
infraDeploymentDetails = json.loads(response.content)
credentials = retreive_aws_creds(project_name, env_name, aws_key=aws_key, aws_secret=aws_secret, prompt=prompt)
awsKey = credentials["aws_key"]
awsSecret = credentials["aws_secret"]
envVars = {} #get_env_vars(env_name, service_key)
spinner = Halo(text=f"deploying {service_name}...", spinner="dots")
spinner.start()
if service_type == ServiceType.WEBAPP:
os.environ["AWS_ACCESS_KEY_ID"] = awsKey
os.environ["AWS_SECRET_ACCESS_KEY"] = awsSecret
build_directory = settings["services"][service_key]["build_directory"]
# TODO: find better way to extract bucket name of webapp
bucket_name = infraDeploymentDetails["terraform_outputs"][f"{service_name}_bucket_main"]["value"]
subprocess.run(["aws", "s3", "sync", f"{build_directory}", f"s3://{bucket_name}"], check=True)
Bcolors.okgreen("Upload succeeded!")
elif service_type == ServiceType.NEXTJS:
print(f"ServiceType is NextJS, do nothing for now.")
elif service_type == ServiceType.CONTAINER or (service_type == ServiceType.SERVERLESS and service_runtime == "Docker"):
docker_registry = infraDeploymentDetails["outputs"]["services"][service_name]["docker_registry"]
lb_url = infraDeploymentDetails["outputs"]["services"][service_name]["lb_url"]
region = infraDeploymentDetails["region"]
response = api.deploy_to_infra({
"environment_pk": f"{envId}",
"cluster_name": f"{project_name}-{env_name}",
"service_name": f"{service_name}",
"task_name": f"{project_name}-{env_name}-{service_name}",
"region": region,
"image_url": f"{docker_registry}:{tag}",
"tag": tag,
"aws_key": awsKey,
"aws_secret": awsSecret,
"env_vars": envVars
})
output = json.loads(response.content)
print(output["msg"])
print(f"your deployment URL: http://{lb_url}")
elif service_type == ServiceType.SERVERLESS and service_runtime != "Docker":
# perform deployment for lambda functions that are not using docker runtime
if service_runtime == "Node.js":
print("Installing packages ...")
subprocess.run(["npm", "i", "--prefix", service_path])
elif service_runtime == "Python3.9":
print("Installing packages ...")
# needs more work .. we need to include python requirements folder into the zip path
reqs_path = os.path.join(service_path, "requirements.txt")
deps_path = service_path
subprocess.run(["pip", "install", "--target", deps_path, "-r", reqs_path])
lambda_handler = settings["services"][service_key]["lambda_handler"]
response = deploy_lambda_function_code(
project_name,
env_name,
service_name,
region,
service_path,
lambda_handler,
awsKey,
awsSecret
)
print(f"lambda deployed successfully {response}")
else:
Bcolors.warn(f"Service type: {service_type} does not support release command, skipping ...")
spinner.stop()
def env_vars_create(env_name, file, prompt=True, overwrite=False):
"""
Update environment variables for an environment based on .yml file
--overwrite forces overwriting of existing variables
"""
action = "vars:create"
if not os.path.exists(file):
Bcolors.fail("File does not exist")
sys.exit(1)
settings = get_project_settings()
report_async({"command": f"dg env {action}"}, settings=settings, status="start")
project_name = settings["project"]["name"]
if prompt and not overwrite:
Bcolors.warn("Note: Environment update will fail if duplicate variables names exist. Proceed? (Y,N)")
Bcolors.okgreen("Hint: If you wish to overwrite existing vars use the --overwrite option along with this command")
answer = input()
if answer.lower() != "y":
Bcolors.fail("Aborting ...")
sys.exit(1)
try:
varsToCreate = yload(open(file), Loader=Loader)
except Exception as e:
Bcolors.fail("Error while loading vars file")
print(e)
sys.exit(1)
envDetails = api.get_environment_details(project_name, env_name)
envId = envDetails["pk"]
services = api.list_services(project_name)
services = json.loads(services.content)["results"]
servicesDict = {}
for s in services:
servicesDict[s["name"]] = s
for serviceName, varItems in varsToCreate.items():
if serviceName == "all":
servicePk = None
else:
if serviceName not in servicesDict.keys():
Bcolors.fail(f"serviceName not found in backend: {serviceName}")
sys.exit(1)
servicePk = servicesDict[serviceName]["pk"]
Bcolors.okgreen(f"Creating vars for service: {serviceName}:")
for varName, varValue in varItems.items():
Bcolors.okgreen(f"> Creating var ({varName}, {varValue}) ...")
response = api.environment_vars_create(
project_name,
envId,
varName,
varValue,
servicePk,
overwrite=overwrite
)
Bcolors.okgreen(f">> Created!")
report_async({"command": f"dg env {action}"}, settings=settings, status="complete")
def env_create(
env_name,
target=None,
region=None,
aws_key=None,
aws_secret=None,
config=[],
prompt=True
):
try:
env_name_validate(env_name)
except ValueError as e:
Bcolors.warn(str(e))
sys.exit()
# parsing config options
cliOptions = parse_env_config_options(config)
try:
configOptions = read_env_config_from_file(env_name, overrideOptions=cliOptions)
except yaml.YAMLError as ex:
print(f"Could not read config file: {exc}")
return
targets = DiggerTargets.TARGETS
settings = get_project_settings()
report_async({"command": f"dg env create"}, settings=settings, status="start")
project_name = settings["project"]["name"]
if target is None:
questions = [
{
'type': 'list',
'name': 'target',
'message': 'Select target',
'choices': targets.keys()
},
]
answers = pyprompt(questions)
target_key = answers["target"]
target = targets[target_key]
if target == "other":
ok = "n"
while (ok.lower() != "y"):
print("Enter target: ", end="")
target = input()
print(f"Confirm Target {target} (Y/N)?", end="")
ok = input()
elif target_key not in [DiggerTargets.FARGATE, DiggerTargets.LAMBDA]:
Bcolors.fail("This option is currently unsupported! Please try again")
return
else:
# use target from cli arg
target = target
if region is None:
questions = [
{
'type': 'list',
'name': 'region',
'message': 'Select region',
'choices': AWS_REGIONS,
'default': "us-east-1"
},
]
answers = pyprompt(questions)
region = answers["region"]
if region not in AWS_REGIONS:
Bcolors.fail("This region is not valid! Please try again")
return
credentials = retreive_aws_creds(project_name, env_name, aws_key=aws_key, aws_secret=aws_secret, prompt=prompt)
aws_key = credentials["aws_key"]
aws_secret = credentials["aws_secret"]
spinner = Halo(text="Creating environment", spinner="dots")
spinner.start()
response = api.create_environment(project_name, {
"name": env_name,
"target": target,
"region": region,
"aws_key": aws_key,
"aws_secret": aws_secret,
"config_options": configOptions
})
spinner.stop()
Bcolors.okgreen("Environment created successfully")
Bcolors.okgreen(f"Use this command to run it: dg env apply {env_name}")