cf_factory 0.0.2

data/examples/test_vpc.rb

@@ -0,0 +1,53 @@
+require 'help/include_libraries'
+
+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
+vpc = CfVpc.new("10.10.0.0/16")
+cf.add_vpc(vpc)
+igw = CfInternetGateway.new("MyInternetGateway", vpc)
+vpc.add_internet_gateway(igw)
+route_table = CfRouteTable.new("MyRouteTable")
+vpc.add_route_table(route_table)
+route1 = CfRoute.new("MyRoute1", "88.44.22.11/32", igw)
+route2 = CfRoute.new("MyRoute2", "188.144.122.111/32", igw)
+route_table.add_route(route1)
+route_table.add_route(route2)
+
+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)
+
+subnet1 = CfSubnet.new("WebTier1", "10.10.0.0/24", "eu-west-1a", route_table, network_acl)
+vpc.add_subnet(subnet1)
+subnet2 = CfSubnet.new("AppTier1", "10.10.1.0/24", "eu-west-1a", route_table, network_acl)
+vpc.add_subnet(subnet2)
+subnet3 = CfSubnet.new("DbTier1", "10.10.2.0/24", "eu-west-1a", route_table, network_acl)
+vpc.add_subnet(subnet2)
+
+#elb
+#elb = CfElb.new("MyElb", {
+#  :availability_zones => "eu-west-1",
+#  :app_cookie_stickiness_policy => CfAppCookieStickinessPolicy.new("cookie-name","policy bla")})
+#cf.add_elb(elb)
+#puts elb.get_cf_properties()
+
+####### output parameters
+output = CfOutput.new("VPC_ID", "Id of the VPC", vpc.generate_ref())
+cf.add_output(output)
+
+
+puts cf.generate
+
+#puts "the reference for the VPC : #{vpc.generate_ref}"

data/lib/cf_factory/as/cf_as_group.rb

@@ -0,0 +1,75 @@
+require 'cf_factory/base/cf_base'
+require 'cf_factory/base/cf_helper'
+
+class CfAsGroup
+  include CfBase  
+  
+  def initialize(name, availability_zones, launch_config, load_balancers, max_size, min_size, options)
+    @name = name
+    @availability_zones = availability_zones
+    @launch_config = launch_config
+    @load_balancers  = load_balancers
+    @max_size = max_size
+    @min_size = min_size
+    
+    @cooldown = options[:cooldown]
+    @desired_capacity = options[:desired_capacity]
+    @health_check_grace_period = options[:health_check_grace_period]
+    @health_check_type = options[:health_check_type]
+    #TODO: NotificationConfiguration      
+    @subnets = options[:subnets]
+    validate()
+  end
+  
+  def set_tags(tag_list)
+    @tag_list = []
+    tag_list.each() {|tg|
+      tg2 = tg.clone
+      tg2.set_propagate_at_launch(true)
+      puts ">>>>>>>>>>>>>>>>>>>>> "+tg2.inspect
+      @tag_list << tg2
+    }
+    @tag_list
+  end
+    
+  def validate
+    if @max_size < @min_size
+      raise Exception.new("max size (#{@max_size}) must be equal or larger min size (#{@min_size})")
+    end
+    if @health_check_type == "ELB" && @health_check_grace_period.nil? 
+      raise Exception.new("HealthCheckGracePeriod must be specified for ElasticLoadBalancer based health checks.")
+    end
+  end
+  
+  def get_cf_type
+    "AWS::AutoScaling::AutoScalingGroup"
+  end
+  
+  def get_cf_attributes
+    {}
+  end
+  
+  def get_cf_properties
+    result = {"AvailabilityZones" => @availability_zones,
+      "LaunchConfigurationName" => @launch_config.generate_ref,
+      "LoadBalancerNames" => CfHelper.generate_ref_array(@load_balancers),
+      "MaxSize" => @max_size,
+      "MinSize" => @min_size
+    }
+    result["Cooldown"] = @cooldown unless @cooldown.nil?
+    result["DesiredCapacity"] = @desired_capacity unless @desired_capacity.nil?
+    result["HealthCheckGracePeriod"] = @health_check_grace_period.to_i unless @health_check_grace_period.nil?
+    result["HealthCheckType"] = @health_check_type unless @health_check_type.nil?  
+    result["VPCZoneIdentifier"] = CfHelper.generate_ref_array(@subnets) unless @subnets.nil?
+    result
+  end
+  
+  def add_ingress_rule(ingress_rule)
+    @ingress_rules << ingress_rule
+  end
+  
+  def add_egress_rule(egress_rule)
+    @egress_rules << egress_rule
+  end
+  
+end

