deis_deploy 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0a57435f77ae92b00838d768f60061cccf920521
+  data.tar.gz: f0e6faa2afb1d9ced144a619f69bb6a7a7f7dce4
+SHA512:
+  metadata.gz: 9ef4db92538d47ce0afdfc5f5c1bc2855b1377d0f696591ccc8fafbcc611fabe8f8ef6252b0db7285282d229a7cda559e5d08d7ea86d0fa6b3dc8d4f0b1088ce
+  data.tar.gz: 316c93427808d327e6357ef06dc7837a51bdf6061cd529d8b245bc43d535af95709eebee7e4da468f99bcc6413c2fdeecd3e9adaa8623cc43712e4d8be22dd24

data/.gitignore

@@ -0,0 +1 @@
+*.gem

data/.ruby-version

@@ -0,0 +1 @@
+2.1.2

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/README.md

@@ -0,0 +1,22 @@
+# DEIS DEPLOYMENT #
+
+Gem to make deploying to deis much easier.
+
+## Install & Setup ##
+
+<code>gem install deis_deploy</code>
+
+## Usage ##
+
+<code>cd $REPO_DIR</code>
+<code>deisConfig name</code>
+this will give you app a name, optional
+<code>deisConfig set $ENV $VARNAME $VALUE</code>
+sets a variable for this application
+<code>deisConfig list</code>
+this will show all config values
+<code>deisConfig domain $ENV $DOMAIN</code>
+<code>deisConfig domains $ENV</code>
+lists all domains
+<code>deisDeploy staging</code>
+deploys to staging cluster

data/bin/deisConfig

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+lib = File.expand_path(File.dirname(__FILE__) + '/../lib')
+$LOAD_PATH.unshift(lib) if File.directory?(lib) && !$LOAD_PATH.include?(lib)
+
+require "deis_deploy"
+DEIS::Config.start(ARGV)

data/bin/deisDeploy

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+lib = File.expand_path(File.dirname(__FILE__) + '/../lib')
+$LOAD_PATH.unshift(lib) if File.directory?(lib) && !$LOAD_PATH.include?(lib)
+
+require "deis_deploy"
+DEIS::Deploy.start(ARGV)

data/deis_deploy.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "deis_deploy/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "deis_deploy"
+  spec.version = DEIS::VERSION
+  spec.authors = ["Charles Marshall"]
+  spec.email = ["cm56marshall@gmail.com"]
+  spec.summary = %q{ }
+  spec.description = %q{ }
+  spec.homepage = ""
+  spec.license = "MIT"
+  spec.files = `git ls-files -z`.split("\x0")
+  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.required_ruby_version = '>= 2.0'
+
+  spec.add_dependency "colorize", "~> 0.7"
+  spec.add_dependency "bundler", "~> 1.5"
+  spec.add_dependency "thor", "~> 0.19"
+  spec.add_dependency "faker", "~> 1.4"
+  spec.add_dependency "net-ssh", "~> 2.9"
+
+  spec.post_install_message = ""
+
+end

data/lib/deis_deploy.rb

@@ -0,0 +1,27 @@
+require "deis_deploy/version"
+require "utils"
+require "ssh"
+require "deis_deploy/strings"
+
+module DEIS
+  require "thor"
+  require "faker"
+  require 'fileutils'
+  require 'json'
+  # utils
+
+  require "deis_deploy/git"
+  require "deis_deploy/file_locations"
+  require "deis_deploy/validations"
+
+  # thor
+  require "deis_deploy/deploy"
+  require "deis_deploy/config"
+  # formatting vars
+  FORMAT_OK = "\e[0;32m%#-40s\t%5s\e[0m\n"
+  FORMAT_ERROR = "\e[33;40m%#-40s\t%5s\e[0m\n"
+  FORMAT_FATAL = "\e[0;31m%#-40s\t%5s\e[0m\n"
+
+end
+
+String::log_level = ENV['DEIS_GEM_LOG_LEVEL'].to_i if ! ENV['DEIS_GEM_LOG_LEVEL'].nil?

data/lib/deis_deploy/config.rb

