cloudformation-tool 0.1.1

data/lib/cloud_formation_tool/cloud_formation/lambda_code.rb

@@ -0,0 +1,41 @@
+require 'net/http'
+
+module CloudFormationTool
+  class CloudFormation
+    
+    class LambdaCode
+      include Storable
+      
+      def initialize(url)
+        log "Downloading Lambda code from #{url}"
+        res = fetch(url)
+        
+        @s3_url = URI(upload(make_filename(url.split('.').last), res.body, res['content-type']))
+        log "uploaded Lambda function to #{@s3_url}"
+      end
+      
+      def fetch(uri_str, limit = 10)
+        raise ArgumentError, 'too many HTTP redirects' if limit == 0
+        response = Net::HTTP.get_response(URI(uri_str))
+        case response
+        when Net::HTTPSuccess then
+          response
+        when Net::HTTPRedirection then
+          location = response['location']
+          log "redirected to #{location}"
+          fetch(location, limit - 1)
+        else
+          raise AppError, "Error downloading #{url}: #{response.value}"
+        end
+      end
+      
+      def to_cloudformation
+        {
+          'S3Bucket' => @s3_url.hostname.split('.').first,
+          'S3Key' => @s3_url.path[1..-1]
+        }
+      end
+    end
+
+  end
+end

data/lib/cloud_formation_tool/cloud_formation/stack.rb

@@ -0,0 +1,152 @@
+module CloudFormationTool
+  class CloudFormation
+    
+    class Stack
+      include Enumerable
+      include Storable
+      include CloudFormationTool
+      
+      attr_reader :name
+      
+      def initialize(name)
+        @name = name
+        @seenev = Set.new
+        @watch_timeouts = 0
+      end
+      
+      def delete
+        awscf.delete_stack  stack_name: @name
+      end
+      
+      def exist?
+        begin
+          awscf.describe_stacks stack_name: name
+          true
+        rescue Aws::CloudFormation::Errors::ValidationError => e
+          false
+        end
+      end
+      
+      def update(url, filepath, params = {})
+        log "Updating existing stack '#{name}' from '#{filepath}' params #{params.inspect}"
+        resp = awscf.update_stack({
+          stack_name: @name,
+          template_url: url,
+          capabilities: %w(CAPABILITY_IAM CAPABILITY_NAMED_IAM),
+          parameters: params.collect do |k,v|
+            {
+              parameter_key: k.to_s,
+              parameter_value: v.to_s,
+              use_previous_value: false,
+            }
+          end
+        })
+        resp.stack_id
+      end
+      
+      def create(template, params = {})
+        tmpl = CloudFormation.parse(template).to_yaml
+        url = upload(make_filename('yaml'), tmpl)
+        return update(url, template, params) if exist?
+        log "Creating stack '#{name}' from '#{template}' params #{params.inspect}"
+        resp = awscf.create_stack({
+          stack_name: @name,
+          template_url: url,
+          capabilities: %w(CAPABILITY_IAM CAPABILITY_NAMED_IAM),
+          on_failure: "DO_NOTHING", ##"ROLLBACK",
+          parameters: params.collect do |k,v|
+            {
+              parameter_key: k.to_s,
+              parameter_value: v.to_s,
+              use_previous_value: false,
+            }
+          end
+        })
+        resp.stack_id
+      end
+      
+      def resources
+        begin
+          resp = awscf.describe_stack_resources  stack_name: @name
+          resp.stack_resources
+        rescue Aws::CloudFormation::Errors::ValidationError => e
+          raise Errors::AppError, "Failed to get resources: #{e.message}"
+        end
+      end
+      
+      def asgroups
+        resources.select do |res|
+          res.resource_type == 'AWS::AutoScaling::AutoScalingGroup'
+        end
+      end
+      
+      def see_events
+        each { |e| @seenev << e.event_id }
+      end
+      
+      def monitor(start_time = nil)
+        done = false
+        begin
+          until done
+            reverse_each do |ev|
+              next if @seenev.add?(ev.event_id).nil?
+              text = "#{ev.timestamp.strftime "%Y-%m-%d %H:%M:%S"}| " + %w(
+                resource_type:40
+                logical_resource_id:38
+                resource_status
+              ).collect { |field|
+                (name,size) = field.split(":")
+                size ||= 1
+                ev.send(name.to_sym).ljust(size.to_i, ' ')
+              }.join("  ")
+              text += " " + ev.resource_status_reason if ev.resource_status =~ /_FAILED/
+              if start_time.nil? or start_time < ev.timestamp
+                puts text
+              end
+              done = (ev.resource_type == "AWS::CloudFormation::Stack" and ev.resource_status =~ /(_COMPLETE|_FAILED)$/)
+            end
+          end
+        rescue CloudFormationTool::Errors::StackDoesNotExistError => e
+          puts "Stack #{name} does not exist"
+        end
+      end
+      
+      def each
+        token = nil
+        sleep(if @_last_poll_time.nil?
+          0
+          else
+            diff = Time.now - @_last_poll_time
+            if diff < 1
+              diff
+            else
+              0
+            end
+          end)
+        begin
+          resp = awscf.describe_stack_events stack_name: name, next_token: token
+          @watch_timeouts = 0
+          resp.stack_events.each do |ev|
+            yield ev
+          end
+        rescue Aws::CloudFormation::Errors::Throttling => e
+          sleep 1
+          retry
+        rescue Seahorse::Client::NetworkingError => e # we get this when there's a timeout
+          if (@watch_timeouts += 1) > 5
+            raise AppError, "Too many timeouts!"
+          else
+            retry
+          end
+        rescue Aws::CloudFormation::Errors::ValidationError => e
+          if e.message =~ /does not exist/
+            raise CloudFormationTool::Errors::StackDoesNotExistError, "Stack does not exist"
+          else
+            raise e
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/cloud_formation_tool/cloud_init.rb

