build-cloud 0.0.1

data/lib/build-cloud/dbparametergroup.rb

@@ -0,0 +1,62 @@
+
+class BuildCloud::DbParameterGroup
+
+    include ::BuildCloud::Component
+
+    @@objects = []
+
+    def initialize ( fog_interfaces, log, options = {} )
+
+        @rds     = fog_interfaces[:rds]
+        @log     = log
+        @options = options
+
+        @log.debug( options.inspect )
+
+        required_options(:family, :description, :id, :params)
+
+    end
+
+    def create
+        
+        return if exists?
+
+        @log.info( "Creating DB Parameter Group #{@options[:id]}" )
+
+        options = @options.dup
+
+        param_group = @rds.create_db_parameter_group(options[:id], options[:family], options[:description])
+
+        @log.debug( param_group.inspect )
+
+        params = @rds.modify_db_parameter_group options[:id], options[:params].collect! { |c| 
+            {
+                'ParameterName' => c[:param_name],
+                'ParameterValue' => c[:param_value],
+                'ApplyMethod' => c[:apply_method],
+            }
+        }
+
+        @log.debug( params.inspect )
+
+    end
+
+    def read
+        @rds.parameter_groups.select { |g| g.id == "#{@options[:id]}".downcase }.first
+    end
+
+    alias_method :fog_object, :read
+
+    def delete
+
+        return unless exists?
+
+        @log.info( "Deleting DB Parameter Group #{@options[:id]}" )
+
+        puts fog_object.inspect
+        fog_object.destroy
+
+    end
+
+end
+

data/lib/build-cloud/dbparameters.rb

@@ -0,0 +1,52 @@
+
+class BuildCloud::DbParameterGroup
+
+    include ::BuildCloud::Component
+
+    @@objects = []
+
+    def initialize ( fog_interfaces, log, options = {} )
+
+        @rds     = fog_interfaces[:rds]
+        @log     = log
+        @options = options
+
+        @log.debug( options.inspect )
+
+        required_options(:family, :description, :id)
+
+    end
+
+    def create
+        
+        return if exists?
+
+        @log.info( "Creating DB Parameter Group #{@options[:id]}" )
+
+        options = @options.dup
+
+        param_group = @rds.create_db_parameter_group(options[:id], options[:family], options[:description])
+
+        @log.debug( param_group.inspect )
+
+    end
+
+    def read
+        @rds.parameter_groups.select { |g| g.id == "#{@options[:name]}" }.first
+    end
+
+    alias_method :fog_object, :read
+
+    def delete
+
+        return unless exists?
+
+        @log.info( "Deleting DB Parameter Group #{@options[:name]}" )
+
+        puts fog_object.inspect
+        fog_object.destroy
+
+    end
+
+end
+

data/lib/build-cloud/dbsubnetgroup.rb

@@ -0,0 +1,64 @@
+
+class BuildCloud::DbSubnetGroup
+
+    include ::BuildCloud::Component
+
+    @@objects = []
+
+    def initialize ( fog_interfaces, log, options = {} )
+
+        @rds     = fog_interfaces[:rds]
+        @log     = log
+        @options = options
+
+        @log.debug( options.inspect )
+
+        required_options(:name)
+        require_one_of(:subnet_ids, :subnet_names)
+
+    end
+
+    def create
+        
+        return if exists?
+
+        @log.info( "Creating DB Subnet Group #{@options[:id]}" )
+
+        options = @options.dup
+
+        unless options[:subnet_ids]
+
+            options[:subnet_ids] = []
+
+            options[:subnet_names].each do |sn|
+                options[:subnet_ids] << BuildCloud::Subnet.get_id_by_name( sn )
+            end
+
+            options.delete(:subnet_names)
+
+        end
+
+        group = @rds.create_db_subnet_group( options[:name], options[:subnet_ids] )
+
+        @log.debug( group.inspect )
+
+    end
+
+    def read
+        @rds.subnet_groups.select { |g| g.id == @options[:name] }.first
+    end
+
+    alias_method :fog_object, :read
+
+    def delete
+
+        return unless exists?
+
+        @log.info( "Deleting DB Subnet Group #{@options[:name]}" )
+
+        fog_object.destroy
+
+    end
+
+end
+

data/lib/build-cloud/iamrole.rb

