skyed 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d4681aeb911a86e19ff48c5728d0a96d85896d76
+  data.tar.gz: b0753c54b56e424066bf53cdce98f34c2c8eea9c
+SHA512:
+  metadata.gz: f6ac335374e0d6550126002c93a388f6b0e758ad58a03929b92770d55a6e2474a058eb56685cc5a3a49d0ad835b52683663900d6314c1a2e1d6c643b60ab58eb
+  data.tar.gz: 494946d8482f9d70a99297ee46815ece8e882aa045a8adb61cf281182123baefc555633978d92cfee916819b04db6be3cc69100ae61dee367fdeeac6f21f436e

data/bin/skyed

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+project_path = File.dirname(File.dirname(__FILE__))
+$LOAD_PATH.unshift project_path + '/lib'
+
+require 'gli'
+require 'skyed'
+
+include GLI::App
+
+program_desc 'Are you surrounded by sky?'
+Skyed::Settings.load!
+
+switch [:q, :quiet]
+
+require 'skyed/commands'
+
+exit run(ARGV)

data/lib/skyed.rb

@@ -0,0 +1,10 @@
+require 'skyed/destroy'
+require 'skyed/run'
+require 'skyed/deploy'
+require 'skyed/init'
+require 'skyed/settings'
+
+# Skyed is a set of tools for cloud computing
+module Skyed
+  VERSION = '0.1.1'
+end

data/lib/skyed/commands.rb

@@ -0,0 +1,49 @@
+desc 'Initialize skyed'
+long_desc 'Sets up skyed configuration for a repository'
+
+command :init do |cmd|
+  cmd.flag :remote, default_value: nil,
+                    type: String,
+                    desc: 'Remote to use in OpsWorks'
+  cmd.action do |global_options, options|
+    Skyed::Init.execute(global_options, options)
+  end
+end
+
+desc 'Deploy current setup'
+long_desc 'Deploys from current repository'
+
+command :deploy do |cmd|
+  cmd.action do |global_options|
+    Skyed::Deploy.execute(global_options)
+  end
+end
+
+desc 'Run specific recipes on instance'
+long_desc 'Runs specified recipes on all running instances'
+
+stack_desc = 'Stack to which the run affects.'
+layer_desc = 'Layer to which the run affects.'
+command :run do |cmd|
+  cmd.flag [:s, :stack], default_value: nil,
+                         type: String,
+                         desc: stack_desc
+  cmd.flag [:l, :layer], default_value: nil,
+                         type: String,
+                         desc: layer_desc
+  cmd.flag [:w, :wait_interval], default_value: 30,
+                                 type: Integer,
+                                 desc: 'Time to wait for AWS responses'
+  cmd.action do |global_options, options, args|
+    Skyed::Run.execute(global_options, options, args)
+  end
+end
+
+desc 'Destroy instance'
+long_desc 'Destroy instance'
+
+command :destroy do |cmd|
+  cmd.action do |global_options, options, args|
+    Skyed::Destroy.execute(global_options, options, args)
+  end
+end

data/lib/skyed/deploy.rb

@@ -0,0 +1,19 @@
+module Skyed
+  # This module encapsulates all the deploy command steps.
+  module Deploy
+    class << self
+      def execute(global_options)
+        fail 'Not initialized, please run skyed init' if Skyed::Settings.empty?
+        push_devel_branch(global_options)
+        output = `cd #{Skyed::Settings.repo} && vagrant up`
+        fail output unless $CHILD_STATUS.success?
+        $CHILD_STATUS.success?
+      end
+
+      def push_devel_branch(_global_options)
+        repo = Git.open(Skyed::Settings.repo)
+        repo.push(Skyed::Settings.remote_name, Skyed::Settings.branch)
+      end
+    end
+  end
+end

data/lib/skyed/destroy.rb

@@ -0,0 +1,19 @@
+module Skyed
+  # This module encapsulates all the destroy command steps.
+  module Destroy
+    class << self
+      def execute(_global_options, _options, _args)
+        repo_path = Skyed::Settings.repo
+        hostname = `cd #{repo_path} && vagrant ssh -c hostname`.strip
+        `cd #{repo_path} && vagrant destroy -f`
+        ow = Skyed::Init.ow_client
+        instances = ow.describe_instances(stack_id: Skyed::Settings.stack_id)
+        instances[:instances].each do |instance|
+          if instance[:hostname] == hostname
+            ow.deregister_instance(instance_id: instance[:instance_id])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/skyed/init.rb