@@ -0,0 +1,280 @@
+module DEIS
+
+  class Config < Thor
+    extend Utils
+    include Utils
+
+    desc "set <env> <varname> <value>", "Set <var> to <value> for <env>"
+    def set(env, varname, value)
+      DEIS::Validations.config
+      stored = DEIS::Config.data
+      current = if stored.nil? then {} else stored end
+      name = DEIS::Config.full_name(env)
+      "Setting #{varname} to #{value} in #{env}".info
+      "Using name: #{name}".log
+      sub_config = if !current[name].nil? && !current[name]["config"].nil? then current[name]["config"] else {:RACK_EV => env, :RAILS_ENV => env} end
+      sub_config[varname] = value
+      current[name] = {
+        :deis_name => "#{name}",
+        :dir => "#{name}-#{Time.now.to_i}",
+        :remote => DEIS::Git.remote,
+        :repo => DEIS::Git.repo,
+        :env => env,
+        :config => sub_config,
+        :removed_config => []
+      }
+      # log output
+      DEIS::Config.save(current)
+      "Complete (run 'deisDeploy #{env}' to deploy changes)".important
+    end
+
+    desc "domain <env> <domain_without_schema>", "Add a custom domain"
+    def domain(env="staging", domain)
+      DEIS::Validations.config
+      stored = DEIS::Config.data
+      current = if stored.nil? then {} else stored end
+      name = DEIS::Config.full_name(env)
+      "Adding domain #{domain} to #{env}".info
+      "Using name: #{name}".log
+      if current.has_key?(name)
+        current[name]["url"] = {} if current[name]["url"].nil?
+        current[name]["url"][env] = [] if current[name]["url"][env].nil?
+        current[name]["url"][env].push(domain)
+        DEIS::Config.save(current)
+        "Complete (run 'deisDeploy #{env}' to deploy changes)".important
+      else
+        "No config values set, create those first".fatal
+        exit 1
+      end
+    end
+
+    desc "domains <env>", "List all domains in <env>"
+    def domains(env="staging")
+      DEIS::Validations.config
+      stored = DEIS::Config.data
+      name = DEIS::Config.full_name(env)
+      current = if stored.nil? then {} else stored end
+      "Listing domains in #{env}..".info
+      if current.has_key?(name) && current[name].has_key?("url") && current[name]["url"].has_key?(env)
+        "Found domains".log
+        printf(DEIS::FORMAT_OK, "Domain", "")
+        printf(DEIS::FORMAT_OK, "-------------------------------", "")
+        current[name]["url"][env].each{|v| printf(DEIS::FORMAT_OK, "#{v}", "") }
+      else
+        "No domains found".info
+      end
+      "Complete".important
+    end
+
+    desc "list <env>", "List all config vars in <env>"
+    def list(env="staging")
+      DEIS::Validations.config
+      stored = DEIS::Config.data
+      name = DEIS::Config.full_name(env)
+      "Getting config data for #{name}\n".info
+      if !stored.nil? && !name.nil? && !stored[name].nil? && !stored[name]["config"].nil?
+        "Found data for #{name}".log
+        printf(DEIS::FORMAT_OK, "Name", "Value")
+        printf(DEIS::FORMAT_OK, "-------------------------------", "---------")
+        stored[name]['config'].each {|k,v| printf(DEIS::FORMAT_OK, "#{k}", "#{v}") }
+      else
+        "No data".info
+      end
+      "checking for config data that will be removed..".log
+      if !stored.nil? && !name.nil? && !stored[name].nil? && !stored[name]["removed_config"].nil? && stored[name]["removed_config"].size > 0
+        "\nThe following config items are waiting to be removed".info
+        printf(DEIS::FORMAT_OK, "Name", "Value")
+        printf(DEIS::FORMAT_OK, "-------------------------------", "---------")
+        stored[name]['removed_config'].each {|r| printf(DEIS::FORMAT_OK, "#{r['k']}", "#{r['v']}") }
+      end
+
+      "Complete".important
+    end
+
+    desc "rm <env> <varname>", "Remove the <varname> from the config"
+    def rm(env, varname)
+      DEIS::Validations.config
+      "Removing #{varname} from #{env}".info
+      stored = DEIS::Config.data
+      if !stored.nil?
+        name = DEIS::Config.full_name(env)
+        "Found data store for #{name}".log
+        if !stored[name].nil? && !stored[name]["config"].nil? && stored[name]["config"].has_key?(varname)
+          value = stored[name]["config"][varname]
+          "Value was #{value}".log
+          stored[name]["removed_config"] = [] if ! stored[name].has_key?("removed_config")
+          stored[name]["removed_config"].push( {:k => varname, :v => value} )
+          stored[name]["config"].tap{|r| r.delete(varname) }
+          DEIS::Config.save(stored)
+        end
+      end
+      "Complete (run 'deisDeploy deis_unset_config #{env}' to deploy changes)".important
+    end
+
+
+    desc "name <name>", "set the name of the app if its not been done before"
+    def name(name)
+      DEIS::Validations.config
+      file = DEIS::Config.name_storage+DEIS::Git.repo+".json"
+      if File.exists?(file)
+        "Cannot set name, use rename instead".fatal
+        exit
+      end
+      data = [ {:name => name, :active => true} ].to_json
+      File.open(file, "w") {|f| f.write( data ) }
+      "Complete".important
+    end
+
+    desc "names", "View all names used for this repo"
+    def names
+      DEIS::Validations.config
+      file = DEIS::Config.name_storage+DEIS::Git.repo+".json"
+      printf(DEIS::FORMAT_OK, "Name", "")
+      printf(DEIS::FORMAT_OK, "-------------------------------", "")
+      JSON.parse( File.open(file, "r"){|f| f.read} ).each{ |row| printf(DEIS::FORMAT_OK, row['name'], "")}
+    end
+
+    # fetch all names
+    def self.names(repo=nil)
+      repo = DEIS::Git.repo if repo.nil?
+      file = DEIS::Config.name_storage+repo+".json"
+      if File.exists?(file)
+        return JSON.parse( File.open(file, "r"){|f| f.read} )
+      else
+        return []
+      end
+    end
+
+    def self.save_names(names, repo=nil)
+      repo = DEIS::Git.repo if repo.nil?
+      file = DEIS::Config.name_storage+repo+".json"
+      if names.class == Array
+        names = names.to_json
+      end
+      File.open(file, "w") {|f| f.write( names ) }
+    end
+
+    desc "rename <env> <new_name>", "generate a new name"
+    def rename(env, newname=nil)
+      DEIS::Validations.config
+      repo = DEIS::Git.repo
+      "Warning, this may break deployed versions of this app.".warning
+      newname = DEIS::Config.new_name(repo) if newname.nil?
+      # find the current name
+      currentname = DEIS::Config.full_name(env)
+      current_short_name = DEIS::Config.name
+      "#{currentname}".log
+      names = DEIS::Config.names(repo)
+      exists = names.select{ |row| row['name'] == newname}
+      if exists.nil? || exists.size == 0
+        "Renaming #{current_short_name} to #{newname}".log
+        # adjust the name file
+        names = names.select!{|row| row['name'] != current_short_name}
+        names = [] if names.nil?
+        names = names.push({:name => newname, :active => true})
+        # adjust config file
+        stored = DEIS::Config.data
+        if stored.has_key?(currentname)
+          key = DEIS::Config.full_name(env, repo, newname)
+          stored[key] = stored[currentname]
+          stored[key]['deis_name'] = newname
+          stored.delete(currentname)
+          DEIS::Config.save(stored)
+          DEIS::Config.save_names(names.to_json, repo)
+          "Renamed to #{newname}".info
+          "Complete".important
+        end
+      else
+        "Cannot rename, #{newname} has already been used".fatal
+      end
+    end
+
+    # save the config array to a file
+    def self.save(array)
+      file = DEIS::Config.config_storage+"#{DEIS::Git.repo}.json"
+      data = array.to_json
+      File.open(file, "w") {|f| f.write( data ) }
+    end
+
+    #
+    def self.deis_end_point
+      self.target_host("deis_router_end_point")
+    end
+
+    # check for / generate a name and store that name in the config file
+    def self.name
+      repo = DEIS::Git.repo
+      names = DEIS::Config.names(repo)
+      if names.size > 0
+        name = DEIS::Config.existing_name(repo)
+        "Found existing name: #{name}".log
+      else
+        name =  DEIS::Config.generate_name(repo)
+        "Created name: #{name}".log
+      end
+      return name
+    end
+
+    def self.existing_name(repo=nil)
+      repo = DEIS::Git.repo if repo.nil?
+      names = DEIS::Config.names(repo)
+      name = nil
+      if names && names.size > 0
+         content = names.select{|r| r["active"]}
+         name = if !content.nil? then content.first["name"] end
+      end
+      name
+    end
+
+    def self.new_name(repo=nil)
+      Faker::App.name.downcase.gsub(" ", "-")
+    end
+    def self.generate_name(repo)
+      name = DEIS::Config.new_name(repo)
+      names = DEIS::Config.names(repo)
+      data = names.push({:name => name, :active => true} ).to_json
+      DEIS::Config.save_names(data, repo)
+      name
+    end
+
+    def self.full_name(env="staging", repo=nil, name=nil)
+      repo = DEIS::Git.repo if repo.nil?
+      name = self.name if name.nil?
+      repo+"-"+name+"-"+env
+    end
+
+    def self.name_storage
+      self.file_store(DEIS::NAMES_STORE)
+    end
+    # make and return the directory path for data storage
+    def self.config_storage
+      self.file_store(DEIS::CONFIG_STORE)
+    end
+
+    # fetch & parse json file containing the data for this app
+    def self.data
+      self.config_data
+    end
+
+
+    # find and return current config
+    def self.current(env="staging")
+      name = DEIS::Config.full_name(env)
+      "found config name: #{name}".log
+      if DEIS::Config.data.has_key?(name)
+        return DEIS::Config.data[name]
+      end
+      return nil
+    end
+
+    def self.save_current(env, config, name=nil)
+      name = DEIS::Config.full_name(env) if name.nil?
+      stored = DEIS::Config.data
+      current = if stored.nil? then {} else stored end
+      current[name] = config
+      DEIS::Config.save(current)
+    end
+
+  end
+
+end

