cf_factory 0.0.3 → 0.0.4

data/bin/cf_factory

@@ -0,0 +1,9 @@
+#!/usr/bin/ruby
+
+require 'cf_factory'
+
+puts "cf_factory command line tool placeholder"
+
+
+
+

data/examples/base_vpc.rb

@@ -2,30 +2,30 @@
 
 require 'cf_factory'
 
-cf = CfMain.new("Bla bla bla")
+cf = CfFactory::CfMain.new("Bla bla bla")
 ####### input parameters
-parameter = CfParameter.new("KeyName", "Name of the key", "String", {"Default" => "majung"})
+parameter = CfFactory::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"})
+parameter2 = CfFactory::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"})
+mapping = CfFactory::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 = CfFactory::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")
+network_acl = CfFactory::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_entry = CfFactory::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())
+output = CfFactory::CfOutput.new("BaseVpc", "Id of the VPC", vpc.generate_ref())
 cf.add_output(output)
 
 cf_json = cf.generate 
@@ -34,7 +34,7 @@ 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 = CfFactory::TemplateValidation.new(cf_json, config_options)
 validator.validate()
 
 #puts "the reference for the VPC : #{vpc.generate_ref}"

data/examples/cloudfront_private.rb

@@ -0,0 +1,23 @@
+require 'help/include_libraries'
+
+#INCOMPLETE: seems as if the OriginAccessIdentity cannot be created via CloudFormation
+
+# CloudFormation template that creates an S3 bucket that allows private access
+# to a cloudfront distribution.
+# What remains at the end:
+# - create content in S3 bucket
+# - create cloudfront access keys (Account -> Security Credentials)
+# - use a library to sign that content  
+cf = CfMain.new("CloudFront for private content")
+s3_bucket = CfS3.new("majung-cloudfront-private-1")
+cf.add_resource(s3_bucket)
+
+#cloudfront
+origin = CfCustomOriginConfig.new("http-only",:http_port => 80)
+origin_config = CfOrigin.new(elb.retrieve_attribute("DNSName") ,"CF001", origin)
+origin_config = CfS3OriginConfig.new(options)
+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)
+

data/examples/cloudinit_script_for_one_instance.rb

@@ -2,29 +2,29 @@
 
 require 'cf_factory'
 
-cf = CfMain.new("Playground")
+cf = CfFactory::CfMain.new("Playground")
 ##########################
 ami = "ami-1624987f"
 
-input_keyname = CfParameter.new("KeyName","Name of key for SSH access","String",{"Default" => "majung"})
+input_keyname = CfFactory::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})
+input_ami = CfFactory::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]})
+statement = CfFactory::CfIamStatement.new("Allow","cloudformation:DescribeStackResource","*")
+role_policy = CfFactory::CfIamPolicy.new("MyRolePolicy", CfFactory::CfPolicyDocument.new([statement]))
+iam_user = CfFactory::CfIamUser.new("IamUser","/",{:policies => [role_policy]})
 cf.add_resource(iam_user)
