cf_factory 0.0.2

data/examples/base_vpc.rb

@@ -0,0 +1,40 @@
+#!/usr/bin/ruby
+
+require 'cf_factory'
+
+cf = CfMain.new("Bla bla bla")
+####### input parameters
+parameter = CfParameter.new("KeyName", "Name of the key", "String", {"Default" => "majung"})
+cf.add_parameter(parameter)
+parameter2 = CfParameter.new("SecurityGroup", "Name of the security group", "String", {"Default" => "Blubber"})
+cf.add_parameter(parameter2)
+
+####### mappings
+mapping = CfMapping.new("Default","AMI",{"us-east-1" => "ami-c6699baf", "us-west-2" => "ami-52ff7262"})
+cf.add_mapping(mapping)
+
+####### resources
+#vpc
+base_vpc = BaseVpc.new("BaseVpc","192.168.0.0/16",2,4,["eu-west-1a","eu-west-1b"],256)
+base_vpc.add_to_template(cf)
+vpc = base_vpc.vpc
+
+network_acl = CfNetworkAcl.new("MyAcl1")
+vpc.add_network_acl(network_acl)
+network_acl_entry = CfNetworkAclEntry.new("Acl1", "110", "6", "ALLOW",  false, "0.0.0.0/0", 80, 80)
+network_acl.add_network_acl_entry(network_acl_entry)
+
+####### output parameters
+output = CfOutput.new("BaseVpc", "Id of the VPC", vpc.generate_ref())
+cf.add_output(output)
+
+cf_json = cf.generate 
+puts cf_json
+
+config_options = YAML.load_file("aws_config.yml")
+config_options["cloud_formation_endpoint"] = "cloudformation.us-east-1.amazonaws.com"
+puts config_options.inspect
+validator = TemplateValidation.new(cf_json, config_options)
+validator.validate()
+
+#puts "the reference for the VPC : #{vpc.generate_ref}"

data/examples/cloudinit_script_for_one_instance.rb

@@ -0,0 +1,77 @@
+#!/usr/bin/ruby
+
+require 'cf_factory'
+
+cf = CfMain.new("Playground")
+##########################
+ami = "ami-1624987f"
+
+input_keyname = CfParameter.new("KeyName","Name of key for SSH access","String",{"Default" => "majung"})
+cf.add_parameter(input_keyname)
+input_ami = CfParameter.new("AMI","ID of AMI for instance","String",{"Default" => ami})
+cf.add_parameter(input_ami)  
+
+statement = CfIamStatement.new("Allow","cloudformation:DescribeStackResource","*")
+role_policy = CfIamPolicy.new("MyRolePolicy", CfPolicyDocument.new([statement]))
+iam_user = CfIamUser.new("IamUser","/",{:policies => [role_policy]})
+cf.add_resource(iam_user)
+iam_access_key = CfIamAccessKey.new("IamAccessKey",iam_user.generate_ref,"Active")
+cf.add_resource(iam_access_key)
+
+script = CfInitScript.create_basic("MyInstance",iam_access_key.generate_ref,iam_access_key.retrieve_attribute("SecretAccessKey"))
+#full_init_script = script.user_data()
+
+full_init_script = CfHelper.join([
+  "#!/bin/bash -v\\n",
+  "yum update -y aws-cfn-bootstrap\\n",
+  "/opt/aws/bin/cfn-init -s ", CfHelper.generate_ref("AWS::StackName"), 
+  " -r ", "MyInstance ",
+  " --access-key ", iam_access_key.generate_ref,
+  " --secret-key ", iam_access_key.retrieve_attribute("SecretAccessKey")]
+)
+
+
+
+instance = CfEc2Instance.new("MyInstance",input_ami.generate_ref,"m1.small", 
+  {:keyname => input_keyname.generate_ref(),
+   :user_data => full_init_script
+  }
+)
+packages = CfCloudFormationPackages.new([CfCloudFormationPackage.new("yum","httpd","2.2.13")])
+commands = CfCloudFormationCommands.new([
+  CfCloudFormationCommand.new("command1","echo cloudinit"),
+  CfCloudFormationCommand.new("command2","echo cloudinit > /var/log/my-cloudinit.txt")
+  ])
+config1 = CfCloudFormationConfig.new("config1", nil, commands, nil, packages)
+config2 = CfCloudFormationConfig.new("config", nil, commands, nil, nil)
+
+meta_data = CfCloudFormationInit.new([config2])
+instance.set_meta_data(meta_data) 
+cf.add_resource(instance)
+
+stackname = CfOutput.new("StackName","Name of CloudFormation stack",CfHelper.generate_ref("AWS::StackName"))
+cf.add_output(stackname)
+instance_ip = CfOutput.new("InstanceIp","DNS Name of instance created",instance.retrieve_attribute("PublicDnsName"))
+cf.add_output(instance_ip)
+access_key = CfOutput.new("AccessKey","Access key",iam_access_key.generate_ref)
+cf.add_output(access_key)
+secret_key = CfOutput.new("SecretKey","Secret key",iam_access_key.retrieve_attribute("SecretAccessKey"))
+cf.add_output(secret_key)
+
+output_command = CfOutput.new("FullCommand", "Full command to be executed", 
+  CfHelper.join(["/opt/aws/bin/cfn-init -s ", CfHelper.generate_ref("AWS::StackName"), 
+    " -r ", instance.get_name(),
+    " --access-key ", iam_access_key.generate_ref,
+    " --secret-key ", iam_access_key.retrieve_attribute("SecretAccessKey")]
+    ))
+cf.add_output(output_command)
+
+##########################
+cf_json = cf.generate 
+puts cf_json
+
+config_options = YAML.load_file("aws_config.yml")
+config_options["cloud_formation_endpoint"] = "cloudformation.us-east-1.amazonaws.com"
+validator = TemplateValidation.new(cf_json, config_options)
+validator.validate()
+

