iota-rb 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1a9d297ba0efe1224491d1e74799dc5cb262deb8
+  data.tar.gz: dc6bf64d7f880cdfe33bb0a1ca40f86858783aa0
+SHA512:
+  metadata.gz: 2f9e57c3f301b974a27777fbff6c7c170b526b89bc37fbaa14f4d0f65664b13c5bdbac802623ad4b6d122a679cf0b4c14f944afa63a881d2dc9f9b174d94d244
+  data.tar.gz: b628d72f25d8fb87d280012b93716e41e2bb7689eca3b328a10d81e5d82bed495c5ea049ee5724500ae44df2892e73729eaa58b083ec8d70cc8c24851ec95840

data/.gitignore

@@ -0,0 +1,38 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+Gemfile.lock
+.ruby-version
+.ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+
+*.swp

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.2.3
+before_install: gem install bundler -v 1.10.6

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 yuichiro-someya
+
+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,74 @@
+[![Build Status](https://travis-ci.org/ayemos/iota.svg)](https://travis-ci.org/ayemos/iota)
+
+# Iota
+
+It will help [Amazon Lambda](http://aws.amazon.com/lambda/) developer to, 
+- Create new function,
+- Deploy current code,
+- and to Rollback last deployment.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'iota'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install iota
+
+## Configuration
+The gem uses [aws-sdk-ruby](http://aws.amazon.com/sdk-for-ruby/) to get an access to AWS api-es.
+
+``` AWS_ACCESS_KEY_ID ``` and ``` AWS_SECRET_ACCESS_KEY ``` have to be set within your environment.
+
+```
+export AWS_ACCESS_KEY_ID = [YOUR_AWS_ACCESS_KEY_ID]
+export AWS_SECRET_ACCESS_KEY = [YOUR_AWS_SECRET_ACCESS_KEY]
+```
+
+## Usage & Basic Workflow
+
+### Create new Lambda Function
+
+```
+iota create my_function --runtime nodejs
+```
+
+### Deploy current code to Remote
+
+You have to be in a directory created by 'create' command with 'iota.conf' file.
+
+Make some change on nodejs/python2.7 function and
+
+```
+iota deploy production
+or
+iota deploy development
+```
+
+### Rollback last deploy
+
+```
+iota rollback production
+or
+iota rollback development
+```
+
+You can also check those result vie AWS console.
+(https://[YOUR_REGION].console.aws.amazon.com/lambda/)
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/ayemos/iota.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "iota"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/exe/iota

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+retried = false
+begin
+  require 'iota'
+  require 'iota/cli'
+rescue LoadError
+  $:.unshift File.expand_path(File.join(__dir__, '..', 'lib'))
+  if retried
+    raise
+  else
+    retried = true
+    retry
+  end
+end
+
+Iota::CLI.start(ARGV)

data/iota.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'iota/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "iota-rb"
+  spec.version       = Iota::VERSION
+  spec.authors       = ["Yuichiro Someya"]
+  spec.email         = ["ayemos.y@gmail.com"]
+
+  spec.summary       = %q{Deploy toolset for Amazon Lambda functions.}
+  spec.description   = %q{Deploy toolset for Amazon Lambda functions..}
+  spec.homepage      = "https://github.com/ayemos/iota"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+
+  spec.add_dependency "aws-sdk", "~> 2"
+  spec.add_dependency "thor", "~> 0.19"
+end

data/lib/iota.rb

@@ -0,0 +1,11 @@
+require 'iota/version'
+require 'iota/function'
+
+require 'aws-sdk'
+
+module Iota
+  module_function
+  def client
+    @client ||= Aws::Lambda::Client.new
+  end
+end

data/lib/iota/cli.rb

@@ -0,0 +1,49 @@
+require 'iota'
+require 'iota/function'
+require 'thor'
+
+module Iota
+  class CLI < Thor
+    class_option :verbose, aliases: '-v', type: :boolean
+    map '--version'  => :print_version
+
+    desc "list-functions", "List lambda functions in AWS"
+    def list_functions
+      if options[:verbose]
+        puts Iota.client.list_functions.functions
+      else
+        puts Iota.client.list_functions.functions.map(&:function_name)
+      end
+    end
+
+    # TODO: deploy {produdcion, development} ...
+    desc "deploy {production, development}",
+      "Upload local lambda function to AWS and deploy."
+    method_option :path, aliases: '-p', type: :string
+    def deploy(environment)
+      require 'iota/cli/deploy'
+      Deploy.new(options, environment.to_sym, self).run
+    end
+
+    desc "rollback {production, development}",
+      "Rollback last deploy."
+    method_option :path, aliases: '-p', type: :string
+    def rollback(environment)
+      require 'iota/cli/rollback'
+      Rollback.new(options, environment.to_sym, self).run
+    end
+
+    desc "create FUNCTION_NAME", "Create new function."
+    method_option :path, aliases: '-p', type: :string
+    method_option :runtime, aliases: '-r', type: :string, required: true
+    def create(function_name)
+      require "iota/cli/create"
+      Create.new(options, function_name, self).run
+    end
+
+    desc "--version", "print the version"
+    def print_version
+      puts Iota::VERSION
+    end
+  end
+end

data/lib/iota/cli/create.rb

@@ -0,0 +1,36 @@
+module Iota
+  class CLI::Create
+    attr_reader :options, :function_name, :runtime, :thor, :path
+
+    def initialize(options, function_name, thor)
+      @options = options
+      @function_name = function_name
+      @thor = thor
+      @path = options[:path] || File.join('.', function_name)
+      @runtime = options[:runtime]
+    end
+
+    def run
+      if Dir.exist?(path)
+        thor.say("Directory '#{path}' already exists.", :red)
+        return
+      end
+
+      unless Iota::Function::DEFAULT_HANDLER.has_key?(runtime)
+        thor.say("Please specify valid runtime. (%s)" %
+                 Iota::Function::DEFAULT_HANDLER.keys.to_s)
+        return
+      end
+
+      function = Iota::Function.new(function_name, path)
+      thor.say("Creating function at directory #{path}.", :yellow)
+      function.create_local(runtime)
+      thor.say("Done.", :blue)
+
+      if function.exists?
+        thor.say("Note: Function #{function_name} already exists in remote. \\
+                Please be careful to deploy it to remote.", :yellow)
+      end
+    end
+  end
+end

data/lib/iota/cli/deploy.rb

@@ -0,0 +1,84 @@
+require 'yaml'
+
+module Iota
+  class CLI::Deploy
+    attr_reader :options, :environment, :thor, :path
+
+    def initialize(options, environment, thor)
+      @options = options
+      @environment = environment
+      @thor = thor
+      @path = options[:path] || '.'
+    end
+
+    def run
+      unless File.exists?('./iota.conf')
+        thor.say("Config file ('./iota.conf') is missing.", :red)
+        return
+      end
+
+      thor.say("Loading configuration.", :yellow)
+      config = YAML.load_file('./iota.conf')
+      thor.say("Done.", :blue)
+
+      unless Iota::Function::ENVIRONMENT_ALIAS_NAME_MAP.keys.include?(environment)
+        thor.say("Invalid environment #{environment}. \\
+          Please specify either 'production' or 'development'.", :red)
+        return
+      end
+
+      # TODO: not found
+      function_name = config['function_name']
+
+      function = Iota::Function.new(function_name, path)
+      if function.exists?
+        thor.say("Updating code...", :yellow)
+        function.update_code
+        thor.say("Done.", :blue)
+        new_version = function.publish_version.version
+        thor.say("Latest code is published as version:#{new_version}.", :yellow)
+
+        aliases = function.list_aliases
+
+        new_version_alias_name = Iota::Function::ENVIRONMENT_ALIAS_NAME_MAP[environment]
+        last_version_alias_name = new_version_alias_name +
+          Iota::Function::LAST_VERSION_SUFFIX
+
+        last_version_alias = aliases.select{|a| a.name == last_version_alias_name}.first
+        new_version_alias = aliases.select{|a| a.name == new_version_alias_name}.first
+
+        # last -> prod/dev, prod/dev -> new_version
+        unless last_version_alias.nil? || new_version_alias.nil?
+          thor.say("Updating aliases...", :yellow)
+          function.update_alias(last_version_alias_name, new_version_alias.function_version)
+          function.update_alias(new_version_alias_name, new_version)
+          thor.say("Done.", :blue)
+        else
+          thor.say("There's no aliases with name '#{last_version_alias_name}' \
+and/or '#{new_version_alias_name}'.", :red)
+        end
+      else
+        thor.say("Function '#{function_name}' doesn't seem to be exists.", :yellow)
+        y_or_n = thor.ask("Do you want to create new function '#{function_name}' ? (y/n)")
+        if y_or_n =~ /[yY]/
+          thor.say("Creating function '#{function_name}' ...", :yellow)
+          begin
+            function.create_function(config['runtime'], config['role'])
+          rescue ArgumentError
+            thor.say("ArgumentError occured. You might need to specify role arn \
+you want to pass to your function via 'iota.conf' file or ENV['AWS_LAMBDA_IAM_ROLE'].", :red)
+            return
+          end
+          thor.say("Done.", :blue)
+          thor.say("Setting aliases.", :yellow)
+          first_version = function.publish_version.version
+          Iota::Function::ENVIRONMENT_ALIAS_NAME_MAP.values.each do |alias_name|
+            function.create_alias(alias_name, first_version)
+            function.create_alias(alias_name << '_LAST', first_version)
+          end
+          thor.say("Done.")
+        end
+      end
+    end
+  end
+end

data/lib/iota/cli/rollback.rb

@@ -0,0 +1,67 @@
+require 'yaml'
+
+module Iota
+  class CLI::Rollback
+    attr_reader :options, :thor, :path, :environment
+
+    def initialize(options, environment, thor)
+      @options = options
+      @environment = environment
+      @thor = thor
+      @path = options[:path] || '.'
+    end
+
+    def run
+      unless File.exists?('./iota.conf')
+        thor.say("Config file ('./iota.conf') is missing.", :red)
+        return
+      end
+
+      thor.say("Loading configuration.", :yellow)
+      config = YAML.load_file('./iota.conf')
+      thor.say("Done.", :blue)
+
+      unless Iota::Function::ENVIRONMENT_ALIAS_NAME_MAP.keys.include?(environment)
+        thor.say("Invalid environment #{environment}. \
+Please specify either 'production' or 'development'.", :red)
+        return
+      end
+
+      # TODO: not found
+      function_name = config['function_name']
+
+
+      function = Iota::Function.new(function_name, path)
+      if function.exists?
+        aliases = function.list_aliases
+
+        current_version_alias_name = Iota::Function::ENVIRONMENT_ALIAS_NAME_MAP[environment]
+        last_version_alias_name = current_version_alias_name +
+          Iota::Function::LAST_VERSION_SUFFIX
+
+        last_version_alias = aliases.select{|a| a.name == last_version_alias_name}.first
+        current_version_alias = aliases.select{|a| a.name == current_version_alias_name}.first
+
+        # last -> current, current -> last
+        unless last_version_alias.nil? || current_version_alias.nil?
+          if last_version_alias.function_version == current_version_alias.function_version
+            thor.say("Can't rollback before deploy.", :yellow)
+            return
+          else
+            thor.say("Updating alias", :yellow)
+            function.update_alias(current_version_alias_name, last_version_alias.function_version)
+            thor.say("Version is now at #{last_version_alias.function_version}.", :yellow)
+            thor.say("Done.", :blue)
+          end
+        end
+      else
+        thor.say("Function #{function_name} doesn't seem to be exists.", :yellow)
+      end
+    end
+
+    private
+    def templates_path
+      File.expand_path(File.join(File.dirname(__FILE__), '../templates'))
+    end
+  end
+end

data/lib/iota/config.rb

@@ -0,0 +1,16 @@
+require 'iota'
+module Iota
+  Config = {
+    lambda_role: envar(%w(AWS_LAMBDA_IAM_ROLE_ARN AWS_LAMBDA_ROLE_ARN AMAZON_LAMBDA_ROLE_ARN))
+  }
+
+  private
+  def envar
+    keys.each do |key|
+      if ENV.key?(key)
+        return ENV[key]
+      end
+    end
+    nil
+  end
+end

data/lib/iota/function.rb

@@ -0,0 +1,199 @@
+require 'aws-sdk'
+require 'erb'
+
+require 'iota'
+
+module Iota
+  class Function
+    DEFAULT_HANDLER = {
+      'nodejs' => {
+        handler_name: 'index.handler',
+        file_name: 'index.js'
+      },
+      'python2.7' => {
+        handler_name: 'lambda_function.lambda_handler',
+        file_name: 'lambda_function.py'
+      }
+    }
+
+    RUNTIMES = DEFAULT_HANDLER.keys
+
+    ENVIRONMENT_ALIAS_NAME_MAP = {
+      production: 'PROD',
+      development: 'DEV'
+    }
+
+    # TODO: multiple last_versions, multiple rollback
+    PROD_VERSION_ALIAS_NAME = ENVIRONMENT_ALIAS_NAME_MAP[:production]
+    DEV_VERSION_ALIAS_NAME  = ENVIRONMENT_ALIAS_NAME_MAP[:development]
+
+    LAST_VERSION_SUFFIX = '_LAST'
+
+    IGNORES = %w(
+      node_modules
+      bin
+      src
+      test
+      iota_conf.rb
+    )
+
+    attr_reader :name, :path
+
+    def initialize(name, path)
+      @name = name
+      @path = path
+    end
+
+    def create_function(runtime, role)
+      if RUNTIMES.include? runtime
+        Dir.mktmpdir do |tmpdir|
+          zip_file_path = package_function(tmpdir)
+
+          handler = DEFAULT_HANDLER[runtime]
+
+          client.create_function({
+            function_name: name,
+            runtime: runtime,
+            handler: handler[:handler_name],
+            role: role || ENV['AWS_LAMBDA_IAM_ROLE'],
+            code: {
+              zip_file: File.open(zip_file_path, "rb")
+            }
+          })
+        end
+      end
+    end
+
+    def create_local(runtime)
+      Dir.mkdir path
+      handler = DEFAULT_HANDLER[runtime]
+
+      # write function
+      File.open(File.join(path, handler[:file_name]), "w") do |file|
+        template = File.read(File.join(templates_path, template_file_name[runtime]))
+        template_code = ERB.new(template).result(binding)
+        file.write(template_code)
+      end
+
+      # write config
+      # TODO: 'iota.conf' is hard-coded
+      File.open(File.join(path, 'iota.conf'), "w") do |file|
+        role = ENV['AWS_LAMBDA_IAM_ROLE'] || ''
+        template = File.read(File.join(templates_path, template_file_name['config']))
+        template_config = ERB.new(template).result(binding)
+        file.write(template_config)
+      end
+
+      path
+    end
+
+    # list versions
+    def list_versions
+      client.list_versions_by_function({
+        function_name: name
+      }).versions
+    end
+
+    # list aliases
+    def list_aliases
+      client.list_aliases({
+        function_name: name
+      }).aliases
+    end
+
+    def exists?
+      begin
+        !!remote
+      rescue Aws::Lambda::Errors::ResourceNotFoundException
+        false
+      end
+    end
+
+    def remote
+      client.get_function({
+          function_name: name
+      })
+    end
+
+    def update_alias(alias_, target_version)
+      client.update_alias({
+        function_name: name,
+        name: alias_,
+        function_version: target_version
+      })
+    end
+
+    def update_code
+      Dir.mktmpdir do |tmpdir|
+        zip_file_path = package_function(tmpdir)
+        resp = client.update_function_code(
+          function_name: name,
+          zip_file: File.open(zip_file_path, "rb"),
+        )
+        return resp
+      end
+    end
+
+    def publish_version
+      client.publish_version({
+        function_name: name
+      })
+    end
+
+    def create_alias(alias_name, version='$LATEST')
+      client.create_alias({
+        function_name: name,
+        name: alias_name,
+        function_version: version
+      })
+    end
+
+    private
+    def client
+      Iota.client
+    end
+
+    def package_function(target_dir)
+      unless File.exist?(path) && File.directory?(path)
+        # TODO: Change flow
+        puts "wrong function path: #{path}"
+      end
+
+      Dir.chdir(path) do
+        build_script = File.join("bin", "build")
+        if File.exist?(build_script) && File.executable?(build_script)
+          puts "Building..."
+          system(build_script)
+        end
+      end
+
+      Dir[File.join(path, '*')].each do |path|
+        next if IGNORES.include?(File.basename(path))
+        FileUtils.cp(path, File.join(target_dir, File.basename(path)))
+      end
+
+      Dir.chdir(target_dir) do
+        if File.exist?('package.json')
+          system("npm", "install", "--production")
+        elsif File.exist?('requirements.txt')
+          system("pip", "install", "-r", "requirements.txt", "-t", ".")
+        end
+        system("zip", "-r", "lambda.zip", ".")
+      end
+
+      File.join(target_dir, "lambda.zip")
+    end
+
+    def template_file_name
+      {
+        'nodejs' => 'index.js.tt',
+        'python2.7' => 'lambda_function.py.tt',
+        'config' => 'iota.conf.tt'
+      }
+    end
+
+    def templates_path
+      File.expand_path(File.join(File.dirname(__FILE__), 'templates'))
+    end
+  end
+end

data/lib/iota/templates/index.js.tt

@@ -0,0 +1,10 @@
+console.log('Loading function');
+
+exports.handler = function(event, context) {
+    //console.log('Received event:', JSON.stringify(event, null, 2));
+    console.log('value1 =', event.key1);
+    console.log('value2 =', event.key2);
+    console.log('value3 =', event.key3);
+    context.succeed(event.key1);  // Echo back the first key value
+    // context.fail('Something went wrong');
+};

data/lib/iota/templates/iota.conf.tt

@@ -0,0 +1,3 @@
+function_name: <%= name || '' %>
+runtime: <%= runtime || `` %>
+role: <%= role || '' %>

data/lib/iota/templates/lambda_function.py.tt

@@ -0,0 +1,11 @@
+import json
+
+print('Loading function')
+
+def lambda_handler(event, context):
+    #print("Received event: " + json.dumps(event, indent=2))
+    print("value1 = " + event['key1'])
+    print("value2 = " + event['key2'])
+    print("value3 = " + event['key3'])
+    return event['key1']  # Echo back the first key value
+    #raise Exception('Something went wrong')

data/lib/iota/version.rb

@@ -0,0 +1,3 @@
+module Iota
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,136 @@
+--- !ruby/object:Gem::Specification
+name: iota-rb
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Yuichiro Someya
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-12-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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: 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: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+description: Deploy toolset for Amazon Lambda functions..
+email:
+- ayemos.y@gmail.com
+executables:
+- iota
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- exe/iota
+- iota.gemspec
+- lib/iota.rb
+- lib/iota/cli.rb
+- lib/iota/cli/create.rb
+- lib/iota/cli/deploy.rb
+- lib/iota/cli/rollback.rb
+- lib/iota/config.rb
+- lib/iota/function.rb
+- lib/iota/templates/index.js.tt
+- lib/iota/templates/iota.conf.tt
+- lib/iota/templates/lambda_function.py.tt
+- lib/iota/version.rb
+homepage: https://github.com/ayemos/iota
+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.4.5.1
+signing_key: 
+specification_version: 4
+summary: Deploy toolset for Amazon Lambda functions.
+test_files: []