@@ -0,0 +1,86 @@
+require 'zlib'
+
+module CloudFormationTool
+  class CloudInit
+    include Storable
+    
+    attr_reader :path
+    
+    def initialize(path)
+      @path = path
+      log "Loading #{path}"
+      begin
+        @initfile = YAML.load(File.read(path)).to_h
+      rescue Errno::ENOENT => e
+        raise AppError.new("Error reading #{@path}: " + e.message)
+      end
+    end
+  
+    def compile
+      basepath = File.dirname(path)
+      basepath = "." if basepath.empty?
+      @initfile['write_files'] = (@initfile['write_files'] || []).collect do |file|
+        if file['file']
+          begin
+            read_file_content(basepath + "/" + file.delete('file'), file)
+          rescue Errno::EISDIR => e
+            raise AppError, "#{path} - error loading embedded file for #{file['path']}: " + e.message
+          rescue Errno::ENOENT => e
+            raise AppError, "#{path} - error loading embedded file for #{file['path']}: " + e.message
+          end
+        else
+          file
+        end
+      end
+      @initfile['write_files'] += (@initfile.delete('write_directories') || []).collect do |directory|
+        realdir = "#{basepath}/#{directory['source']}"
+        raise AppError.new("Cloud-init file #{path} references missing directory #{realdir}") unless File.exist? realdir
+        read_dir_files(realdir, directory['target'])
+      end.flatten
+      "#cloud-config\n" + @initfile.to_yaml
+    end
+    
+    def encode
+      yamlout = compile
+      if yamlout.size > 16384 # max AWS EC2 user data size - try compressing it
+        yamlout = Zlib::Deflate.new(nil, 31).deflate(yamlout, Zlib::FINISH) # 31 is the magic word to have deflate create a gzip compatible header
+      end
+      if yamlout.size > 16384 # still to big, we should upload to S3 and create an include file
+        url = upload  make_filename('init'),
+                      yamlout, 'text/cloud-config'
+        log "Wrote cloud config to #{url}"
+        [ "#include", url ].join "\n"  
+      else
+        yamlout
+      end
+    end
+    
+    def read_file_content(filepath, spec)
+      spec['encoding'] = 'base64'
+      spec['content'] = Base64.strict_encode64(File.read(filepath))
+      spec
+    end
+    
+    def read_dir_files(source, target)
+      Dir.entries(source).select do |entry|
+        entry !~ /^\.{1,2}$/
+      end.collect do |entry|
+        path = source + "/" + entry
+        targetpath = target + "/" + entry
+        if File.directory? path
+          read_dir_files(path, targetpath)
+        else
+          [ read_file_content(path, {
+            'path' => targetpath,
+            'permissions' => (("%o" % File.stat(path).mode)[-4..-1])
+          }) ]
+        end
+      end.flatten
+    end
+    
+    def to_base64
+      Base64.encode64(encode)
+    end
+    
+  end
+end

