rdeis 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1cc0d69fdcf8dd2e9943afc4547d314c6dfaf95f
+  data.tar.gz: 6a128b021f283c44c30ed925effff21fc4f5523f
+SHA512:
+  metadata.gz: 271d64396b5396e1c647e02a833a24947ad1f57fdea58deb9487491559ebacd263c5a52c62980fea1eeed5e4bc18a0259c1e87ca85d1dcad10530ae81517f81b
+  data.tar.gz: 046e6e26c9886d317021e5aa3c124ba07659b5b71105746415ceb97e85b8b15ae417d8d6ed9dfaf996f3c62ce5e0cafe31f6d6c4c728a2f8a90d3a65d427829c

data/.gitignore

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

data/Gemfile

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

data/README.md

@@ -0,0 +1,32 @@
+# Deployment to a Deis Cluster
+
+A gem that will use `deis` to deploy to your environment. 
+
+This is an early version, so there is currently no removals and presumes that only one version of the repo will existing per environment. You can change the environment if you are planning on using this in CI style setup.
+
+This will also automatically convert gem files that have protected github repos over to use token based url
+
+
+## Installation
+
+`gem install rdeis`
+
+## Usage
+
+Mirrors the `deis` binary as closely as possible, so the base commands are:
+
+- `rdeis config`
+	- `rdeis config set`
+	- `rdeis config unset`
+	- `rdeis config list`
+- `rdeis domains`
+	- `rdeis domains add`
+	- `rdeis domains remove`	
+	- `rdeis domains list`
+- `rdeis deploy`
+- `rdeis help`
+- `rdeis scale`
+
+
+During the first use of the gem, it will ask some questions in order to generate a environment configuration file (github tokens and the like)
+

data/bin/rdeis

@@ -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 "rdeis"
+DEIS::Deis.start(ARGV)

data/gemconversion

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+file = "./Gemfile"
+ignore = "./gitignore"
+if File.exists?(file)
+  contents = File.open(file, "r") {|f| f.read }
+  # convert values over
+  contents = contents.gsub("'", '"').gsub("git@github.com:", "https://#{ENV['GITHUB_TOKEN']}:x-oauth-basic@github.com/")
+  # write back to file
+  File.open(file, "w"){ |f| f.write(contents) }
+  # add this file to the gitignore
+  if File.exists?(ignore)
+    puts "adding to ignore file"
+    igoring = File.open(ignore, "r"){|g| g.read }
+    File.open(ignore, "w"){|g| g.write(ignoring.gsub("gemconversion", "") + "\ngemconversion" ) }
+  end
+  # run the bundle
+  install = `bundle install 2>&1 | grep 'Your bundle is complete!' | wc -l`.to_i
+  # check the status
+  status = `git status | grep "modified.*Gemfile" | wc -l`.to_i
+  # create the commit
+  commit = 0
+  commit = `git commit Gemfile Gemfile.lock -m '[rdeis] Automated Gemfile conversion - #{Time.now.to_s}' 2>&1 | grep 'Error' | wc -l`.to_i if install == 1 && status > 0
+
+  if status == 0
+    $stdout.puts "Already converted & commited"
+  elsif install == 1 && commit == 0
+    $stdout.puts "Converted & commited"
+  else
+    abort("Error: install / commit failed (#{install}/#{commit})")
+  end
+else
+  abort("Error: Gemfile not found")
+end

data/lib/rdeis/base.rb

@@ -0,0 +1,23 @@
+module DEIS
+  class Base
+    include Thor::Shell
+    attr_accessor :verbose, :environment, :proxy, :cluster, :path, :output
+    YES = "\u2713"
+    NO = "\u274C"
+
+    def log(cmd)
+      say "[#{@proxy} #{Time.now}] #{cmd}", :black if @verbose
+    end
+
+    # run commands either locally or remotely
+    def run(command)
+      self.log(command)
+      if @proxy
+        return @ssh.exec!(command)
+      else
+        return `#{command}`.strip
+      end
+    end
+
+  end
+end

data/lib/rdeis/bootstrap.rb