data/examples/cloudinit_script_with_autoscaling.rb

@@ -0,0 +1,85 @@
+#!/usr/bin/ruby
+
+require 'cf_factory'
+
+cf = CfMain.new("Playground")
+##########################
+ami = "ami-1624987f"
+
+input_keyname = CfParameter.new("KeyName","Name of key for SSH access","String",{"Default" => "majung"})
+cf.add_parameter(input_keyname)
+input_ami = CfParameter.new("AMI","ID of AMI for instance","String",{"Default" => ami})
+cf.add_parameter(input_ami)  
+
+statement = CfIamStatement.new("Allow","cloudformation:DescribeStackResource","*")
+role_policy = CfIamPolicy.new("MyRolePolicy", CfPolicyDocument.new([statement]))
+iam_user = CfIamUser.new("IamUser","/",{:policies => [role_policy]})
+cf.add_resource(iam_user)
+iam_access_key = CfIamAccessKey.new("IamAccessKey",iam_user.generate_ref,"Active")
+cf.add_resource(iam_access_key)
+
+script = CfInitScript.create_basic("MyInstance",iam_access_key.generate_ref,iam_access_key.retrieve_attribute("SecretAccessKey"))
+#full_init_script = script.user_data()
+full_init_script = CfHelper.join([
+  "#!/bin/bash -v\\n",
+  "yum update -y aws-cfn-bootstrap\\n",
+  "/opt/aws/bin/cfn-init -s ", CfHelper.generate_ref("AWS::StackName"), 
+  " -r ", "InstanceLaunchConfig ",
+  " --access-key ", iam_access_key.generate_ref,
+  " --secret-key ", iam_access_key.retrieve_attribute("SecretAccessKey")]
+)
+
+packages = CfCloudFormationPackages.new([CfCloudFormationPackage.new("yum","httpd","2.2.13")])
+commands = CfCloudFormationCommands.new([
+  CfCloudFormationCommand.new("command1","echo cloudinit"),
+  CfCloudFormationCommand.new("command2","echo cloudinit > /var/log/my-cloudinit.txt")
+  ])
+config1 = CfCloudFormationConfig.new("config1", nil, commands, nil, packages)
+config2 = CfCloudFormationConfig.new("config", nil, commands, nil, nil)
+
+#auto-scaling group
+launch_config = CfAsLaunchConfig.new("InstanceLaunchConfig", input_ami.generate_ref, "t1.micro", { :key_name => input_keyname.generate_ref(), :user_data => full_init_script})
+meta_data = CfCloudFormationInit.new([config2])
+launch_config.set_meta_data(meta_data) 
+cf.add_resource(launch_config)
+availability_zones = CfHelper.az_array_in_region(["b","c"])
+as_group = CfAsGroup.new("AppServerFleet",availability_zones, launch_config, [], 4 ,2 ,{:desired_capacity => 2})
+cf.add_resource(as_group)
+as_up_scaling_policy = CfAsScalingPolicy.new("MyUpscalePolicy",as_group,"ChangeInCapacity","1",{:cooldown => 300})
+cf.add_resource(as_up_scaling_policy)
+as_down_scaling_policy = CfAsScalingPolicy.new("MyDownscalePolicy",as_group,"ChangeInCapacity","-1",{:cooldown => 300})
+cf.add_resource(as_down_scaling_policy)
+as_up_alarm = CfCloudWatchAlarm.new("MyUpAlarm",CfCloudWatchAlarm::GREATER_THAN_OR_EQUAL_TO_THRESHOLD, "3", "CPUUtilization","AWS/EC2",
+  "60","Average","80", {:alarm_actions => [as_up_scaling_policy]})
+as_down_alarm = CfCloudWatchAlarm.new("MyDownAlarm",CfCloudWatchAlarm::LESS_THAN_THRESHOLD, "3", "CPUUtilization","AWS/EC2",
+  "60","Average","30", {:alarm_actions => [as_down_scaling_policy]}) 
+cf.add_resource(as_up_alarm)
+cf.add_resource(as_down_alarm)
+
+stackname = CfOutput.new("StackName","Name of CloudFormation stack",CfHelper.generate_ref("AWS::StackName"))
+cf.add_output(stackname)
+access_key = CfOutput.new("AccessKey","Access key",iam_access_key.generate_ref)
+cf.add_output(access_key)
+secret_key = CfOutput.new("SecretKey","Secret key",iam_access_key.retrieve_attribute("SecretAccessKey"))
+cf.add_output(secret_key)
+
+output_command = CfOutput.new("FullCommand", "Full command to be executed", 
+  CfHelper.join(["/opt/aws/bin/cfn-init -s ", CfHelper.generate_ref("AWS::StackName"), 
+    " -r ", launch_config.get_name(),
+    " --access-key ", iam_access_key.generate_ref,
+    " --secret-key ", iam_access_key.retrieve_attribute("SecretAccessKey")]
+    ))
+cf.add_output(output_command)
+
+tag = CfEc2Tag.new("CloudFormationTests","active")
+cf.apply_tags_to_all_resources([tag])
+
+##########################
+cf_json = cf.generate 
+puts cf_json
+
+config_options = YAML.load_file("aws_config.yml")
+config_options["cloud_formation_endpoint"] = "cloudformation.us-east-1.amazonaws.com"
+validator = TemplateValidation.new(cf_json, config_options)
+validator.validate()
+