data/lib/cloud_formation_tool/errors.rb

@@ -0,0 +1,11 @@
+module CloudFormationTool
+  module Errors
+    
+    Autoloaded.module {  }
+    
+    class AppError < StandardError; end
+    
+    class StackDoesNotExistError < StandardError; end
+    
+  end
+end

data/lib/cloud_formation_tool/storable.rb

@@ -0,0 +1,41 @@
+require 'digest'
+
+module CloudFormationTool
+  module Storable
+    include CloudFormationTool
+    
+    def make_filename(ext = '')
+      base = "#{File.basename(Dir.pwd)}-#{Time.now.strftime("%Y%m%d%H%M%S")}"
+      if ext.empty?
+        base
+      else
+        "#{base}.#{ext}"
+      end
+    end
+    
+    def upload(path, content, mime_type = 'text/yaml')
+      md5 = Digest::MD5.hexdigest content
+      prefix = "#{md5[0]}/#{md5[1..2]}/#{md5}"
+      b = Aws::S3::Bucket.new(s3_bucket_name(region), client: awss3(region))
+      # return early if we already have a copy of this object stored.
+      # if this object was previously uploaded, we use its URLs (and not, for example,
+      # do a local copy to the requested path) because this way cloudformation can see
+      # that the updated template is exactly the same as the old one and will not force
+      # an unneeded update.
+      o = b.objects(prefix: "cf-compiled/#{prefix}/").first
+      if o.nil?
+        # no such luck, we need to actually upload the file
+        o = b.object("cf-compiled/#{prefix}/#{path}")
+        o.put acl: 'public-read',
+              body: content,
+              content_disposition: 'attachment',
+              content_encoding: 'gzip',
+              content_type: mime_type,
+              storage_class: 'REDUCED_REDUNDANCY'
+      else
+        log "re-using cached object"
+      end
+      o.public_url
+    end
+  end
+end

data/lib/cloud_formation_tool/version.rb

@@ -0,0 +1,3 @@
+module CloudFormationTool
+  VERSION = '0.1.1'
+end

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification
+name: cloudformation-tool
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Oded Arbel
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-03-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: clamp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: aws-sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: autoloaded
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+description: 
+email: oded.arbel@greenfieldtech.net
+executables:
+- cftool
+extensions: []
+extra_rdoc_files:
+- LICENSE
+- README.md
+files:
+- LICENSE
+- README.md
+- bin/cftool
+- lib/cloud_formation_tool.rb
+- lib/cloud_formation_tool/cli.rb
+- lib/cloud_formation_tool/cli/compile.rb
+- lib/cloud_formation_tool/cli/create.rb
+- lib/cloud_formation_tool/cli/delete.rb
+- lib/cloud_formation_tool/cli/list_stacks.rb
+- lib/cloud_formation_tool/cli/main.rb
+- lib/cloud_formation_tool/cli/monitor.rb
+- lib/cloud_formation_tool/cli/parameters.rb
+- lib/cloud_formation_tool/cli/servers.rb
+- lib/cloud_formation_tool/cli/status.rb
+- lib/cloud_formation_tool/cloud_formation.rb
+- lib/cloud_formation_tool/cloud_formation/lambda_code.rb
+- lib/cloud_formation_tool/cloud_formation/stack.rb
+- lib/cloud_formation_tool/cloud_init.rb
+- lib/cloud_formation_tool/errors.rb
+- lib/cloud_formation_tool/storable.rb
+- lib/cloud_formation_tool/version.rb
+homepage: http://github.com/GreenfieldTech/cloudformation-tool
+licenses:
+- GPL-2.0
+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.4.5
+signing_key: 
+specification_version: 4
+summary: A pre-compiler tool for CloudFormation YAML templates
+test_files: []