@@ -0,0 +1,96 @@
+module DEIS
+  class Bootstrap < Base
+    include Thor::Shell
+
+    attr_accessor :proxy, :token, :ssh, :deploy_to
+
+    def initialize(options)
+      @repo = DEIS::Git.name
+      @verbose = options[:verbose]
+      @environment = options[:environment]
+      say( "Checking local environment..", :green)
+    end
+
+    def proxy
+      if yes?("Do you need to connect to another machine to run deis commands? (y/n): ", :yellow)
+        @proxy = ask("Enter the hostname / ip / ssh config name of this host: ", :yellow)
+      end
+    end
+
+    def github_token
+      # if local env doesnt have it and no proxy host, just ask
+      if ENV[DEIS::Git.github_token_varname].nil? && @proxy.nil?
+        @token = ask("Please enter your github auth token: ", :yellow)
+      # if proxy is set, then check for the var on the proxy:key => "value",
+      elsif ENV[DEIS::Git.github_token_varname].nil? && ! @proxy.nil?
+        cmd = DEIS::Git.github_token_cmd
+        say("[#{Time.now.to_s}] "+cmd+"\n", :black) if @verbose
+        remote = @ssh.exec!(cmd).to_s.strip
+        if ! remote.nil? && remote.length > 0 && (yes?("Found #{remote} on #{@proxy}, set as local version? (y/n): ", :yellow) )
+          @token = remote
+        end
+      else
+       @token = ask("Please enter a github auth token for deployment: ", :yellow)
+      end
+
+    end
+
+    def deploy_path
+      if @proxy.nil?
+        @deploy_to = ask("Please enter local folder to deploy to: ", :yellow)
+      else
+        @deploy_to = ask("Please enter containing folder on #{@proxy} to deploy to: ", :yellow)
+      end
+    end
+
+    # add a hush login file so we dont get the MOTD ouput in our shell commands
+    def hush
+      if yes? ("Does the deploy location run a Message of the Day? ")
+        run("if [[ ! -f $HOME/.hushlogin ]]; then > $HOME/.hushlogin ; fi ")
+      end
+    end
+
+    def all
+      @proxy = nil
+      @token = nil
+      file = DEIS::Storage::BASE_PATH.gsub("$HOME", ENV['HOME'])+".profile"
+      if ! File.exists?(file)
+        self.proxy
+        @ssh = SSH.new({:host => @proxy, :user => nil}) if ! @proxy.nil?
+        self.hush
+        self.github_token
+        self.deploy_path
+        self.save
+        @ssh.close
+        say "Bootstrap Completed", :blue
+      end
+    end
+
+    def save
+      # the base file location for the env vars we need
+      file = DEIS::Storage::ENV_VAR_PATH
+      replaced = DEIS::Storage::BASE_PATH.gsub("$HOME", ENV['HOME'])
+      FileUtils.mkdir_p(replaced) if ! File.directory?(replaced)
+      out = "# [rdeis #{DEIS::VERSION}] Auto generated at #{Time.now.to_s}\n"
+      out = out+"export RDEIS_PROXY=\"#{@proxy}\"\n" if ! @proxy.nil?
+      out = out+"export RDEIS_PATH=\"#{@deploy_to.gsub('$', '\$') }\"\n" if ! @deploy_to.nil?
+      out = out+"export #{DEIS::Git.github_token_varname}=\"#{@token}\"\n" if ! @token.nil?
+      # write locally
+      File.open(file.gsub("$HOME", ENV['HOME']), "w"){ |f| f.write(out) }
+      # run remote, keep the $HOME notation as we want that evaluated in the cmd
+      run("mkdir -p #{DEIS::Storage::BASE_PATH} ; echo -e '#{out}' > #{file}") if ! @proxy.nil?
+      # remove any existing references from the various shell options on the local machine
+      shell=`echo $SHELL | sed -E "s#/bin/##i"`.strip
+      profile = ["#{ENV['HOME']}/.#{shell}rc", "#{ENV['HOME']}/.#{shell}_profile", "#{ENV['HOME']}/.profile"].select{|f| File.exists?(f)}.first
+      if ! profile.nil?
+        content = File.open(profile, "r"){ |f| f.read }.gsub(". #{file}", "") + "\n. #{file}"
+        File.open(profile, "w") { |f| f.write(content) }
+      else
+        say "Could not save environment setup", :red
+      end
+      # add include to the remote profile
+      run("echo -e '. #{file}\n' >> ~/.profile") if ! @proxy.nil?
+    end
+
+  end
+end

data/lib/rdeis/config.rb