@@ -0,0 +1,285 @@
+require 'English'
+require 'fileutils'
+require 'erb'
+require 'git'
+require 'aws-sdk'
+require 'highline/import'
+require 'digest/sha1'
+
+ACCESS_QUESTION = 'What is your AWS Access Key? '
+SECRET_QUESTION = 'What is your AWS Secret Key? '
+
+STACK = { name: '',
+          region: '',
+          service_role_arn: '',
+          default_instance_profile_arn: '',
+          default_os: 'Ubuntu 12.04 LTS',
+          default_ssh_key_name: '',
+          custom_cookbooks_source: {
+            type: 'git'
+          },
+          configuration_manager: {
+            name: 'Chef',
+            version: '11.10'
+          },
+          use_custom_cookbooks: true,
+          use_opsworks_security_groups: false
+        }
+
+module Skyed
+  # This module encapsulates all the init command steps.
+  module Init
+    class << self
+      def execute(global_options, options)
+        fail 'Already initialized' unless Skyed::Settings.empty?
+        Skyed::Settings.repo = repo_path(get_repo).to_s
+        branch global_options, options
+        credentials
+        opsworks_git_key
+        opsworks
+        vagrant
+        Skyed::Settings.save
+      end
+
+      def opsworks
+        opsworks = ow_client
+        params = stack_params
+        check_stack(opsworks, params[:name])
+        stack = opsworks.create_stack(params).data[:stack_id]
+        Skyed::Settings.stack_id = stack
+        Skyed::Settings.layer_id = opsworks.create_layer(
+          layer_params(stack)).data[:layer_id]
+      end
+
+      def check_stack(ow, name)
+        stacks = ow.describe_stacks[:stacks]
+        stack = stacks.select { |x| x[:name] == name }[0] || return
+        stack_summ = ow.describe_stack_summary(stack_id: stack[:stack_id])
+        delete_stack(ow, stack_summ[:stack_summary])
+      end
+
+      def delete_stack(ow, stack_summ)
+        total = stack_summ[:instances_count].values.compact.inject(:+)
+        total ||= 0
+        error_msg = "Stack with name #{stack_summ[:name]}"
+        error_msg += ' exists and contains instances'
+        fail error_msg unless total == 0
+        ow.delete_stack(stack_id: stack_summ[:stack_id])
+        File.delete(vagrantfile) if File.exist?(vagrantfile)
+      end
+
+      def layer_params(stack_id)
+        # TODO: Include extra layer parameters
+        { stack_id: stack_id,
+          type: 'custom',
+          name: "test-#{ENV['USER']}",
+          shortname: "test-#{ENV['USER']}",
+          custom_security_group_ids: ['sg-f1cc2498'] }
+      end
+
+      def stack_params
+        # TODO: Include extra stack parameters
+        result = STACK
+        result[:name]                         = ENV['USER']
+        result[:region]                       = region
+        result[:service_role_arn]             = Skyed::Settings.role_arn
+        result[:default_instance_profile_arn] = Skyed::Settings.profile_arn
+        result[:default_ssh_key_name]         = Skyed::Settings.aws_key_name
+        result[:custom_cookbooks_source]      = custom_cookbooks_source(
+          STACK[:custom_cookbooks_source])
+        result
+      end
+
+      def custom_cookbooks_source(base_source)
+        base_source[:url] = Skyed::Settings.remote_url
+        base_source[:revision] = Skyed::Settings.branch
+        base_source[:ssh_key] = read_key_file(Skyed::Settings.opsworks_git_key)
+        base_source
+      end
+
+      def read_key_file(key_file)
+        File.open(key_file, 'rb').read
+      end
+
+      def region
+        ENV['DEFAULT_REGION'] || 'us-east-1'
+      end
+
+      def ow_client(
+        access = Skyed::Settings.access_key,
+        secret = Skyed::Settings.secret_key,
+        region = ENV['AWS_REGION'])
+        region ||= 'us-east-1'
+        Aws::OpsWorks::Client.new(
+          access_key_id: access,
+          secret_access_key: secret,
+          region: region)
+      end
+
+      def vagrantfile
+        File.join(Skyed::Settings.repo, 'Vagrantfile')
+      end
+
+      def create_vagrant_files
+        provisioning_path = File.join(Skyed::Settings.repo, '.provisioning')
+        tasks_path = File.join(provisioning_path, 'tasks')
+        aws_path = File.join(provisioning_path, 'templates', 'aws')
+        create_template(Skyed::Settings.repo, 'Vagrantfile',
+                        'templates/Vagrantfile.erb')
+        create_template(tasks_path, 'ow-on-premise.yml',
+                        'templates/ow-on-premise.yml.erb')
+        create_template(aws_path, 'config.j2', 'templates/config.j2.erb')
+        create_template(aws_path, 'credentials.j2',
+                        'templates/credentials.j2.erb')
+      end
+
+      def vagrant
+        return if File.exist?(vagrantfile)
+        pip_install 'ansible'
+        create_directory(Skyed::Settings.repo, '.provisioning/templates/aws')
+        create_directory(Skyed::Settings.repo, '.provisioning/tasks')
+        create_vagrant_files
+      end
+
+      def create_template(base, subpath, template_file)
+        b = binding
+        folders = subpath.split('/')
+        template = ERB.new(
+          File.read(
+            File.join(
+              File.dirname(File.dirname(File.dirname(__FILE__))),
+              template_file)))
+        File.open(File.join(base, folders), 'w') do |f|
+          f.write(template.result b)
+        end
+      end
+
+      def create_directory(base, subpath)
+        folders = subpath.split('/')
+        new_dir = File.join(base, folders)
+        FileUtils.mkdir_p(new_dir)
+      end
+
+      def pip_install(package)
+        `pip list | grep #{package}`
+        return if $CHILD_STATUS.success?
+        `which pip`
+        easy_install 'pip' unless $CHILD_STATUS.success?
+        `sudo pip install #{package}`
+        fail "Can't install #{package}" unless $CHILD_STATUS.success?
+      end
+
+      def easy_install(package)
+        `easy_install #{package}`
+        fail "Can't install #{package}" unless $CHILD_STATUS.success?
+      end
+
+      def branch(global_options, options)
+        branch = "devel-#{Digest::SHA1.hexdigest Skyed::Settings.repo}"
+        repo = repo?(Skyed::Settings.repo)
+        repo.branch(branch).checkout
+        Skyed::Settings.branch = branch
+        remote_data = git_remote_data(repo, global_options, options)
+        Skyed::Settings.remote_name = remote_data[:name]
+        Skyed::Settings.remote_url = remote_data[:url]
+      end
+
+      def git_remote_data(repo, _global_options, options = {})
+        name ||= options[:remote]
+        name = ask_remote_name(
+          repo.remotes.map(&:name)) if repo.remotes.length > 1 && name.nil?
+        name = repo.remotes[0].name if name.nil?
+        select_remote(name, repo.remotes)
+      end
+
+      def select_remote(name, remotes)
+        url = nil
+        remotes.each do |remote|
+          url = remote.url if remote.name == name
+        end
+        if url.nil?
+          { name: remotes[0].name, url: remotes[0].url }
+        else
+          { name: name, url: url }
+        end
+      end
+
+      def ask_remote_name(remotes_names)
+        question = 'Which remote should be used for the git repository? '
+        ask(question + remotes_names.to_s)
+      end
+
+      def opsworks_git_key
+        question = 'Which ssh key should be used for the git repository? '
+        Skyed::Settings.opsworks_git_key = ask(question)
+      end
+
+      def credentials(
+        access       = ENV['AWS_ACCESS_KEY'],
+        secret       = ENV['AWS_SECRET_KEY'],
+        role_arn     = ENV['OW_SERVICE_ROLE'],
+        profile_arn  = ENV['OW_INSTANCE_PROFILE'],
+        aws_key_name = ENV['AWS_SSH_KEY_NAME'])
+        iam = aws_access_key(access, secret)
+        set_arns(iam, profile_arn, role_arn)
+        Skyed::Settings.aws_key_name = aws_key_name
+      end
+
+      def set_arns(iam, profile_arn, role_arn)
+        Skyed::Settings.role_arn     = role_arn || iam
+          .get_role(role_name: 'aws-opsworks-service-role')[:role][:arn]
+        key = :instance_profile
+        Skyed::Settings.profile_arn  = profile_arn || iam
+          .get_instance_profile(
+            instance_profile_name: 'aws-opsworks-ec2-role')[key][:arn]
+      end
+
+      def aws_access_key(access, secret)
+        access = ask(ACCESS_QUESTION) unless valid_credential?('AWS_ACCESS_KEY')
+        secret = ask(SECRET_QUESTION) unless valid_credential?('AWS_SECRET_KEY')
+        iam = iam_client(access, secret)
+        Skyed::Settings.access_key = access
+        Skyed::Settings.secret_key = secret
+        iam
+      end
+
+      def iam_client(
+        access = Skyed::Settings.access_key,
+        secret = Skyed::Settings.secret_key,
+        region = ENV['AWS_REGION'])
+        region ||= 'us-east-1'
+        Aws::IAM::Client.new(
+          access_key_id: access,
+          secret_access_key: secret,
+          region: region)
+      end
+
+      def valid_credential?(env_name)
+        ENV[env_name] != '' && !ENV[env_name].nil?
+      end
+
+      def repo_path(repo)
+        Pathname.new(repo.repo.path).dirname
+      end
+
+      def get_repo(path = '.', ask = true)
+        question = 'Which is your CM repository? '
+        repo = repo?(path)
+        if !repo
+          say("ERROR: #{path} is not a repository")
+          repo = get_repo(ask(question), false)
+        elsif ask
+          repo = get_repo(
+            ask(question) { |q| q.default = repo_path(repo).to_s }, false)
+        end
+        repo
+      end
+
+      def repo?(path)
+        Git.open(path)
+      rescue ArgumentError
+        return false
+      end
+    end
+  end
+end