data/examples/elb_with_cloudfront.rb

@@ -0,0 +1,101 @@
+require 'help/include_libraries'
+
+# CloudFormation template for Atraveo. 2-Tiered web-application with load-balancing.
+cf = CfMain.new("CloudFront with ELB as origin with dynamic content")
+app_port = 8080
+key_name = "default"
+app_server_ami = "ami-c6699baf"
+spot_price = "0.02"
+
+####### input parameters
+param_app_server_ami = CfParameter.new("AppServerAmi", "AMI of App-Server", "String")
+cf.add_parameter(param_app_server_ami)
+param_app_server_key = CfParameter.new("AppServerKey", "Key used to start  App-Server", "String")
+cf.add_parameter(param_app_server_key)
+param_app_port = CfParameter.new("AppPort", "Port of the Web/App-Servers", "Number", {"Default" => "8080"})
+cf.add_parameter(param_app_port)
+
+zone = "us-east"
+
+####### mappings
+
+####### resources
+
+#VPC/subnets: all public to be able to be able to connect the instances by adding an EIP
+#VPC, IGW, and route tables
+vpc = CfVpc.new("10.10.0.0/16")
+cf.add_vpc(vpc)
+igw = CfInternetGateway.new("MyInternetGateway", vpc)
+vpc.add_internet_gateway(igw)
+public_route_table = CfRouteTable.new("InternetRouteTable")
+igw_route = CfRoute.new("IgwRoute", "0.0.0.0/0", igw)
+public_route_table.add_route(igw_route)
+vpc.add_route_table(public_route_table)
+
+# subnets
+subnet_elb_a = CfSubnet.new("SubnetElbA", "10.10.1.0/24", "#{zone}-1c", public_route_table)
+vpc.add_subnet(subnet_elb_a)
+subnet_elb_b = CfSubnet.new("SubnetElbB", "10.10.2.0/24", "#{zone}-1b", public_route_table)
+vpc.add_subnet(subnet_elb_b)
+subnet_web_a = CfSubnet.new("SubnetWebA", "10.10.3.0/24", "#{zone}-1c", public_route_table)
+vpc.add_subnet(subnet_web_a)
+subnet_web_b = CfSubnet.new("SubnetWebB", "10.10.4.0/24", "#{zone}-1b", public_route_table)
+vpc.add_subnet(subnet_web_b)
+
+#security groups
+elb_security_group_name = "ElbSecurityGroup"
+elb_sec_group = CfEc2SecurityGroup.new(elb_security_group_name, "Group for ELB", vpc)
+elb_sec_group.add_ingress_rule(CfEc2SecurityGroupIngress.new("tcp", 80, 80, "0.0.0.0/0"))
+elb_sec_group.add_ingress_rule(CfEc2SecurityGroupIngress.new("tcp", 443, 443, "0.0.0.0/0"))
+cf.add_resource(elb_sec_group)
+
+app_security_group_name = "AppSecurityGroup"
+app_sec_group = CfEc2SecurityGroup.new(app_security_group_name, "Group for web and app", vpc)
+app_sec_group.add_ingress_rule(CfEc2SecurityGroupIngress.new("tcp", 22, 22, "0.0.0.0/0"))
+app_sec_group.add_ingress_rule(CfEc2SecurityGroupIngress.new("tcp", param_app_port.generate_ref(), param_app_port.generate_ref(), nil, elb_sec_group))
+cf.add_resource(app_sec_group)
+
+#application servers (one in each region)
+options = {}
+instance_a = CfEc2Instance.new("InstanceA",param_app_server_ami.generate_ref, "t1.micro", {:subnet => subnet_web_a, :vpc_security_groups => [app_sec_group]})
+instance_b = CfEc2Instance.new("InstanceB",param_app_server_ami.generate_ref, "t1.micro", {:subnet => subnet_web_b, :vpc_security_groups => [app_sec_group]})
+cf.add_resource(instance_a)
+cf.add_resource(instance_b)
+
+#elb
+#health_check_string = "HTTP:#{param_app_port.generate_ref()}/index.html"
+health_check_string = "HTTP:80/index.html"
+elb = CfElb.new("MyLoadBalancer", {
+  :subnets => [subnet_elb_a, subnet_elb_b],  
+  #:app_cookie_stickiness_policy => [CfAppCookieStickinessPolicy.new("cookiename","policybla")],    
+  :health_check => CfHealthCheck.new("3","60", health_check_string,"10","2"),
+  :listeners => [CfListener.new(param_app_port.generate_ref(),"http","80","http")],
+  :security_groups => [elb_sec_group],
+  :instances => [instance_a, instance_b]
+  }
+)
+cf.add_resource(elb)
+
+#cloudfront
+origin = CfCustomOriginConfig.new("http-only",:http_port => 80)
+origin_config = CfOrigin.new(elb.retrieve_attribute("DNSName") ,"CF001", origin)
+default_cache_behavior = CfDefaultCacheBehavior.new(origin_config.id,CfForwardedValues.new(true),"allow-all",{:min_ttl => 0})
+distribution_details = CfDistributionConfig.new([origin_config],default_cache_behavior,true)
+cloudfront_distribution = CfCloudfrontDistribution.new("MyDistribution",distribution_details)
+cf.add_resource(cloudfront_distribution)
+
+####### output parameters
+elb_output = CfOutput.new("ElbEndpoint","Endpoint of the ELB",elb.retrieve_attribute("DNSName"))
+cf.add_output(elb_output)
+cloudfront_domain = CfOutput.new("CloudfrontDomain", "Endpoint of the CloudFront distribution", cloudfront_distribution.retrieve_attribute("DomainName"))
+cf.add_output(cloudfront_domain)
+
+cf_json = cf.generate 
+puts cf_json
+
+config_options = YAML.load_file("aws_config.yml")
+validator = TemplateValidation.new(cf_json, config_options)
+validator.validate()
+validator.apply({"AppServerAmi" => "ami-e96bdf80", "AppServerKey" => "majung", "AppPort" => "80"})
+
+#puts "the reference for the VPC : #{vpc.generate_ref}"

