akashi 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2ca4dbff7522ca5b3a2e37ac4f2be92a443e66cb
+  data.tar.gz: 0277b555b90816bc0ba16a64001a6e387b4ed6c4
+SHA512:
+  metadata.gz: 6eb6682215d85eb4e4402823b7ae5bdba322b2c2fcd6cab4f34d1c80ec999046a3d60264de3ad8245b6b00713628375271814ae9a9e2dfb0ba1fbbf65917c2b5
+  data.tar.gz: 134c5f8c3a9122204b06ffaf0bfcfe1c1bebf58d77ca126bfc790f1d36fa8e7600c4c22ce4ad622c3853f1030cc4677b1b18a21370252b643e1e105f99740f89

data/.gitignore

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

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in akashi.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,39 @@
+PATH
+  remote: .
+  specs:
+    akashi (0.0.1)
+      activesupport
+      aws-sdk
+      hashie
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (4.1.1)
+      i18n (~> 0.6, >= 0.6.9)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.1)
+      tzinfo (~> 1.1)
+    aws-sdk (1.43.1)
+      json (~> 1.4)
+      nokogiri (>= 1.4.4)
+    hashie (3.0.0)
+    i18n (0.6.9)
+    json (1.8.1)
+    mini_portile (0.6.0)
+    minitest (5.3.4)
+    nokogiri (1.6.2.1)
+      mini_portile (= 0.6.0)
+    rake (10.3.2)
+    thread_safe (0.3.4)
+    tzinfo (1.2.1)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  akashi!
+  bundler (~> 1.3)
+  rake

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 asonas
+
+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,66 @@
+# Akashi
+
+Wrapping aws-sdk
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'akashi'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install akashi
+
+## Usage
+
+``` ruby
+require "yaml"
+require "akashi"
+
+Akashi::Aws.config = YAML.load_file("aws.yml"))
+
+Akashi.application = application
+Akashi.environment = environment
+Akashi.manifest    = YAML.load_file("#{Akashi.name(separator: "_")}.yml")
+
+Akashi.send(action.intern)
+```
+
+## Configurations
+### VPC
+Cidr block is 10.0.0.0/16.
+
+### Roles
+|Role|Cidr block
+|---|---|
+|ELB|10.0.0.0/19|
+|SSH Gateway|10.0.32.0/19|
+|RDS|10.0.64.0/19|
+|Web Server|10.0.96.0/19|
+
+#### Allowed input
+|Role|Protocol|Port|Source|
+|---|---|---|---|
+|ELB|TCP|443|0.0.0.0/0|
+|SSH Gateway|TCP|9922|0.0.0.0/0|
+||ICMP|-|0.0.0.0/0|
+|RDS|TCP|3306|10.0.96.0/19|
+|Web Server|TCP|80|10.0.0.0/19|
+||TCP|9922|10.0.32.0/19|
+||ICMP|-|10.0.32.0/19|
+
+### Subnets
+Cidr is 24. Create subnet from cidr block of role each availability zone.
+Example of ELB: 10.0.0.0/24, 10.0.1.0/24, 10.0.2.0/24...
+## Contributing
+
+1. Fork it
+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/akashi.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'akashi/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "akashi"
+  spec.version       = Akashi::VERSION
+  spec.authors       = ["asonas", "int_remain"]
+  spec.email         = ["hzw1258@gmail.com", "ponde.ponde.ponde@gmail.com"]
+  spec.description   = %q{Wrapping aws-sdk}
+  spec.summary       = %q{Wrapping awd-sdk}
+  spec.homepage      = "https://github.com/spice-life/akashi"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  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_dependency "activesupport"
+  spec.add_dependency "aws-sdk"
+  spec.add_dependency "hashie"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

data/config/application_enviroment.yml.example