data/lib/skyed/run.rb

@@ -0,0 +1,126 @@
+module Skyed
+  # This module encapsulates all the run command steps.
+  module Run
+    class << self
+      def execute(global_options, options, args)
+        if !options.nil? && options.key?(:stack) && !options[:stack].nil?
+          run(global_options, options, args)
+        else
+          recipes = check_recipes_exist(args)
+          check_vagrant
+          execute_recipes(Skyed::Init.ow_client, recipes)
+        end
+      end
+
+      def run(_global_options, options, args)
+        check_run_options(options)
+        ow = login
+        Skyed::Settings.stack_id = stack(ow, options)
+        Skyed::Settings.layer_id = layer(ow, options)
+        instances = running_instances(ow, Skyed::Settings.layer_id)
+        update_custom_cookbooks(ow, Skyed::Settings.stack_id, instances,
+                                options[:wait_interval])
+        execute_recipes(ow, args, instances, options[:wait_interval])
+      end
+
+      def deploy_status(ow, id)
+        deploy = ow.describe_deployments(deployment_ids: [id[:deployment_id]])
+        deploy[:deployments].map do |s|
+          s[:status]
+        end.compact
+      end
+
+      def wait_for_deploy(ow, deploy_id, wait = 0)
+        status = deploy_status(ow, deploy_id)
+        while status[0] == 'running'
+          sleep(wait)
+          status = deploy_status(ow, deploy_id)
+        end
+        status
+      end
+
+      def update_custom_cookbooks(ow, stack_id, instances, wait = 0)
+        command = { name: 'update_custom_cookbooks' }
+        wait_for_deploy(ow, ow.create_deployment(
+          stack_id: stack_id,
+          instance_ids: instances,
+          command: command), wait)
+      end
+
+      def running_instances(ow, layer_id)
+        instances = ow.describe_instances(layer_id: layer_id)
+        instances[:instances].map do |instance|
+          instance[:instance_id] if instance[:status] != 'stopped'
+        end.compact
+      end
+
+      def layer(ow, options)
+        layers = ow.describe_layers(stack_id: options[:stack])[:layers]
+        layer = nil
+        layers.each do |layer_reply|
+          id = layer_reply[:layer_id]
+          layer = id if id == options[:layer]
+        end
+        msg = "There's no such layer with id #{options[:layer]}"
+        fail msg unless layer
+        layer
+      end
+
+      def stack(ow, options)
+        stacks = ow.describe_stacks[:stacks]
+        stack = nil
+        stacks.each do |stack_reply|
+          id = stack_reply[:stack_id]
+          stack = id if id == options[:stack]
+        end
+        msg = "There's no such stack with id #{options[:stack]}"
+        fail msg unless stack
+        stack
+      end
+
+      def login
+        Skyed::Init.credentials if Skyed::Settings.empty?
+        Skyed::Init.ow_client
+      end
+
+      def check_run_options(options)
+        msg = 'Specify stack and layer or initialize for local management'
+        fail msg unless options[:stack] && options[:layer]
+      end
+
+      def check_vagrant
+        output = `cd #{Skyed::Settings.repo} && vagrant status`
+        msg = 'Vagrant failed'
+        fail msg unless $CHILD_STATUS.success?
+        msg = 'Vagrant machine is not running'
+        fail msg unless output =~ /running/
+      end
+
+      def check_recipes_exist(args)
+        recipes = args.select { |recipe| recipe_in_cookbook(recipe) }
+        msg = "Couldn't found #{args - recipes} recipes in repository"
+        fail msg unless recipes == args
+        recipes
+      end
+
+      def execute_recipes(ow, recipes, instances = nil, wait = 0)
+        command = { name: 'execute_recipes', args: { recipes: recipes } }
+        deploy_params = { stack_id: Skyed::Settings.stack_id, command: command }
+        deploy_params[:instance_ids] = instances unless instances.nil?
+        deploy_id = ow.create_deployment(deploy_params)
+        wait_for_deploy(ow, deploy_id, wait)
+      end
+
+      def recipe_in_cookbook(recipe)
+        cookbook, recipe = recipe.split('::')
+        recipe = 'default' if recipe.nil?
+        File.exist?(
+          File.join(
+            Skyed::Settings.repo,
+            cookbook,
+            'recipes',
+            "#{recipe}.rb"))
+      end
+    end
+  end
+end