data/lib/cf_factory/as/cf_as_launch_config.rb

@@ -0,0 +1,53 @@
+require 'cf_factory/base/cf_base'
+require 'cf_factory/base/cf_helper'
+
+class CfAsLaunchConfig
+  include CfBase  
+  
+  def initialize(name, image_id, instance_type, options)
+    @name = name
+    @image_id = image_id
+    @instance_type = instance_type
+    
+    @user_data = options[:user_data]
+    @key_name = options[:key_name]
+    @security_groups = options[:security_groups]
+    @spot_price = options[:spot_price]
+    #TODO: a couple of properties missing
+    validate()
+  end
+  
+  def get_cf_type
+    "AWS::AutoScaling::LaunchConfiguration"
+  end
+  
+  def get_cf_attributes
+    super
+  end
+  
+  def get_cf_properties
+    result = {"ImageId" => @image_id,
+      "InstanceType" => @instance_type
+    }
+    result["UserData"] = CfHelper.base64(@user_data) unless @user_data.nil?
+    result["KeyName"] = @key_name unless @key_name.nil?
+    result["SecurityGroups"] = CfHelper.generate_ref_array(@security_groups) unless @security_groups.nil?
+    result["SpotPrice"] = @spot_price unless @spot_price.nil?
+    result
+  end
+  
+  def add_ingress_rule(ingress_rule)
+    @ingress_rules << ingress_rule
+  end
+  
+  def add_egress_rule(egress_rule)
+    @egress_rules << egress_rule
+  end
+
+  private
+  
+  def validate
+    raise Exception.new("instance type #{@instance_type} is not supported") unless CfEc2Instance::SUPPORTED_TYPES.include?(@instance_type)
+  end
+    
+end

data/lib/cf_factory/as/cf_as_scaling_policy.rb

@@ -0,0 +1,33 @@
+require 'cf_factory/base/cf_base'
+require 'cf_factory/base/cf_helper'
+
+class CfAsScalingPolicy
+  include CfBase  
+  
+  def initialize(name, auto_scaling_group, adjustment_type, scaling_adjustment, options = {})
+    @name = name
+    @auto_scaling_group = auto_scaling_group
+    @adjustment_type = adjustment_type
+    @scaling_adjustment = scaling_adjustment
+    @cooldown = options[:cooldown]
+  end
+    
+  def get_cf_type
+    "AWS::AutoScaling::ScalingPolicy"
+  end
+  
+  def get_cf_attributes
+    {}
+  end
+  
+  def get_cf_properties
+    result = {
+      "AutoScalingGroupName" => @auto_scaling_group.generate_ref,
+      "AdjustmentType" => @adjustment_type,
+      "ScalingAdjustment" => @scaling_adjustment
+    }
+    result["Cooldown"] = @cooldown unless @cooldown.nil?
+    result
+  end
+    
+end

data/lib/cf_factory/base/cf_base.rb