@@ -0,0 +1,102 @@
+module DEIS
+  class Config < Storage
+    include Thor::Shell
+    attr_accessor :verbose, :environment
+
+    def initialize(options)
+      @repo = DEIS::Git.name
+      @verbose = options[:verbose]
+      @environment = options[:environment]
+      @set_selector = self.class.to_s.downcase.gsub("deis::", "")
+      @remove_selector = "removed_"+@set_selector
+    end
+
+    # output data using thors print_table & say
+    def list(vars)
+      data = DEIS::Storage.get(@repo, @environment, @set_selector)
+      # if vars have been set then we filter the config data to matching keys
+      if ! vars.nil? && vars.length > 0
+        keys = []
+        DEIS::Parse.var_array(vars).each { |f| keys.push(f[:k]) }
+        data = data.select!{ |k,v| keys.include? (k) }
+      end
+
+      self.results("#{@set_selector} for #{@repo} -> #{@environment}", "No data found" ,data, :green)
+      to_remove = DEIS::Storage.get(@repo, @environment, @remove_selector)
+      self.results("\n\n#{@set_selector} to be removed", nil, to_remove, :blue)
+    end
+
+    # set config vars for the repo
+    def set(vars)
+      if vars.nil? || vars.length == 0
+        say "Please provide a value", :red
+      else
+        set = {}
+        DEIS::Parse.var_array(vars).each do |var|
+          set[var[:k]] = var[:v]
+          DEIS::Storage.subset(@repo, @environment, @set_selector, var[:k], var[:v])
+        end
+        self.results("Setting #{@set_selector} for #{@repo} -> #{@environment}", "Error setting #{@set_selector}", set, :green)
+      end
+    end
+
+    def add(vars)
+      self.set(vars)
+    end
+
+    # remove vars
+    def unset(vars)
+      if vars.nil? || vars.length == 0
+        say "Please enter a key to unset", :red
+      else
+        unset = {}
+        DEIS::Parse.var_array(vars).each do |var|
+          unset[var[:k]] = "\u2713"
+          DEIS::Storage.subunset(@repo, @environment, @set_selector, var[:k])
+        end
+        self.results("Removing #{@set_selector} for #{@repo} -> #{@environment}", "Error removing #{@set_selector}", unset, :green)
+      end
+    end
+
+    def remove(vars)
+      self.unset(vars)
+    end
+
+    # vars should just be the file name
+    def export(vars)
+      raw = DEIS::Storage.load(@repo, @environment)
+      if ! vars.nil? && vars.length > 0 && (file = vars.first)
+        File.open(file, "w"){|f| f.write( raw.to_json ) }
+        say "Data for #{@repo} -> #{@environment} written to #{file}", :green
+      else
+        say "Please specify a file path to export to", :red
+      end
+    end
+
+    # import from a file
+    def import(vars)
+      if !vars.nil? && vars.length > 0 && (file = vars.first) && (content = File.open(file, "r"){ |f| f.read } )
+        content = JSON.parse(content)
+        DEIS::Storage.save(@repo, @environment, content)
+        say "Data imported from #{file} into #{@repo} -> #{@environment}", :green
+      else
+        say "Please specify a valid file", :red
+      end
+    end
+
+    def results(message, error_message, data, colour)
+      if ! data.nil? && data.length > 0
+        say message, colour
+        say "----------------------------------", colour
+        print_table data
+        say "----------------------------------", colour
+      elsif ! error_message.nil?
+        say message, colour
+        say error_message, :red
+      end
+
+    end
+
+
+  end
+end

data/lib/rdeis/deis.rb