data/examples/instance_with_eip.rb

@@ -0,0 +1,38 @@
+require 'help/include_libraries'
+
+cf = CfMain.new("Playground")
+##########################
+
+mapping = CfMapping.new("Region2AmiMapping","AMI", {
+    "us-east-1" => "ami-c6699baf",
+    "us-west-2" => "ami-52ff7262",
+    "us-west-1" => "ami-3bcc9e7e",
+    "eu-west-1" => "ami-0b5b6c7f",
+    "ap-southeast-1" => "ami-02eb9350",
+    "ap-northeast-1" => "ami-14d86d15",
+    "sa-east-1" => "ami-0439e619"
+  })
+cf.add_mapping(mapping)
+ami = mapping.map_from_region()
+instance = CfEc2Instance.new("MyInstance", ami, "t1.micro")
+cf.add_resource(instance)
+eip = CfEip.new("MyEip",instance)
+cf.add_resource(eip)
+instance_ip_assoc = CfEipAssociation.new("MyEipAllocation", eip, instance, nil)
+cf.add_resource(instance_ip_assoc)
+
+eip_output = CfOutput.new("Eip", "Id of the EIP", eip.generate_ref())
+cf.add_output(eip_output)
+#eip_ip_output = CfOutput.new("Eip", "Id of the EIP", eip.retrieve_attribute("AllocationId")) only works for VPC
+#cf.add_output(eip_ip_output)
+assoc_output = CfOutput.new("Assoc", "Id of the Assoc", instance_ip_assoc.generate_ref())
+cf.add_output(assoc_output)
+##########################
+cf_json = cf.generate 
+puts cf_json
+
+config_options = YAML.load_file("aws_config.yml")
+validator = TemplateValidation.new(cf_json, config_options)
+validator.validate()
+validator.apply()
+