data/lib/deis_deploy/deploy.rb

@@ -0,0 +1,172 @@
+module DEIS
+
+  class Deploy < Thor
+    extend Utils
+    include Utils
+
+    desc "staging", "Deploy to staging"
+    def staging
+      env = "staging"
+      name = DEIS::Config.name
+      host = self.target_host(env)
+      "Deploying '#{name}' to '#{env}' on '#{host}'".info
+      # fetch config data for this name
+      config = DEIS::Config.current(env)
+      # run validations
+      DEIS::Validations.deploy(env, host, config)
+      if ! config.nil?
+        # clone repo to $HOME/APPS/$FULL_NAME (swap if exists - add to saved config data)
+        # fetch
+        # checkout to matching branch
+        self.checkout(env,host, config)
+        # deis create $name
+        self.deis_create(env, host, config)
+        # add domain
+        self.deis_domain(env, host, config)
+        # create deis config command and run it
+        self.deis_unset_config(env, host, config)
+        self.deis_config(env, host, config)
+
+        # git push deis $branch
+        self.push(env, host, config)
+      end
+    end
+
+    desc "push <env> <host> <config>", "Push to deis for building"
+    def push(env, host=nil, config=nil)
+      host = self.target_host(env) if host.nil?
+      config = DEIS::Config.current(env) if config.nil? || config.class != Hash
+      "Deploying..".info
+      ssh = SSH.new({:host => host, :user => nil})
+      location = "#{DEIS::REMOTE_APP_DIR}#{config['dir']}"
+      ref = DEIS::Git.ref
+      branch = DEIS::Git.branch
+      # actually deploys it
+      res = ssh.exec!("cd #{location} && git push deis #{branch}:#{ref}")
+      "Failed to deploy".fatal if res == false
+      up = ssh.exec!("cd #{location} && deis scale web=1 | grep 'web\..* up' | wc -l").to_i if res != false
+      "Complete".important if ! up.nil? && up > 0
+      ssh.close
+    end
+
+    desc "deis_domain <env> <host> <config>", "Set a domain on the app"
+    def deis_domain(env, host=nil, config=nil)
+      host = self.target_host(env) if host.nil?
+      config = DEIS::Config.current(env) if config.nil? || config.class != Hash
+      "Adding domain..".info
+      ssh = SSH.new({:host => host, :user => nil})
+      location = "#{DEIS::REMOTE_APP_DIR}#{config['dir']}"
+      if config.has_key?("url") && config["url"].has_key?(env)
+        domains = config['url'][env]
+        domains.each do |domain|
+          exists = ssh.exec!("cd #{location} && deis domains | grep #{domain} -o | wc -l").to_i
+          res = ssh.exec!("cd #{location} && deis domains:add #{domain} | grep 400 | wc -l").to_i if exists == 0
+          "Domain #{domain} already in use".warning if ! res.nil? && res > 0
+          "Added #{domain}".info if ! res.nil? && res == 0
+        end
+      else
+        "No custom url to add".info
+      end
+      ssh.close
+
+    end
+
+    desc "deis_unset_config <env> <host> <config>", "Remove a series of values from deis app data"
+    def deis_unset_config(env, host=nil, config=nil)
+      host = self.target_host(env) if host.nil?
+      config = DEIS::Config.current(env) if config.nil? || config.class != Hash
+      name = DEIS::Config.full_name(env)
+      "Checking for old config data to remove..".info
+      ssh = SSH.new({:host => host, :user => nil})
+      location = "#{DEIS::REMOTE_APP_DIR}#{config['dir']}"
+      # run the unset calls
+      config['removed_config'].each{|r| ssh.exec!( "cd #{location} && deis config:unset #{r['k']}" ) }
+      ssh.close
+      config['removed_config'] = []
+      DEIS::Config.save_current(env, config, name)
+      "Removed".info
+    end
+
+    desc "deis_config <env> <host> <config>", "Sets config on deis for this app"
+    def deis_config(env, host=nil, config=nil)
+      host = self.target_host(env) if host.nil?
+      config = DEIS::Config.current(env) if config.nil? || config.class != Hash
+      "Setting config data..".info
+      # presume you have a working ssh config so we dont need to worry about the ssh user
+      ssh = SSH.new({:host => host, :user => nil})
+      location = "#{DEIS::REMOTE_APP_DIR}#{config['dir']}"
+      # generate deis config string from the config data
+      config_cmd = self.data_to_deis_config_set(config['config'])
+      res = ssh.exec!("cd #{location} && #{config_cmd}") unless config_cmd.nil?
+      ssh.close
+      if res.nil? && ! config_cmd.nil?
+        "Config command failed".fatal
+        exit 1
+      elsif config_cmd.nil?
+        "No config data to set".info
+      end
+    end
+
+    desc "deis create <env> <host> <config>", "Tries to create a deis application based on the data"
+    def deis_create(env, host=nil, config=nil)
+      host = self.target_host(env) if host.nil?
+      config = DEIS::Config.current(env) if config.nil? || config.class != Hash
+
+      "Creating deis app".info
+      # presume you have a working ssh config so we dont need to worry about the ssh user
+      ssh = SSH.new({:host => host, :user => nil})
+      location = "#{DEIS::REMOTE_APP_DIR}#{config['dir']}"
+      # check if already created the app
+      app_exists = ssh.exec!("deis apps | grep #{config['deis_name']} | wc -l").to_i
+      creation_failed = 0
+      # if the app does exist, create it
+      if app_exists == 0
+        creation_failed = ssh.exec!("cd #{location} && deis create #{config['deis_name']} --cluster=#{config['env']} | grep 400 | wc -l").to_i
+      else
+        "Application alrady exists..".info
+      end
+      # if creation failed, die
+      if creation_failed >= 1
+        "Failed to create deis app".fatal
+        "\nThis could be due to cluster being missing, the application name may be in use or other issues.".warning
+        exit 1
+      end
+      # make sure this dir uses this app name
+      matches = ssh.exec!("sleep 1; cd #{location} && deis info | grep '#{config['deis_name']} Application' -o  | wc -l").to_i
+      if matches != 1
+        "Application names do not match".fatal
+        exit 1
+      end
+      ssh.close
+
+    end
+
+    desc "checkout <env> <host> <config>", "runs a git clone, fetch & checkout"
+    def checkout(env, host=nil, config=nil)
+      host = self.target_host(env) if host.nil?
+      config = DEIS::Config.current(env) if config.nil? || config.class != Hash
+      # presume you have a working ssh config so we dont need to worry about the ssh user
+      ssh = SSH.new({:host => host, :user => nil})
+      # check base location exists
+      base = ssh.exec!("ls -lart #{DEIS::REMOTE_APP_DIR} | wc -l").to_i
+      # create if it doesnt
+      ssh.exec!("mkdir -p #{DEIS::REMOTE_APP_DIR}") if base == 0
+      # check location
+      location = ssh.exec!("ls -lart #{DEIS::REMOTE_APP_DIR}#{config['dir']} | wc -l").to_i
+      # clone if it doesn't exist
+      ssh.exec!("cd #{DEIS::REMOTE_APP_DIR} && git clone #{config['remote']} #{config['deis_name']}") if location == 0
+      # find current ref head
+      ref = DEIS::Git.branch
+      "current git ref: #{ref}".log
+      # checkout to that ref head
+      res = nil
+      res = ssh.exec!("cd #{DEIS::REMOTE_APP_DIR}#{config['dir']} && git fetch && git checkout #{ref}") unless ref.nil?
+      ssh.close
+      res
+    end
+
+
+
+  end
+
+end