@@ -0,0 +1,167 @@
+module DEIS
+  class Deis < Thor
+    include Thor::Shell
+    class_option :verbose, :type => :boolean, :default => false
+    class_option :environment , :type => :string, :default => "staging", :aliases => "-e"
+
+    desc "config <export|import|list|set|unset> <varstring>", "set or unset a variable"
+    long_desc <<-LONGDESC
+    Modifies the the LOCAL configuration variables in the current environment (set with --environment or -e). When deployed, these will become environment variables for your application.
+
+    Examples:
+
+    `rdeis config list`
+    `rdeis config`
+
+    Returns all config items for this environment. List is the default action for config.
+
+    `redis export $destination_file -e $environment`
+
+    Export all data for the set $environment into the $file path specified. This will be in a JSON format
+
+    `redis import $origin_file -e $environment`
+
+    Import and replace current setup for $environment with the data contained in $origin_file
+
+    `rdeis config list TEST`
+
+    Filters the list to just the value for TEST (if present)
+
+    `rdeis config set FOO=BAR TEST=1`
+
+    This sets two variables, FOO & TEST, to BAR & 1 respectively and matches the syntax for the `deis` binary
+
+    `rdeis config unset FOO TEST`
+
+    This will unset two variables, FOO & TEST, as long as they exist in the configuration settings.
+
+    You will need to deploy for changes to effect the running environment.
+
+    LONGDESC
+    def config(action="list", *vars)
+      self.bootstrap
+      if DEIS::Config.method_defined? action
+        config = DEIS::Config.new(options)
+        config.send(action, vars)
+      else
+        say "invalid option", :red
+      end
+    end
+
+
+
+    desc "domains <add|remove|list> <domain>", "add, remove or list domains"
+    long_desc <<-LONGDESC
+    Modifies the the LOCAL domains in the current environment (set with --environment or -e). Once deployed, this will be the domains that route to your application.
+
+    Examples:
+
+    `rdeis domains list`
+    `rdeis domains`
+
+    Returns all domains for this environment. List is the default action.
+
+    `rdeis domains add test.example.com foo.bar.com`
+
+    This adds two domains to the setup for this application.
+
+    `rdeis domains remove foo.bar.com`
+
+    This will unset foo.bar.com, as long as they exist in the settings.
+
+    You will need to deploy for changes to effect the running environment.
+
+
+    LONGDESC
+    def domains(action="list", *domains)
+      self.bootstrap
+      if DEIS::Domains.method_defined? action
+        domain = DEIS::Domains.new(options)
+        domain.send(action, domains)
+      else
+        say "invalid option", :red
+      end
+    end
+
+    desc "deploy <all|create|config|domains|gems|git|remotes>", "deploy this repo"
+    option :proxy, :type => :string, :aliases => "-P", :banner => "<Hostname|IP> of proxy host, for vpc etc"
+    option :cluster, :type => :string, :default => "staging", :banner => "<name> of the cluster to deploy to"
+    option :path, :type => :string, :aliases => "-p", :banner => "<FILE_PATH> to deploy to"
+    long_desc <<-LONGDESC
+    Deploy to the deis cluster that is configured. This will run over the actions to checkout the git repo to a set location, create the deis application, use your local config and domain values on the deis application, find and add the deis remote to local version and the run a push to that remote
+
+    Examples
+
+    `rdeis deploy`
+    `rdeis deploy all`
+
+    This will run all elements of the checkout
+
+    `rdeis create`
+
+    Runs just a deis create $application --cluster=$cluster
+
+    `rdeis config`
+
+    Deploys the local config to the deis application
+
+    `rdeis domains`
+
+    Deploys the local domain list to the deis application
+
+    `rdeis gems`
+
+    Modifies your local gem file and convert and git@github based gems to run from oauth basic token access from an ENV variable
+
+    `rdeis git`
+
+    Create and clone the repo at --path
+
+    `rdeis remotes`
+
+    Find and setup deis remotes on current directory
+
+    LONGDESC
+    def deploy(action="all")
+      self.bootstrap
+      if DEIS::Deploy.method_defined? action
+        deploy = DEIS::Deploy.new(options)
+        deploy.send(action)
+      else
+        say "invalid option", :red
+      end
+    end
+
+    desc "scale <varstring>", "Scale a proc"
+    long_desc <<-LONGDESC
+    Scale a proc up or down based on value you enter.
+
+    Examples:
+
+    `rdeis scale web=1`
+    Would turn on 1 instance of the web proc
+
+    LONGDESC
+    def scale(*vars)
+      self.bootstrap
+      if DEIS::Deploy.method_defined? "scale"
+        deploy = DEIS::Deploy.new(options)
+        deploy.send("scale", vars)
+      else
+        say "invalid option", :red
+      end
+    end
+
+    desc "bootstrap <type>", "first run install setup funcs"
+    def bootstrap(action="all")
+      if DEIS::Bootstrap.method_defined? action
+        bootstrap = DEIS::Bootstrap.new(options)
+        bootstrap.send(action)
+      else
+        say "invalid option", :red
+      end
+    end
+
+
+  end
+end

data/lib/rdeis/deploy.rb