@@ -0,0 +1,84 @@
+class BuildCloud::IAMRole
+
+    require 'json'
+
+    include ::BuildCloud::Component
+
+    @@objects = []
+
+    def initialize ( fog_interfaces, log, options = {} )
+
+        @iam     = fog_interfaces[:iam]
+        @log     = log
+        @options = options
+
+        @log.debug( options.inspect )
+
+        required_options(:rolename, :assume_role_policy_document)
+
+    end
+
+    def create
+        
+        return if exists?
+
+        @log.info( "Creating new IAM role for #{@options[:rolename]}" )
+
+        policies = @options.delete(:policies)
+
+        # Genuinely don't think I've understood the data model with 
+        # this stuff.  In particular how roles, instance profiles etc. relate
+        #
+        # It does what we need right now though, and can be revisited if necessary
+
+        role = @iam.roles.new( @options )
+        role.save
+
+        @log.debug( role.inspect )
+
+        policies.each do |policy|
+
+            @log.debug( "Adding policy #{policy}" )
+
+            policy_document = JSON.parse( policy[:policy_document] )
+
+            @iam.put_role_policy( @options[:rolename], policy[:policy_name],
+                policy_document )
+
+            @iam.create_instance_profile( @options[:rolename] )
+            @iam.add_role_to_instance_profile( @options[:rolename], @options[:rolename] )
+
+        end
+
+    end
+
+    def read
+        @iam.roles.select { |r| r.rolename == @options[:rolename] }.first
+    end
+
+    alias_method :fog_object, :read
+
+    def delete
+
+        return unless exists?
+
+        @log.info( "Deleting IAM role for #{@options[:rolename]}" )
+
+        instance_profiles = @iam.list_instance_profiles_for_role( @options[:rolename] ).body['InstanceProfiles'].map { |k| k['InstanceProfileName'] }
+        instance_profiles.each do |ip|
+            @iam.delete_instance_profile( ip )
+            @iam.remove_role_from_instance_profile( @options[:rolename], ip )
+        end
+
+        policies = @iam.list_role_policies( @options[:rolename] ).body['PolicyNames']
+        policies.each do |policy|
+            @iam.delete_role_policy( @options[:rolename], policy )
+        end
+
+
+        fog_object.destroy
+
+    end
+
+end
+

data/lib/build-cloud/instance.rb

@@ -0,0 +1,140 @@
+class BuildCloud::Instance
+
+    include ::BuildCloud::Component
+
+    @@objects = []
+
+    def self.get_id_by_name( name )
+
+        instance = self.search( :name => name ).first
+
+        unless instance
+            raise "Couldn't get an instance object for #{name} - is it defined?"
+        end
+
+        instance_fog = instance.read
+
+        unless instance_fog
+            raise "Couldn't get an instance fog object for #{name} - is it created?"
+        end
+
+        instance_fog.id
+
+    end
+
+    def initialize ( fog_interfaces, log, options = {} )
+
+        @ec2     = fog_interfaces[:compute]
+        @log     = log
+        @options = options
+
+        @log.debug( options.inspect )
+
+        required_options(:image_id, :flavor_id, :private_ip_address, :name)
+        require_one_of(:security_group_ids, :security_group_names, :network_interfaces)
+        require_one_of(:subnet_id, :subnet_name, :network_interfaces)
+        #require_one_of(:network_interfaces, :private_ip_address)
+        require_one_of(:vpc_id, :vpc_name)
+
+    end
+
+    def ready_timeout
+        5 * 60 # some instances (eg big EBS root vols) can take a while
+    end
+
+    def create
+        
+        return if exists?
+
+        @log.info( "Creating instance #{@options[:name]}" )
+
+        options = @options.dup
+
+        if options[:security_group_names] or options[:security_group_ids]
+            unless options[:security_group_ids]
+
+                options[:security_group_ids] = []
+
+                options[:security_group_names].each do |sg|
+                    options[:security_group_ids] << BuildCloud::SecurityGroup.get_id_by_name( sg )
+                end
+
+                options.delete(:security_group_names)
+
+            end
+        end
+
+        if options[:subnet_id] or options[:subnet_name]
+            unless options[:subnet_id]
+
+                options[:subnet_id] = BuildCloud::Subnet.get_id_by_name( options[:subnet_name] )
+                options.delete(:subnet_name)
+
+            end
+        end
+
+        unless options[:vpc_id]
+
+            options[:vpc_id] = BuildCloud::VPC.get_id_by_name( options[:vpc_name] )
+            options.delete(:vpc_name)
+
+        end
+
+        if options[:private_ip_address] and options[:network_interfaces]
+            puts "WARNING: InvalidParameterCombination => Network interfaces and an instance-level private IP address should not be specified on the same request"
+            puts "Using Network interface"
+            options.delete(:private_ip_address)
+        end
+
+        if options[:subnet_id] and options[:network_interfaces]
+            puts "WARNING: InvalidParameterCombination => Network interfaces and subnet_ids should not be specified on the same request"
+            puts "Using Network interface"
+            options.delete(:subnet_id)
+        end
+
+        options[:user_data] = JSON.generate( @options[:user_data] )
+
+        options[:network_interfaces].each { |iface|
+            if ! iface[:network_interface_name].nil?
+                interface_id = BuildCloud::NetworkInterface.get_id_by_name( iface[:network_interface_name] )
+                iface['NetworkInterfaceId'] = interface_id
+                iface.delete(:network_interface_name)
+            end
+        } unless options[:network_interfaces].nil?
+
+        @log.debug( options.inspect )
+
+        instance = @ec2.servers.new( options )
+        instance.save
+
+        options[:tags].each do | tag |
+            attributes = {}
+            attributes[:resource_id] = instance.id.to_s
+            attributes[:key] = tag[:key]
+            attributes[:value] = tag[:value]
+            new_tag = @ec2.tags.new( attributes )
+            new_tag.save
+        end unless options[:tags].empty? or options[:tags].nil?
+
+        @log.debug( instance.inspect )
+
+    end
+
+    def read
+        instances = @ec2.servers.select{ |l| l.tags['Name'] == @options[:name]}
+        instances.select{ |i| i.state =~ /(running|pending)/ }.first
+    end
+
+    alias_method :fog_object, :read
+
+    def delete
+
+        return unless exists?
+
+        @log.info( "Deleting instance #{@options[:name]}" )
+
+        fog_object.destroy
+
+    end
+
+end