data/lib/deis_deploy/file_locations.rb

@@ -0,0 +1,7 @@
+module DEIS
+  CONFIG_STORE    = "#{ENV['HOME']}/.deis/Gem/config/"
+  NAMES_STORE    = "#{ENV['HOME']}/.deis/Gem/names/"
+  HOSTS_STORE    = "#{ENV['HOME']}/.deis/Gem/hosts/"
+  # remote locations
+  REMOTE_APP_DIR = "$HOME/APPS/"
+end

data/lib/deis_deploy/git.rb

@@ -0,0 +1,33 @@
+module DEIS
+  class Git
+
+    def self.is_git?
+      res = `git status 2>&1 | grep 'fatal: Not a git' | wc -l`.to_i
+      "is git: #{res} (#{res.class})".log
+      if res == 0 then true else false end
+    end
+
+    def self.repo
+      remote = DEIS::Git.remote
+      "remote: #{remote}".log
+      if remote.nil? || remote.length == 0
+        return "na"
+      else
+        `echo #{remote} | grep "/.*\.git" -o | sed -E "s#/##" | sed -E "s#.git##" 2>/dev/null`.strip
+      end
+    end
+
+    def self.remote
+      `c=$(git remote show | wc -l ) ; if [ "$c" -gt 0 ]; then git remote show -n origin | grep " Fetch URL:" | grep ": .*" -o | sed -E "s#: ##" 2>/dev/null ; fi`.strip
+    end
+
+    def self.ref
+      `git rev-parse --verify HEAD 2>/dev/null`.strip
+    end
+
+    def self.branch
+      `git rev-parse --abbrev-ref HEAD`.strip
+    end
+
+  end
+end

