Python Template.add_parameter方法代码示例

# 需要导入模块: from troposphere import Template [as 别名]
# 或者: from troposphere.Template import add_parameter [as 别名]
 def test_add_or_get_returns_with_out_adding_duplicate(self):
     t = Template()
     p = Parameter("param", Type="String", Default="foo")
     t.add_parameter(p)
     result = t.get_or_add_parameter(p)
     self.assertEquals(t.parameters["param"], p)
     self.assertEquals(result, p)
     self.assertEquals(len(t.parameters), 1)

# 需要导入模块: from troposphere import Template [as 别名]
# 或者: from troposphere.Template import add_parameter [as 别名]
def template():
    t = Template()
    for p in parameters.values():
        t.add_parameter(p)
    for k in conditions:
        t.add_condition(k, conditions[k])
    for r in resources.values():
        t.add_resource(r)
    return t

# 需要导入模块: from troposphere import Template [as 别名]
# 或者: from troposphere.Template import add_parameter [as 别名]
    def test_parameter_label_replace(self):
        t = Template()
        p1 = t.add_parameter(Parameter("Foo"))
        t.add_parameter(Parameter("Bar"))
        t.set_parameter_label(p1, "Foo label")
        t.set_parameter_label("Foo", "Bar label")

        self.assertEqual(t.metadata, {
            "AWS::CloudFormation::Interface": {
                "ParameterLabels": {
                    "Foo": {"default": "Bar label"},
                },
            },
        })

# 需要导入模块: from troposphere import Template [as 别名]
# 或者: from troposphere.Template import add_parameter [as 别名]
    def output_template(self):
        template = Template()
        for parameter in self.parameters:
            template.add_parameter(parameter)

        for mapping in self.mappings:
            template.add_mapping(mapping[0], mapping[1])

        for resource in self.resources:
            template.add_resource(resource)

        for output in self.outputs:
            template.add_output(output)

        print template.to_json()
        return

# 需要导入模块: from troposphere import Template [as 别名]
# 或者: from troposphere.Template import add_parameter [as 别名]
def sceptre_handler(sceptre_user_data):
    t = Template()

    cidr_block_param = t.add_parameter(Parameter(
        "CidrBlock",
        Type="String",
        Default="10.0.0.0/16",
    ))

    vpc = t.add_resource(VPC(
        "VirtualPrivateCloud",
        CidrBlock=Ref(cidr_block_param),
        InstanceTenancy="default",
        EnableDnsSupport=True,
        EnableDnsHostnames=True,
    ))

    igw = t.add_resource(InternetGateway(
        "InternetGateway",
    ))

    t.add_resource(VPCGatewayAttachment(
        "IGWAttachment",
        VpcId=Ref(vpc),
        InternetGatewayId=Ref(igw),
    ))

    t.add_output(Output(
        "VpcId",
        Description="New VPC ID",
        Value=Ref(vpc)
    ))
    return t.to_json()

# 需要导入模块: from troposphere import Template [as 别名]
# 或者: from troposphere.Template import add_parameter [as 别名]
def render(context):
    secgroup = ec2_security(context)
    instance = ec2instance(context)

    template = Template()
    template.add_resource(secgroup)
    template.add_resource(instance)

    keyname = template.add_parameter(Parameter(KEYPAIR, **{
        "Type": "String",
        "Description": "EC2 KeyPair that enables SSH access to this instance",
    }))
    
    cfn_outputs = outputs()

    if context['project']['aws'].has_key('rds'):
        map(template.add_resource, rdsinstance(context))
        cfn_outputs.extend([
            mkoutput("RDSHost", "Connection endpoint for the DB cluster", (RDS_TITLE, "Endpoint.Address")),
            mkoutput("RDSPort", "The port number on which the database accepts connections", (RDS_TITLE, "Endpoint.Port")),])
    
    if context['project']['aws'].has_key('ext'):
        map(template.add_resource, ext_volume(context))

    if context['hostname']: # None if one couldn't be generated
        template.add_resource(external_dns(context))
        template.add_resource(internal_dns(context))        
        cfn_outputs.extend([
            mkoutput("DomainName", "Domain name of the newly created EC2 instance", Ref(R53_EXT_TITLE)),
            mkoutput("IntDomainName", "Domain name of the newly created EC2 instance", Ref(R53_INT_TITLE))])

    map(template.add_output, cfn_outputs)
    return template.to_json()