data/lib/build-cloud/internetgateway.rb

@@ -0,0 +1,86 @@
+class BuildCloud::InternetGateway
+
+    include ::BuildCloud::Component
+
+    @@objects = []
+
+    def self.get_id_by_name( name )
+
+        internet_gateway = self.search( :name => name ).first
+
+        unless internet_gateway
+            raise "Couldn't get an InternetGateway object for #{name} - is it defined?"
+        end
+
+        internet_gateway_fog = internet_gateway.read
+
+        unless internet_gateway_fog
+            raise "Couldn't get an InternetGateway fog object for #{name} - is it created?"
+        end
+
+        internet_gateway_fog.internet_gateway_id
+
+    end
+
+    def initialize ( fog_interfaces, log, options = {} )
+
+        @compute = fog_interfaces[:compute]
+        @log     = log
+        @options = options
+
+        @log.debug( options.inspect )
+
+        required_options(:name)
+        require_one_of(:vpc_id, :vpc_name)
+
+    end
+
+    def create
+
+        return if exists?
+
+        @log.info("Creating Internet Gateway #{@options[:name]}")
+
+        options = @options.dup
+
+        unless options[:vpc_id]
+
+            options[:vpc_id] = BuildCloud::VPC.get_id_by_name( options[:vpc_name] )
+            options.delete(:vpc_name)
+
+        end
+
+        options[:tags] = { 'Name' => options.delete(:name) }
+
+        ig = @compute.internet_gateways.new()
+        ig.save
+
+        @log.debug(ig.inspect)
+
+        @compute.create_tags( ig.id, options[:tags] )
+
+        ig.attach(options[:vpc_id])
+
+    end
+
+    def read
+        @compute.internet_gateways.select { |r| r.tag_set['Name'] == @options[:name] }.first
+    end
+
+    alias_method :fog_object, :read
+
+    def delete
+
+        return unless exists?
+
+        @log.info("Deleting Internet Gateway #{@options[:name]}")
+
+        read.detach(read.attachment_set['vpcId'])
+
+        fog_object.destroy
+
+    end
+
+end
+
+

data/lib/build-cloud/launchconfiguration.rb

