build-cloud 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 44ac926d7827973fce157398265b248b9f2263df
+  data.tar.gz: 4d4ae065f177a4c2cd16840c5501c3d90b7f27fa
+SHA512:
+  metadata.gz: 63aa3403dddf30aa6623d1b006953fb00fed715e1099eda8070d1f5a7bc27ba7549e86347c0490da46d310232a52aa20cd6d73c44adf2341e6093176993cdd97
+  data.tar.gz: 18380bcc47e5ac2c635210e59f0d90c67aaf94c00be3609d3f2eab5a2589db2740e28455791fcf3cc652032d66ea4c8afeb634ecb3d616395639376da2dcb9fe

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.ruby-version

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 The Scale Factory
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# Build::Cloud
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'build-cloud'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install build-cloud
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( http://github.com/<my-github-username>/build-cloud/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/build-cloud

@@ -0,0 +1,181 @@
+#!/usr/bin/env ruby
+
+$:.push( File.join( File.dirname(__FILE__), 'lib' ) )
+
+require 'optparse'
+
+require 'build-cloud'
+require 'build-cloud/component'
+require 'build-cloud/vpc'
+require 'build-cloud/subnet'
+require 'build-cloud/routetable'
+require 'build-cloud/route'
+require 'build-cloud/zone'
+require 'build-cloud/securitygroup'
+require 'build-cloud/launchconfiguration'
+require 'build-cloud/loadbalancer'
+require 'build-cloud/asgroup'
+require 'build-cloud/r53recordset'
+require 'build-cloud/rdsserver'
+require 'build-cloud/dbsubnetgroup'
+require 'build-cloud/dbparametergroup'
+require 'build-cloud/cachesubnetgroup'
+require 'build-cloud/cachecluster'
+require 'build-cloud/cacheparametergroup'
+require 'build-cloud/iamrole'
+require 'build-cloud/s3bucket'
+require 'build-cloud/instance'
+require 'build-cloud/networkinterface'
+require 'build-cloud/internetgateway'
+
+options = {}
+optparse = OptionParser.new do |opts|
+
+    options[:config] = nil
+    opts.on('-c', '--config=file', 'Config file path') do |c|
+        options[:config] = c
+    end
+
+    options[:debug] = false
+    opts.on('-d', '--debug', 'Enable debugging') do
+        options[:debug] = true
+    end
+
+    options[:mock] = false
+    opts.on('-m', '--mock', 'Use fog\'s mock interfaces') do
+        options[:mock] = true
+    end
+
+    options[:all] = false
+    opts.on('--all', 'Select all objects') do
+        options[:all] = true
+    end
+
+    options[:create] = false
+    opts.on('--create', 'Create objects') do
+        options[:create] = true
+    end
+
+    options[:delete] = false
+    opts.on('--delete', 'Delete objects') do
+        options[:delete] = true
+    end
+
+    options[:read] = false
+    opts.on('--read', 'read objects') do
+        options[:read] = true
+    end
+
+    options[:pry] = false
+    opts.on('--pry', 'Start pry console') do
+        options[:pry] = true
+    end
+
+    options[:find_type] = []
+    opts.on('--find-type=t', 'Find objects by type') do |t|
+        options[:find_type].push(t.to_sym)
+    end
+
+    options[:find] = {}
+    opts.on('--find=f', 'Find objects by key match') do |f|
+        args = f.split('=')
+        options[:find][ args[0].to_sym ] = args[1]
+    end
+
+
+end
+
+begin
+
+    optparse.parse!
+
+    if options[:config].nil?
+        raise OptionParser::MissingArgument, "--config"
+    end
+
+    if options[:create] and options[:delete]
+        raise OptionParser::InvalidOption, "Choose only one of --create or --delete"
+    end
+
+    if !options[:create] and !options[:delete]
+        options[:read] = true
+    end
+
+    if options[:all] and ( !options[:find].empty? or options[:find_type].length > 0 )
+        raise OptionParser::InvalidOption, "Use either --all or the --find/--find-type options, not both"
+    end
+
+    options[:find_type].each do |ft|
+        if !BuildCloud.dispatch.keys.include?(ft)
+            raise OptionParser::InvalidOption, "--find-type didn't match one of #{BuildCloud.dispatch.keys.join(', ')}"
+        end
+    end
+
+rescue OptionParser::InvalidOption, OptionParser::MissingArgument
+
+    $stderr.puts $!.to_s
+    $stderr.puts optparse
+    exit 2
+
+end
+
+log = Logger.new(STDERR)
+
+if options[:debug]
+    log.level = Logger::DEBUG
+else
+    log.level = Logger::INFO
+end
+
+inf = BuildCloud.new( :config => options[:config], :logger => log, :mock => options[:mock] )
+
+
+if options[:all]
+
+    objects = inf.all
+
+else
+
+    objects = []
+
+    options[:find_type].each do |ft|
+        objects.concat inf.find( ft, options[:find] )
+    end
+
+    if objects.length == 0
+        $stderr.puts "Didn't find any matching object"
+    end
+
+end
+
+
+if options[:create]
+
+    objects.each do |o|
+        begin
+            o.create
+            o.wait_until_ready
+        rescue Fog::Errors::MockNotImplemented => e
+            log.error("No Fog mock support for #{o.class}")
+        end
+    end
+
+elsif options[:delete]
+
+    objects.reverse.each do |o|
+        o.delete
+    end
+
+elsif options[:read]
+
+    objects.each do |o|
+        puts o.inspect
+    end
+
+end
+
+
+if options[:pry]
+    inf.pry
+end
+

data/build-cloud.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name          = "build-cloud"
+  spec.version       = "0.0.1"
+  spec.authors       = ["The Scale Factory"]
+  spec.email         = ["info@scalefactory.com"]
+  spec.summary       = %q{Tools for building resources in AWS}
+  spec.homepage      = "https://github.com/scalefactory/build-cloud"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+
+  spec.add_dependency "fog", ">=1.22.0"
+  spec.add_dependency "pry", ">=0.9.12.6"
+end

data/lib/build-cloud/asgroup.rb

@@ -0,0 +1,68 @@
+class BuildCloud::ASGroup
+
+    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, :launch_configuration_name, :min_size, :max_size,
+                         :desired_capacity, :availability_zones, :health_check_grace_period)
+        require_one_of(:vpc_zone_identifier, :subnet_names)
+
+    end
+
+    def create
+        
+        return if exists?
+
+        @log.info( "Creating AS Group #{@options[:id]}" )
+
+        options = @options.dup
+
+        unless options[:vpc_zone_identifier]
+
+            subnet_ids = []
+
+            options[:subnet_names].each do |subnet|
+                subnet_ids << BuildCloud::Subnet.get_id_by_name( subnet )
+            end
+
+            options.delete(:subnet_names)
+            options[:vpc_zone_identifier] = subnet_ids.join(',')
+
+        end
+
+        @log.debug( options )
+
+        asg = @as.groups.new( options )
+        asg.save
+
+        @log.debug( asg.inspect )
+
+    end
+
+    def read
+        @as.groups.select { |g| g.id == @options[:id] }.first
+    end
+
+    alias_method :fog_object, :read
+
+    def delete
+
+        return unless exists?
+
+        @log.info( "Deleting ASG #{@options[:id]}" )
+
+        fog_object.destroy( :force => true )
+
+    end
+
+end
+

