build-cloud 0.0.1

data/lib/build-cloud/networkinterface.rb

@@ -0,0 +1,121 @@
+class BuildCloud::NetworkInterface
+
+    include ::BuildCloud::Component
+
+    @@objects = []
+
+    def self.get_id_by_name( name )
+
+        interface = self.search( :name => name ).first
+
+        unless interface
+            raise "Couldn't get an NetworkInterface object for #{name} - is it defined?"
+        end
+
+        interface_fog = interface.read
+
+        unless interface_fog
+            raise "Couldn't get a NetworkInterface fog object for #{name} - is it created?"
+        end
+
+        interface_fog.network_interface_id
+
+    end
+
+    def initialize ( fog_interfaces, log, options = {} )
+
+        @compute = fog_interfaces[:compute]
+        @log     = log
+        @options = options
+
+        @log.debug( options.inspect )
+
+        required_options(:name, :private_ip_address)
+        require_one_of(:subnet_id, :subnet_name)
+        require_one_of(:security_groups, :security_group_names)
+
+    end
+
+    def create
+        
+        return if exists?
+
+        @log.info( "Creating network interface #{@options[:private_ip_address]}" )
+
+        options = @options.dup
+
+        unless options[:subnet_id]
+
+            options[:subnet_id] = BuildCloud::Subnet.get_id_by_name( options[:subnet_name] )
+            options.delete(:subnet_name)
+
+        end
+
+        unless options[:security_groups]
+
+            options[:group_set] = []
+
+            options[:security_group_names].each do |sg|
+                options[:group_set] << BuildCloud::SecurityGroup.get_id_by_name( sg )
+            end
+
+            options.delete(:security_group_names)
+
+        end
+
+        options[:description] = options[:name]
+        options.delete(:name)
+
+        interface = @compute.network_interfaces.new(options)
+        interface.save
+
+        attributes = {}
+        attributes[:resource_id] = interface.network_interface_id
+        attributes[:key] = 'Name'
+        attributes[:value] = options[:description]
+        interface_tag = @compute.tags.new( attributes )
+        interface_tag.save
+
+        if options[:assign_new_public_ip] and ! options[:existing_public_ip].nil?
+            raise "Cannot specifiy both new and existing IP addresses"
+        end
+
+        if options[:assign_new_public_ip]
+            ip = @compute.addresses.create
+            public_ip = ip.public_ip
+            allocation_id = ip.allocation_id
+            @compute.associate_address(nil, nil, interface.network_interface_id, allocation_id )
+        end
+
+        unless options[:existing_public_ip].nil?
+            ip = @compute.addresses.get(options[:existing_public_ip])
+            public_ip = ip.public_ip
+            allocation_id = ip.allocation_id
+            @compute.associate_address(nil, nil, interface.network_interface_id, allocation_id )
+        end
+
+        @log.debug( interface.inspect )
+        @log.debug( interface_tag.inspect )
+        @log.debug( ip.inspect ) unless ! options[:assign_new_public_ip]
+        @log.debug( ip.inspect ) unless options[:existing_public_ip].nil?
+
+    end
+
+    def read
+        @compute.network_interfaces.select { |ni| ni.private_ip_address == @options[:private_ip_address]}.first
+    end
+
+    alias_method :fog_object, :read
+
+    def delete
+
+        return unless exists?
+
+        @log.info( "Deleting network interface with IP address #{@options[:private_ip_address]}" )
+
+        fog_object.destroy
+
+    end
+
+end
+

data/lib/build-cloud/r53recordset.rb