data/lib/deis_deploy/strings.rb

@@ -0,0 +1,55 @@
+require 'colorize'
+class String
+  ##
+  # data logging
+  ##
+
+  # add a log level value to string class for output handling
+  # 0 = fatal only
+  # 1 = fatal & warnings
+  # 2 = fatal, warnings & important
+  # 3 = fatal, warnings, important & info
+  # 4 = fatal, warnings, important, info & log
+  @@log_level = 3
+  def self.log_level
+    return @@log_level
+  end
+  def self.log_level=(lvl)
+    @@log_level = lvl.to_i
+  end
+
+  # functions to output various log types
+  def log
+    if @@log_level >= 4
+      puts "\e[2m[#{Time.now}]: #{self}\e[22m"
+    end
+  end
+
+  def info
+    if @@log_level >= 3
+      puts self.colorize(:green)
+    end
+  end
+
+  def important
+    if @@log_level >= 2
+      puts ""
+      puts self.colorize(:blue)
+      puts ""
+    end
+  end
+
+  def warning
+    if @@log_level >= 1
+      puts self.colorize(:red)
+    end
+  end
+
+  def fatal
+    if @@log_level >= 0
+      puts self.colorize(:background => :red, :color => :white)
+    end
+  end
+
+
+end

data/lib/deis_deploy/validations.rb

