comodule 0.0.4 → 0.1.0

data/lib/comodule/deployment/helper.rb

@@ -0,0 +1,9 @@
+module Comodule::Deployment::Helper
+
+  def self.included(receiver)
+    receiver.send(
+      :include,
+      SystemUtility, ShellCommand, Uploader, Aws
+    )
+  end
+end

data/lib/comodule/deployment/helper/aws.rb

@@ -0,0 +1,96 @@
+require 'aws-sdk'
+
+module Comodule::Deployment::Helper::Aws
+
+  def self.included(receiver)
+    receiver.send :include, InstanceMethods, CloudFormation, S3, Ec2, Ssl, Rds
+  end
+
+  module InstanceMethods
+    def aws
+      @aws ||= ::Comodule::Deployment::Helper::Aws::Service.new(self)
+    end
+  end
+
+  class Service
+    include ::Comodule::Deployment::Helper::Base
+
+    def initialize(platform)
+      self.owner = platform
+
+      @aws_sdk_object = {}
+      @access_credentials = access_credentials || {}
+      @method_map = {}
+      ::AWS.constants.each do |const_name|
+        const = ::AWS.const_get(const_name)
+        if defined?(const.new)
+          @method_map[const_name.to_s.underscore.to_sym] = const
+        end
+      end
+    end
+
+    def access_credentials
+      config.aws_access_credentials || {}
+    end
+
+    def search_credential_directive(aws_resource_name, directive)
+      (access_credentials[aws_resource_name] && access_credentials[aws_resource_name][directive]) ||
+      (access_credentials[:common] && access_credentials[:common][directive]) ||
+      access_credentials[directive] ||
+      config["aws_#{directive}".to_sym]
+    end
+
+    def access_key_id(aws_resource_name)
+      search_credential_directive(aws_resource_name, :access_key_id)
+    end
+
+    def secret_access_key(aws_resource_name)
+      search_credential_directive(aws_resource_name, :secret_access_key)
+    end
+
+    def region(aws_resource_name)
+      search_credential_directive(aws_resource_name, :region)
+    end
+
+    def validate_credential(aws_resource_name, iam)
+      case aws_resource_name
+      when :cloud_formation, :rds, :auto_scaling
+        if !iam || !iam[:region]
+          raise ArgumentError, "Please specify aws_access_credentials.#{aws_resource_name}.region on your config.yml."
+        end
+      when :cloud_front, :s3
+        iam.delete(:region)
+      end
+
+      iam
+    end
+
+    def method_missing(method_name)
+      if @method_map[method_name]
+        return @aws_sdk_object[method_name] if @aws_sdk_object[method_name]
+
+        iam = {}
+
+        key_id = access_key_id(method_name)
+        secret = secret_access_key(method_name)
+        region = region(method_name)
+        iam[:access_key_id] = key_id if key_id
+        iam[:secret_access_key] = secret if secret
+        iam[:region] = region if region && region.present?
+
+        iam = (@access_credentials[method_name] || @access_credentials[:common] || {}).to_hash.merge(iam)
+
+        validate_credential(method_name, iam)
+        if !iam.empty?
+          @aws_sdk_object[method_name] = @method_map[method_name].new(iam)
+        else
+          @aws_sdk_object[method_name] = @method_map[method_name].new
+        end
+
+        return @aws_sdk_object[method_name]
+      end
+
+      raise ArgumentError, "#{self.class.name} was missing AWS class #{method_name}."
+    end
+  end
+end

data/lib/comodule/deployment/helper/aws/base.rb

@@ -0,0 +1,14 @@
+module Comodule::Deployment::Helper::Aws::Base
+
+  def self.included(receiver)
+    receiver.send :include, ::Comodule::Deployment::Helper::Base
+    receiver.send :include, InstanceMethods
+  end
+
+  module InstanceMethods
+
+    def aws
+      owner.aws
+    end
+  end
+end

data/lib/comodule/deployment/helper/aws/cloud_formation.rb