data/examples/instance_with_yum.rb

@@ -0,0 +1,38 @@
+require 'help/include_libraries'
+
+cf = CfMain.new("Playground")
+##########################
+
+mapping = CfMapping.new("Region2AmiMapping","AMI", {
+    "us-east-1" => "ami-c6699baf",
+    "us-west-2" => "ami-52ff7262",
+    "us-west-1" => "ami-3bcc9e7e",
+    "eu-west-1" => "ami-c37474b7",#"ami-0b5b6c7f",
+    "ap-southeast-1" => "ami-02eb9350",
+    "ap-northeast-1" => "ami-14d86d15",
+    "sa-east-1" => "ami-0439e619"
+  })
+cf.add_mapping(mapping)
+ami = mapping.map_from_region()
+  puts "AMI = #{ami}"
+instance = CfEc2Instance.new("MyInstance", ami, "t1.micro", {:keyname => "majung-eu"})
+cf.add_resource(instance)
+
+packages = CfCloudFormationPackages.new([
+  CfCloudFormationPackage.new("yum", "rubygems", []),
+  CfCloudFormationPackage.new("yum", "rubygem-aws-sdk", []),
+  CfCloudFormationPackage.new("rubygems", "cloudyscripts", ["2.14.60"])
+])
+config = CfCloudFormationConfig.new("GemInstallation", nil, nil, nil, packages)
+cloud_init_config = CfCloudFormationInit.new([config])
+instance.set_meta_data(cloud_init_config)
+
+##########################
+cf_json = cf.generate 
+puts cf_json
+
+config_options = YAML.load_file("aws_config.yml")
+validator = TemplateValidation.new(cf_json, config_options)
+validator.validate()
+#validator.apply()
+

data/examples/just_an_instance.rb