data/lib/skyed/settings.rb

@@ -0,0 +1,40 @@
+module Skyed
+  # This module encapsulates settings for Skyed
+  module Settings
+    CONFIG_FILE = "#{ENV['HOME']}/.skyed"
+    @_settings = {}
+    attr_accessor :_settings
+
+    class << self
+      def load!(filename = CONFIG_FILE)
+        newsets = {}
+        newsets = YAML.load_file(filename) if File.file? filename
+        deep_merge!(@_settings, newsets)
+      end
+
+      def empty?
+        @_settings.empty?
+      end
+
+      def deep_merge!(target, data)
+        merger = proc do |_, v1, v2|
+          v1.is_a?(Hash) && v2.is_a?(Hash) ? v1.merge(v2, &merger) : v2
+        end
+        target.merge! data, &merger
+      end
+
+      def method_missing(name, *args)
+        if name.match(/.*=/)
+          @_settings[name.to_s.split('=')[0]] = args[0]
+        else
+          @_settings[name.to_s] ||
+            fail(NoMethodError, "unknown configuration root #{name}", caller)
+        end
+      end
+
+      def save(filename = CONFIG_FILE)
+        File.open(filename, 'w') { |f| YAML.dump @_settings, f }
+      end
+    end
+  end
+end

data/templates/Vagrantfile.erb