@@ -0,0 +1,43 @@
+ec2:
+  instances:
+    gateway: &instance_for_gateway
+      ami_id:
+      instance_class: m3.medium
+      allocated_storage: 8 # GB
+    web: &instance_for_web
+      ami_id:
+      instance_class: m3.medium
+      allocated_storage: 8 # GB
+  public_key:
+rds:
+  allocated_storage: 5 # GB
+  instance_class: db.t1.micro
+  multi_az: false
+  availability_zone: ap-northeast-1c
+  engine_version: 5.6.17
+elb:
+  ssl_certificate:
+    server_certificate:
+    private_key_path:
+  health_check:
+    target: HTTP:80/ping
+role:
+  elb:
+    internet_connection: true
+    subnets:
+      - availability_zone: ap-northeast-1c
+  gateway:
+    internet_connection: true
+    subnets:
+      - availability_zone: ap-northeast-1c
+        instance: *instance_for_gateway
+        number_of_instances: 1
+  rds:
+    subnets:
+      - availability_zone: ap-northeast-1b
+      - availability_zone: ap-northeast-1c
+  web:
+    subnets:
+      - availability_zone: ap-northeast-1c
+        instance: *instance_for_web
+        number_of_instances: 1

data/config/aws.yml.exapmle

@@ -0,0 +1,3 @@
+access_key_id: XXXXXX
+secret_access_key: XXXXXX
+region: ap-northeast-1

data/lib/akashi/aws.rb

@@ -0,0 +1,37 @@
+require "aws-sdk"
+
+module Akashi
+  module Aws
+    module_function
+
+    def config=(new_value)
+      ::AWS.config(new_value)
+      services.each { |service| instance_variable_set(:"@#{service}", nil) }
+    end
+
+    def ec2
+      @ec2 ||= ::AWS::EC2.new
+    end
+
+    def elb
+      @elb ||= ::AWS::ELB.new
+    end
+
+    def iam
+      @iam ||= ::AWS::IAM.new
+    end
+
+    def rds
+      @rds ||= ::AWS::RDS.new
+    end
+
+    def services
+      @services ||= [
+        :ec2,
+        :elb,
+        :iam,
+        :rds,
+      ]
+    end
+  end
+end

data/lib/akashi/base.rb

@@ -0,0 +1,50 @@
+require "forwardable"
+
+module Akashi
+  class Base
+    extend Forwardable
+    def_delegators :@object, :id
+
+    private_class_method :new
+
+    def initialize(id)
+      @object = self.class.base_class.new(id)
+    end
+
+    class << self
+      def all
+        collection.map { |object| new(object.id) }
+      end
+
+      def where(conditions = {})
+        all.select do |instance|
+          conditions.all? { |k, v| instance.send(k.intern) == v }
+        end
+      end
+
+      def find(id)
+        instances = where(id: id)
+        fail "#{id} does not exist" if instances.empty?
+        instances.first
+      end
+
+      def find_by(conditions = {})
+        instances = where(conditions)
+        fail "#{conditions} does not exist" if instances.empty?
+        instances.first
+      end
+
+      def object_class
+        @object_class ||= self.to_s.demodulize
+      end
+
+      def collection
+        Akashi::Aws.send(service_class.underscore).send(object_class.underscore.pluralize)
+      end
+
+      def base_class
+        @base_class ||= "::AWS::#{service_class}::#{object_class}".constantize
+      end
+    end
+  end
+end

data/lib/akashi/ec2/ami.rb

@@ -0,0 +1,14 @@
+module Akashi
+  class Ec2
+    class Ami < Akashi::Ec2::Base
+      def_delegators :@object, :architecture, :name, :state, :type,
+                               :root_device_name, :root_device_type
+
+      class << self
+        def object_class
+          @object_class ||= "Image"
+        end
+      end
+    end
+  end
+end

data/lib/akashi/ec2/base.rb

@@ -0,0 +1,19 @@
+module Akashi
+  class Ec2
+    class Base < Akashi::Base
+      def name=(new_value)
+        @object.add_tag("Name", value: new_value)
+      end
+
+      def name
+        @object.tags["Name"]
+      end
+
+      class << self
+        def service_class
+          @service_class ||= "EC2"
+        end
+      end
+    end
+  end
+end

data/lib/akashi/ec2/instance.rb