@@ -0,0 +1,29 @@
+require 'help/include_libraries'
+
+cf = CfMain.new("JustAnInstance")
+##########################
+
+mapping = CfMapping.new("Region2AmiMapping","AMI", {
+    "us-east-1" => "ami-c6699baf",
+    "us-west-2" => "ami-52ff7262",
+    "us-west-1" => "ami-3bcc9e7e",
+    "eu-west-1" => "ami-0b5b6c7f",
+    "ap-southeast-1" => "ami-02eb9350",
+    "ap-northeast-1" => "ami-14d86d15",
+    "sa-east-1" => "ami-0439e619"
+  })
+cf.add_mapping(mapping)
+ami = mapping.map_from_region()
+  puts "AMI = #{ami}"
+instance = CfEc2Instance.new("MyInstance", ami, "t1.micro")
+cf.add_resource(instance)
+
+##########################
+cf_json = cf.generate 
+puts cf_json
+
+config_options = YAML.load_file("aws_config.yml")
+validator = TemplateValidation.new(cf_json, config_options)
+validator.validate()
+validator.apply()
+

data/examples/play_with_region_and_zones.rb

@@ -0,0 +1,26 @@
+require 'help/include_libraries'
+
+cf = CfMain.new("Playground")
+##########################
+ami = "ami-6d555119"
+
+az = CfHelper.az_in_region("a")
+instance = CfEc2Instance.new("MyInstance", ami, "t1.micro", {:availability_zone => az })
+cf.add_resource(instance)
+
+region_output = CfOutput.new("Region", "Region the stack was started", CfHelper.ref_current_region())
+cf.add_output(region_output)
+target_zone_output = CfOutput.new("TargetZone", "AZ where instance to be started", az)
+cf.add_output(target_zone_output)
+actual_zone_output = CfOutput.new("ActualInstanceZone", "AZ of started instance", instance.retrieve_attribute("AvailabilityZone"))
+cf.add_output(actual_zone_output)
+
+##########################
+cf_json = cf.generate 
+puts cf_json
+
+config_options = YAML.load_file("aws_config.yml")
+validator = TemplateValidation.new(cf_json, config_options)
+validator.validate()
+validator.apply()
+

data/examples/ra_web_hosting.rb