@@ -0,0 +1,110 @@
+class BuildCloud::R53RecordSet
+
+    include ::BuildCloud::Component
+
+    @@objects = []
+
+    def initialize ( fog_interfaces, log, options = {} )
+
+        @log     = log
+        @options = options
+
+        @log.debug( options.inspect )
+
+        required_options(:name, :type, :zone)
+
+        @zone_name = options.delete(:zone)
+    end
+
+    def create
+        
+        return if exists?
+
+        @log.info( "Creating record set #{@options[:name]}" )
+
+        options = @options.dup
+
+        if options.has_key?(:alias_target)
+
+            unless options[:alias_target][:dns_name] and options[:alias_target][:hosted_zone_id]
+
+                elb_name = options[:alias_target].delete(:elb)
+                elb = BuildCloud::LoadBalancer.search( :id => elb_name ).first
+
+                unless elb
+                    raise "Can't find ELB object for #{elb_name}"
+                end
+
+                options[:alias_target][:dns_name]       = elb.read.dns_name
+                options[:alias_target][:hosted_zone_id] = elb.read.hosted_zone_name_id
+                
+            end
+
+        end
+
+        if rds_server = options.delete(:rds_server)
+
+            rds = BuildCloud::RDSServer.search( :id => rds_server ).first
+
+            unless rds 
+                raise "Can't find RDS Server for #{rds_server}"
+            end
+
+            options[:value] = [ rds.read.endpoint["Address"] ]
+        end
+
+        if cache_cluster = options.delete(:cache_cluster)
+
+            cache = BuildCloud::CacheCluster.search( :id => cache_cluster ).first
+
+            unless cache
+                raise "Can't find cache cluster for #{cache_cluster}"
+            end
+
+            options[:value] = [ cache.read.nodes.first["Address"] ]
+
+        end
+
+
+        record = zone.records.create( options )
+
+        @log.debug(record.inspect)
+
+    end
+
+    def read
+        if zone
+            return zone.records.select { |r| r.name == @options[:name] }.first
+        end
+        nil
+    end
+
+    alias_method :fog_object, :read
+
+    def delete
+
+        return unless exists?
+
+        @log.info( "Deleting record #{@options[:name]}" )
+
+        # Fog errors unless ttl is set:
+        fog_object.ttl = 1
+        fog_object.destroy
+
+    end
+
+    def wait_until_ready
+        @log.debug("Can't wait on r53 record set creation")
+    end
+
+    private
+
+    def zone
+
+        BuildCloud::Zone.search( :domain => @zone_name ).first.fog_object
+
+    end
+
+
+end
+

data/lib/build-cloud/rdsserver.rb

@@ -0,0 +1,73 @@
+
+class BuildCloud::RDSServer
+
+    include ::BuildCloud::Component
+
+    @@objects = []
+
+    def initialize ( fog_interfaces, log, options = {} )
+
+        @rds     = fog_interfaces[:rds]
+        @log     = log
+        @options = options
+
+        @log.debug( options.inspect )
+
+        required_options(:id, :engine, :allocated_storage, :backup_retention_period,
+                         :flavor_id, :db_name, :master_username, :password, :vpc_security_group_names)
+
+    end
+
+    def create
+
+        return if exists?
+
+        @log.info( "Creating RDS Server #{@options[:id]}" )
+
+        options = @options.dup
+
+        options[:db_security_groups] = []
+
+        unless options[:vpc_security_groups]
+
+            options[:vpc_security_groups] = []
+
+            options[:vpc_security_group_names].each do |sg|
+                options[:vpc_security_groups] << BuildCloud::SecurityGroup.get_id_by_name( sg )
+            end
+
+            options.delete(:vpc_security_group_names)
+
+        end
+
+        @log.debug( options.inspect)
+
+        rds_server = @rds.servers.new( options )
+        rds_server.save
+
+        @log.debug( rds_server.inspect )
+
+    end
+
+    def ready_timeout
+        20 * 60 # RDS instances take a while
+    end
+
+    def read
+        @rds.servers.select { |r| r.id == @options[:id] }.first
+    end
+
+    alias_method :fog_object, :read
+
+    def delete
+
+        return unless exists?
+
+        @log.info( "Deleting RDS Server #{@options[:id]}" )
+
+        fog_object.destroy
+
+    end
+
+end
+

data/lib/build-cloud/route.rb