# 需要导入模块: from troposphere import Template [as 别名]
# 或者: from troposphere.Template import add_parameter [as 别名]
    def test_parameter_group(self):
        t = Template()
        p1 = t.add_parameter(Parameter("Foo"))
        t.add_parameter(Parameter("Bar"))
        t.add_parameter_to_group(p1, "gr")
        t.add_parameter_to_group("Bar", "gr")

        self.assertEqual(t.metadata, {
            "AWS::CloudFormation::Interface": {
                "ParameterGroups": [
                    {
                        "Label": {"default": "gr"},
                        "Parameters": ["Foo", "Bar"],
                    },
                ],
            },
        })

# 需要导入模块: from troposphere import Template [as 别名]
# 或者: from troposphere.Template import add_parameter [as 别名]
 def InstanceVolumeTemplate(self):
     self.stack_name = "volumeTest{0}".format(int(time.time()))
     template = Template()
     keyname_param = template.add_parameter(Parameter("KeyName", Description="Name of an existing EC2 KeyPair "
                                                                             "to enable SSH access to the instance",
                                                      Type="String",))
     template.add_mapping('RegionMap', {"": {"AMI": self.tester.get_emi().id}})
     for i in xrange(2):
         ec2_instance = template.add_resource(ec2.Instance("Instance{0}".format(i),
                                                           ImageId=FindInMap("RegionMap", Ref("AWS::Region"), "AMI"),
                                                           InstanceType="t1.micro", KeyName=Ref(keyname_param),
                                                           SecurityGroups=[self.group.name], UserData=Base64("80")))
         vol = template.add_resource(ec2.Volume("Volume{0}".format(i), Size="8",
                                                AvailabilityZone=GetAtt("Instance{0}".format(i), "AvailabilityZone")))
         mount = template.add_resource(ec2.VolumeAttachment("MountPt{0}".format(i), InstanceId=Ref("Instance{0}".format(i)),
                                                            VolumeId=Ref("Volume{0}".format(i)), Device="/dev/vdc"))
     stack = self.tester.create_stack(self.stack_name, template.to_json(), parameters=[("KeyName",self.keypair.name)])
     def stack_completed():
         return self.tester.cloudformation.describe_stacks(self.stack_name).status == "CREATE_COMPLETE"
     self.tester.wait_for_result(stack_completed, True, timeout=600)
     self.tester.delete_stack(self.stack_name)

# 需要导入模块: from troposphere import Template [as 别名]
# 或者: from troposphere.Template import add_parameter [as 别名]
def GenerateGlobalLayer():
    t = Template()

    t.add_description("""\
    Global Layer
    """)

    stackname_param = t.add_parameter(Parameter(
        "StackName",
        Description="Environment Name (default: StepGlobals)",
        Type="String",
        Default="StepGlobals",
    ))

    crontab_table = t.add_resource(dynamodb.Table(
        "scheduleTable",
        AttributeDefinitions=[
            dynamodb.AttributeDefinition("taskname", "S"),
        ],
        KeySchema=[
            dynamodb.Key("taskname", "HASH")
        ],
        ProvisionedThroughput=dynamodb.ProvisionedThroughput(
            1,
            1
        )
    ))

    t.add_output([
        Output(
            "crontabtablename",
            Description="Crontab Table Name",
            Value=Ref(crontab_table),
        )
    ])

    return t

# 需要导入模块: from troposphere import Template [as 别名]
# 或者: from troposphere.Template import add_parameter [as 别名]
#!/usr/bin/env python

from troposphere import Ref, Template
import troposphere.ec2 as ec2
from troposphere import GetAZs, Parameter, Output, Ref, GetAtt, FindInMap
import sys
t = Template()