@@ -0,0 +1,68 @@
+require 'json'
+
+class BuildCloud::LaunchConfiguration
+
+    include ::BuildCloud::Component
+
+    @@objects = []
+
+    def initialize ( fog_interfaces, log, options = {} )
+
+        @as      = fog_interfaces[:as]
+        @log     = log
+        @options = options
+
+        @log.debug( options.inspect )
+
+        required_options(:id, :image_id, :key_name, :user_data, :instance_type)
+        require_one_of(:security_groups, :security_group_names)
+
+    end
+
+    def create
+        
+        return if exists?
+
+        @log.info( "Creating launch configuration #{@options[:id]}" )
+
+        options = @options.dup
+
+        unless options[:security_groups]
+
+            options[:security_groups] = []
+
+            options[:security_group_names].each do |sg|
+                options[:security_groups] << BuildCloud::SecurityGroup.get_id_by_name( sg )
+            end
+
+            options.delete(:security_group_names)
+
+        end
+
+        options[:user_data] = JSON.generate( @options[:user_data] )
+
+        launch_config = @as.configurations.new( options )
+        launch_config.save
+
+        @log.debug( launch_config.inspect )
+
+    end
+
+    def read
+        @as.configurations.select { |lc| lc.id == @options[:id] }.first
+    end
+
+    alias_method :fog_object, :read
+
+    def delete
+
+        return unless exists?
+
+        @log.info( "Deleting Launch Configuration #{@options[:id]}" )
+
+        fog_object.destroy
+
+    end
+
+end
+

data/lib/build-cloud/loadbalancer.rb

@@ -0,0 +1,119 @@
+class BuildCloud::LoadBalancer
+
+    include ::BuildCloud::Component
+
+    @@objects = []
+
+    def initialize ( fog_interfaces, log, options = {} )
+
+        @elb     = fog_interfaces[:elb]
+        @log     = log
+        @options = options
+
+        @log.debug( options.inspect )
+
+        required_options(:id, :listeners)
+        require_one_of(:security_groups, :security_group_names)
+        require_one_of(:subnet_ids, :subnet_names)
+        require_one_of(:vpc_id, :vpc_name)
+
+    end
+
+    def create
+        
+        return if exists?
+
+        @log.info( "Creating load balancer #{@options[:id]}" )
+
+        options = @options.dup
+
+        unless options[:security_groups]
+
+            options[:security_groups] = []
+
+            options[:security_group_names].each do |sg|
+                options[:security_groups] << BuildCloud::SecurityGroup.get_id_by_name( sg )
+            end
+
+            options.delete(:security_group_names)
+
+        end
+
+        unless options[:subnet_ids]
+
+            options[:subnet_ids] = []
+
+            options[:subnet_names].each do |sn|
+                options[:subnet_ids] << BuildCloud::Subnet.get_id_by_name( sn )
+            end
+
+            options.delete(:subnet_names)
+
+        end
+
+        unless options[:vpc_id]
+
+            options[:vpc_id] = BuildCloud::VPC.get_id_by_name( options[:vpc_name] )
+            options.delete(:vpc_name)
+
+        end
+
+        options.delete(:listeners)
+
+        elb = @elb.load_balancers.new( options )
+        elb.save
+
+        # Remove first port 80 listener - we can add it back if we need
+        elb.listeners.select { |l| l.instance_port == 80 }.first.destroy
+
+        @options[:listeners].each do |listener_options|
+
+            [:instance_port, :instance_protocol, :lb_port, :protocol].each do |o|
+                raise "Listeners need #{o.to_s}" unless listener_options.has_key?(o)
+            end
+
+            elb.listeners.new( listener_options ).save
+
+        end 
+
+        unless @options[:instance_names].nil?
+
+            options[:instance_ids] = []
+
+            options[:instance_names].each do |i|
+                options[:instance_ids] << BuildCloud::Instance.get_id_by_name( i )
+            end
+
+            @log.info( options[:instance_ids] )
+            @log.info( "#{options[:instance_ids].inspect}" )
+
+            options.delete(options[:instance_names])
+
+            elb.register_instances(options[:instance_ids])
+
+        end
+
+        @elb.configure_health_check( elb.id, options[:health_check] )
+
+        @log.debug( elb.inspect )
+
+    end
+
+    def read
+        @elb.load_balancers.select { |l| l.id == @options[:id] }.first
+    end
+
+    alias_method :fog_object, :read
+
+    def delete
+
+        return unless exists?
+
+        @log.info( "Deleting load balancer #{@options[:id]}" )
+
+        fog_object.destroy
+
+    end
+
+end
+