cf_factory 0.0.2

data/lib/cf_factory/help/ip_mask.rb

@@ -0,0 +1,165 @@
+class IpMask
+  attr_reader :bits, :ip_mask 
+  
+  def initialize(ip_mask, bits = 32) #if one parameter specified, means it's not a range, it's one address
+    @ip_mask = ip_mask
+    @bits = bits.to_i
+  end
+  
+  def self.create(ip_mask, bits = 32)
+    cleaned = IpMask.new(ip_mask, bits)
+    cleaned.clean_mask()
+  end
+  
+  def self.create_from_cidr(cidr)
+    #ip  = cidr.split("/")[0].split(".")
+    #bits  = cidr.split("/")[1].to_i
+    ip = cidr.split("/")[0]
+    bits = cidr.split("/")[1]
+    IpMask.new(ip, bits)
+  end
+  
+  def self.create_from_num(number, bits)
+    ip_bytes = []
+    3.downto(0) {|i|
+      div = 256 ** i
+      b = number/div.to_i
+      ip_bytes << b.to_i
+      number = number % div
+    }
+    ip_bytes
+    IpMask.new(ip_bytes.join("."), bits)
+  end
+  
+  def to_num
+    sum = 0
+    exp = 3
+    @ip_mask.split(".").each() {|ip|
+      sum += ip.to_i * (256 ** exp)
+      exp -= 1
+    }
+    sum
+  end
+
+  def to_mask
+    bit_string = self.to_bit_string 
+    r = bit_string.to_i(2)
+  end
+  
+  def to_bit_string    
+    bit_string = ("1"*@bits+"0"*(32-@bits))
+    #puts "#{bit_string}"
+    bit_string
+  end
+  
+  def free()
+    (2 ** 32) / used()
+  end
+  
+  def used()
+    2 ** @bits 
+  end
+  
+  def generate_free()
+    self.to_num()
+  end
+    
+  def to_s
+    if @bits.to_i == 32
+      "#{@ip_mask}"
+    else
+      "#{@ip_mask}/#{@bits}"
+    end
+  end
+    
+  def clean_mask
+    ip_base_num = self.to_num
+    ip_bits_num = self.to_mask()
+    clean_mask = ip_base_num & ip_bits_num
+    #puts "clean_mask = #{clean_mask}"
+    IpMask.create_from_num(clean_mask,@bits)
+  end
+  
+  def is_clean?
+    comp = self.clean_mask
+    return self.ip_mask != comp.ip_mask
+  end
+  
+  def divide(number_of_addresses)
+    possible_ranges = []
+    bits_to_move = (Math.log(number_of_addresses+1)/Math.log(2)).to_i
+    puts "asked to allocate #{number_of_addresses}; that corresponds to #{bits_to_move} bits"
+    puts "#{self.free()} are free"
+    max_subnets = self.free()/number_of_addresses
+    puts "given that every subnet should have #{number_of_addresses} addresses, there is currently space for #{max_subnets}"
+    0.upto(max_subnets-1) {|i|
+      num = self.to_num()
+      num += i*number_of_addresses
+      possible_range = IpMask.create_from_num(num, 32 - bits_to_move)
+      possible_ranges << possible_range
+      puts "possible range: #{possible_range}"
+    }
+    possible_ranges
+  end  
+      
+  # Takes an array of IP-Address-Numbers into account and allocates corresponding IP address ranges
+  def divide_individually(array_with_number_of_addresses)
+    possible_ranges = []
+    num = self.to_num()
+    bits_to_move = 32 - @bits
+    remaining_addresses = self.free
+    array_with_number_of_addresses.each() {|number_of_addresses_for_subnet|
+      if (2 ** bits_to_move) < number_of_addresses_for_subnet
+        puts "WARNING: could not allocate #{number_of_addresses_for_subnet} anymore (max #{(2 ** bits_to_move)})"
+        next
+      end        
+      bits_to_move = [(Math.log(number_of_addresses_for_subnet+1)/Math.log(2)).to_i, bits_to_move].min      
+      possible_range = IpMask.create_from_num(num, 32 - bits_to_move)
+      unless self.are_all_in_range?(possible_range)
+        puts "WARNING: the selected range '#{possible_range}' is outside the base range"
+        next
+      end
+      num += number_of_addresses_for_subnet
+      puts "[alloc #{number_of_addresses_for_subnet}] \tpossible range: #{possible_range}"
+      possible_ranges << possible_range
+      remaining_addresses -= (2 ** bits_to_move)
+      #puts "[to allocate = #{number_of_addresses_for_subnet}] => free = #{possible_range.free}"
+    }
+    possible_ranges
+  end
+  
+  def is_in_range?(ip_address)
+    comp_mask = IpMask.new(ip_address)
+    # transform ip address string to numerical values for bitwise operations
+    comp_ip = comp_mask.to_num
+    #puts "ip_address checked = #{comp_ip.to_s(2)}"
+    ip_base_num = self.to_num
+    #puts "range_mask         = #{ip_base_num.to_s(2)}"
+    ip_bits_num = self.to_mask
+    #puts "bit_mask           = #{ip_bits_num.to_s(2)}"
+    # perform an AND operation to get rid of the bits in the mask that don't count
+    clean_mask = ip_base_num & ip_bits_num
+    #puts "cleaned range_mask = #{ip_base_num.to_s(2)}"
+    # the ip address belongs to the range, when an AND with the bitmask equals the cleaned mask
+    #puts "(ip_address&bits   = #{(comp_ip & ip_bits_num).to_s(2)}"
+    (comp_ip & ip_bits_num) == clean_mask
+  end
+   
+  def are_all_in_range?(ip_mask)
+    #puts "check for #{ip_mask}"
+    return false if ip_mask.bits < self.bits
+    #
+    comp_ip = ip_mask.to_num
+    ip_base_num = self.to_num
+    ip_bits_num = self.to_mask
+    ip_clean = ip_base_num & ip_bits_num
+    #puts "comp = #{(comp_ip & ip_bits_num)} ip_clean = #{ip_clean} (ip_bits_num = #{ip_bits_num})"
+    (comp_ip & ip_bits_num) == ip_clean
+  end
+   
+  def ==(comp)
+    puts "comp = #{comp.class} #{comp.inspect}"
+    self.ip_mask == comp.ip_mask && self.bits == comp.bits
+  end
+    
+end