data/lib/build-cloud/cachecluster.rb

@@ -0,0 +1,66 @@
+
+class BuildCloud::CacheCluster
+
+    include ::BuildCloud::Component
+
+    @@objects = []
+
+    def initialize ( fog_interfaces, log, options = {} )
+
+        @elasticache = fog_interfaces[:elasticache]
+        @log         = log
+        @options     = options
+
+        @log.debug( options.inspect )
+
+        required_options(:id, :node_type, :num_nodes, :auto_minor_version_upgrade, 
+            :engine, :cache_subnet_group_name)
+        require_one_of(:vpc_security_groups, :vpc_security_group_names)
+
+    end
+
+    def create
+
+        return if exists?
+
+        @log.info( "Creating Elasticache Cluster #{@options[:id]}" )
+
+        options = @options.dup
+
+        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
+
+        cluster = @elasticache.clusters.new( options )
+        cluster.save
+
+        @log.debug( cluster.inspect )
+
+    end
+
+    def read
+        @elasticache.clusters.select { |c| c.id == @options[:id] }.first
+    end
+
+    alias_method :fog_object, :read
+
+    def delete
+
+        return unless exists?
+
+        @log.info( "Deleting Elasticache cluster #{@options[:id]}" )
+
+        fog_object.destroy
+
+    end
+
+end
+