@@ -0,0 +1,40 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+ram = ENV['VAGRANT_RAM'] || '2048'
+aws_access_key_id = ENV['AWS_ACCESS_KEY_ID'] || ENV['AWS_ACCESS_KEY']
+aws_access_key_id ||= 'AAAAAA'
+aws_secret_access_key = ENV['AWS_SECRET_ACCESS_KEY'] || ENV['AWS_SECRET_KEY']
+aws_secret_access_key ||= 'AAAAAA'
+aws_session_token = ENV['AWS_SESSION_TOKEN'] || ''
+aws_default_region = ENV['AWS_DEFAULT_REGION'] || 'us-east-1'
+aws_opsworks_stack_id = '<%= Skyed::Settings.stack_id %>'
+aws_opsworks_layer_id = '<%= Skyed::Settings.layer_id %>'
+
+# Vagrantfile API/syntax version. Don't touch unless you know what you're doing!
+VAGRANTFILE_API_VERSION = '2'
+
+Vagrant.configure(VAGRANTFILE_API_VERSION) do |config|
+  config.vm.hostname = "test-#{ENV['USER']}"
+
+  config.vm.provider :virtualbox do |virtualbox, override|
+    override.vm.box = 'trusty-cloudimg-64'
+    override.vm.box_url = 'https://cloud-images.ubuntu.com/vagrant/trusty/current/trusty-server-cloudimg-amd64-vagrant-disk1.box'
+    override.vm.network :forwarded_port, host: 9200, guest: 9200
+    override.vm.network :forwarded_port, host: 9300, guest: 9300
+    virtualbox.memory = ram.to_i
+    virtualbox.cpus = 2
+  end
+
+  config.vm.provision :ansible do |ansible|
+    ansible.playbook = '.provisioning/tasks/ow-on-premise.yml'
+    ansible.extra_vars = {
+      aws_access_key_id: aws_access_key_id,
+      aws_secret_access_key: aws_secret_access_key,
+      aws_session_token: aws_session_token,
+      aws_default_region: aws_default_region,
+      aws_opsworks_stack_id: aws_opsworks_stack_id,
+      aws_opsworks_layer_id: aws_opsworks_layer_id
+    }
+  end
+end