@@ -0,0 +1,195 @@
+module DEIS
+  require 'shellwords'
+  class Deploy < Storage
+    include Thor::Shell
+    attr_accessor :verbose, :environment, :proxy, :cluster, :path, :output
+
+    def initialize(options)
+      @repo = DEIS::Git.name
+      @verbose = options["verbose"]
+      @environment = options["environment"]
+      @cluster = options["cluster"]
+      # location data that fetch from env as well as options from thor
+      @proxy = if ! options["proxy"].nil? then options["proxy"] elsif ! ENV['RDEIS_PROXY'].nil? then ENV['RDEIS_PROXY'] else nil end
+      @base_path = if ! options["path"].nil? then options["path"] elsif ! ENV['RDEIS_PATH'].nil? then ENV['RDEIS_PATH'] else ENV['HOME'] end
+      # git data
+      @ref = DEIS::Git.ref
+      @branch = DEIS::Git.branch
+      @remote = DEIS::Git.remote
+
+      @name = @repo+"-"+@environment
+      @deploy_to = @base_path.to_s + "/"+ @name + "/"
+      @ssh = SSH.new({:host => @proxy, :user => nil}) if ! @proxy.nil?
+    end
+
+    # deis create wrapper
+    def create
+      output ={"CREATE" => ""}
+      # check it exists
+      exists = run("deis apps 2>&1 | grep '#{@name}' | wc -l").to_i
+      output[" exists"] = if exists == 1 then DEIS::Deploy::YES else DEIS::Deploy::NO end
+      # try to make it if it doesnt
+      created = run("cd #{@deploy_to} && deis create #{@name} --cluster=#{@environment} 2>&1 | grep 'not found\\\|400' | wc -l").to_i if exists == 0
+      output[" created"]  = if created == 0 then DEIS::Deploy::YES else DEIS::Deploy::NO end
+
+      print_table output
+      if exists == 0 && created != 0
+        say "Could not create application.", :red
+        exit
+      end
+    end
+
+    # deis config:set / unset wrapper
+    def config
+      self.setter("config")
+    end
+
+    # deis domains:add / remote wrapper
+    def domains
+      self.setter("domains", "remove", "add")
+    end
+
+    # generalised setter for config &
+    def setter(name="config", rm="unset", add="set")
+      output = {"#{name.upcase}" => ""}
+
+      removed = DEIS::Storage.get(@repo, @environment, "removed_#{name}")
+      remove =DEIS::Parse.JSON_to_unset(removed) if removed.length > 0
+      remove_res = run("cd #{@deploy_to} && deis #{name}:#{rm} #{remove} | grep 'not found\\\|400' | wc -l").to_i if !remove.nil? && remove.length > 0
+      output[" unset"] = if remove_res == 0 then DEIS::Deploy::YES else DEIS::Deploy::NO end
+
+      to_add = DEIS::Storage.get(@repo, @environment, name)
+      set = DEIS::Parse.JSON_to_set(to_add) if to_add.length > 0
+      set_res = run("cd #{@deploy_to} && deis #{name}:#{add} #{set} | grep 'not found\\\|400' | wc -l").to_i if !set.nil? && set.length > 0
+
+      output[" set"] = if set_res == 0 then DEIS::Deploy::YES else DEIS::Deploy::NO end
+      print_table output
+      # if there were things to set, that ran, but failed, throw
+      if !set.nil? && ! set_res.nil? && set_res > 0
+        say "#{name.upcase} failed to set.. please check manually", :red
+        say "This may have failed due to values for #{name.upcase} already being set", :red
+      end
+
+    end
+
+
+    # adjust the gem files & rebuild
+    def gems
+      output = {"GEMS" => ""}
+      # make sure we have token in env
+      token = run(DEIS::Git.github_token_cmd).to_s.strip
+      token = if token.length == 0 then nil else token end
+      output[" github token"] = if ! token.nil? then DEIS::Deploy::YES else DEIS::Deploy::NO end
+      # check gemfile to see if we need a github token
+      file = Dir.pwd + "/Gemfile"
+      contents = File.open(file, "r") { |f| f.read } if File.exists?(file)
+      needed = ! contents.index("git@github.com").nil? if ! contents.nil?
+      output[" git token needed"] = if ! needed.nil? then DEIS::Deploy::YES else DEIS::Deploy::NO end
+
+      # check to see if the token is being used already
+      conversion_needed = contents.index(DEIS::Git.github_token_varname)
+      output[" conversion needed"] = if conversion_needed.nil? then DEIS::Deploy::YES else DEIS::Deploy::NO end
+      # if the conversion is needed, upload the pre run ruby script that will convert and commit on the remote deploy end
+      if conversion_needed.nil? && ! contents.nil? && ! token.nil?
+        upload_file = File.expand_path(File.dirname(__FILE__)) + "/../../gemconversion"
+        upload = File.open(upload_file, "r") { |f| f.read }
+        install = run("cd #{@deploy_to} && echo -e #{Shellwords.escape(upload)} > gemconversion ; chmod 0777 gemconversion; ls | grep gemconversion | wc -l").to_i
+      else
+        install = 1
+        output[" converted"] = DEIS::Deploy::YES
+      end
+      print_table output
+      # if need a token, and no token is set, fail
+      if ! needed.nil? && token.nil?
+        say "Github token needed, but not found", :red
+        exit 1
+      end
+      # convert gem message
+      if install != 1
+        say "Failed to upload Gemfile conversion", :red
+        exit 1
+      end
+
+    end
+
+    # run the git checkout & clone setup
+    def git
+      output = {"GIT" => ""}
+      # check for directory
+      directory = run( "ls -l #{@deploy_to} 2> /dev/null | wc -l").to_i
+      if directory == 0
+        created = run( "mkdir -p #{@deploy_to}")
+        output[" directory"] = if created then DEIS::Deploy::YES else DEIS::Deploy::NO end
+      else
+        output[" directory"] = DEIS::Deploy::YES
+      end
+
+      # check if git & initialise
+      is_git = run( "cd #{@deploy_to} && #{DEIS::Git.is_git_cmd}").to_i
+      if is_git > 0
+        git_init_remote = run("cd #{@deploy_to} && #{DEIS::Git.init_with_remote_cmd(@remote)}").to_i
+        output[" init and remote"] = if git_init_remote == 0 then DEIS::Deploy::YES else DEIS::Deploy::NO end
+      else
+        output[" init and remote"] = DEIS::Deploy::YES
+      end
+      # checkout to the correct branch from the remote
+      checkout = run ("cd #{@deploy_to} && #{DEIS::Git.checkout_to_ref_cmd('origin/'+@ref)}")
+      output[" checkout to #{@ref[0..8]}"] = if checkout then DEIS::Deploy::YES else DEIS::Deploy::NO end
+      print_table output
+    end
+
+    # parse the remotes that have been created and add to local version if proxy is set
+    # this is to allow easier pushes
+    def remotes
+      output = {"REMOTES" => ""}
+      remote = run("cd #{@deploy_to} && " + 'git remote -v | grep "deis.*(push)" | sed -E "s#deis|\(push\)##g"').to_s.strip
+      # presume the remote is an ssh protocol, as that is what deis currently sets it as
+      output[" found"] = if ! remote.index("ssh://").nil? then DEIS::Deploy::YES else DEIS::Deploy::NO end
+
+      if ! remote.nil? && remote.length > 0
+        self.log(remote)
+        # run this locally only, adding to the
+        local_command = "cd #{Dir.pwd} && git remote add #{@name} #{remote} 2>/dev/n"
+        self.log(local_command)
+        `#{local_command}`
+      end
+      print_table output
+    end
+
+    # run a git push to the deis remote
+    def push
+      output = {"PUSH" => ""}
+      # make sure the profile is loaded, cd to the right place & run the converstion script.
+      conversion = run(". $HOME/.profile && cd #{@deploy_to} && ./gemconversion | grep Error | wc -l").to_i
+      output[" Gem conversion"] = if conversion == 0 then DEIS::Deploy::YES else DEIS::Deploy::NO end
+      # push the branch to deis
+      deis = run("cd #{@deploy_to} && git push deis #{@branch} | grep Error | wc -l") if conversion == 0
+      output[" Deis push"] =  if deis.to_i == 0 then DEIS::Deploy::YES else DEIS::Deploy::NO end
+      print_table output
+    end
+
+    def scale(vars)
+      output = {"SCALE" => ""}
+      if ! vars.nil? && vars.length > 0
+        procs = DEIS::Parse.var_array(vars) if ! vars.nil? && vars.length > 0
+        procs.each{ |r| output[" #{r[:k]}=#{r[:v]}"] = if run("cd #{@deploy_to} 2>&1 /dev/null && deis scale #{r[:k]}=#{r[:v]} 2>&1 | grep 'done in\\\|#{r[:k]}.*up ' | wc -l").to_i == 2 then DEIS::Deploy::YES else DEIS::Deploy::NO end } if ! procs.nil? && procs.length > 0
+      end
+      print_table output
+    end
+
+    # runs everyhing in order
+    def all
+      self.git
+      self.create
+      self.config
+      self.domains
+      self.remotes
+      self.gems
+      self.push
+      self.scale([DEIS::Parse.first_proc])
+      say "Complete", :blue
+    end
+
+
+  end
+end