@@ -0,0 +1,43 @@
+module Akashi
+  class Ec2
+    class Instance < Akashi::Ec2::Base
+      def_delegators :@object, :public_dns_name, :public_ip_address,
+                               :private_dns_name, :private_ip_address, :image_id,
+                               :key_name, :subnet_id, :vpc_id, :status, :statub_code
+
+      class << self
+        def create(ami:, instance_class:, security_group:, subnet:, allocated_storage:)
+          name = "#{subnet.name}-#{next_number(subnet: subnet)}"
+
+          response = Akashi::Aws.ec2.instances.create(
+            image_id:                    ami.id,
+            key_name:                    Akashi.name,
+            security_group_ids:          [ security_group.id ],
+            subnet_id:                   subnet.id,
+            instance_type:               instance_class,
+            associate_public_ip_address: true,
+            block_device_mappings:       [
+              {
+                device_name:  ami.root_device_name,
+                ebs:          {
+                  volume_size:           allocated_storage,
+                  delete_on_termination: true,
+                  volume_type:           "standard",
+                },
+              },
+            ],
+          )
+
+          new(response.id).tap do |instance|
+            instance.name = name
+            puts "Created an EC2 Instance (#{instance.id}) on a Subnet (#{subnet.id})."
+          end
+        end
+
+        def next_number(subnet:)
+          "%03d" % (where(subnet_id: subnet.id).count + 1)
+        end
+      end
+    end
+  end
+end

data/lib/akashi/ec2/key_pair.rb

@@ -0,0 +1,22 @@
+require "base64"
+
+module Akashi
+  class Ec2
+    class KeyPair < Akashi::Ec2::Base
+      def_delegators :@object, :fingerprint, :name
+
+      class << self
+        def create
+          response = Akashi::Aws.ec2.client.import_key_pair(
+            key_name:            Akashi.name,
+            public_key_material: Base64.encode64(Akashi.manifest.ec2.public_key)
+          )
+
+          new(response[:key_name]).tap do |instance|
+            puts "Created a KeyPair (#{instance.id})."
+          end
+        end
+      end
+    end
+  end
+end

data/lib/akashi/ec2/monkey_patch.rb

@@ -0,0 +1,7 @@
+module AWS
+  class EC2
+    class KeyPair
+      alias id name
+    end
+  end
+end

data/lib/akashi/ec2.rb

@@ -0,0 +1,10 @@
+require "akashi/ec2/base"
+require "akashi/ec2/ami"
+require "akashi/ec2/key_pair"
+require "akashi/ec2/monkey_patch"
+require "akashi/ec2/instance"
+
+module Akashi
+  class Ec2
+  end
+end

data/lib/akashi/elb/base.rb

@@ -0,0 +1,11 @@
+module Akashi
+  class Elb
+    class Base < Akashi::Base
+      class << self
+        def service_class
+          @service_class ||= "ELB"
+        end
+      end
+    end
+  end
+end

data/lib/akashi/elb/load_balancer.rb

@@ -0,0 +1,53 @@
+module Akashi
+  class Elb
+    class LoadBalancer < Akashi::Elb::Base
+      def_delegators :@object, :dns_name, :name, :subnet_ids, :configure_health_check
+
+      def modify_attributes(options)
+        Akashi::Aws.elb.client.
+          modify_load_balancer_attributes(options.merge({ load_balancer_name: name }))
+      end
+
+      class << self
+        def create(security_group:, subnets:, ssl_certificate:)
+          Akashi::Aws.elb.client.create_load_balancer(
+            load_balancer_name: Akashi.name,
+            security_groups:    [ security_group.id ],
+            subnets:            Array.wrap(subnets).map(&:id),
+            listeners:          [
+              {
+                protocol:           "HTTPS",
+                load_balancer_port: 443,
+                instance_protocol:  "HTTP",
+                instance_port:      80,
+                ssl_certificate_id: ssl_certificate.arn,
+              }
+            ],
+          )
+
+          new(Akashi.name).tap do |instance|
+            instance.modify_attributes(
+              load_balancer_attributes: {
+                cross_zone_load_balancing: {
+                  enabled: true,
+                },
+                connection_draining: {
+                  enabled: true,
+                  timeout: 300,
+                },
+              },
+            )
+            instance.configure_health_check(
+              target:              Akashi.manifest.elb.health_check.target,
+              interval:            60,
+              timeout:             30,
+              unhealthy_threshold: 2,
+              healthy_threshold:   2,
+            )
+            puts "Created a LoadBalancer(#{instance.name})."
+          end
+        end
+      end
+    end
+  end
+end

data/lib/akashi/elb/ssl_certificate.rb