-iam_access_key = CfIamAccessKey.new("IamAccessKey",iam_user.generate_ref,"Active")
+iam_access_key = CfFactory::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"))
+script = CfFactory::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([
+full_init_script = CfFactory::CfHelper.join([
   "#!/bin/bash -v\\n",
   "yum update -y aws-cfn-bootstrap\\n",
-  "/opt/aws/bin/cfn-init -s ", CfHelper.generate_ref("AWS::StackName"), 
+  "/opt/aws/bin/cfn-init -s ", CfFactory::CfHelper.generate_ref("AWS::StackName"), 
   " -r ", "MyInstance ",
   " --access-key ", iam_access_key.generate_ref,
   " --secret-key ", iam_access_key.retrieve_attribute("SecretAccessKey")]
@@ -32,34 +32,34 @@ full_init_script = CfHelper.join([
 
 
 
-instance = CfEc2Instance.new("MyInstance",input_ami.generate_ref,"m1.small", 
+instance = CfFactory::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")
+packages = CfFactory::CfCloudFormationPackages.new([CfFactory::CfCloudFormationPackage.new("yum","httpd","2.2.13")])
+commands = CfFactory::CfCloudFormationCommands.new([
+  CfFactory::CfCloudFormationCommand.new("command1","echo cloudinit"),
+  CfFactory::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)
+config1 = CfFactory::CfCloudFormationConfig.new("config1", nil, commands, nil, packages)
+config2 = CfFactory::CfCloudFormationConfig.new("config", nil, commands, nil, nil)
 
-meta_data = CfCloudFormationInit.new([config2])
+meta_data = CfFactory::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"))
+stackname = CfFactory::CfOutput.new("StackName","Name of CloudFormation stack",CfFactory::CfHelper.generate_ref("AWS::StackName"))
 cf.add_output(stackname)
-instance_ip = CfOutput.new("InstanceIp","DNS Name of instance created",instance.retrieve_attribute("PublicDnsName"))
+instance_ip = CfFactory::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)
+access_key = CfFactory::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"))
+secret_key = CfFactory::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"), 
+output_command = CfFactory::CfOutput.new("FullCommand", "Full command to be executed", 
+  CfFactory::CfHelper.join(["/opt/aws/bin/cfn-init -s ", CfFactory::CfHelper.generate_ref("AWS::StackName"), 
     " -r ", instance.get_name(),
     " --access-key ", iam_access_key.generate_ref,
     " --secret-key ", iam_access_key.retrieve_attribute("SecretAccessKey")]
@@ -72,6 +72,6 @@ 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 = CfFactory::TemplateValidation.new(cf_json, config_options)
 validator.validate()
 

data/examples/cloudinit_script_with_autoscaling.rb

@@ -2,76 +2,76 @@
 
 require 'cf_factory'
 
-cf = CfMain.new("Playground")
+cf = CfFactory::CfMain.new("Playground")
 ##########################
 ami = "ami-1624987f"
 
-input_keyname = CfParameter.new("KeyName","Name of key for SSH access","String",{"Default" => "majung"})
+input_keyname = CfFactory::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})
+input_ami = CfFactory::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]})
+statement = CfFactory::CfIamStatement.new("Allow","cloudformation:DescribeStackResource","*")
+role_policy = CfFactory::CfIamPolicy.new("MyRolePolicy", CfFactory::CfPolicyDocument.new([statement]))
+iam_user = CfFactory::CfIamUser.new("IamUser","/",{:policies => [role_policy]})
 cf.add_resource(iam_user)
-iam_access_key = CfIamAccessKey.new("IamAccessKey",iam_user.generate_ref,"Active")
+iam_access_key = CfFactory::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"))
+script = CfFactory::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([
+full_init_script = CfFactory::CfHelper.join([
   "#!/bin/bash -v\\n",
   "yum update -y aws-cfn-bootstrap\\n",
-  "/opt/aws/bin/cfn-init -s ", CfHelper.generate_ref("AWS::StackName"), 
+  "/opt/aws/bin/cfn-init -s ", CfFactory::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")
+packages = CfFactory::CfCloudFormationPackages.new([CfFactory::CfCloudFormationPackage.new("yum","httpd","2.2.13")])
+commands = CfFactory::CfCloudFormationCommands.new([
+  CfFactory::CfCloudFormationCommand.new("command1","echo cloudinit"),
+  CfFactory::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)
+config1 = CfFactory::CfCloudFormationConfig.new("config1", nil, commands, nil, packages)
+config2 = CfFactory::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 = CfFactory::CfAsLaunchConfig.new("InstanceLaunchConfig", input_ami.generate_ref, "t1.micro", { :key_name => input_keyname.generate_ref(), :user_data => full_init_script})
+meta_data = CfFactory::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})
+availability_zones = CfFactory::CfHelper.az_array_in_region(["b","c"])
+as_group = CfFactory::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})
+as_up_scaling_policy = CfFactory::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})
+as_down_scaling_policy = CfFactory::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",
+as_up_alarm = CfFactory::CfCloudWatchAlarm.new("MyUpAlarm",CfFactory::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",
+as_down_alarm = CfFactory::CfCloudWatchAlarm.new("MyDownAlarm",CfFactory::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"))
+stackname = CfFactory::CfOutput.new("StackName","Name of CloudFormation stack",CfFactory::CfHelper.generate_ref("AWS::StackName"))
 cf.add_output(stackname)
-access_key = CfOutput.new("AccessKey","Access key",iam_access_key.generate_ref)
+access_key = CfFactory::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"))
+secret_key = CfFactory::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"), 
+output_command = CfFactory::CfOutput.new("FullCommand", "Full command to be executed", 
+  CfFactory::CfHelper.join(["/opt/aws/bin/cfn-init -s ", CfFactory::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")
+tag = CfFactory::CfEc2Tag.new("CloudFormationTests","active")
 cf.apply_tags_to_all_resources([tag])
 
 ##########################
@@ -80,6 +80,6 @@ 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 = CfFactory::TemplateValidation.new(cf_json, config_options)
 validator.validate()
 

data/examples/dynamodb_table.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/ruby
+
+require 'cf_factory'
+
+cf = CfFactory::CfMain.new("DynamoTableStack")
+
+parameter_hash = CfFactory::CfParameter.new("HashKeyName", "Name of the hash key", "String", {"Default" => "hashkey"})
+cf.add_parameter(parameter_hash)
+
+dynamo_table = CfFactory::CfDynamoTable.new("DynamoTable",
+                                            10, 10,
+                                            parameter_hash.generate_ref, "S")
+                                            
+cf.add_resource(dynamo_table)
+
+output_dynamo_table_name = CfFactory::CfOutput.new("DynamoTableName", "The name of the Dynamo table", dynamo_table.generate_ref())
+cf.add_output(output_dynamo_table_name)
+
+cf_json = cf.generate 
+puts cf_json
+
+config_options = YAML.load_file("aws_config.yml")
+validator = CfFactory::TemplateValidation.new(cf_json, config_options)
+validator.validate()

data/examples/elastic_beanstalk_example.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/ruby
+
+require 'cf_factory'
+
+cf = CfFactory::CfMain.new("IngestReferenceArchitecture")
+
+keypair = CfFactory::CfParameter.new("KeyName", "Name of the key",
+                                     "String", {"Default" => ""})
+cf.add_parameter(keypair)
+
+capture_version = CfFactory::CfEbApplicationVersion.new("Capture Version 1", "Capture Version 1", "capture.zip", "1.0")
+
+capture_option = CfFactory::CfEbOptionSetting.new("aws:autoscaling:launchconfiguration", "EC2KeyName", keypair.generate_ref())
+
+capture_template = CfFactory::CfEbConfigurationTemplate.new("Capture Template", "Capture Template", [capture_option], :s64ruby193)
+capture_application = CfFactory::CfEbApplication.new("Capture","Twitter Capture Service",
+                                                     [capture_version], [capture_template])
+
+cf_json = cf.generate
+puts cf_json
+ 
+validator = CfFactory::TemplateValidation.new(cf_json, config_options)
+validator.validate()

data/examples/elb_with_cloudfront.rb

@@ -1,18 +1,20 @@
-require 'help/include_libraries'
+#!/usr/bin/ruby
+
+require 'cf_factory'
 
 # CloudFormation template for Atraveo. 2-Tiered web-application with load-balancing.
-cf = CfMain.new("CloudFront with ELB as origin with dynamic content")
+cf = CfFactory::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")
+param_app_server_ami = CfFactory::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")
+param_app_server_key = CfFactory::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"})
+param_app_port = CfFactory::CfParameter.new("AppPort", "Port of the Web/App-Servers", "Number", {"Default" => "8080"})
 cf.add_parameter(param_app_port)
 
 zone = "us-east"
@@ -23,53 +25,53 @@ zone = "us-east"
 
 #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")
+vpc = CfFactory::CfVpc.new("10.10.0.0/16")
 cf.add_vpc(vpc)
-igw = CfInternetGateway.new("MyInternetGateway", vpc)
+igw = CfFactory::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 = CfFactory::CfRouteTable.new("InternetRouteTable")
+igw_route = CfFactory::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)
+subnet_elb_a = CfFactory::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)
+subnet_elb_b = CfFactory::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)
+subnet_web_a = CfFactory::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)
+subnet_web_b = CfFactory::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"))
+elb_sec_group = CfFactory::CfEc2SecurityGroup.new(elb_security_group_name, "Group for ELB", vpc)
+elb_sec_group.add_ingress_rule(CfFactory::CfEc2SecurityGroupIngress.new("tcp", 80, 80, "0.0.0.0/0"))
+elb_sec_group.add_ingress_rule(CfFactory::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))
+app_sec_group = CfFactory::CfEc2SecurityGroup.new(app_security_group_name, "Group for web and app", vpc)
+app_sec_group.add_ingress_rule(CfFactory::CfEc2SecurityGroupIngress.new("tcp", 22, 22, "0.0.0.0/0"))
+app_sec_group.add_ingress_rule(CfFactory::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]})
+instance_a = CfFactory::CfEc2Instance.new("InstanceA",param_app_server_ami.generate_ref, "t1.micro", {:subnet => subnet_web_a, :vpc_security_groups => [app_sec_group]})
+instance_b = CfFactory::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", {
+elb = CfFactory::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")],
+  :health_check => CfFactory::CfHealthCheck.new("3","60", health_check_string,"10","2"),
+  :listeners => [CfFactory::CfListener.new(param_app_port.generate_ref(),"http","80","http")],
   :security_groups => [elb_sec_group],
   :instances => [instance_a, instance_b]
   }