@@ -0,0 +1,97 @@
+require 'cf_factory/base/cf_helper'
+
+module CfBase
+  def get_name
+    @name
+  end
+  
+  def get_cf_type
+    raise Exception.new("must be defined")
+  end
+    
+  def get_deletion_policy
+    @deletion_policy
+  end
+  
+  def get_cf_attributes
+    result = {}
+    result["Metadata"] = @meta_data.generate unless @meta_data.nil?
+    result
+  end
+  
+  def get_cf_properties
+    raise Exception.new("must be defined")
+  end
+  
+  def generate_ref
+    CfHelper.generate_ref(self.get_name)
+  end
+  
+  def retrieve_attribute(attribute)
+    CfHelper.generate_att(@name, attribute)
+  end
+  
+  def set_meta_data(meta_data)
+    @meta_data = meta_data
+  end
+    
+  def set_tags(tag_list)
+    #should be overwritten by those resources that support tags 
+  end
+    
+  def hash_to_string(hash, indent=0)
+    output = ""
+    hash.keys.each() do |key|
+      value = hash[key]
+      output += " " * indent
+      case value.class.to_s
+      when "Hash"
+        output += "        \"#{key}\" : \n{#{hash_to_string(value,indent+5)}},\n"
+      else
+        output += "        \"#{key}\" : #{set_quotes(value)},\n"
+      end
+    end
+    output
+    output = output.chomp().chomp(",")
+
+  end
+
+  def generate
+    @result = ""
+    @result += "    \"#{@name}\" : {\n"
+    unless self.get_cf_type() == nil
+      @result += "      \"Type\" : \"#{self.get_cf_type()}\",\n"
+    end
+    unless self.get_deletion_policy() == nil
+      @result += "      \"DeletionPolicy\" : \"#{self.get_deletion_policy()}\",\n"
+    end            
+    attributes = self.get_cf_attributes  
+    unless attributes.size == 0
+      @result += "#{hash_to_string(attributes)},\n"
+    end
+    #
+    properties = self.get_cf_properties
+    properties["Tags"] = CfHelper.generate_inner_array(@tag_list) unless @tag_list.nil?
+    unless properties.size == 0
+      @result += "      \"Properties\" : {\n"
+      @result += hash_to_string(properties)
+      @result += "\n      }"  
+    end
+    @result = @result.chomp.chomp(",")
+    @result += "\n    },\n"
+  end
+  
+  # Sets leading and trailing quotes
+  def set_quotes(value)
+    if value.class.to_s == "String"
+      if value.delete(" ").start_with?("{") || value.delete(" ").start_with?("[") 
+        value
+      else
+        "\"#{value}\""
+      end
+    else
+      value
+    end
+  end
+  
+end

data/lib/cf_factory/base/cf_ec2_tag.rb

@@ -0,0 +1,32 @@
+require 'cf_factory/base/cf_inner'
+
+class CfEc2Tag
+  include CfInner  
+  
+  def initialize(key, value, options = {})
+    @key = key
+    @value = value
+    @propagate_at_launch = options[:propagate_at_launch]
+  end
+     
+  def set_propagate_at_launch(pal)
+    @propagate_at_launch = pal
+  end
+   
+  def get_cf_attributes
+    result = {"Key" => @key,
+     "Value" => @value
+    }
+    result["PropagateAtLaunch"] = @propagate_at_launch unless @propagate_at_launch.nil?
+    result
+  end
+
+  def clone
+    options = {} 
+    if @propagate_at_launch
+      options[:propagate_at_launch] = @propagate_at_launch 
+    end
+    CfEc2Tag.new(@key,@value,options)
+  end
+    
+end

data/lib/cf_factory/base/cf_generator.rb

@@ -0,0 +1,18 @@
+class CfGenerator
+  def initialize(indent)
+    @indent = indent
+  end
+  
+  def self.add_line(indent, input, result)
+    result += "\n#{self.indent(indent, input)}"
+  end
+  
+  def self.indent(indent, string)
+    result = ""
+    string.each_line() {|s|
+      result += "#{" "*indent}#{s}"      
+    }
+    result
+  end
+  
+end

data/lib/cf_factory/base/cf_helper.rb