@@ -0,0 +1,44 @@
+require "openssl"
+
+module Akashi
+  class Elb
+    class SslCertificate < Akashi::Elb::Base
+      def_delegators :@object, :arn, :name, :delete
+
+      class << self
+        def create
+          ssl_certificate = Akashi.manifest.elb.ssl_certificate
+
+          certificate_chain  = ssl_certificate.certificate_chain
+          private_key_path   = ssl_certificate.private_key_path
+          server_certificate = ssl_certificate.server_certificate
+
+          options = {
+            certificate_body:        server_certificate,
+            private_key:             OpenSSL::PKey::RSA.new(File.read(private_key_path)).to_pem,
+            server_certificate_name: Akashi.name,
+          }
+          options.merge!({ certificate_chain: certificate_chain }) if !!certificate_chain
+
+          response = Akashi::Aws.iam.client.upload_server_certificate(options)
+
+          new(response[:server_certificate_metadata][:server_certificate_name]).tap do |instance|
+            puts "Created a SSL Certificate (#{instance.name})."
+          end
+        end
+
+        def all
+          collection.map { |object| new(object.name) }
+        end
+
+        def service_class
+          @service_class ||= "IAM"
+        end
+
+        def object_class
+          @object_class ||= "ServerCertificate"
+        end
+      end
+    end
+  end
+end

data/lib/akashi/elb.rb

@@ -0,0 +1,8 @@
+require "akashi/elb/base"
+require "akashi/elb/load_balancer"
+require "akashi/elb/ssl_certificate"
+
+module Akashi
+  class Elb
+  end
+end

data/lib/akashi/rds/base.rb

@@ -0,0 +1,11 @@
+module Akashi
+  class Rds
+    class Base < Akashi::Base
+      class << self
+        def service_class
+          @service_class ||= "RDS"
+        end
+      end
+    end
+  end
+end

data/lib/akashi/rds/db_instance.rb

@@ -0,0 +1,43 @@
+module Akashi
+  class Rds
+    class DbInstance < Akashi::Rds::Base
+      def_delegators :@object, :db_instance_status, :db_name, :endpoint, :endpoint_port,
+                               :engine, :engine_version, :vpc_id
+
+      class << self
+        def create(security_group:)
+          password = random_password(10)
+
+          response = Akashi::Aws.rds.client.create_db_instance(
+            db_name:                    Akashi.name(separator: "_"),
+            db_instance_identifier:     Akashi.name,
+            allocated_storage:          Akashi.manifest.rds.allocated_storage,
+            db_instance_class:          Akashi.manifest.rds.instance_class,
+            engine:                     "mysql",
+            master_username:            Akashi.application,
+            master_user_password:       password,
+            multi_az:                   !!Akashi.manifest.rds.multi_az,
+            availability_zone:          Akashi.manifest.rds.availability_zone,
+            vpc_security_group_ids:     [ security_group.id ],
+            db_subnet_group_name:       Akashi.name,
+            engine_version:             Akashi.manifest.rds.engine_version,
+            auto_minor_version_upgrade: true,
+            publicly_accessible:        false,
+          )
+
+          new(response[:db_instance_identifier]).tap do |instance|
+            puts "Created a RDS (#{instance.id}). Password is \"#{password}\"."
+          end
+        end
+
+        def random_password(length)
+          [*0..9, *"a".."z", *"A".."Z"].sample(length).join
+        end
+
+        def object_class
+          @object_class ||= "DBInstance"
+        end
+      end
+    end
+  end
+end

data/lib/akashi/rds/subnet_group.rb

@@ -0,0 +1,18 @@
+module Akashi
+  class Rds
+    class SubnetGroup
+      class << self
+        def create(subnets:)
+          response = Akashi::Aws.rds.client.create_db_subnet_group(
+            db_subnet_group_name:        Akashi.name,
+            db_subnet_group_description: Akashi.name,
+            subnet_ids:                  Array.wrap(subnets).map(&:id)
+          )
+          id = response[:db_subnet_group_name]
+
+          puts "Created a SubnetGroup (#{id})."
+        end
+      end
+    end
+  end
+end

data/lib/akashi/rds.rb

@@ -0,0 +1,8 @@
+require "akashi/rds/base"
+require "akashi/rds/db_instance"
+require "akashi/rds/subnet_group"
+
+module Akashi
+  class Rds
+  end
+end

data/lib/akashi/version.rb

@@ -0,0 +1,3 @@
+module Akashi
+  VERSION = "0.0.1"
+end

data/lib/akashi/vpc/base.rb

@@ -0,0 +1,6 @@
+module Akashi
+  class Vpc
+    class Base < Akashi::Ec2::Base
+    end
+  end
+end