data/lib/rdeis/domains.rb

@@ -0,0 +1,5 @@
+module DEIS
+  class Domains < Config
+
+  end
+end

data/lib/rdeis/git.rb

@@ -0,0 +1,58 @@
+module DEIS
+  class Git
+
+    def self.is_git?
+      res = `#{DEIS::Git.is_git_cmd}`.to_i
+      if res == 0 then true else false end
+    end
+
+    def self.is_git_cmd
+      "git status 2>&1 | grep 'fatal: Not a git' | wc -l"
+    end
+
+    def self.name
+      remote = DEIS::Git.remote
+      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
+
+    def self.init_with_remote_cmd(remote)
+      "git init && git remote add origin #{remote} 2>&1 | grep 'fatal:' -o | wc -l"
+    end
+
+    def self.checkout_to_ref_cmd(ref)
+      "git fetch origin && git checkout -f #{ref} 2>&1 | grep 'error:' | wc -l"
+    end
+
+    # find env based token
+    def self.github_token
+      v = self.github_token_varname
+      ENV[v]
+    end
+
+    # more advanced version that reads config files
+    def self.github_token_cmd
+      "cat #{DEIS::Storage::BASE_PATH}.profile  | grep #{DEIS::Git.github_token_varname}=.* -o | sed -E 's##{DEIS::Git.github_token_varname}=##' | sed -E 's#\"##g'"
+    end
+
+    def self.github_token_varname
+      "GITHUB_TOKEN"
+    end
+
+  end
+end