@@ -0,0 +1,146 @@
+module Comodule::Deployment::Helper::Aws::CloudFormation
+
+  def self.included(receiver)
+    receiver.send :include, InstanceMethods
+  end
+
+  module InstanceMethods
+    def cloud_formation
+      @cloud_formation ||= ::Comodule::Deployment::Helper::Aws::CloudFormation::Service.new(self)
+    end
+  end
+
+  class Service
+    include ::Comodule::Deployment::Helper::Aws::Base
+
+    def cfn
+      @cfn ||= aws.cloud_formation
+    end
+
+    def stack_basename
+      stack_name = []
+      stack_name << (config.stack_name_prefix || owner.project_name)
+      stack_name << owner.name
+      stack_name.join(?-)
+    end
+
+    def own_stacks
+      cfn.stacks.find_all { |stack| stack.name =~ /#{stack_basename}/ }
+    end
+
+    def latest_stack
+      filter = -> stack { stack.name.match(/[0-9]*$/)[0].to_i }
+      own_stacks.max { |a,b| filter[a] <=> filter[b] }
+    end
+
+    def create_stack(&block)
+      if config.upload_secret_files
+        puts 'Upload secret files'
+        owner.upload_secret_files
+      end
+
+      if config.upload_project
+        puts 'Upload project'
+        owner.upload_project
+      end
+
+      stack_name = [stack_basename, Time.now.strftime("%Y%m%d")].join(?-)
+
+      template = validate_template(&block)
+
+      stack = cfn.stacks.create(stack_name, template)
+
+      puts "Progress of creation stack: #{stack.name}"
+
+      status = stack_status_watch(stack)
+
+      puts "\n!!! #{status} !!!\n"
+    end
+
+    def delete_stack
+      stack = latest_stack
+
+      if !stack || !stack.exists?
+        puts "Stack:/#{stack_basename}-[0-9]*/ is not found.\n"
+        exit
+      end
+
+      print "You are going to delete stack #{stack.name}. Are you sure? [N/y] "
+      confirm = STDIN.gets
+      unless confirm =~ /^y(es)?$/
+        puts "\nAbort!\n"
+        exit
+      end
+
+      stack.delete
+
+      puts "Progress of deletion stack: #{stack.name}"
+
+      status = stack_status_watch(stack)
+
+      puts "\n!!! #{status} !!!\n"
+    end
+
+    def stack_status_watch(stack, interval=10)
+      begin
+        status = stack.status
+      rescue
+        return 'Missing stack'
+      end
+
+      first_status = status
+      before_status = ""
+
+      while status == first_status
+        if status == before_status
+          before_status, status = status, ?.
+        else
+          before_status = status
+        end
+
+        print status
+
+        sleep interval
+
+        begin
+          status = stack.status
+        rescue
+          status = "Missing stack"
+          break
+        end
+      end
+
+      status
+    end
+
+    def validate_template(&block)
+      template = cloud_formation_template(&block)
+
+      template_path = File.join(owner.test_cloud_formation_dir, 'template.json')
+
+      File.open(template_path, 'w') do |file|
+        file.write template
+      end
+
+      result = cfn.validate_template(template)
+
+      puts "Validation result:"
+      result.each do |key, msg|
+        puts "  #{key}: #{msg}"
+      end
+
+      template
+    end
+
+    def cloud_formation_template
+      if block_given?
+        yield config
+      end
+
+      file = File.join(owner.cloud_formation_dir, 'template.json.erb')
+      common_file = File.join(owner.common_cloud_formation_dir, 'template.json.erb')
+
+      owner.render( File.file?(file) ? file : common_file )
+    end
+  end
+end

data/lib/comodule/deployment/helper/aws/ec2.rb

@@ -0,0 +1,37 @@
+module Comodule::Deployment::Helper::Aws::Ec2
+
+  def self.included(receiver)
+    receiver.send :include, InstanceMethods
+  end
+
+  module InstanceMethods
+    def ec2
+      @ec2 ||= ::Comodule::Deployment::Helper::Aws::Ec2::Service.new(self)
+    end
+  end
+
+  class Service
+    include ::Comodule::Deployment::Helper::Aws::Base
+
+    def ec2
+      @ec2 ||= aws.ec2
+    end
+
+    def own_images
+      ec2.images.with_owner('self')
+    end
+
+    def latest_ami
+      images = own_images
+      if config.ec2 && config.ec2.ami && config.ec2.ami.prefix
+        images = images.find_all { |ami| ami.name =~ /^#{config.ec2.ami.prefix}/ }
+
+        filter = -> ami { ami.name.match(/[0-9]*$/)[0].to_i }
+        images = images.sort do |a, b|
+          filter[b] <=> filter[a]
+        end
+      end
+      images.first
+    end
+  end
+end

data/lib/comodule/deployment/helper/aws/rds.rb

@@ -0,0 +1,46 @@
+module Comodule::Deployment::Helper::Aws::Rds
+
+  def self.included(receiver)
+    receiver.send :include, InstanceMethods
+  end
+
+  module InstanceMethods
+    def rds
+      @rds ||= ::Comodule::Deployment::Helper::Aws::Rds::Service.new(self)
+    end
+  end
+
+  class Service
+    include ::Comodule::Deployment::Helper::Aws::Base
+
+    def db(db_instance_identifier)
+      ::Comodule::Deployment::Helper::Aws::Rds::Db.new(owner, db_instance_identifier)
+    end
+
+    def latest_automated_snapshot
+      if config.db && config.db.master && !config.db.snapshot_identifier
+        config.db.snapshot_identifier = db(config.db.master).latest_automated_snapshot
+      end
+    end
+  end
+
+  class Db
+    include ::Comodule::Deployment::Helper::Aws::Base
+
+    attr_accessor :db
+
+    def initialize(platform, db_instance_identifier)
+      self.owner = platform
+      self.db = aws.rds.db_instances[db_instance_identifier]
+    end
+
+    def latest_automated_snapshot
+      snapshot =
+        db.snapshots.with_type('automated').sort do |a, b|
+          b.created_at <=> a.created_at
+        end
+
+      snapshot.first.db_snapshot_identifier
+    end
+  end
+end

data/lib/comodule/deployment/helper/aws/s3.rb

@@ -0,0 +1,52 @@
+module Comodule::Deployment::Helper::Aws::S3
+
+  def self.included(receiver)
+    receiver.send :include, InstanceMethods
+  end
+
+  module InstanceMethods
+    def s3
+      @s3 ||= ::Comodule::Deployment::Helper::Aws::S3::Service.new(self)
+    end
+  end
+
+  class Service
+    include ::Comodule::Deployment::Helper::Aws::Base
+
+    def s3
+      @s3 ||= aws.s3
+    end
+
+    def bucket_name
+      @bucket_name ||= config.s3_bucket
+    end
+
+    def bucket
+      return @bucket if @bucket
+
+      bucket_obj = s3.buckets[bucket_name]
+      @bucket =
+        if bucket_obj.exists?
+          bucket_obj
+        else
+          s3.buckets.create(bucket_name)
+        end
+    end
+
+    def local_to_cloud(local_path)
+      local_path.sub(%r|#{owner.project_root}/|, "#{owner.name}/")
+    end
+
+    def cloud_to_local(s3_path)
+      s3_path.sub(%r|#{owner.name}/|, "#{owner.project_root}/")
+    end
+
+    def public_url(s3_path)
+      s3.bucket[s3_path].public_url secure: true
+    end
+
+    def local_to_public_url(local_path)
+      public_url local_to_cloud(local_path)
+    end
+  end
+end

data/lib/comodule/deployment/helper/aws/ssl.rb

@@ -0,0 +1,111 @@
+module Comodule::Deployment::Helper::Aws::Ssl
+
+  def self.included(receiver)
+    receiver.send :include, InstanceMethods
+  end
+
+  module InstanceMethods
+    def ssl
+      @ssl ||= ::Comodule::Deployment::Helper::Aws::Ssl::Service.new(self)
+    end
+  end
+
+  class Service
+    include ::Comodule::Deployment::Helper::Aws::Base
+
+    def iam
+      aws.iam
+    end
+
+    def describe
+      puts
+      iam.server_certificates.each do |cert|
+        inspect_certificate cert
+      end
+    end
+
+    def delete
+      name = config.ssl.name
+      cert = iam.server_certificates[name]
+      puts "I am going to delete this server certificate #{name}. Are you sure? [N/y] "
+      confirm = STDIN.gets
+      unless confirm =~ /^y(es)?$/
+        puts "\nAbort!\n"
+        return
+      end
+      puts cert.delete
+    end
+
+    def upload
+      body  = File.open(owner.file_path(config.ssl.dir, config.ssl.body_file)).read
+      chain = File.open(owner.file_path(config.ssl.dir, config.ssl.chain_file)).read
+      key   = File.open(owner.file_path(config.ssl.dir, config.ssl.key_file)).read
+      puts "body:"
+      puts body
+      puts
+      puts "chain:"
+      puts chain
+      puts
+      puts "key"
+      puts key
+      puts
+      puts "AWS IAM server certificate name: #{config.ssl.name}"
+      puts "I am going to upload this server certificate to AWS IAM. Are you sure? [N/y] "
+      confirm = STDIN.gets
+      unless confirm =~ /^y(es)?$/
+        puts "\nAbort!\n"
+        return
+      end
+
+      cert = iam.server_certificates.create(
+        certificate_body: body,
+        name: config.ssl.name,
+        path: config.ssl.path || ?/,
+        private_key: key,
+        certificate_chain: chain
+      )
+
+      unless cert
+        'Failed!'
+        return
+      end
+
+      puts
+      puts "Success:"
+      inspect_certificate cert
+    end
+
+    def inspect_certificate(cert)
+      inspect_certificate_summary cert
+      inspect_certificate_body cert
+      inspect_certificate_chain cert
+    end
+
+    def inspect_certificate_summary(cert)
+      puts "arn:         #{cert.arn}"
+      puts "id:          #{cert.id}"
+      puts "name:        #{cert.name}"
+      puts "path:        #{cert.path}"
+      puts "upload_date: #{cert.upload_date}"
+      puts
+    end
+
+    def inspect_certificate_body(cert)
+      puts "body:"
+      puts cert.certificate_body
+      puts
+    end
+
+    def inspect_certificate_chain(cert)
+      puts "chain:"
+      puts cert.certificate_chain
+      puts
+    end
+
+    def find
+      iam.server_certificates.find do |cert|
+        cert.name == config.ssl.name
+      end
+    end
+  end
+end