@@ -0,0 +1,146 @@
+require 'help/include_libraries'
+
+# CloudFormation template for Atraveo. 2-Tiered web-application with load-balancing.
+cf = CfMain.new("Reference Architecture Web-Hosting")
+
+####### input parameters
+hosted_zone_id = "ZSSFB90C439AA"
+hosted_zone_name = "dezidr.com"
+
+#ami_id = "ami-c6699baf"
+#ami_id = "ami-e96bdf80" #eu-west NAT instance
+ami_id = "ami-e96bdf80" #us-east web-server returning something
+
+param_hosted_zone = CfParameter.new("HostedZoneId", "Needs an existing hosted zone in Route53 to be configured", "String", {"Default" => hosted_zone_id})
+cf.add_parameter(param_hosted_zone)
+param_app_server_ami = CfParameter.new("AppServerAmi", "AMI of App-Server", "String", {"Default" => ami_id})
+cf.add_parameter(param_app_server_ami)
+param_app_server_key = CfParameter.new("AppServerKey", "Key used to start  App-Server", "String")
+cf.add_parameter(param_app_server_key)
+param_app_port = CfParameter.new("AppPort", "Port of the Web/App-Servers", "Number", {"Default" => "8080"})
+cf.add_parameter(param_app_port)
+param_db_user = CfParameter.new("MasterUserName", "Name of the master user name of the DB", "String", {"Default" => "masteruser"})
+cf.add_parameter(param_db_user)
+param_db_pw = CfParameter.new("MasterPassword", "Password of the master user of the DB", "String")
+cf.add_parameter(param_db_pw)
+
+zone = "us-east"
+
+####### mappings
+
+####### resources
+
+#ebs test
+ebs = CfEbsVolume.create_normal("MyEbs",CfHelper.az_in_region(az_id = "b"),  5)
+cf.add_resource(ebs)
+
+s3_bucket = CfS3Bucket.new("MyS3Bucket")
+cf.add_resource(s3_bucket)
+s3_log_bucket = CfS3Bucket.new("MyS3LogBucket")
+s3_log_bucket.set_deletion_policy("Delete")
+cf.add_resource(s3_log_bucket)
+
+#security groups
+# ELB security groups apparently only available for VPC
+#elb_sec_group = CfEc2SecurityGroup.new("ElbSecurityGroup", "Security Group for ELB")
+#elb_sec_group.add_ingress_rule(CfEc2SecurityGroupIngress.new("tcp", 80, 80, "0.0.0.0/0"))
+#elb_sec_group.add_ingress_rule(CfEc2SecurityGroupIngress.new("tcp", 443, 443, "0.0.0.0/0"))
+#cf.add_resource(elb_sec_group)
+
+#elb
+#health_check_string = "HTTP:#{param_app_port.generate_ref()}/index.html"
+health_check_string = "HTTP:80/index.html"
+elb = CfElb.new("MyLoadBalancer", {    
+  :health_check => CfHealthCheck.new("3","60", health_check_string,"10","2"),
+  :listeners => [CfListener.new(param_app_port.generate_ref(),"http","80","http")],
+  #:security_groups => [elb_sec_group], #only for VPC based ELBs
+  :availability_zones => CfHelper.availability_zones()
+  }
+)
+cf.add_resource(elb)
+
+app_sec_group = CfEc2SecurityGroup.new("AppSecurityGroup", "Security Group for web and app")
+app_sec_group.add_ingress_rule(CfEc2SecurityGroupIngress.new("tcp", 22, 22, "0.0.0.0/0"))
+ir1 = CfEc2SecurityGroupIngress.new("tcp", param_app_port.generate_ref(), param_app_port.generate_ref(), "0.0.0.0/0")
+app_sec_group.add_ingress_rule(ir1)
+cf.add_resource(app_sec_group)
+
+rds_sec_group = CfRdsSecurityGroup.new("RdsSecurityGroup","Security Group for RDS")
+ir = CfRdsSecurityGroupIngress.new(nil,app_sec_group)
+ir.set_use_sg_id(false)
+rds_sec_group.add_rule(ir)
+cf.add_resource(rds_sec_group)
+
+#rds
+rds_endpoint= "rdsendpoint"
+options = {:multi_az => true, :security_groups => [rds_sec_group]}
+rds_instance = CfRdsInstance.new("MyDatabase",5,"MySql","db.t1.micro",param_db_user.generate_ref(), param_db_pw.generate_ref, options)
+cf.add_resource(rds_instance)
+rds_endpoint = rds_instance.retrieve_attribute("Endpoint.Address") 
+
+#iam-role to be able to read meta-data
+statement = CfIamStatement.new("Allow","cloudformation:DescribeStackResource","*")
+role_policy = CfIamPolicy.new("MyRolePolicy", CfPolicyDocument.new([statement]))
+iam_role = CfIamRole.new("ReadMetaData","/",{:policies => [role_policy]})
+cf.add_resource(iam_role)
+
+#auto-scaling group
+launch_config = CfAsLaunchConfig.new("AppServerLaunchConfig", ami_id, "t1.micro", {:security_groups => [app_sec_group], :user_data => rds_endpoint})
+cf.add_resource(launch_config)   
+availability_zones = CfHelper.az_array_in_region(["b","c"])
+as_group = CfAsGroup.new("AppServerFleet",availability_zones, launch_config, [elb], 4 ,2 ,{:desired_capacity => 2})
+cf.add_resource(as_group)
+as_up_scaling_policy = CfAsScalingPolicy.new("MyUpscalePolicy",as_group,"ChangeInCapacity","1",{:cooldown => 300})
+cf.add_resource(as_up_scaling_policy)
+as_down_scaling_policy = CfAsScalingPolicy.new("MyDownscalePolicy",as_group,"ChangeInCapacity","-1",{:cooldown => 300})
+cf.add_resource(as_down_scaling_policy)
+as_up_alarm = CfCloudWatchAlarm.new("MyUpAlarm",CfCloudWatchAlarm::GREATER_THAN_OR_EQUAL_TO_THRESHOLD, "3", "CPUUtilization","AWS/EC2",
+  "60","Average","80", {:alarm_actions => [as_up_scaling_policy]})
+as_down_alarm = CfCloudWatchAlarm.new("MyDownAlarm",CfCloudWatchAlarm::LESS_THAN_THRESHOLD, "3", "CPUUtilization","AWS/EC2",
+  "60","Average","30", {:alarm_actions => [as_down_scaling_policy]}) 
+cf.add_resource(as_up_alarm)
+cf.add_resource(as_down_alarm)
+
+#cloudfront
+# distribution with multiple origins, one for S3, one for the ELB   
+#define origins
+elb_origin = CfOrigin.create_elb_origin(elb)
+s3_origin = CfOrigin.create_s3_origin(s3_bucket) 
+origins = [elb_origin, s3_origin]
+#define cache behaviors for origins
+default_cache_behavior = CfDefaultCacheBehavior.create_basic(elb_origin.id)
+cache_behaviors = [
+  CfCacheBehavior.create_basic(s3_origin.id, "/static/*", :min_ttl => 24*60*60),
+  CfCacheBehavior.create_basic(s3_origin.id, "*.jpg", :min_ttl => 24*60*60)  
+]
+#tie everything together
+cname_endpoint = "cached-elb-#{(Random.new.rand*100000).to_i}.dezidr.com"
+logging = CfLogging.new(s3_log_bucket,"log-") #activate logging
+cf_distribution = CfCloudfrontDistribution.create_multi_origin_distribution("MyDistribution", origins,
+  default_cache_behavior, cache_behaviors, {:logging => logging, :aliases => [cname_endpoint]})
+cf.add_resource(cf_distribution)
+
+#route53
+cloudfront_dns = cf_distribution.retrieve_attribute("DomainName")
+cname = CfRoute53RecordSet.new("CnameRecord", "#{cname_endpoint}", "CNAME", {:ttl => 1, :resource_records => [cloudfront_dns], :hosted_zone_id => hosted_zone_id})
+cf.add_resource(cname)
+elb_alias = CfRoute53RecordSet.new("ElbAliasRecord","elb-#{(Random.new.rand*100000).to_i}.#{hosted_zone_name}","A", {:alias_target => CfElbAliasTarget.new(elb), :hosted_zone_id => hosted_zone_id})
+cf.add_resource(elb_alias)
+
+####### output parameters
+elb_output = CfOutput.new("ElbEndpoint","Endpoint of the ELB",elb.retrieve_attribute("DNSName"))
+cf.add_output(elb_output)
+cloudfront_domain = CfOutput.new("CloudfrontDomain", "Endpoint of the CloudFront distribution", cf_distribution.retrieve_attribute("DomainName"))
+cf.add_output(cloudfront_domain)
+
+cf_json = cf.generate 
+puts cf_json
+
+config_options = YAML.load_file("aws_config.yml")
+config_options["cloud_formation_endpoint"] = "cloudformation.us-east-1.amazonaws.com"
+puts config_options.inspect
+validator = TemplateValidation.new(cf_json, config_options)
+validator.validate()
+#validator.apply({"AppServerAmi" => ami_id, "AppServerKey" => "majung", "AppPort" => "80",  "MasterUserName" => "iamauser", "MasterPassword" => "abcd1234"})
+
+#puts "the reference for the VPC : #{vpc.generate_ref}"