data/lib/cf_factory/help/template_validation.rb

@@ -0,0 +1,28 @@
+require 'aws'
+
+class TemplateValidation
+  def initialize(template_string, config_options)
+    @template_string = template_string
+    @config_options = config_options
+  end
+  
+  def validate
+    cf = AWS::CloudFormation.new(@config_options)
+    response = cf.validate_template(@template_string)
+    if response[:code] == "ValidationError"
+      puts "Validation failed: #{response[:message]}"
+    else
+      puts "Validation successful"
+    end
+    response
+  end
+  
+  def apply(parameters = {})
+    cf = AWS::CloudFormation.new(@config_options)
+    stack_name = "StackStartedFromEclipse#{Time.new.to_i}"
+    puts "going to start stack #{stack_name} with parameters #{parameters.inspect}"
+    stack = cf.stacks.create(stack_name, @template_string, :parameters => parameters, :capabilities => ["CAPABILITY_IAM"])
+    puts "started stack with parameters: #{stack.parameters}"
+  end
+  
+end

data/lib/cf_factory/iam/cf_iam_access_key.rb

@@ -0,0 +1,32 @@
+require 'cf_factory/base/cf_base'
+require 'cf_factory/base/cf_helper'
+require 'cf_factory/iam/cf_iam_instance_profile'
+
+class CfIamAccessKey
+  include CfBase
+  
+  def initialize(name, user_name, status, options = {})
+    @name = name 
+    @status = status
+    @user_name = user_name
+    @serial = options[:serial]
+  end
+    
+  def get_cf_type
+    "AWS::IAM::AccessKey"
+  end
+  
+  def get_cf_attributes
+    {}
+  end
+  
+  def get_cf_properties
+    result = {
+      "Status" => @status,
+      "UserName" => @user_name
+    }
+    result["Serial"] = @serial unless @serial.nil?
+    result
+  end
+  
+end

data/lib/cf_factory/iam/cf_iam_group.rb

@@ -0,0 +1,30 @@
+require 'cf_factory/base/cf_base'
+require 'cf_factory/base/cf_helper'
+require 'cf_factory/iam/cf_iam_instance_profile'
+
+class CfIamGroup
+  include CfBase
+  
+  def initialize(name, path, options)
+    @name = name 
+    @path = path
+    @policies = options[:policies]
+  end
+    
+  def get_cf_type
+    "AWS::IAM::Group"
+  end
+  
+  def get_cf_attributes
+    {}
+  end
+  
+  def get_cf_properties
+    result = {
+      "Path" => @path
+    }
+    result["Policies"] = CfHelper.generate_inner_array(@policies) unless @policies.nil?
+    result
+  end
+  
+end