@@ -0,0 +1,33 @@
+module DEIS
+  class Validations
+
+    def self.config
+      DEIS::Validations.git
+    end
+
+    def self.deploy(env, host, config)
+      # make sure a cluster exists
+      DEIS::Validations.cluster(env, host)
+    end
+
+    def self.cluster(env, host)
+      ssh = SSH.new({:host => host, :user => nil})
+      cluster = ssh.exec!("deis clusters | grep #{env} | wc -l").to_i
+      ssh.close
+      if cluster == 1 then true else false end
+    end
+
+    def self.git
+      if ! DEIS::Git.is_git?
+        "Not a git repository, exiting".fatal
+        exit 1
+      end
+      if DEIS::Git.remote.nil?
+        "Git remote could not be found, exiting".fatal
+        exit 1
+      end
+    end
+
+
+  end
+end

data/lib/deis_deploy/version.rb

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

data/lib/ssh.rb

@@ -0,0 +1,51 @@
+require 'net/ssh'
+class SSH
+
+  def initialize(config)
+    @config = config
+    "SSH: #{@config[:user]}@#{@config[:host]}".log
+    @ssh = Net::SSH.start(@config[:host], @config[:user])
+  end
+
+  def exec!(command)
+    # I am not awesome enough to have made this method myself
+    # I've just modified it a bit
+    # Originally submitted by 'flitzwald' over here: http://stackoverflow.com/a/3386375
+    stdout_data = ""
+    stderr_data = ""
+    exit_code = nil
+    "#{command.strip}".log
+    @ssh.open_channel do |channel|
+      channel.exec(command) do |ch, success|
+        unless success
+          abort "FAILED: couldn't execute command (ssh.channel.exec)"
+        end
+        channel.on_data do |ch,data|
+          stdout_data+=data
+        end
+
+        channel.on_extended_data do |ch,type,data|
+          stderr_data+=data
+        end
+
+        channel.on_request("exit-status") do |ch,data|
+          exit_code = data.read_long
+        end
+      end
+    end
+    @ssh.loop
+    stdout_data.strip.log
+    stderr_data.strip.log
+    if exit_code > 0
+      return false
+    else
+      return stdout_data.strip
+    end
+  end
+
+
+  def close
+    @ssh.close
+  end
+
+end