data/lib/build-cloud/cacheparametergroup.rb

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

data/lib/build-cloud/cachesubnetgroup.rb

@@ -0,0 +1,64 @@
+
+class BuildCloud::CacheSubnetGroup
+
+    include ::BuildCloud::Component
+
+    @@objects = []
+
+    def initialize ( fog_interfaces, log, options = {} )
+
+        @elasticache = fog_interfaces[:elasticache]
+        @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 Cache 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 = @elasticache.create_cache_subnet_group( options[:name], options[:subnet_ids] )
+
+        @log.debug( group.inspect )
+
+    end
+
+    def read
+        @elasticache.subnet_groups.select { |g| g.id == @options[:name] }.first
+    end
+
+    alias_method :fog_object, :read
+
+    def delete
+
+        return unless exists?
+
+        @log.info( "Deleting Cache Subnet Group #{@options[:name]}" )
+
+        fog_object.destroy
+
+    end
+
+end
+

data/lib/build-cloud/component.rb

@@ -0,0 +1,143 @@
+module BuildCloud::Component
+
+    # Using idiom for putting class methods in mixin
+    # http://stackoverflow.com/questions/10692961/inheriting-class-methods-from-mixins
+    
+    def self.included(base)
+        base.send :include, InstanceMethods
+        base.extend ClassMethods
+    end
+
+    module InstanceMethods
+
+        def [](key)
+            @options[key]
+        end
+
+        def has_key?(key)
+            @options.has_key?(key)
+        end
+
+        def exists?
+            !read.nil?
+        end
+
+        def ready_timeout
+            30
+        end
+
+        def wait_until_ready
+
+            unless read.class.method_defined?(:ready?)
+                @log.debug("Can't wait for readiness on #{read.class.to_s}")
+                return
+            end
+
+            timeout = ready_timeout # default from this superclass
+
+            wait_timer = 1
+            start_time = Time.now.to_i
+
+            begin
+
+                if fog_object.ready?
+                    @log.info("Object ready")
+                    return true
+                end
+
+                @log.debug("Object not yet ready. Sleeping #{wait_timer}s")
+
+                sleep( wait_timer )
+
+                if wait_timer < 60
+                    wait_timer *= 2
+                end
+
+                time_diff = Time.now.to_i - start_time
+
+            end while time_diff < timeout
+
+            @log.error("Timed out after #{timeout} waiting for #{read.class}")
+
+        end
+
+        def required_options( *required )
+
+            cn = self.class.name.split('::').last
+            missing = []
+
+            required.each do |o|
+                missing << o unless @options.has_key?(o)
+            end
+
+            if missing.length > 0
+                raise "#{cn} requires missing #{missing.join(', ')} option#{missing.length > 1 ? 's' : ''}" 
+            end 
+
+        end
+
+        def require_one_of( *required )
+
+            cn = self.class.name.split('::').last
+
+            intersection = @options.keys & required
+
+            if intersection.length != 1
+                raise "#{cn} requires only one of #{required.join(', ')}"
+            end
+    
+
+        end
+
+        def to_s
+            return @options.to_yaml
+        end
+
+    end
+
+    module ClassMethods
+
+        # implied "self." for all methods here
+
+        def load( items, fog_interfaces, log )
+
+            objects = self.send :class_variable_get, :@@objects
+
+            items.each do |item|
+                objects << self.new( fog_interfaces, log, item )
+            end
+
+            objects
+
+        end
+
+         
+        def search(options)
+
+            objects = self.send :class_variable_get, :@@objects
+
+            objects.select { |o|
+
+                matches = true
+
+                options.each_pair do |k,v|
+
+                    unless o.has_key?(k) and o[k] == v
+                        matches = false
+                    end
+
+                end
+
+                matches
+
+            }
+
+        end
+
+        def objects 
+            self.send :class_variable_get, :@@objects
+        end
+
+    end
+
+end