@@ -0,0 +1,110 @@
+class BuildCloud::Route
+
+    include ::BuildCloud::Component
+
+    @@objects = []
+
+    def initialize ( fog_interfaces, log, options = {} )
+
+        @compute = fog_interfaces[:compute]
+        @log     = log
+        @options = options
+
+        @log.debug( options.inspect )
+
+        required_options(:name, :route_table_name, :destination_cidr_block)
+        require_one_of(:internet_gateway_name, :network_interface_name, :internet_gateway_id, :network_interface_id)
+        require_one_of(:route_table_id, :route_table_name)
+
+    end
+
+    def create
+
+        return if exists?
+
+        @log.info("Creating route #{@options[:name]}")
+
+        options = @options.dup
+
+        options[:tags] = { 'Name' => options.delete(:name) }
+
+        unless options[:network_interface_name]
+            options[:network_interface_id] = BuildCloud::NetworkInterface.get_id_by_name( options[:network_interface_name] )
+            options.delete(:network_interface_name)
+        end
+
+        unless options[:internet_gateway_name]
+            options[:internet_gateway_id] = BuildCloud::InternetGateway.get_id_by_name( options[:internet_gateway_name] )
+            options.delete(:internet_gateway_name)
+        end
+
+        unless options[:route_table_name]
+            options[:route_table_id] = BuildCloud::RouteTable.get_id_by_name( options[:route_table_name] )
+            options.delete(:route_table_name)
+        end
+
+        route_table_id = options[:route_table_id]
+        destination_cidr_block = options[:destination_cidr_block]
+        internet_gateway_id = options[:internet_gateway_id]
+        network_interface_id = options[:network_interface_id]
+
+        # Using requests instead of model here, because the model
+        #  doesn't support associations.
+
+        begin
+
+            if create_route(route_table_id, destination_cidr_block, internet_gateway_id, nil, network_interface_id)
+                @log.debug("route created successfully")
+            else 
+                @log.debug("failed to create route")
+            end
+
+        rescue Exception => e
+            @log.error( "An exception - #{e} - occured")
+        end
+
+    end
+
+    def read
+        rt = @compute.route_tables.select { |rt| rt.tags['Name'] == @options[:name] }.first 
+        @log.info( rt.inspect )
+        @log.info( rt.routes ) unless rt.routes.empty?
+
+        route = rt.routes.select { |t| t['destinationCidrBlock'] == @options[:destination_cidr_block]}
+        @log.info( route.inspect )
+
+    end
+
+    alias_method :fog_object, :read
+
+    def delete
+
+        return unless exists?
+
+        @log.info("Deleting route #{@options[:name]}")
+
+        unless options[:route_table_name]
+            options[:route_table_id] = BuildCloud::RouteTable.get_id_by_name( options[:route_table_name] )
+            options.delete(:route_table_name)
+        end
+
+        route_table_id = options[:route_table_id]
+        destination_cidr_block = options[:destination_cidr_block]
+
+        begin
+
+            if delete_route(route_table_id, destination_cidr_block)
+                @log.debug("route deleted successfully")
+            else 
+                @log.debug("failed to delet route")
+            end
+
+        rescue Exception => e
+            @log.error( "An exception - #{e} - occured")
+        end
+
+    end
+
+end
+
+

data/lib/build-cloud/routetable.rb