data/lib/utils.rb

@@ -0,0 +1,41 @@
+module Utils
+  require "thor"
+  include Thor::Shell
+
+  def target_host(env)
+    file = DEIS::HOSTS_STORE+env
+    if ! File.exists?(file)
+      host = ask "Hostname / IP for #{env}: ".colorize(:yellow)
+      self.file_store(DEIS::HOSTS_STORE)
+      File.open(file, "w"){|f| f.write(host) }
+    end
+    File.read(file)
+  end
+
+  def file_store(dir)
+    FileUtils.mkdir_p(dir) unless Dir.exists?(dir)
+    dir
+  end
+
+  def config_data
+    "looking for data file".log
+    name = DEIS::Git.repo
+    file = DEIS::Config.config_storage+"#{name}.json"
+    "data file: #{file}".log
+    if File.exists?(file) && ( content = File.read(file) ) && (json = JSON.parse(content))
+      return json
+    end
+    return nil
+  end
+
+
+  def data_to_deis_config_set(config)
+    if config.length > 0
+      string = "deis config:set "
+      config.each{|k,v| string += "#{k}=\"#{v.strip}\" "}
+      return string.strip
+    end
+    nil
+  end
+
+end

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification
+name: deis_deploy
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Charles Marshall
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !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'
+- !ruby/object:Gem::Dependency
+  name: faker
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: net-ssh
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.9'
+description: " "
+email:
+- cm56marshall@gmail.com
+executables:
+- deisConfig
+- deisDeploy
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".ruby-version"
+- Gemfile
+- README.md
+- bin/deisConfig
+- bin/deisDeploy
+- deis_deploy.gemspec
+- lib/deis_deploy.rb
+- lib/deis_deploy/config.rb
+- lib/deis_deploy/deploy.rb
+- lib/deis_deploy/file_locations.rb
+- lib/deis_deploy/git.rb
+- lib/deis_deploy/strings.rb
+- lib/deis_deploy/validations.rb
+- lib/deis_deploy/version.rb
+- lib/ssh.rb
+- lib/utils.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: ''
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: ''
+test_files: []