count = 0


#Define some things, I think
environmentName = t.add_parameter(Parameter("EnvironmentName", Description="Environment Name",
	Default="Demo",
	Type="String"))
vpn_sg = t.add_parameter(Parameter("vpnsg",
	Description = "VPN SG",
	Type = "String"))

web_sg = t.add_parameter(Parameter("websg", 
	Description="Web ELB SG", 
	Type="String"))

keyname = t.add_parameter(Parameter("demokey", 
	Description="Demo description", 
	Type="String"))

mgmtkey = t.add_parameter(Parameter("mgmtkey",
	Description = "VPN ssh key",
	Type = "String"))

# 需要导入模块: from troposphere import Template [as 别名]
# 或者: from troposphere.Template import add_parameter [as 别名]
 def test_parameter(self):
     t = Template()
     p = Parameter("MyParameter", Type="String")
     t.add_parameter(p)
     with self.assertRaises(ValueError):
         t.add_parameter(p)

# 需要导入模块: from troposphere import Template [as 别名]
# 或者: from troposphere.Template import add_parameter [as 别名]
 def test_invalid_parameter_property_in_template(self):
     t = Template()
     p = Parameter("BasicNumber", Type="Number", AllowedPattern=".*")
     t.add_parameter(p)
     with self.assertRaises(ValueError):
         t.to_json()

# 需要导入模块: from troposphere import Template [as 别名]
# 或者: from troposphere.Template import add_parameter [as 别名]
 def test_max_parameters(self):
     template = Template()
     for i in range(0, MAX_PARAMETERS):
         template.add_parameter(Parameter(str(i), Type='String'))
     with self.assertRaises(ValueError):
         template.add_parameter(Parameter("parameter", Type='String'))

# 需要导入模块: from troposphere import Template [as 别名]
# 或者: from troposphere.Template import add_parameter [as 别名]
# Converted from EC2InstanceSample.template located at:
# http://aws.amazon.com/cloudformation/aws-cloudformation-templates/

from troposphere import Base64, FindInMap, GetAtt
from troposphere import Parameter, Output, Ref, Template
import troposphere.ec2 as ec2


template = Template()

keyname_param = template.add_parameter(Parameter(
    "KeyName",
    Description="Name of an existing EC2 KeyPair to enable SSH "
                "access to the instance",
    Type="String",
))

template.add_mapping('RegionMap', {
    "us-east-1": {"AMI": "ami-7f418316"},
    "us-west-1": {"AMI": "ami-951945d0"},
    "us-west-2": {"AMI": "ami-16fd7026"},
    "eu-west-1": {"AMI": "ami-24506250"},
    "sa-east-1": {"AMI": "ami-3e3be423"},
    "ap-southeast-1": {"AMI": "ami-74dda626"},
    "ap-northeast-1": {"AMI": "ami-dcfa4edd"}
})
ebs=ec2.EBSBlockDevice(VolumeSize=20,VolumeType="gp2",DeletionPolicy="Snapshot")
ec2_instance = template.add_resource(ec2.Instance(
    "Ec2Instance",
    ImageId=FindInMap("RegionMap", Ref("AWS::Region"), "AMI"),
    InstanceType="t1.micro",

# 需要导入模块: from troposphere import Template [as 别名]
# 或者: from troposphere.Template import add_parameter [as 别名]
#!/usr/bin/env python

from troposphere import Template, Parameter, Ref, Output
from troposphere.cloudwatch import Alarm, MetricDimension

t = Template()

rds_instance = t.add_parameter(Parameter(
    'RdsInstance',
    Type='String',
    Description='Instance to monitor'
))

up_threshold = t.add_parameter(
    Parameter(
        'UpThreshold',
        Type='String'
    )
)

up_evaluations = t.add_parameter(
    Parameter(
        'UpEvaluations',
        Type='String'
    )
)

down_threshold = t.add_parameter(
    Parameter(
        'DownThreshold',
        Type='String'