data/lib/cf_factory/iam/cf_iam_instance_profile.rb

@@ -0,0 +1,30 @@
+require 'cf_factory/base/cf_base'
+require 'cf_factory/base/cf_helper'
+require 'cf_factory/elb/cf_app_cookie_stickiness_policy'
+
+class CfIamInstanceProfile
+  include CfBase
+  
+  def initialize(name, path, roles)
+    @name = name 
+    @path = path
+    @roles = roles
+  end
+    
+  def get_cf_type
+    "AWS::IAM::InstanceProfile"
+  end
+  
+  def get_cf_attributes
+    {}
+  end
+  
+  def get_cf_properties
+    result = {
+      "Path" => @path,
+      "Roles" => "["+@roles.collect() {|r| CfHelper.generate_ref(r)}.join(",")+"]"
+    }
+    result
+  end
+  
+end

data/lib/cf_factory/iam/cf_iam_policy.rb

@@ -0,0 +1,18 @@
+require 'cf_factory/base/cf_inner'
+require 'cf_factory/iam/cf_policy_document'
+
+class CfIamPolicy
+  include CfInner  
+  
+  def initialize(policy_name, policy_doc)
+    @policy_name = policy_name
+    @policy_doc = policy_doc
+  end
+      
+  def get_cf_attributes
+    {"PolicyName" => @policy_name,
+      "PolicyDocument" => @policy_doc.generate
+    }
+  end
+
+end

data/lib/cf_factory/iam/cf_iam_role.rb

@@ -0,0 +1,56 @@
+require 'cf_factory/base/cf_base'
+require 'cf_factory/base/cf_helper'
+require 'cf_factory/iam/cf_iam_instance_profile'
+
+class CfIamRole
+  include CfBase
+  
+  def initialize(name, path, options)
+    @name = name 
+    @path = path
+    @policies = options[:policies]
+  end
+    
+  def get_cf_type
+    "AWS::IAM::Role"
+  end
+  
+  def get_cf_attributes
+    {}
+  end
+  
+  def get_cf_properties
+    result = {
+      "Path" => @path,
+      "AssumeRolePolicyDocument" => assume_role_ec2() #no other supported right now
+    }
+    result["Policies"] = CfHelper.generate_inner_array(@policies) unless @policies.nil?
+    result
+  end
+  
+  def generate
+    result = super
+    result += CfIamInstanceProfile.new(@name+"Profile", @path, [@name]).generate
+  end
+  
+  private
+  
+  def assume_role_ec2
+    ' {
+          "Statement":[
+            {
+              "Effect":"Allow",
+              "Principal":{
+                  "Service":[
+                      "ec2.amazonaws.com"
+                  ]
+              },
+              "Action":[
+                  "sts:AssumeRole"
+              ]
+            }
+          ] 
+        }'
+  end
+  
+end

data/lib/cf_factory/iam/cf_iam_statement.rb

@@ -0,0 +1,23 @@
+require 'cf_factory/base/cf_inner'
+
+class CfIamStatement
+  include CfInner  
+  
+  def initialize(effect, action, resource)
+    @effect = effect
+    @action = action
+    @resource = resource
+  end
+      
+  def get_cf_attributes
+    {"Effect" => @effect,
+     "Action" => @action,
+     "Resource" => @resource
+    }
+  end
+
+  def additional_indent
+    4
+  end
+  
+end

data/lib/cf_factory/iam/cf_iam_user.rb

@@ -0,0 +1,34 @@
+require 'cf_factory/base/cf_base'
+require 'cf_factory/base/cf_helper'
+require 'cf_factory/iam/cf_iam_instance_profile'
+
+class CfIamUser
+  include CfBase
+  
+  def initialize(name, path, options = {})
+    @name = name 
+    @path = path
+    @policies = options[:policies]
+    @login_profile = options[:login_profile]
+    @groups = options[:groups]
+  end
+    
+  def get_cf_type
+    "AWS::IAM::User"
+  end
+  
+  def get_cf_attributes
+    {}
+  end
+  
+  def get_cf_properties
+    result = {
+      "Path" => @path
+    }
+    result["Policies"] = CfHelper.generate_inner_array(@policies) unless @policies.nil?
+    result["LoginProfile"] = "XXX" unless @login_profile.nil?
+    result["Groups"] = CfHelper.generate_ref_array(@groups) unless @groups.nil?
+    result
+  end
+  
+end