data/examples/s3_with_cloudfront.rb

@@ -0,0 +1,36 @@
+require 'help/include_libraries'
+
+# CloudFormation template for Atraveo. 2-Tiered web-application with load-balancing.
+cf = CfMain.new("S3 Bucket with CloudFront distribution")
+
+####### input parameters
+
+####### mappings
+
+####### resources
+
+s3_bucket = CfS3Bucket.new("OriginBucket")
+cf.add_resource(s3_bucket)
+s3_log_bucket = CfS3Bucket.new("LogBucket")
+
+#cloudfront
+logging = CfLogging.new(s3_bucket,"MyDistribution")
+options = {:logging => logging}
+cloudfront_distribution = CfCloudfrontDistribution.create_s3_distribution("MyS3Distribution",s3_bucket)
+cf.add_resource(cloudfront_distribution)
+
+####### output parameters
+s3_domain = CfOutput.new("S3Domain","Domain name of S3 bucket",s3_bucket.retrieve_attribute("DomainName"))
+cf.add_output(s3_domain)
+cloudfront_domain = CfOutput.new("CloudfrontDomain", "Endpoint of the CloudFront distribution", cloudfront_distribution.retrieve_attribute("DomainName"))
+cf.add_output(cloudfront_domain)
+
+cf_json = cf.generate 
+puts cf_json
+
+config_options = YAML.load_file("aws_config.yml")
+validator = TemplateValidation.new(cf_json, config_options)
+validator.validate()
+validator.apply()
+
+#puts "the reference for the VPC : #{vpc.generate_ref}"