def test_issue35():
"""Issue 35: missing some vSphere data sources and resources."""
ts = Terrascript()
ts += r.vsphere_custom_attribute(
"attribute",
name="terraform-test-attribute",
managed_object_type="VirtualMachine",
)
ts += r.vsphere_datastore_cluster(
"datastore_cluster",
name="terraform-datastore-cluster-test",
datacenter_id="ID",
sdrs_enabled=True,
)
ts += r.vsphere_storage_drs_vm_override(
"drs_vm_override",
datastore_cluster_id="ID1",
virtual_machine_id="IS2",
sdrs_enabled=False,
)
ts += d.vsphere_custom_attribute("attribute",
name="terraform-test-attribute")
ts += d.vsphere_datastore_cluster("datastore_cluster",
name="datastore-cluster1",
datacenter_id="ID")
assert ts.validate() is True
def test_issue35():
"""Issue 35: missing some vSphere data sources and resources."""
ts = Terrascript()
ts += r.vsphere_custom_attribute('attribute',
name='terraform-test-attribute',
managed_object_type='VirtualMachine')
ts += r.vsphere_datastore_cluster('datastore_cluster',
name='terraform-datastore-cluster-test',
datacenter_id='ID',
sdrs_enabled=True)
ts += r.vsphere_storage_drs_vm_override('drs_vm_override',
datastore_cluster_id='ID1',
virtual_machine_id='IS2',
sdrs_enabled=False)
ts += d.vsphere_custom_attribute('attribute',
name='terraform-test-attribute')
ts += d.vsphere_datastore_cluster('datastore_cluster',
name='datastore-cluster1',
datacenter_id='ID')
assert ts.validate() is True
def create_variables(app_name, app_port, cluster_name):
var_file = config.tf_dir + "/variables.tf"
ts = Terrascript()
var_access_key = variable('aws_access_key', default='')
var_secret_key = variable('aws_secret_key', default='')
var_region = variable('region', default='eu-west-1')
var_ami = variable('ami', default='ami-066826c6a40879d75')
var_az_qty = variable('az_qty', default='2')
var_cluster_name = variable('ecs_cluster_name', default=cluster_name)
var_instance_type = variable('instance_type', default='t2.micro')
var_key_name = variable('key_name', default='rep')
var_app_port = variable('app_port', default=app_port)
var_app_name = variable('app_name', default=app_name)
ts += var_access_key
ts += var_secret_key
ts += var_region
ts += var_ami
ts += var_az_qty
ts += var_cluster_name
ts += var_instance_type
ts += var_key_name
ts += var_app_port
ts += var_app_name
print ("Creating file: " + var_file)
with open(var_file, 'w') as tfile:
tfile.write(ts.dump())
def test_update_raise_error():
ts = Terrascript()
var_region = variable('region')
exception_raised = False
try:
ts.update(var_region)
except TypeError as e:
exception_raised = True
assert exception_raised is True
def ts_digitalocean(version='>= 1.7, < 1.9', **kwargs):
ts_local = Terrascript()
do_token = ts_local.add(variable('do_token'))
default_parms = dict(token=do_token)
default_parms.update(kwargs)
ts_local.add(provider('digitalocean', version=version, **default_parms))
return ts_local
def ts_amazon_aws(version='=< 2.30', AWS_REGION_LIST=['us-east-1'], **kwargs):
ts_local = Terrascript()
aws_access_key = ts_local.add(variable('aws_access_key'))
aws_secret_key = ts_local.add(variable('aws_secret_key'))
aws_region = ts_local.add(variable('aws_region', default='us-east-1'))
default_params = dict(
version=version,
access_key=aws_access_key,
secret_key=aws_secret_key,
)
default_params.update(kwargs)
# Providers
aws_providers_map = {}
for region in AWS_REGION_LIST:
_provider = provider('aws',
region=region,
alias=region,
**default_params)
aws_providers_map[region] = ts_local.add(_provider)
ts_local.add(provider('aws', region=aws_region, **default_params))
# VPC
aws_vpc_map = {}
for region in AWS_REGION_LIST:
aws_provider = 'aws.{0}'.format(region)
vpc_name = 'vpc-{}'.format(region)
aws_vpc_map[region] = ts_local.add(
aws_vpc(vpc_name, provider=aws_provider))
return ts_local
def test_issue32():
"""Issue 32: provisioner return one line with provisioner.file instead a dictionary."""
ts = Terrascript()
ts += provider('aws', region='ap-southeast-2')
p = provisioner('local-exec', command='date > $(mktemp tmpXXXXXXX.terrascript)')
ts += aws_instance('I1', ami='ami-60a26a02', instance_type='t2.nano', provisioner=p)
j = ts.dump()
assert 'mktemp' in j
assert ts.validate() is True
def upload_file(
self,
content: str,
*,
destination: str = DEFAULT_UPLOAD_PATH,
ssh_user: str = DEFAULT_SSH_USER,
ssh_private_key: str,
ssh_host: str,
ssh_port: int = DEFAULT_SSH_PORT,
):
upload_config = Terrascript()
ssh_conn = self.gen_ssh_conn_config(
ssh_user=ssh_user,
ssh_private_key=ssh_private_key,
ssh_host=ssh_host,
ssh_port=ssh_port,
)
file_resource = self.null_resource(
"upload_file_resource",
provisioner=provisioner(
self.TERRAFORM_RESOURCE_FILE,
content=content,
destination=destination,
connection=ssh_conn,
),
)
upload_config += file_resource
return upload_config
def __init__(self,
integration,
integration_prefix,
thread_pool_size,
oc_map={}):
self.integration = integration
self.integration_prefix = integration_prefix
self.oc_map = oc_map
self.thread_pool_size = thread_pool_size
self.populate_configs_and_vars_from_vault()
tss = {}
locks = {}
for name, config in self.configs.items():
# Ref: https://github.com/mjuenema/python-terrascript#example
ts = Terrascript()
ts += provider('aws',
access_key=config['aws_access_key_id'],
secret_key=config['aws_secret_access_key'],
version=config['aws_provider_version'],
region=config['region'])
b = backend("s3",
access_key=config['aws_access_key_id'],
secret_key=config['aws_secret_access_key'],
bucket=config['bucket'],
key=config['{}_key'.format(integration)],
region=config['region'])
ts += terraform(backend=b)
tss[name] = ts
locks[name] = Lock()
self.tss = tss
self.locks = locks
def __init__(self, name, guestid, cpu, memory, folder=''):
self.ts = Terrascript()
self.name = name
self.guestid = guestid
self.cpu = cpu
self.memory = memory
self.folder = folder
self.provider = None
self.datacenter = None
self.datastore = None
self.template = None
self.gateway = None
self.disks = []
self.networks = []
self.interfaces = []
self.iface_customization = []
self.dns = []
def test_issue33():
"""Issue 33: Suggestion of syntax to terrascript"""
ts = Terrascript()
var_access_key = ts.add(variable('access_key'))
assert isinstance(var_access_key, variable)
var_secret_key = ts.add(variable('secret_key'))
assert isinstance(var_secret_key, variable)
var_region = ts.add(variable('region', default='us-east-1'))
assert isinstance(var_region, variable)
ts += provider('aws', access_key=var_access_key,
secret_key=var_secret_key, region=var_region
)
resource_aws_instance = ts.add(aws_instance('example', ami='ami-2757f631', instance_type='t2.micro'))
assert isinstance(resource_aws_instance, aws_instance)
ts += output('example_public_ip', value=resource_aws_instance.public_ip,
description='Public IP of example')
assert ts.validate() is True
def __init__(self, record_file_name, resource_type, id_field_name,
keywords_names):
keywords_names_list = str(keywords_names).replace(" ", "").split(',')
keywords_in_record = [
str(v).replace(" ", "").split('=')[0] for v in keywords_names_list
]
keywords_in_hcl = [
str(v).replace(" ", "").split('=')[1]
if '=' in str(v) else str(v).replace(" ", "").split('=')[0]
for v in keywords_names_list
]
keywords_names_dict = dict(zip(keywords_in_record, keywords_in_hcl))
self.file = open(record_file_name, 'r')
json_data = json.load(self.file)
alicloud_factory = factory(alicloud_instance, str(resource_type))
self.alicloud_hcl_store = Terrascript()
self.alicloud_cmd_store = []
for record in json_data:
assert record.get(id_field_name, "") != ""
factory_parameter_dict = {}
for k_record, k_hcl in keywords_names_dict.items():
v = json.dumps(
record[k_record], sort_keys=True
) if record[k_record] is dict else record[k_record]
factory_parameter_dict[k_hcl] = v
# factory_parameter_dict[k_hcl] = record[k_record]
resource_name = str(resource_type) + '-' + str(
record[id_field_name])
one_hcl_item = alicloud_factory(resource_name,
**factory_parameter_dict)
one_cmd_item = "terraform import {}.{} {}".format(
resource_type, resource_name, str(record[id_field_name]))
self.alicloud_hcl_store.add(one_hcl_item)
self.alicloud_cmd_store.append(one_cmd_item)
def get_aws_ec2_image(name='ubuntu-18-04-minimal',
aws_region_list=['us-east-1'], **kwargs):
ts_local = Terrascript()
filter_value = 'ubuntu-minimal/images/hvm-ssd/ubuntu-bionic-18.04-amd64-minimal-20190723*'
filter_value = kwargs.pop('filter_value', '') or filter_value
default_params = dict(
owners=['099720109477'],
most_recent=True,
filter=[
dict(
name='name',
values=[
filter_value
]
),
dict(
name='root-device-type',
values=[
'ebs'
]
)
]
)
default_params.update(kwargs)
aws_ami_ubuntu_18_04_minimal_map = {}
for region in aws_region_list:
_provider = 'aws.{}'.format(region)
_aws_ami = ts_local.add(aws_ami(
'{0}-{1}'.format(name, region),
provider=_provider,
**default_params
))
aws_ami_ubuntu_18_04_minimal_map[region] = _aws_ami
return aws_ami_ubuntu_18_04_minimal_map, ts_local
def remote_exec(self,
*,
ssh_user: str = DEFAULT_SSH_USER,
ssh_private_key: str,
ssh_host: str,
ssh_port: int = DEFAULT_SSH_PORT):
exec_config = Terrascript()
ssh_conn = self.gen_ssh_conn_config(ssh_user=ssh_user,
ssh_private_key=ssh_private_key,
ssh_host=ssh_host,
ssh_port=ssh_port)
exec_resource = self.null_resource('remote-exec',
provisioner=provisioner(
"remote-exec",
inline=['ls -la'],
connection=ssh_conn))
exec_config += exec_resource
return exec_config
def ts_cloudflare(version='< 1.9.0', **kwargs):
ts_local = Terrascript()
cloudflare_email = ts_local.add(variable('cloudflare_email'))
cloudflare_token = ts_local.add(variable('cloudflare_token', default=''))
default_parms = dict(
email=cloudflare_email,
token=cloudflare_token,
)
default_parms.update(kwargs)
ts_local.add(provider('cloudflare', version=version, **default_parms))
return ts_local
def gen_vultr_config(cls,
config_data: dict,
token: str,
public_key: str = None):
vultr_config = Terrascript()
vultr_provider = cls.vultr(api_key=token,
rate_limit=700,
retry_limit=3)
vultr_server = cls.vultr_server(
"server",
plan_id=config_data["plan_code"],
region_id=config_data["region_code"],
os_id=config_data["os_code"],
hostname=config_data["hostname"],
ssh_key_ids=config_data["ssh_keys"]
if config_data.get("ssh_keys") else [],
)
vultr_output_ip = Output("ip", value="${vultr_server.server.main_ip}")
vultr_output_id = Output("server_id",
value="${vultr_server.server.id}")
if public_key:
vultr_ssh_key = cls.vultr_ssh_key("vultr_ssh_key",
name="default_key",
ssh_key=public_key)
vultr_server["ssh_key_ids"] += [
"${vultr_ssh_key.vultr_ssh_key.id}"
]
vultr_config += vultr_ssh_key
vultr_config += vultr_provider
vultr_config += vultr_server
vultr_config += vultr_output_ip
vultr_config += vultr_output_id
return vultr_config
def gen_digital_ocean_config(cls,
config_data: dict,
token: str,
public_key: str = None):
do_config = Terrascript()
do_provider = provider.digitalocean(token=token)
do_droplet_resource = resource.digitalocean_droplet(
"server",
image=config_data["os_code"],
name=config_data["hostname"],
region=config_data["region_code"],
size=config_data["plan_code"],
ssh_keys=config_data["ssh_keys"]
if config_data.get("ssh_keys") else [],
)
if public_key:
digitalocean_ssh_key = resource.digitalocean_ssh_key(
"digitalocean_ssh_key",
name="default",
public_key=public_key,
)
do_droplet_resource["ssh_keys"] += [
"${digitalocean_ssh_key.digitalocean_ssh_key.id}"
]
do_config += digitalocean_ssh_key
do_output_ip = Output(
"ip", value="${digitalocean_droplet.server.ipv4_address}")
do_output_id = Output("server_id",
value="${digitalocean_droplet.server.id}")
do_config += do_provider
do_config += do_droplet_resource
do_config += do_output_ip
do_config += do_output_id
return do_config
def gen_vultr_config(cls,
config_data: dict,
token: str,
public_key: str = None):
vultr_config = Terrascript()
vultr_provider = cls.vultr(api_key=token,
rate_limit=700,
retry_limit=3)
vultr_server = cls.vultr_server(f"server",
plan_id=config_data['plan_code'],
region_id=config_data['region_code'],
os_id=config_data['os_code'],
hostname=config_data['hostname'],
ssh_key_ids=config_data['ssh_keys']
if config_data.get('ssh_keys') else [])
vultr_output_ip = Output('ip', value="${vultr_server.server.main_ip}")
vultr_output_id = Output('server_id',
value="${vultr_server.server.id}")
if public_key:
vultr_ssh_key = cls.vultr_ssh_key('vultr_ssh_key',
name='default_key',
ssh_key=public_key)
vultr_server["ssh_key_ids"] += [
"${vultr_ssh_key.vultr_ssh_key.id}"
]
vultr_config += vultr_ssh_key
vultr_config += vultr_provider
vultr_config += vultr_server
vultr_config += vultr_output_ip
vultr_config += vultr_output_id
return vultr_config
from terrascript import Terrascript, provider
from terrascript.google.r import *
from variables import *
ts = Terrascript()
## Add Resources to Terraform files
nw = ts.add(
google_compute_network('test-network',
name='test-pavan-nw',
auto_create_subnetworks=False,
routing_mode='GLOBAL'))
snw = ts.add(
google_compute_subnetwork('test-snw',
name='test-pavan-snw',
ip_cidr_range='10.5.0.0/16',
region=region,
network=nw.name))
firewall80 = ts.add(
google_compute_firewall('test-firewall-80',
name='test-pavan-80',
network=nw.name,
allow=[{
'protocol': 'tcp',
'ports': ['80', '443']
}],
source_ranges=['0.0.0.0/0'],
target_tags=['test-http']))
firewall22 = ts.add(
google_compute_firewall('test-firewall-22',
def test_update_add_value():
ts = Terrascript()
ts2 = Terrascript()
var_access_key = ts.add(variable('access_key'))
var_secret_key = ts.add(variable('secret_key'))
var_region = ts.add(variable('region', default='us-east-1'))
ts += provider('aws',
access_key=var_access_key,
secret_key=var_secret_key,
region=var_region)
resource_aws_instance = ts.add(
aws_instance('example', ami='ami-2757f631', instance_type='t2.micro'))
resource_aws_instance_2 = ts2.add(
aws_instance('example_second',
ami='ami-2757f631',
instance_type='t2.micro'))
assert isinstance(resource_aws_instance, aws_instance)
assert isinstance(resource_aws_instance_2, aws_instance)
# ts2 add resource "example_second" to ts
ts.update(ts2)
assert isinstance(ts, Terrascript)
assert isinstance(ts2, Terrascript)
ts_resources = ts.config.get('resource', {})
assert len(ts_resources.items()) == 1
ts_aws_instances = ts_resources.get('aws_instance')
assert len(ts_aws_instances.items()) == 2
assert resource_aws_instance._name in ts_aws_instances.keys()
assert resource_aws_instance_2._name in ts_aws_instances.keys()
assert ts.validate(delete=False) is True
def test_update_override_value():
ts = Terrascript()
ts2 = Terrascript()
ts.add(variable('access_key'))
ts.add(variable('secret_key'))
var_region = ts.add(variable('region', default='us-east-1'))
var_region2 = ts2.add(variable('region', default='ca-central-1'))
assert var_region._kwargs['default'] != var_region2._kwargs['default']
# ts2 override variable "region" in ts
ts.update(ts2)
assert isinstance(ts, Terrascript)
assert isinstance(ts2, Terrascript)
ts_variables = ts.config.get('variable', {})
assert len(ts_variables.items()) == 3 # ensure that only three
ts_var_region = ts_variables.get('region', {})
assert ts_var_region.get('default',
'') == var_region2._kwargs.get('default')
assert ts.validate(delete=False) is True
def process(terrayaml: str, metadata: dict, logger: KopfObjectLogger) -> str:
#
# User input YAML
#
env = jinja2.Environment()
env.filters['random_password'] = random_password
env.filters['random_name'] = random_name
template = T(template_text=terrayaml, environment=env).render(**metadata)
provision = yaml.load(template, Loader=yaml.FullLoader)
logger.info(f"provision this template {provision}")
# print(provision)
#
# Start terraform
#
meta = provision.pop('meta', {})
team = meta.get('team', 'oss')
profile = meta.get('profile', PROFILE)
environment = meta.get('environment', 'testing')
application = meta.get('application', 'wurkflow')
statefile_region = meta.get('statefile_region', 'eu-west-1')
ts = Terrascript()
ts += Terraform(required_version=">= 0.12.7").backend(
"s3",
bucket=REMOTE_STATE_S3_BUCKET,
key=
f"k8/terrayaml-operator/{team}/{environment}/{application}-terraform.tfstate",
region=statefile_region,
profile=ROOT_PROFILE)
#
# Extract the notify component
#
notify = provision.pop('notify')
if notify:
# tuple of email, key
recipient_emails = notify.get('email', [])
# append out infra provisioner email
recipient_emails.append('*****@*****.**')
recipients = get_recipients_from_pgp(recipient_emails=recipient_emails)
logger.info(f"notify these emails: {recipient_emails}")
#
# Parse the yaml
#
for provider in provision:
#print(f"----- output for provider: {provider.upper()} -----")
for resource, data in provision.get(provider).items():
#print(f"----- output for resource: {resource} -----")
for item in data.get('items', []):
api = TF_YAML_MAP.get(resource)
outputs = item.pop('outputs', [])
item_name = item.pop('name', random_name(value=resource))
tf_resource = api(item_name, **item)
ts.add(tf_resource)
# handle terraform outputs
for opt in outputs:
assert getattr(
tf_resource, opt.get('value')
), f"{tf_resource} has no attribute {opt.get('value')}"
ts.add(
Output(opt.get('name'),
value=getattr(tf_resource, opt.get('value'))))
# Add a provider (+= syntax)
ts += Provider('aws',
skip_metadata_api_check=True,
profile=profile,
region=REGION)
data = ts.dump()
# Plan
working_dir = tempfile.mkdtemp(dir='./runs')
crd_api = kubernetes.client.CustomObjectsApi()
selfLink = metadata.get('selfLink').split('/')
# update with planId
logger.info(f"planId: {working_dir}")
crd_api.patch_namespaced_custom_object(
group=selfLink[2],
version=selfLink[3],
name=selfLink[7],
namespace=selfLink[5],
plural=selfLink[6],
body={"spec": {
"planId": working_dir
}})
tf_response, tf_code = terraform(working_dir=working_dir,
data=data,
logger=logger)
logger.info(f"Terraform Plan result: {tf_response}")
if recipients:
logger.info(f"Send email to {recipients}")
send_email(to=recipients,
attachment=tf_response,
message_type='success' if tf_code != 1 else 'error')
else:
logger.info('No recipients defined')
logger.info(f"PlanId is {working_dir}")
return f"{working_dir}"
def __init__(self, name):
self.name = name
self.ts = Terrascript()
from terrascript import Terrascript, provider
from terrascript.google.r import *
from python_terraform import *
ts = Terrascript()
region = 'asia-south1'
ts += provider('google',
credentials='../service_account_gke.json',
project='learn-internal',
region=region)
nw = ts.add(
google_compute_network('test-network',
name='test-gke-nw',
auto_create_subnetworks=False,
routing_mode='GLOBAL'))
snw = ts.add(
google_compute_subnetwork('test-snw',
name='test-gke-snw',
ip_cidr_range='10.5.0.0/16',
region=region,
network=nw.name))
gke = ts.add(
google_container_cluster(
'primary',
name='my-cluster',
zone='asia-south1-a',
additional_zones=['asia-south1-b', 'asia-south1-c'],
cluster_ipv4_cidr='172.16.0.0/16',
from terrascript import Terrascript, provider
from python_terraform import *
from terrascript.google.r import google_compute_instance
from google.oauth2 import service_account
credentials = service_account.Credentials.from_service_account_file(
'/home/nasiruddin_happy/ns002p/service_account.json')
ts = Terrascript()
ts += provider(
'google',
credentials='/home/nasiruddin_happy/ns002p/service_account.json',
project='learn-internal',
region='us-central1')
inst = ts.add(
google_compute_instance('test-vm',
name='test-nasir1-tft',
boot_disk=[{
'initialize_params': [{
'image':
'debian-cloud/debian-9'
}]
}],
network_interface=[{
'network': 'default',
'access_config': {}
}],
machine_type='n1-standard-1',
zone='us-east1-b'))
print(ts.dump())
class TerrascriptVSphereVM:
def __init__(self, name, guestid, cpu, memory, folder=''):
self.ts = Terrascript()
self.name = name
self.guestid = guestid
self.cpu = cpu
self.memory = memory
self.folder = folder
self.provider = None
self.datacenter = None
self.datastore = None
self.template = None
self.gateway = None
self.disks = []
self.networks = []
self.interfaces = []
self.iface_customization = []
self.dns = []
def setProvider(self, host, username, password):
logger = logging.getLogger()
logger.debug("Set VSphere provider to {}".format(host))
self.provider = provider(
"vsphere",
user=username,
password=password,
vsphere_server=host,
allow_unverified_ssl=True)
self.ts.add(self.provider)
def setDatacenter(self, datacenter):
logger = logging.getLogger()
logger.debug("Set VSphere datacenter to {}".format(datacenter))
self.datacenter = vsphere_datacenter(
"dc",
name=datacenter)
self.ts.add(self.datacenter)
def setDatastore(self, datastore):
if not self.datacenter:
raise Exception
else:
logger = logging.getLogger()
logger.debug("Set VSphere datastore to {}".format(datastore))
self.datastore = vsphere_datastore(
"ds",
name=datastore,
datacenter_id=self.datacenter.id)
self.ts.add(self.datastore)
def setResourcePool(self, pool):
if not self.datacenter:
raise Exception
else:
logger = logging.getLogger()
logger.debug("Set VSphere Resource Pool to {}".format(pool))
self.pool = vsphere_resource_pool(
"pool",
name=pool,
datacenter_id=self.datacenter.id)
self.ts.add(self.pool)
def setTemplate(self, template):
if not self.datacenter:
raise Exception
else:
logger = logging.getLogger()
logger.debug("Set VSphere template to {}".format(template))
self.template = data_vsphere_virtual_machine(
"template",
name=template,
datacenter_id=self.datacenter.id)
self.ts.add(self.template)
def addDisk(self, size):
idx = len(self.disks) + 1
logger = logging.getLogger()
logger.debug("Add {}GB disk".format(size))
self.disks.append({
"label": "disk{}".format(idx),
"size": size,
"unit_number": idx})
def addNetworkInterface(self, dvp, ipaddr, cidr):
if not self.datacenter:
raise Exception
else:
logger = logging.getLogger()
logger.debug("Add network card on {} DVP, with {}/{}".format(dvp, ipaddr, cidr))
vnet = vsphere_network(
dvp,
name=dvp,
datacenter_id=self.datacenter.id)
self.networks.append(vnet)
self.ts.add(vnet)
self.interfaces.append({"network_id": vnet.id})
self.iface_customization.append({
"ipv4_address": ipaddr,
"ipv4_netmask": cidr})
def setDomain(self, domain):
logger = logging.getLogger()
logger.debug("Set {} domain".format(domain))
self.domain = domain
def setTimezone(self, timezone):
logger = logging.getLogger()
logger.debug("Set timezone to {}".format(timezone))
self.timezone = timezone
def setGateway(self, gateway):
logger = logging.getLogger()
logger.debug("Set default gateway to {}".format(gateway))
self.gateway = gateway
def addDns(self, dns):
logger = logging.getLogger()
logger.debug("Add {} to DNS list".format(dns))
self.dns.append(dns)
def saveConfiguration(self, filename):
linuxOptions = {}
linuxOptions["host_name"] = self.name
linuxOptions["domain"] = self.domain
linuxOptions["time_zone"] = self.timezone
customize = {}
customize["linux_options"] = linuxOptions
customize["network_interface"] = self.iface_customization
customize["ipv4_gateway"] = self.gateway
customize["dns_server_list"] = self.dns
clone = {}
clone["template_uuid"] = self.template.id
clone["linked_clone"] = False
clone["customize"] = customize
if self.folder != '':
self.virtualMachine = vsphere_virtual_machine(
'vm',
name=self.name,
resource_pool_id=self.pool.id,
datastore_id=self.datastore.id,
guest_id=self.guestid,
folder=self.folder,
num_cpus=self.cpu,
memory=self.memory,
network_interface=self.interfaces,
disk=self.disks,
clone=clone)
else:
self.virtualMachine = vsphere_virtual_machine(
'vm',
name=self.name,
resource_pool_id=self.pool.id,
datastore_id=self.datastore.id,
guest_id=self.guestid,
num_cpus=self.cpu,
memory=self.memory,
network_interface=self.interfaces,
disk=self.disks,
clone=clone)
self.ts.add(self.virtualMachine)
fd = open(filename, 'w')
fd.writelines(self.ts.dump())
fd.close()
return 0
def gen_site_docker_deploy_config(cls,
*,
docker_host: str = DEFAULT_DOCKER_HOST,
site_name: str = None,
template_tar_bytes: bytes = None,
script: str = None,
ssh_user: str = DEFAULT_SSH_USER,
ssh_private_key: str,
ssh_host: str,
ssh_port: int = DEFAULT_SSH_PORT):
config = Terrascript()
docker_provider = provider.docker(host=docker_host,
connection=cls.gen_ssh_conn_config(
ssh_user=ssh_user,
ssh_private_key=ssh_private_key,
ssh_host=ssh_host,
ssh_port=ssh_port))
docker_image_resource = resource.docker_image(
'nginx_image',
name=cls.DEFAULT_NGINX_DOCKER_IMAGE,
)
docker_container_resource = resource.docker_container(
'nginx_container',
name=f"{site_name}-container-${{random_pet.docker_pet_name.id}}",
image="${docker_image.nginx_image.latest}",
restart="always",
start=True,
ports={'internal': 80},
upload=[])
docker_name_resource = resource.random_pet(
'docker_pet_name',
length=1,
)
if template_tar_bytes:
template_tar_file = f"{site_name}-tar-${{random_pet.docker_pet_name.id}}.tar.gz",
template_tar_file_content = base64.b64encode(
template_tar_bytes).decode('utf8')
template_tar_path = f"{cls.DEFAULT_NGINX_DOCKER_CONTAINER_HTML_PATH}/${template_tar_file}"
# self.upload_file(
# content='conf/myapp.conf',
# destination=f"{self.DEFAULT_UPLOAD_PATH}/${template_tar_file}",
# ssh_user=ssh_user,
# ssh_private_key=ssh_private_key,
# ssh_host=ssh_host,
# ssh_port=ssh_port
# )
docker_container_resource['upload'].append({
'content_base64':
template_tar_file_content,
'file':
template_tar_path
})
if script:
entrypoint_sh_content = TemplateRender().render(
cls.DEFAULT_NGINX_DOCKER_ENTRYPOINT_PATH,
init_script_path=cls.DEFAULT_DOCKER_ENTRYPOINT_PATH,
html_path=cls.DEFAULT_NGINX_DOCKER_CONTAINER_HTML_PATH)
docker_container_resource['upload'].append({
'content':
entrypoint_sh_content,
'file':
cls.DEFAULT_DOCKER_ENTRYPOINT_PATH
})
config += docker_provider
config += docker_image_resource
config += docker_container_resource
config += docker_name_resource
return config
from terrascript import Terrascript
from terrascript import provider
from terrascript import variable
from terrascript.aws.d import aws_vpc
ts = Terrascript()
#########################################
# DigitalOcean
def ts_digitalocean(version='>= 1.7, < 1.9', **kwargs):
ts_local = Terrascript()
do_token = ts_local.add(variable('do_token'))
default_parms = dict(token=do_token)
default_parms.update(kwargs)
ts_local.add(provider('digitalocean', version=version, **default_parms))
return ts_local
#########################################
# Cloudflare
def ts_cloudflare(version='< 1.9.0', **kwargs):
ts_local = Terrascript()
from pip._vendor.html5lib.constants import EOF
from terrascript import Terrascript, provider
from terrascript.google.r import *
from nw import *
from variables import *
ts = Terrascript()
# metadata_startup_script = '${data.start_up.startup_script.rendered}'
inst = ts.add(
google_compute_instance(
'test-vm',
name='test-pavan-tft',
boot_disk=[{
'initialize_params': [{
'image': 'debian-cloud/debian-9'
}]
}],
network_interface=[{
'subnetwork': snw.self_link,
'access_config': {}
}],
machine_type='n1-standard-1',
tags=['test-http', 'test-ssh'],
zone=zone,
metadata_startup_script=
'#!/bin/bash\napt-get update -y\napt-get install nginx -y\nservice nginx start'
))
file = open("./terraform/vm.tf.json", "w")
file.write(ts.dump())
from terrascript import Terrascript
from terrascript.digitalocean.r import digitalocean_ssh_key
ts = Terrascript()
def do_ssh_key(name, **kwargs):
"""
Example of public_key:
public_key='${file("/tmp/ssh_keys/soar-staging-keypair.pub")}'
"""
default_params = dict(name=name)
default_params.update(kwargs)
return digitalocean_ssh_key(name, **default_params)
ts_key_pairs = ts
__all__ = ['ts_key_pairs', 'do_ssh_key']