@@ -0,0 +1,106 @@
+class BuildCloud::RouteTable
+
+    include ::BuildCloud::Component
+
+    @@objects = []
+
+    def self.get_id_by_name( name )
+
+        route_table = self.search( :name => name ).first
+
+        unless route_table
+            raise "Couldn't get a RouteTable object for #{name} - is it defined?"
+        end
+
+        route_table_fog = route_table.read
+
+        unless route_table_fog
+            raise "Couldn't get a RouteTable fog object for #{name} - is it created?"
+        end
+
+        route_table_fog.route_table_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)
+        require_one_of(:subnet_ids, :subnet_names)
+
+
+    end
+
+    def create
+
+        return if exists?
+
+        @log.info("Creating route table #{@options[:name]}")
+
+        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
+
+        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) }
+
+        # Using requests instead of model here, because the model
+        #  doesn't support associations.
+ 
+        rt = @compute.route_tables.new ( options )
+        rt.save
+        @log.debug(rt.inspect)
+
+        @compute.create_tags( rt.id, options[:tags] )
+       
+        options[:subnet_ids].each do |s|
+            @compute.associate_route_table( rt.id, s )
+        end
+
+    end
+
+    def read
+        @compute.route_tables.select { |r| r.tags['Name'] == @options[:name] }.first
+    end
+
+    alias_method :fog_object, :read
+
+    def delete
+
+        return unless exists?
+
+        @log.info("Deleting route table #{@options[:name]}")
+
+        read.associations.each do |ra|
+            @compute.disassociate_route_table( ra['routeTableAssociationId'] )
+        end
+
+        fog_object.destroy
+
+    end
+
+end
+
+

data/lib/build-cloud/s3bucket.rb

@@ -0,0 +1,49 @@
+class BuildCloud::S3Bucket
+
+    include ::BuildCloud::Component
+
+    @@objects = []
+
+    def initialize ( fog_interfaces, log, options = {} )
+
+        @s3      = fog_interfaces[:s3]
+        @log     = log
+        @options = options
+
+        @log.debug( options.inspect )
+
+        required_options(:key, :location)
+
+    end
+
+    def create
+        
+        return if exists?
+
+        @log.info( "Creating new S3 bucket #{@options[:key]}" )
+
+        bucket = @s3.directories.new( @options )
+        bucket.save
+
+        @log.debug( bucket.inspect )
+
+    end
+
+    def read
+        @s3.directories.select { |d| d.key == @options[:key] }.first
+    end
+
+    alias_method :fog_object, :read
+
+    def delete
+
+        return unless exists?
+
+        @log.info( "Deleting S3 bucket #{@options[:key]}" )
+
+        fog_object.destroy
+
+    end
+
+end
+

data/lib/build-cloud/securitygroup.rb

@@ -0,0 +1,91 @@
+class BuildCloud::SecurityGroup
+
+    include ::BuildCloud::Component
+
+    @@objects = []
+
+    def self.get_id_by_name( name )
+
+        sg = self.search( :name => name ).first
+
+        unless sg
+            raise "Couldn't get a SecurityGroup object for #{name} - is it defined?"
+        end
+
+        sg_fog = sg.read
+
+        unless sg_fog
+            raise "Couldn't get a SecurityGroup fog object for #{name} - is it created?"
+        end
+
+        sg_fog.group_id
+
+    end
+
+    def initialize ( fog_interfaces, log, options = {} )
+
+        @compute = fog_interfaces[:compute]
+        @log     = log
+        @options = options
+
+        @log.debug( options.inspect )
+
+        required_options(:name, :description)
+        require_one_of(:vpc_id, :vpc_name)
+
+    end
+
+    def create
+        
+        return if exists?
+
+        @log.info( "Creating security group #{@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
+
+        authorized_ranges = []
+        if options[:authorized_ranges]
+            authorized_ranges = options[:authorized_ranges]
+            options.delete(:authorized_ranges)
+        end
+
+        security_group = @compute.security_groups.new( options )
+        security_group.save
+
+        authorized_ranges.each do |r|
+
+            security_group.authorize_port_range(
+                r.delete(:min_port)..r.delete(:max_port), r
+            )
+
+        end
+
+        @log.debug( security_group.inspect )
+
+    end
+
+    def read
+        @compute.security_groups.select { |sg| sg.name == @options[:name] }.first
+    end
+
+    alias_method :fog_object, :read
+
+    def delete
+
+        return unless exists?
+
+        @log.info( "Deleting security group #{@options[:name]}" )
+
+        fog_object.destroy
+
+    end
+
+end
+