data/lib/cf_factory/iam/cf_policy_document.rb

@@ -0,0 +1,19 @@
+require 'cf_factory/base/cf_inner'
+
+class CfPolicyDocument
+  include CfInner
+    
+  def initialize(statements, additional_indent = 2)
+    @additional_indent = additional_indent
+    @statements = statements
+  end
+  
+  def get_cf_attributes()
+    {"Statement" => CfHelper.generate_inner_array(@statements)} 
+  end
+  
+  def additional_indent
+    @additional_indent
+  end  
+  
+end

data/lib/cf_factory/modules/base_vpc.rb

@@ -0,0 +1,61 @@
+class BaseVpc
+  attr_reader :vpc, :subnets, :private_route_table, :public_route_table
+  
+  def initialize(name, cidr, number_public_subnets, number_private_subnets, availability_zones, subnet_size = 256)
+    @name = name
+    @cidr = cidr
+    @number_public_subnets = number_public_subnets
+    @number_private_subnets = number_private_subnets
+    @subnet_size = subnet_size  
+    @availability_zones = availability_zones
+    setup()    
+  end
+  
+  def add_to_template(cf)
+    cf.add_vpc(@vpc)
+  end
+    
+  def setup
+    define_vpc()
+    define_subnets()
+  end
+  
+  def define_vpc
+    @vpc = CfVpc.new(@cidr)
+    igw = CfInternetGateway.new("#{@name}Igw", @vpc)
+    @vpc.add_internet_gateway(igw)
+    @private_route_table = CfRouteTable.new("#{@name}PrivRt")
+    @vpc.add_route_table(@private_route_table)
+    @public_route_table = CfRouteTable.new("#{@name}PubRt")
+    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)
+  end
+  
+  def define_subnets
+    myMask = IpMask.create_from_cidr(@cidr)
+    puts "myMask = #{myMask.inspect}"
+    divider_array = [@subnet_size]*(@number_public_subnets + @number_private_subnets)
+    puts "divider_array = #{divider_array}"
+    subnet_ranges = myMask.divide_individually(divider_array)
+    puts "subnet ranges = #{subnet_ranges.inspect}"
+    @subnets = []
+    0.upto(@number_public_subnets-1) do |i| 
+      @vpc.add_subnet(CfSubnet.new("#{@name}PublicSubnet#{i+1}", @cidr, @availability_zones[i%(@availability_zones.size)], @public_route_table))  
+    end
+    0.upto(@number_private_subnets-1) do |i| 
+      @vpc.add_subnet(CfSubnet.new("#{@name}PrivateSubnet#{i+1}", @cidr, @availability_zones[i%(@availability_zones.size)], @private_route_table))  
+    end    
+  end
+  
+  def ip2num(ip_part)
+    sum = 0
+    exp = 3
+    ip_part.split(".").each() {|ip|
+      sum += ip.to_i * (256 ** exp)
+      exp -= 1
+    }
+    sum
+  end
+    
+end

data/lib/cf_factory/rds/cf_rds_instance.rb

@@ -0,0 +1,53 @@
+require 'cf_factory/base/cf_base'
+require 'cf_factory/base/cf_helper'
+
+class CfRdsInstance
+  VALID_TYPES = ["db.t1.micro", "db.m1.small","db.m1.medium","db.m1.large","db.m1.xlarge","db.m2.xlarge","db.m2.2xlarge","db.m2.4xlarge"]
+  include CfBase
+  
+  def initialize(name, allocated_storage, engine, db_instance_class, master_username, master_userpassword, options = {})
+    @name = name
+    @allocated_storage = allocated_storage
+    @db_instance_class = db_instance_class
+    @engine = engine
+    @master_username = master_username
+    @master_userpassword = master_userpassword
+    @multi_az = options[:multi_az]
+    @security_groups = options[:security_groups]
+    @subnet_group = options[:subnet_group]
+    validate()
+  end
+  
+  def get_cf_type
+    "AWS::RDS::DBInstance"
+  end
+  
+  def get_cf_attributes
+    {}
+  end
+  
+  def get_cf_properties
+    result = {"AllocatedStorage" => @allocated_storage, 
+      "DBInstanceClass" => @db_instance_class, 
+      "Engine" => @engine, "MasterUsername" => @master_username,
+      "MasterUserPassword" => @master_userpassword
+    }
+    result["MultiAZ"] = @multi_az unless @multi_az.nil?
+    result["DBSecurityGroups"] = CfHelper.generate_ref_array(@security_groups) unless @security_groups.nil?
+    result["DBSubnetGroupName"] = @subnet_group.generate_ref unless @subnet_group.nil?
+    result
+  end
+  
+  def add_rule(ingress_rule)
+    @rules << ingress_rule
+  end
+  
+  private
+  
+  def validate
+    if !VALID_TYPES.include?(@db_instance_class)
+      raise Exception.new("invalid type '#{@db_instance_class}' - supported classes are #{@VALID_TYPES.inspect}")
+    end
+  end
+  
+end