@@ -77,25 +79,22 @@ elb = CfElb.new("MyLoadBalancer", {
 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)
+origin = CfFactory::CfCustomOriginConfig.new("http-only",:http_port => 80)
+origin_config = CfFactory::CfOrigin.new(elb.retrieve_attribute("DNSName") ,"CF001", origin)
+default_cache_behavior = CfFactory::CfDefaultCacheBehavior.new(origin_config.id,CfFactory::CfForwardedValues.new(true),"allow-all",{:min_ttl => 0})
+distribution_details = CfFactory::CfDistributionConfig.new([origin_config],default_cache_behavior,true)
+cloudfront_distribution = CfFactory::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"))
+elb_output = CfFactory::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"))
+cloudfront_domain = CfFactory::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 = CfFactory::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

@@ -1,9 +1,11 @@
-require 'help/include_libraries'
+#!/usr/bin/ruby
 
-cf = CfMain.new("Playground")
+require 'cf_factory'
+
+cf = CfFactory::CfMain.new("Playground")
 ##########################
 
-mapping = CfMapping.new("Region2AmiMapping","AMI", {
+mapping = CfFactory::CfMapping.new("Region2AmiMapping","AMI", {
     "us-east-1" => "ami-c6699baf",
     "us-west-2" => "ami-52ff7262",
     "us-west-1" => "ami-3bcc9e7e",
@@ -14,25 +16,25 @@ mapping = CfMapping.new("Region2AmiMapping","AMI", {
   })
 cf.add_mapping(mapping)
 ami = mapping.map_from_region()
-instance = CfEc2Instance.new("MyInstance", ami, "t1.micro")
+instance = CfFactory::CfEc2Instance.new("MyInstance", ami, "t1.micro")
 cf.add_resource(instance)
-eip = CfEip.new("MyEip",instance)
+eip = CfFactory::CfEip.new("MyEip",instance)
 cf.add_resource(eip)
-instance_ip_assoc = CfEipAssociation.new("MyEipAllocation", eip, instance, nil)
+instance_ip_assoc = CfFactory::CfEipAssociation.new("MyEipAllocation", eip, instance, nil)
 cf.add_resource(instance_ip_assoc)
 
-eip_output = CfOutput.new("Eip", "Id of the EIP", eip.generate_ref())
+eip_output = CfFactory::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())
+assoc_output = CfFactory::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()
+#validator = CfFactory::TemplateValidation.new(cf_json, config_options)
+#validator.validate()
+#validator.apply()
 

data/examples/instance_with_yum.rb

@@ -1,9 +1,11 @@
-require 'help/include_libraries'
+#!/usr/bin/ruby
 
-cf = CfMain.new("Playground")
+require 'cf_factory'
+
+cf = CfFactory::CfMain.new("Playground")
 ##########################
 
-mapping = CfMapping.new("Region2AmiMapping","AMI", {
+mapping = CfFactory::CfMapping.new("Region2AmiMapping","AMI", {
     "us-east-1" => "ami-c6699baf",
     "us-west-2" => "ami-52ff7262",
     "us-west-1" => "ami-3bcc9e7e",
@@ -15,16 +17,16 @@ mapping = CfMapping.new("Region2AmiMapping","AMI", {
 cf.add_mapping(mapping)
 ami = mapping.map_from_region()
   puts "AMI = #{ami}"
-instance = CfEc2Instance.new("MyInstance", ami, "t1.micro", {:keyname => "majung-eu"})
+instance = CfFactory::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"])
+packages = CfFactory::CfCloudFormationPackages.new([
+  CfFactory::CfCloudFormationPackage.new("yum", "rubygems", []),
+  CfFactory::CfCloudFormationPackage.new("yum", "rubygem-aws-sdk", []),
+  CfFactory::CfCloudFormationPackage.new("rubygems", "cloudyscripts", ["2.14.60"])
 ])
-config = CfCloudFormationConfig.new("GemInstallation", nil, nil, nil, packages)
-cloud_init_config = CfCloudFormationInit.new([config])
+config = CfFactory::CfCloudFormationConfig.new("GemInstallation", nil, nil, nil, packages)
+cloud_init_config = CfFactory::CfCloudFormationInit.new([config])
 instance.set_meta_data(cloud_init_config)
 
 ##########################
@@ -32,7 +34,7 @@ cf_json = cf.generate
 puts cf_json
 
 config_options = YAML.load_file("aws_config.yml")
-validator = TemplateValidation.new(cf_json, config_options)
+validator = CfFactory::TemplateValidation.new(cf_json, config_options)
 validator.validate()
 #validator.apply()
 

data/examples/just_an_instance.rb

@@ -1,9 +1,11 @@
-require 'help/include_libraries'
+#!/usr/bin/ruby
 
-cf = CfMain.new("JustAnInstance")
+require 'cf_factory'
+
+cf = CfFactory::CfMain.new("JustAnInstance")
 ##########################
 
-mapping = CfMapping.new("Region2AmiMapping","AMI", {
+mapping = CfFactory::CfMapping.new("Region2AmiMapping","AMI", {
     "us-east-1" => "ami-c6699baf",
     "us-west-2" => "ami-52ff7262",
     "us-west-1" => "ami-3bcc9e7e",
@@ -15,7 +17,7 @@ mapping = CfMapping.new("Region2AmiMapping","AMI", {
 cf.add_mapping(mapping)
 ami = mapping.map_from_region()
   puts "AMI = #{ami}"
-instance = CfEc2Instance.new("MyInstance", ami, "t1.micro")
+instance = CfFactory::CfEc2Instance.new("MyInstance", ami, "t1.micro")
 cf.add_resource(instance)
 
 ##########################
@@ -23,7 +25,7 @@ cf_json = cf.generate
 puts cf_json
 
 config_options = YAML.load_file("aws_config.yml")
-validator = TemplateValidation.new(cf_json, config_options)
+validator = CfFactory::TemplateValidation.new(cf_json, config_options)
 validator.validate()
-validator.apply()
+