data/templates/config.j2.erb

@@ -0,0 +1,2 @@
+[default]
+region = {{ aws_default_region }}

data/templates/credentials.j2.erb

@@ -0,0 +1,6 @@
+[default]
+aws_access_key_id = {{ aws_access_key_id }}
+aws_secret_access_key = {{ aws_secret_access_key }}
+{% if aws_session_token -%}
+aws_session_token = {{ aws_session_token }}
+{%- endif %}

data/templates/ow-on-premise.yml.erb

@@ -0,0 +1,52 @@
+- hosts: all
+  sudo: true
+  vars:
+    aws_access_key_id: ´{{ aws_access_key_id }}´
+    aws_secret_access_key: ´{{ aws_secret_access_key }}´
+    aws_session_token: ´{{ aws_session_token }}´
+    aws_default_region: ´{{ aws_default_region }}´
+    aws_opsworks_stack_id: ´{{ aws_opsworks_stack_id }}´
+    aws_opsworks_layer_id: ´{{ aws_opsworks_layer_id }}´
+  tasks:
+    - name: Install pip
+      apt: name=python-pip
+    - name: Install AWS CLI
+      pip: name=awscli
+    - name: Prepare directory for AWS credentials
+      file: path=/home/vagrant/.aws state=directory owner=vagrant group=vagrant mode=0700
+    - name: Setup AWS credentials
+      template: src=../templates/aws/credentials.j2 dest=/home/vagrant/.aws/credentials owner=vagrant group=vagrant mode=0600
+    - name: Setup AWS config
+      template: src=../templates/aws/config.j2 dest=/home/vagrant/.aws/config owner=vagrant group=vagrant mode=0644
+    - name: Register into opsworks
+      shell: aws opsworks register --infrastructure-class on-premises --local --stack-id {{ aws_opsworks_stack_id }}
+      args:
+          creates: /opt/aws/opsworks
+      sudo: false
+      register: ow_register
+    - name: Debug OW registration
+      debug: var=ow_register
+    - name: Save the instance ID
+      set_fact: ow_instance_id={{ ow_register.stderr.split()[-1] }}
+      when: ow_register|success
+    - name: Debug OW registration
+      debug: var=ow_instance_id
+    - name: Wait for the instance to be registered
+      shell: aws opsworks describe-instances --instance-id {{ ow_instance_id }} | grep -c registered
+      sudo: false
+      ignore_errors: true
+      register: result
+      until: result.stdout == "1"
+      retries: 30
+      delay: 10
+    - name: Debug registration
+      debug: var=result
+      when: result|failed
+    - name: Assign layer in opsworks
+      shell: aws opsworks assign-instance --instance-id {{ ow_instance_id }} --layer-id {{ aws_opsworks_layer_id}}
+      sudo: false
+      register: ow_assign
+      ignore_errors: true
+    - name: Debug OW layer assign
+      debug: var=ow_assign
+      when: ow_assign|failed

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification
+name: skyed
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Ignasi Fosch
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: git
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.2.8
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.2.8
+- !ruby/object:Gem::Dependency
+  name: aws-sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.0.33
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.0.33
+- !ruby/object:Gem::Dependency
+  name: gli
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.12.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.12.2
+- !ruby/object:Gem::Dependency
+  name: highline
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.6.21
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.6.21
+description: A cloudy gem
+email: natx@y10k.ws
+executables:
+- skyed
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/skyed
+- lib/skyed.rb
+- lib/skyed/commands.rb
+- lib/skyed/deploy.rb
+- lib/skyed/destroy.rb
+- lib/skyed/init.rb
+- lib/skyed/run.rb
+- lib/skyed/settings.rb
+- templates/Vagrantfile.erb
+- templates/config.j2.erb
+- templates/credentials.j2.erb
+- templates/ow-on-premise.yml.erb
+homepage: http://rubygems.org/gems/skyed
+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.3
+signing_key: 
+specification_version: 4
+summary: Are you surrounded by sky?
+test_files: []