build-cloud 0.0.1

data/lib/build-cloud/subnet.rb

@@ -0,0 +1,86 @@
+class BuildCloud::Subnet
+
+    include ::BuildCloud::Component
+
+    @@objects = []
+
+    def self.get_id_by_name( name )
+
+        subnet = self.search( :name => name ).first
+
+        unless subnet
+            raise "Couldn't get a Subnet object for #{name} - is it defined?"
+        end
+
+        subnet_fog = subnet.read
+
+        unless subnet_fog
+            raise "Couldn't get a Subnet fog object for #{name} - is it created?"
+        end
+
+        subnet_fog.subnet_id
+
+    end
+
+    def initialize ( fog_interfaces, log, options = {} )
+
+        @compute = fog_interfaces[:compute]
+        @log     = log
+        @options = options
+
+        @log.debug( options.inspect )
+
+        required_options(:availability_zone, :cidr_block, :name)
+        require_one_of(:vpc_id, :vpc_name)
+
+    end
+
+    def create
+        
+        return if exists?
+
+        @log.info( "Creating subnet for #{@options[:cidr_block]} ( #{@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
+
+        subnet = @compute.subnets.new( options )
+        subnet.save
+
+        options[:tag_set].each do | tag |
+            attributes = {}
+            attributes[:resource_id] = subnet.subnet_id.to_s
+            attributes[:key] = tag[:key]
+            attributes[:value] = tag[:value]
+            new_tag = @compute.tags.new( attributes )
+            new_tag.save
+        end unless options[:tag_set].empty? or options[:tag_set].nil?
+
+        @log.debug( subnet.inspect )
+
+    end
+
+    def read
+        @compute.subnets.select { |s| s.cidr_block == @options[:cidr_block] }.first
+    end
+
+    alias_method :fog_object, :read
+
+    def delete
+
+        return unless exists?
+
+        @log.info( "Subnet #{@options[:name]}" )
+
+        fog_object.destroy
+
+    end
+
+end
+

data/lib/build-cloud/vpc.rb

@@ -0,0 +1,73 @@
+class BuildCloud::VPC
+
+    include ::BuildCloud::Component
+
+    @@objects = []
+
+    def self.get_id_by_name( name )
+
+        vpc = self.search( :name => name ).first
+
+        unless vpc
+            raise "Couldn't get a VPC object for #{name} - is it defined?"
+        end
+
+        vpc_fog = vpc.read
+
+        unless vpc_fog
+            raise "Couldn't get a VPC fog object for #{name} - is it created?"
+        end
+
+        vpc_fog.id
+
+    end
+
+    def initialize ( fog_interfaces, log, options = {} )
+
+        @compute = fog_interfaces[:compute]
+        @log     = log
+        @options = options
+
+        @log.debug( options.inspect )
+
+        required_options(:cidr_block)
+
+    end
+
+    def create
+        
+        return if exists?
+
+        @log.info( "Creating new VPC for #{@options[:cidr_block]}" )
+
+        vpc = @compute.vpcs.new( @options )
+        vpc.save
+
+        @log.debug( vpc.inspect )
+
+        @compute.modify_vpc_attribute( vpc.id, { 'EnableDnsHostnames.Value' => true } )
+
+    end
+
+    def read
+        @compute.vpcs.select { |v| v.cidr_block == @options[:cidr_block] }.first
+    end
+
+    alias_method :fog_object, :read
+
+    def delete
+
+        return unless exists?
+
+        @log.info( "Deleting VPC for #{@options[:cidr_block]}" )
+
+        fog_object.destroy
+
+    end
+
+    def [](key)
+        @options[key]
+    end
+
+end
+

data/lib/build-cloud/zone.rb

@@ -0,0 +1,96 @@
+class BuildCloud::Zone
+
+    include ::BuildCloud::Component
+
+    @@objects = []
+
+    def initialize ( fog_interfaces, log, options = {} )
+
+        @r53     = fog_interfaces[:r53]
+        @log     = log
+        @options = options
+
+        @log.debug( options.inspect )
+
+        required_options(:domain)
+
+    end
+
+    def create
+        
+        return if exists?
+
+        @log.info( "Creating zone for #{@options[:domain]}" )
+
+        options = @options.dup
+
+        zone = @r53.zones.new( options )
+        zone.save
+
+        if options.has_key?(:ttl)
+
+            # Change TTL of default RR sets if required:
+
+            record_sets = @r53.list_resource_record_sets( zone.id ).data[:body]['ResourceRecordSets']
+            changes = []
+
+            record_sets.each do |set|
+
+                next if set['TTL'].to_i == options[:ttl].to_i
+
+                rr = set['ResourceRecords']
+
+                changes << {
+                    :action           => 'DELETE',
+                    :name             => set['Name'],
+                    :type             => set['Type'],
+                    :ttl              => set['TTL'],
+                    :resource_records => rr,
+                }
+
+                if( set['Type'] == 'SOA' )
+
+                    # Set min TTL in SOA too
+
+                    soa = rr.first.split(/\s+/)
+                    soa[6] = options[:ttl]
+                    rr = [ soa.join(' ') ]
+
+                end
+
+                changes << {
+                    :action           => 'CREATE',
+                    :name             => set['Name'],
+                    :type             => set['Type'],
+                    :ttl              => options[:ttl],
+                    :resource_records => rr,
+                }
+
+            end
+
+            @r53.change_resource_record_sets( zone.id, changes )
+
+        end
+
+        @log.debug( zone.inspect )
+
+    end
+
+    def read
+        @r53.zones.select { |z| z.domain == @options[:domain] }.first
+    end
+
+    alias_method :fog_object, :read
+
+    def delete
+
+        return unless exists?
+
+        @log.info( "Deleting zone for #{@options[:domain]}" )
+
+        fog_object.destroy
+
+    end
+
+end
+

data/lib/build-cloud.rb

@@ -0,0 +1,204 @@
+require 'fog'
+require 'yaml'
+require 'pry'
+require 'logger'
+require 'pp'
+
+class BuildCloud
+
+    @config
+    @log
+    @infrastructure
+    @mock
+
+    def initialize( options )
+
+        @log = options[:logger] or Logger.new( STDERR )
+        @mock = options[:mock] or false
+        @config = YAML::load( File.open( options[:config] ) )
+        
+        if include_file = @config.delete(:include)
+            include_path = File.join( File.dirname( options[:config] ), include_file)
+
+            if File.exists?( include_path )
+               included_conf = YAML::load( File.open( include_path ) )
+               @config = @config.merge( included_conf )
+            end
+
+        end
+
+        @log.debug( @config.inspect )
+
+        new_config = recursive_interpolate_config(@config)
+        @config = new_config
+
+        @log.debug( @config.inspect )
+
+        connect_fog
+
+        BuildCloud::dispatch.each_pair do |component, klass|
+
+            if @config.has_key?(component)
+                klass.load( @config[component], @fog_interfaces, @log )
+            end
+
+        end
+
+    end
+
+    def pry
+        binding.pry
+    end
+
+    def find( component, options )
+
+        if BuildCloud::dispatch.has_key?( component )
+            BuildCloud::dispatch[component].search(options)
+        else
+            []
+        end
+
+    end
+
+    def all
+
+        objects = []
+
+        BuildCloud::create_order.each do |component|
+            next unless BuildCloud::dispatch.has_key?( component )
+            objects.concat BuildCloud::dispatch[component].objects()
+        end
+
+        objects
+
+    end
+
+    private
+
+    def self.dispatch
+
+        {
+            :vpcs                  => BuildCloud::VPC,
+            :internet_gateways     => BuildCloud::InternetGateway,
+            :subnets               => BuildCloud::Subnet,
+            :route_tables          => BuildCloud::RouteTable,
+            :zones                 => BuildCloud::Zone,
+            :security_groups       => BuildCloud::SecurityGroup,
+            :network_interfaces    => BuildCloud::NetworkInterface,
+            :routes                => BuildCloud::Route,
+            :launch_configurations => BuildCloud::LaunchConfiguration,
+            :load_balancers        => BuildCloud::LoadBalancer,
+            :as_groups             => BuildCloud::ASGroup,
+            :r53_record_sets       => BuildCloud::R53RecordSet,
+            :rds_servers           => BuildCloud::RDSServer,
+            :db_subnet_groups      => BuildCloud::DbSubnetGroup,
+            :db_parameter_groups   => BuildCloud::DbParameterGroup,
+            :cache_subnet_groups   => BuildCloud::CacheSubnetGroup,
+            :cache_clusters        => BuildCloud::CacheCluster,
+            :cache_parameter_groups => BuildCloud::CacheParameterGroup,
+            :iam_roles             => BuildCloud::IAMRole,
+            :s3_buckets            => BuildCloud::S3Bucket,
+            :instances             => BuildCloud::Instance,
+        }
+
+    end
+
+    def self.create_order
+        [
+            :vpcs,
+            :internet_gateways,
+            :iam_roles,
+            :subnets,
+            :db_subnet_groups,
+            :cache_subnet_groups,
+            :route_tables,
+            :zones,
+            :security_groups,
+            :network_interfaces,
+            :routes,
+            :db_parameter_groups,
+            :rds_servers,
+            :cache_parameter_groups,
+            :cache_clusters,
+            :launch_configurations,
+            :load_balancers,
+            :as_groups,
+            :r53_record_sets,
+            :s3_buckets,
+            :instances,
+        ]
+    end
+
+    def self.search( type, options )
+        BuildCloud::dispatch[type].search(options)
+    end
+    
+    def recursive_interpolate_config(h)
+
+        # Work through the given config replacing all strings matching
+        # %{..x..} by looking up ..x.. in the existing @config hash and
+        # substituting the template with the value
+
+        case h
+        when Hash
+            Hash[
+            h.map do |k, v|
+                [ k, recursive_interpolate_config(v) ]
+            end
+            ]
+        when Enumerable
+            h.map { |v| recursive_interpolate_config(v) }
+        when String
+
+            while h =~ /%\{(.+?)\}/
+                var = $1
+                val = ""
+
+                if @config.has_key?(var.to_sym)
+                    val = @config[var.to_sym]
+                else
+                    raise "Attempt to interpolate with non-existant key '#{var}'"
+                end
+                
+                h.gsub!(/%\{#{var}\}/, val)
+
+            end
+
+            h
+
+        else
+            h
+        end
+
+    end
+
+    def connect_fog
+
+        @mock and Fog.mock!
+
+        fog_options = {
+            :aws_access_key_id     => @config[:aws_access_key_id] ||= ENV['AWS_ACCESS_KEY'],
+            :aws_secret_access_key => @config[:aws_secret_access_key] ||= ENV['AWS_SECRET_KEY'],
+            :region                => @config[:aws_region],
+        }
+
+        @fog_interfaces = {
+
+            :compute     => Fog::Compute::AWS.new( fog_options ),
+            :s3          => Fog::Storage::AWS.new( fog_options ),
+            :as          => Fog::AWS::AutoScaling.new( fog_options ),
+            :elb         => Fog::AWS::ELB.new( fog_options ),
+            :iam         => Fog::AWS::IAM.new( fog_options ),
+            :rds         => Fog::AWS::RDS.new( fog_options ),
+            :elasticache => Fog::AWS::Elasticache.new( fog_options ),
+            :r53         => Fog::DNS::AWS.new(
+                :aws_access_key_id     => @config[:aws_access_key_id] ||= ENV['AWS_ACCESS_KEY'],
+                :aws_secret_access_key => @config[:aws_secret_access_key] ||= ENV['AWS_SECRET_KEY'],
+            )
+
+        }
+
+    end
+
+end
+

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification
+name: build-cloud
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- The Scale Factory
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fog
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.22.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.22.0
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.9.12.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.9.12.6
+description: 
+email:
+- info@scalefactory.com
+executables:
+- build-cloud
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/build-cloud
+- build-cloud.gemspec
+- lib/build-cloud.rb
+- lib/build-cloud/asgroup.rb
+- lib/build-cloud/cachecluster.rb
+- lib/build-cloud/cacheparametergroup.rb
+- lib/build-cloud/cachesubnetgroup.rb
+- lib/build-cloud/component.rb
+- lib/build-cloud/dbparametergroup.rb
+- lib/build-cloud/dbparameters.rb
+- lib/build-cloud/dbsubnetgroup.rb
+- lib/build-cloud/iamrole.rb
+- lib/build-cloud/instance.rb
+- lib/build-cloud/internetgateway.rb
+- lib/build-cloud/launchconfiguration.rb
+- lib/build-cloud/loadbalancer.rb
+- lib/build-cloud/networkinterface.rb
+- lib/build-cloud/r53recordset.rb
+- lib/build-cloud/rdsserver.rb
+- lib/build-cloud/route.rb
+- lib/build-cloud/routetable.rb
+- lib/build-cloud/s3bucket.rb
+- lib/build-cloud/securitygroup.rb
+- lib/build-cloud/subnet.rb
+- lib/build-cloud/vpc.rb
+- lib/build-cloud/zone.rb
+homepage: https://github.com/scalefactory/build-cloud
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: Tools for building resources in AWS
+test_files: []