@@ -0,0 +1,91 @@
+class CfHelper
+  def self.generate_ref(cf_object_ref)
+    "{ \"Ref\" : \"#{cf_object_ref}\" }"
+  end
+  
+  def self.generate_att(resource_name, attribute_name)
+    "{ \"Fn::GetAtt\" : [ \"#{resource_name}\", \"#{attribute_name}\" ] }"
+  end
+  
+  def self.generate_ref_array(cf_array)
+    result = "["
+    cf_array.each() {|cf|
+      result += "#{cf.generate_ref},"
+    }
+    result = result.chomp(",")
+    result += "]"
+    result    
+  end
+  
+  def self.generate_inner_array(cf_array)
+    result = "["
+    cf_array.each() {|cf|
+      result += "#{cf.generate()},"
+    }
+    result = result.chomp(",")
+    result += "]"
+    result
+  end
+  
+  def self.generate_inner_list(cf_array)
+    result = ""
+    cf_array.each() {|cf|
+      result += "#{cf.generate},\n"
+    }
+    result = result.chomp("\n").chomp(",") 
+    result
+  end
+  
+  def self.base64(string)
+    base = "{ \"Fn::Base64\": \"#{string}\" }"
+    return clean(base)
+  end
+  
+  def self.join(array)
+    "{ \"Fn::Join\" : [ \"\", #{print_array(array)} ]}"
+  end
+  
+  def self.clean(string)
+    string.gsub(/\"{/,"{").gsub(/\"}/,"}").gsub(/}\"/,"}").gsub(/\"\[/,"[").gsub(/\"\]/,"]")#.gsub(/\\/,"") #TODO: the last gsub invalidated line-breaks
+  end
+  
+  def self.availability_zones(string = "")
+    "{ \"Fn::GetAZs\" : \"#{string}\" }"
+  end
+
+  def self.ref_current_region()
+    '{ "Ref" : "AWS::Region" }'
+  end
+  
+  def self.az_in_region(az_id = "a", region = "")
+    clean(join([ref_current_region(), az_id]))
+  end
+  
+  def self.az_array_in_region(az_ids = ["b","c"], region = "")
+    result = "["
+    az_ids.each() {|az_id|
+      result += CfHelper.az_in_region(az_id)+", "
+    }
+    result = result.chomp(" ").chomp(",")
+    result += "]"
+  end
+  
+  def self.print_array(array)
+    inner = ""
+    array.each() {|element|
+      if element == "\n"
+        inner += "\"\\n\" ,"
+      else
+        inner += "\"#{element}\" ,"
+      end
+    }
+    inner.chomp!(",")
+    result = "[ #{inner} ]"
+    #result = array.inspect
+    #puts "rsult before CLEAN = #{result}"    
+    res = clean(result)
+    #puts "rsult after CLEAN = #{res}"
+    res
+  end
+  
+end

data/lib/cf_factory/base/cf_inner.rb

@@ -0,0 +1,55 @@
+require 'cf_factory/base/cf_helper'
+
+module CfInner
+  def get_cf_attributes
+    raise Exception.new("must be defined")
+  end
+  
+  def additional_indent
+    0
+  end
+  
+  def generate_name()
+    indent = " "*additional_indent()
+    @result = "#{indent}"
+    @result += "#{indent}{\n"
+    attributes = self.get_cf_attributes
+    @result += "#{indent}          \"#{@name}\" : {\n"
+    attributes.keys.each() {|key|
+      value = attributes[key]
+      @result += "#{indent}            \"#{key}\" : #{set_quotes(value)},\n"
+    }
+    #
+    @result = @result.chomp.chomp(",")
+    @result += "\n#{indent}      }"
+    @result += "\n#{indent}        }"
+  end
+  
+  def generate()
+    indent = " "*additional_indent()
+    @result = "#{indent}"
+    @result += "#{indent}{\n"
+    attributes = self.get_cf_attributes
+    attributes.keys.each() {|key|
+      value = attributes[key]
+      @result += "#{indent}          \"#{key}\" : #{set_quotes(value)},\n"
+    }
+    #
+    @result = @result.chomp.chomp(",")
+    @result += "\n#{indent}        }"
+  end  
+  
+  # Sets leading and trailing quotes
+  def set_quotes(value)
+    if value.class.to_s == "String"
+      if value.delete(" ").start_with?("{") || value.delete(" ").start_with?("[")
+        value
+      else
+        "\"#{value}\""
+      end
+    else
+      value
+    end
+  end
+  
+end

data/lib/cf_factory/base/cf_main.rb