data/lib/cf_factory/rds/cf_rds_security_group.rb

@@ -0,0 +1,33 @@
+require 'cf_factory/base/cf_base'
+require 'cf_factory/base/cf_helper'
+
+class CfRdsSecurityGroup
+  include CfBase
+  
+  def initialize(name, description, vpc = nil)
+    @name = name
+    @description = description
+    @vpc = vpc
+    @rules = []
+  end
+  
+  def get_cf_type
+    "AWS::RDS::DBSecurityGroup"
+  end
+  
+  def get_cf_attributes
+    {}
+  end
+  
+  def get_cf_properties
+    rules_array = CfHelper.generate_inner_array(@rules)
+    result = {"GroupDescription" => @description, "DBSecurityGroupIngress" => rules_array}
+    result["EC2VpcId"] = @vpc.generate_ref unless @vpc.nil?
+    result
+  end
+  
+  def add_rule(ingress_rule)
+    @rules << ingress_rule
+  end
+  
+end

data/lib/cf_factory/rds/cf_rds_security_group_ingress.rb

@@ -0,0 +1,29 @@
+require 'cf_factory/base/cf_inner'
+
+class CfRdsSecurityGroupIngress
+  include CfInner
+    
+  def initialize(cidr = nil, ec2_sec_group = nil, ec2_sec_group_owner_id = nil)
+    @cidr = cidr
+    @ec2_sec_group = ec2_sec_group
+    @ec2_sec_group_owner_id = ec2_sec_group_owner_id 
+    @use_sg_id = true
+  end
+  
+  def set_use_sg_id(flag)
+    @use_sg_id = flag
+  end
+  
+  def get_cf_attributes
+    result = {}
+    result["CIDRIP"] = @cidr unless @cidr.nil?
+    if @use_sg_id
+      result["EC2SecurityGroupId"] = @ec2_sec_group.generate_ref unless @ec2_sec_group.nil?
+    else
+      result["EC2SecurityGroupName"] = @ec2_sec_group.generate_ref unless @ec2_sec_group.nil?      
+    end       
+    result["EC2SecurityGroupOwnerId"] = @ec2_sec_group_owner_id unless @ec2_sec_group_owner_id.nil?            
+    result
+  end
+  
+end

data/lib/cf_factory/rds/cf_rds_subnet_group.rb

@@ -0,0 +1,29 @@
+require 'cf_factory/base/cf_base'
+
+class CfRdsSubnetGroup
+  include CfBase  
+  
+  def initialize(name, description)
+    @name = name
+    @description = description
+    @subnets = []
+  end
+  
+  def get_cf_type
+    "AWS::RDS::DBSubnetGroup"
+  end
+  
+  def get_cf_attributes
+    {}
+  end
+  
+  def get_cf_properties
+    subnet_array = @subnets.collect() {|s| s.generate_ref}.join(",")
+    {"DBSubnetGroupDescription" => @description, "SubnetIds" => "[#{subnet_array}]"}
+  end  
+  
+  def add_subnet(subnet)
+    @subnets << subnet
+  end
+  
+end

data/lib/cf_factory/route53/cf_elb_alias_target.rb

@@ -0,0 +1,21 @@
+require 'cf_factory/base/cf_inner'
+
+class CfElbAliasTarget
+  include CfInner
+    
+  def additional_indent
+    2
+  end  
+
+  def initialize(elb)
+    @elb = elb 
+  end
+  
+  def get_cf_attributes
+    result = {}
+    result["HostedZoneId"] = @elb.retrieve_attribute("CanonicalHostedZoneNameID")
+    result["DNSName"] = @elb.retrieve_attribute("CanonicalHostedZoneName")
+    result
+  end
+  
+end