data/lib/rdeis/parse.rb

@@ -0,0 +1,64 @@
+module DEIS
+  class Parse
+
+    # vars is an array from the cli taking the form of:
+    # KEY=VALUE
+    # KEY1=V1 KEY2=V2
+    # KEY1 KEY2
+    def self.var_array(vars)
+      parsed = []
+      if ! vars.nil? && vars.length > 0
+        vars.each{ |pair| parsed.push ( {:k =>DEIS::Parse.key(pair), :v=>DEIS::Parse.value(pair) } ) }
+      end
+      # reverse so the last value of the key is used, then sort alpabetically, ignoring case
+      parsed.reverse.uniq {|r| r[:k]}.sort{|a ,b | a[:k].downcase <=> b[:k].downcase}
+    end
+
+    # finds just the key from a string like KEY=VALUE
+    def self.key(pair)
+      # start by assuming there might be no value or = symbol
+      index = pair.length - 1
+      index = pair.index("=") - 1 if ! pair.index("=").nil?
+      # return the sub string
+      pair[0..index]
+    end
+
+    # finds just the value from a string like KEY=VALUE
+    def self.value(pair)
+      #if theres no = then presume no value, just key, so default to nil
+      index = pair.index("=")
+      length = pair.length - 1
+      if ! index.nil?
+        pair[index+1..length]
+      else
+        nil
+      end
+    end
+
+    def self.JSON_to_set(json)
+      cmd = ""
+      json.each{|k,v| cmd += if v.to_s.length > 0 && v.to_s != "null" then "#{k}=\"#{v}\" " else "#{k} " end}
+      cmd + " 2>&1"
+    end
+
+    def self.JSON_to_unset(json)
+      cmd = ""
+      json.each{|k,v| cmd += "#{k} "}
+      cmd + " 2>&1"
+    end
+
+    def self.first_proc
+      file = Dir.pwd+"/Procfile"
+      procs = []
+      if File.exists?(file)
+        File.open(file, "r") {|f| f.read}.split("\n").each do |r|
+          key = r.split(":").first
+          procs.push(key)
+        end
+        return "#{procs.first}=1"
+      end
+      nil
+    end
+
+  end
+end

data/lib/rdeis/storage.rb