@@ -0,0 +1,101 @@
+class CfMain
+  def initialize(description, version = "2010-09-09")
+    @description = description
+    @version = version
+    @mappings = []
+    @parameters = []
+    @outputs = []
+    @resources = []
+  end
+  
+  # Go through all resources and tag them with the specified array of tags.
+  def apply_tags_to_all_resources(tag_list)
+    @resources.each() {|resource|
+      resource.set_tags(tag_list)
+    }
+  end
+  
+  def add_vpc(vpc)
+    @resources << vpc
+  end
+  
+  def add_elb(elb)
+    @resources << elb
+  end
+  
+  def add_mapping(mapping)
+    @mappings << mapping
+  end
+  
+  def add_parameter(parameter)
+    @parameters << parameter
+  end
+  
+  def add_output(parameter)
+    @outputs << parameter
+  end  
+  
+  def add_resource(resource)
+    @resources << resource
+  end
+  
+  def generate()
+    @result = "{\n"
+    generate_version
+    generate_description
+    generate_parameters
+    generate_mappings unless @mappings.size == 0
+    generate_resources
+    generate_outputs
+    @result += "}\n"
+    @result
+  end
+  
+  private
+    
+  def generate_version
+    @result += "  \"Description\" : \"#{@description}\",\n"
+  end
+  
+  def generate_description
+    @result += "  \"AWSTemplateFormatVersion\" : \"#{@version}\",\n"
+  end
+  
+  def generate_parameters
+    @result += "  \"Parameters\" : {\n"
+    @parameters.each() {|p|
+      @result += p.generate
+    }
+    @result = @result.chomp.chomp(",")
+    @result += "\n  },\n"
+  end
+  
+  def generate_mappings
+    @result += "  \"Mappings\" : {\n"
+    @mappings.each() {|m|
+      @result += m.generate
+    }
+    @result = @result.chomp(",")
+    @result += "\n  },\n"      
+  end  
+  
+  def generate_resources
+    @result += "  \"Resources\" : {\n"
+    @resources.each() do |resource|
+      @result += resource.generate
+    end
+    @result = @result.chomp.chomp(",")
+    @result += "\n  },\n"
+  end  
+  
+  
+  def generate_outputs
+    @result += "  \"Outputs\" : {\n"
+    @outputs.each() {|o|
+      @result += o.generate
+    }
+    @result = @result.chomp.chomp(",")
+    @result += "\n  }\n"
+  end
+    
+end

data/lib/cf_factory/base/cf_mapping.rb

@@ -0,0 +1,26 @@
+class CfMapping
+  def initialize(name, target, from_to_hash)
+    @name = name
+    @target = target
+    @from_to_hash = from_to_hash
+  end
+  
+  def generate
+    @result = ""
+    @result += "    \"#{@name}\" : {\n"
+    @from_to_hash.keys.each() {|key|
+      value = @from_to_hash[key]
+      @result += "      \"#{key}\"\t : { \"#{@target}\" : \"#{value}\" },\n"
+    }
+    @result = @result.chomp.chomp(",")
+    @result += "\n    },"
+  end
+  
+  def generate_ref(key)
+    "{\"Fn::FindInMap\" : [ \"#{@name}\", #{CfHelper.generate_ref(key)}, \"#{@target}\" ]}"    
+  end
+  
+  def map_from_region()
+    "{\"Fn::FindInMap\" : [ \"#{@name}\", \"#{CfHelper.ref_current_region()}\", \"#{@target}\" ]}"
+  end
+end

data/lib/cf_factory/base/cf_output.rb

@@ -0,0 +1,24 @@
+require 'cf_factory/base/cf_base'
+
+class CfOutput
+  include CfBase
+  
+  def initialize(name, description, value)
+    @name = name
+    @description = description
+    @value = value
+  end
+  
+  def get_cf_type
+    nil
+  end
+  
+  def get_cf_attributes
+    {"Description" => @description, "Value" => @value}
+  end
+  
+  def get_cf_properties
+    {}
+  end  
+  
+end

data/lib/cf_factory/base/cf_parameter.rb

@@ -0,0 +1,25 @@
+require 'cf_factory/base/cf_base'
+
+class CfParameter
+  include CfBase
+  
+  def initialize(name, description, type, properties_hash = {})
+    @name = name
+    @description = description
+    @type = type
+    @properties_hash = properties_hash
+  end
+  
+  def get_cf_type
+    @type
+  end
+  
+  def get_cf_attributes
+    @properties_hash.merge({"Description" => @description})
+  end
+  
+  def get_cf_properties
+    {}
+  end  
+  
+end