@@ -0,0 +1,71 @@
+module DEIS
+  require "json"
+  class Storage < Base
+    BASE_PATH = "$HOME/.deis/gem/#{DEIS::VERSION}/"
+    ENV_VAR_PATH = DEIS::Storage::BASE_PATH+".profile"
+
+    def self.file(repo, env)
+      BASE_PATH.gsub("$HOME", ENV['HOME'])+repo+"/#{env}.json"
+    end
+
+    def self.load(repo, env)
+      data = {}
+      data = JSON.parse( File.open( DEIS::Storage.file(repo, env) , "r" ) { | f | f.read } ) if File.exists? (DEIS::Storage.file(repo, env))
+      data
+    end
+
+    def self.save(repo, env, data)
+      working_dir = DEIS::Storage::BASE_PATH.gsub("$HOME", ENV['HOME'])
+      FileUtils.mkdir_p(working_dir+repo) unless Dir.exists?(working_dir+repo)
+      File.open( DEIS::Storage.file(repo, env) , "w" ){ |f| f.write ( data.to_json ) }
+    end
+
+    def self.get(repo, env, key=nil)
+      current = DEIS::Storage.load(repo, env)
+      # key asked for and is present
+      if ! key.nil? && current.has_key?(key)
+        current[key]
+      # key asked for but not present
+      elsif !key.nil?
+        {}
+      # key not asked for
+      else
+        current
+      end
+    end
+
+    # only handles top level, not sub levels
+    def self.set(repo, env, key, value)
+      current = DEIS::Storage.load(repo, env)
+      # overwrite the value existing
+      current[key] = value
+      DEIS::Storage.save(repo, env, current)
+    end
+
+    def self.subset(repo, env, key, subkey, value)
+      current = DEIS::Storage.load(repo, env)
+      current[key] = {} if ! current.has_key?(key)
+      current[key][subkey] = value
+      # if it exists in the unset, remove it
+      DEIS::Storage.save(repo, env, current)
+      # remove from items that need to be removed
+      DEIS::Storage.subunset(repo, env, "removed_#{key}", subkey) if key.index("removed_").nil?
+    end
+
+    # only have the option to remove low level, not top level
+    def self.subunset(repo, env, key, subkey)
+      current = DEIS::Storage.load(repo, env)
+      if current.has_key?(key) && current[key].has_key?(subkey)
+        tmp = current[key]
+        val = tmp[subkey]
+        tmp.delete(subkey)
+        current[key] = tmp
+        # save
+        DEIS::Storage.save(repo, env, current)
+        #also need to store removals for actions to be performed on the server, if check to stop recursive loops
+        DEIS::Storage.subset(repo, env, "removed_#{key}", subkey, val) if key.index("removed_").nil?
+      end
+    end
+
+  end
+end

data/lib/rdeis/version.rb

@@ -0,0 +1,3 @@
+module DEIS
+  VERSION='0.0.2'
+end

data/lib/rdeis.rb

@@ -0,0 +1,15 @@
+require "rdeis/version"
+require "thor"
+require "ssh"
+
+module DEIS
+  require "rdeis/base"
+  require "rdeis/git"
+  require "rdeis/parse"
+  require "rdeis/storage"
+  require "rdeis/bootstrap"
+  require "rdeis/config"
+  require "rdeis/domains"
+  require "rdeis/deploy"
+  require "rdeis/deis"
+end

data/lib/ssh.rb

@@ -0,0 +1,42 @@
+require 'net/ssh'
+
+
+class SSH
+
+  def initialize(config)
+    @config = config
+    @ssh = Net::SSH.start(@config[:host], @config[:user])
+  end
+
+  def exec!(command)
+   
+    stdout_data = ""
+    stderr_data = ""
+    exit_code = nil
+    @ssh.open_channel do |channel|
+      channel.send_channel_request "shell" do |ch, success|
+        unless success
+          abort "FAILED to connect"
+        end
+        channel.on_data {|c,data| stdout_data+=data.to_s }
+        channel.on_extended_data {|c,data| stderr_data+=data.to_s }
+        channel.on_request("exit-status") {|c,data| exit_code = data.read_long }
+        ch.send_data "#{command}\n"
+        ch.send_data "exit\n"
+      end
+    end
+    @ssh.loop
+    if exit_code > 0
+      return false
+    else
+      return stdout_data.strip
+    end
+  end
+
+
+  def close
+    @ssh.close
+  end
+
+end
+

data/rdeis.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "rdeis/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "rdeis"
+  spec.version = DEIS::VERSION
+  spec.authors = ["Charles Marshall"]
+  spec.email = ["cm56marshall@gmail.com"]
+  spec.summary = %q{ }
+  spec.description = %q{ }
+  spec.homepage = "https://github.com/charlesmarshall/deis_deploy/tree/#{DEIS::VERSION}"
+  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 "bundler", "~> 1.5"
+  spec.add_dependency "thor", "~> 0.19"
+  spec.add_dependency "net-ssh", "~> 2.9"
+
+  spec.post_install_message = ""
+
+end

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: rdeis
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Charles Marshall
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-03 00:00:00.000000000 Z
+dependencies:
+- !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: 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:
+- rdeis
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- README.md
+- bin/rdeis
+- gemconversion
+- lib/rdeis.rb
+- lib/rdeis/base.rb
+- lib/rdeis/bootstrap.rb
+- lib/rdeis/config.rb
+- lib/rdeis/deis.rb
+- lib/rdeis/deploy.rb
+- lib/rdeis/domains.rb
+- lib/rdeis/git.rb
+- lib/rdeis/parse.rb
+- lib/rdeis/storage.rb
+- lib/rdeis/version.rb
+- lib/ssh.rb
+- rdeis.gemspec
+homepage: https://github.com/charlesmarshall/deis_deploy/tree/0.0.2
+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: []