elasticdot 1.3.3

data/bin/elasticdot

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'elasticdot/cli'
+
+ElasticDot::CLI.run ARGV

data/lib/elasticdot.rb

@@ -0,0 +1,3 @@
+module ElasticDot
+  require 'elasticdot/cli'
+end

data/lib/elasticdot/api.rb

@@ -0,0 +1,60 @@
+class ElasticDot::API
+  require 'restclient'
+  require 'json'
+
+  attr_reader :email, :host
+
+  def initialize(opts = {})
+    @host  = opts[:host] || 'https://api.elasticdot.com'
+
+    if opts[:email] and opts[:password]
+      @email, @pass = opts[:email], opts[:password]
+    else
+      @email, @pass = ElasticDot::Command::Auth.credentials
+    end
+  end
+
+  def login
+    return unless (@email && @pass)
+
+    @pass = RestClient.post(
+      "#{@host}/auth",
+      email: @email, password: @pass
+    )
+  rescue => e
+    puts e.response
+    exit 1
+  end
+
+  def method_missing(m, *args, &block)
+    unless ['get', 'post', 'put', 'delete'].include? m.to_s
+      raise NoMethodError, "undefined method: #{m}"
+    end
+
+    res = self.send('req', m, args)
+    JSON.parse res rescue ""
+  end
+
+  private
+  def req(method, *args)
+    raise if args.empty?
+    args = args.shift
+    path = args.shift
+
+    resource = RestClient::Resource.new(
+      "#{@host}#{path}", user: @email, password: @pass
+    )
+
+    begin
+      resource.send method, (args.first || {})
+    rescue => e
+      if e.respond_to? :response
+        puts e.response
+      else
+        puts 'Something went wrong, we have been notified.'
+      end
+
+      exit 1
+    end
+  end
+end

data/lib/elasticdot/cli.rb

@@ -0,0 +1,51 @@
+module ElasticDot
+  libs = Dir[File.join(File.dirname(__FILE__), "initializers", "*.rb")]
+  libs.each { |file| require file }
+
+  require 'elasticdot/command'
+
+  class CLI
+    require 'optparse'
+
+    def self.parse(args)
+      options = {}
+
+      opt_parser = OptionParser.new do |opts|
+        opts.banner = "Usage: example.rb [options]"
+
+        opts.on("-a", "--app APP", "Specify the app involved") do |v|
+          options[:app] = v
+        end
+
+        opts.on("-d", "--database DATABASE", "Specify the database involved") do |v|
+          options[:db] = v
+        end
+
+        opts.on("-f", "--follow", "Continue running and print new events (off)") do |v|
+          options[:follow] = v
+        end
+
+        opts.on("-p", "--plan PLAN", "Specify pricing plan") do |v|
+          options[:plan] = v
+        end
+
+        opts.on("-c", "--extra-conf CONF", "Specify extra config file") do |v|
+          options[:conf] = v
+        end
+
+        opts.on("-h", "--help", "Show this help") do |v|
+          options[:help] = true
+        end
+      end
+
+      opt_parser.parse! args
+
+      [ARGV, options]
+    end
+
+    def self.run(args)
+      cmd, opts = parse ARGV
+      ElasticDot::Command.run cmd, opts
+    end
+  end
+end

data/lib/elasticdot/command.rb

@@ -0,0 +1,67 @@
+module ElasticDot::Command
+  require 'elasticdot/api'
+  require 'elasticdot/command/base'
+
+  libs = Dir[File.join(File.dirname(__FILE__), "command", "*.rb")]
+  libs.each { |file| require file }
+
+  def self.run(args, opts)
+    cmd  = args.shift
+
+    unless cmd
+      ElasticDot::Command::Help.root_help
+      exit 0
+    end
+
+    klass, act = cmd.split ':', 2
+    klass = klass.downcase
+
+    if klass == 'help'
+      m = args.shift || 'root_help'
+      m = m.split(':')[0]
+
+      ElasticDot::Command::Help.send m
+      exit 0
+    end
+
+    unless (klass == 'login' or cmd == 'auth:login')
+      ElasticDot::Command::Auth.authenticate!
+    end
+
+    ElasticDot::Command::Base.api = ElasticDot::API.new
+
+    if ElasticDot::Command::Alias.respond_to? klass
+      ElasticDot::Command::Alias.send klass.downcase, args, opts
+      exit 0
+    end
+
+    act ||= 'list'
+
+    begin
+      klass = "ElasticDot::Command::#{klass.capitalize}".constantize
+    rescue
+      unless ElasticDot::Command::Base.respond_to? cmd
+        puts 'Invalid command: ' + cmd
+        exit 1
+      end
+
+      return ElasticDot::Command::Base.send cmd
+    end
+
+    unless klass.respond_to? act
+      puts 'Invalid action ' + act
+      exit 1
+    end
+
+    method_args = klass.method(act).arity
+
+    case method_args
+    when 0
+      klass.send act
+    when 1
+      klass.send act, opts
+    when 2
+      klass.send act, args, opts
+    end
+  end
+end

data/lib/elasticdot/command/addons.rb

@@ -0,0 +1,29 @@
+class ElasticDot::Command::Addons < ElasticDot::Command::Base
+  def self.add(addon, opts)
+    find_app! opts
+
+    addon, tier = addon[0].split ':', 2
+
+    puts "Configuring addon #{addon} for app #{@app}..."
+
+    api.post "/apps/#{@app}/addons/#{addon}", tier: tier
+  end
+
+  def self.remove(addons, opts)
+    find_app! opts
+
+    addons.each do |addon|
+      addon = addon.split(':')[0]
+
+      puts "Removing addon #{addon} from app #{@app}..."
+      api.delete "/apps/#{@app}/addons/#{addon}"
+    end
+  end
+
+  def self.list
+    addons = api.get '/addons'
+
+    puts '=== available'
+    addons.each { |a, i| puts a['name'] }
+  end
+end

data/lib/elasticdot/command/alias.rb

@@ -0,0 +1,33 @@
+class ElasticDot::Command::Alias < ElasticDot::Command::Base
+  def self.login(*opts)
+    ElasticDot::Command::Auth.login
+  end
+
+  def self.logout(*opts)
+    ElasticDot::Command::Auth.logout
+  end
+
+  def self.signup(*opts)
+    puts 'Please go to: https://s.elasticdot.com/signup'
+  end
+
+  def self.version(*opts)
+    puts 'ElasticDot CLI 1.3.3'
+  end
+
+  def self.ls(*opts)
+    ElasticDot::Command::Apps.list
+  end
+
+  def self.create(args, opts)
+    ElasticDot::Command::Apps.create args, opts
+  end
+
+  def self.info(args, opts)
+    ElasticDot::Command::Apps.info opts
+  end
+
+  def self.open(args, opts)
+    ElasticDot::Command::Apps.open opts
+  end
+end

data/lib/elasticdot/command/apps.rb

@@ -0,0 +1,71 @@
+class ElasticDot::Command::Apps < ElasticDot::Command::Base
+  def self.create(args, opts)
+    info = api.post '/domains', domain: args[0]
+
+    if info['error']
+      puts info['error']
+      exit 1
+    end
+
+    puts "Creating app #{info['app_name']}... done"
+    puts "http://#{info['app_name']}.elasticdot.io/ | #{info['app_repo']}"
+
+    create_git_remote 'elasticdot', info['app_repo']
+  end
+
+  def self.open(opts)
+    require 'launchy'
+
+    find_app! opts
+
+    spinner "Opening #{@app}..." do
+      info = api.get "/domains/#{@app}"
+      Launchy.open info['live_address']
+    end
+  end
+
+  def self.destroy(opts)
+    find_app! opts
+
+    spinner "Destroying app #{@app}..." do
+      api.delete "/domains/#{@app}"
+    end
+  end
+
+  def self.info(opts)
+    find_app! opts
+
+    h = api.get "/domains/#{@app}"
+
+    puts "=== #{@app}"
+    puts
+    puts "Git URL:\t#{h['git_repo']}"
+    puts "Owner Email:\t#{h['owner_email']}"
+    puts "Region:\t\tEU"
+    #   puts "Slug Size:\t#{h['slug_size']}"
+    puts "Web URL:\thttp://#{h['live_address']}"
+
+    return unless (db = h['db'])
+
+    puts
+    puts "=== Database #{db['identifier']}"
+    puts "Plan:           \t#{db['plan']['name']}"
+    puts "Nodes:          \t#{db['plan']['nodes']}" unless db['plan']['shared']
+    puts "Version:        \t#{db['version']}"
+    puts "Status:         \t#{db['status']}"
+    puts "Name:           \t#{db['name']}"
+    puts "User:           \t#{db['user']}"
+    puts "Password:       \t#{db['pass']}"
+    puts "URI:            \t#{db['uri']}"
+    puts "Tables:         \t#{db['tables']}"
+    puts "Disk Space Used:\t#{db['space_used']}"
+    puts "AVG CPU Load:   \t#{db['cpu_load']}"
+    puts "Created at:     \t#{db['created_at']}"
+  end
+
+  def self.list
+    apps = api.get "/apps?type=web"
+    puts '=== My Apps'
+    apps.each { |app| puts app }
+  end
+end

data/lib/elasticdot/command/auth.rb

@@ -0,0 +1,67 @@
+class ElasticDot::Command::Auth < ElasticDot::Command::Base
+  require 'netrc'
+
+  def self.login
+    puts "Enter your ElasticDot credentials."
+
+    print "email: "
+    email = ask
+
+    print "password: "
+
+    echo_off
+    pass = ask_for_password
+    echo_on
+
+    api = ElasticDot::API.new(email: email, password: pass)
+    key = api.login
+
+    netrc.delete 'j.elasticops.com'
+
+    netrc['j.elasticops.com'] = email, key
+    netrc.save
+
+    true
+  end
+
+  def self.logout
+    netrc.delete 'j.elasticops.com'
+    netrc.save
+
+    true
+  end
+
+  def self.authenticate!
+    return true if authenticated?
+    login
+  end
+
+  def self.credentials
+    netrc['j.elasticops.com']
+  end
+
+  private
+  def self.netrc
+    @netrc ||= Netrc.read netrc_path
+  end
+
+  def self.netrc_path
+    default   = Netrc.default_path
+    encrypted = default + ".gpg"
+
+    File.exists?(encrypted) ? encrypted : default
+  end
+
+  def self.ask_for_password
+    echo_off
+    password = ask
+    puts
+    echo_on
+
+    password
+  end
+
+  def self.authenticated?
+    netrc['j.elasticops.com'] ? true : false
+  end
+end

data/lib/elasticdot/command/base.rb

@@ -0,0 +1,121 @@
+class Module
+  def cattr_accessor(attribute_name)
+    class_eval <<-CODE
+      def self.#{attribute_name}
+        @@#{attribute_name} ||= nil
+      end
+      def self.#{attribute_name}=(value)
+        @@#{attribute_name} = value
+      end
+    CODE
+  end
+end
+
+class ElasticDot::Command::Base
+  cattr_accessor :api
+
+  protected
+  def self.echo_off
+    with_tty do
+      system "stty -echo"
+    end
+  end
+
+  def self.echo_on
+    with_tty do
+      system "stty echo"
+    end
+  end
+
+  def self.with_tty(&block)
+    return unless $stdin.isatty
+    yield
+  end
+
+  def self.ask
+    $stdin.gets.to_s.strip
+  end
+
+  def self.find_app!(opts)
+    if opts[:app]
+      @app = opts[:app]
+    elsif app = extract_app_in_dir
+      @app = app
+    end
+
+    return true if @app
+
+    puts 'No app specified.'
+    puts 'Specify which app to use with --app APP.'
+    exit 1
+  end
+
+  def self.has_git?
+    %x{ git --version }
+    $?.success?
+  end
+
+  def self.git(args)
+    return "" unless has_git?
+    flattened_args = [args].flatten.compact.join(" ")
+    %x{ git #{flattened_args} 2>&1 }.strip
+  end
+
+  def self.create_git_remote(remote, url)
+    return if git('remote').split("\n").include?(remote)
+    return unless File.exists?(".git")
+
+    git "remote add #{remote} #{url}"
+
+    puts "Git remote #{remote} added"
+  end
+
+  def self.which(cmd)
+    exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+    ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+      exts.each { |ext|
+        exe = File.join(path, "#{cmd}#{ext}")
+        return exe if File.executable? exe
+      }
+    end
+    return nil
+  end
+
+  def self.extract_app_in_dir
+    if app = extract_app_from_git_config
+      return app
+    elsif app = extract_app_from_git_config('elasticdot')
+      return app
+    else
+      nil
+    end
+  end
+
+  def self.extract_app_from_git_config(remote = 'origin')
+    url = git "config remote.#{remote}.url"
+    return nil if url.empty?
+
+    if  url =~ /^git@git\.elasticdot\.com:([\w\d\-\.]+)\.git$/
+      $1
+    else
+      nil
+    end
+  end
+
+  def self.spinner(desc, &block)
+    chars = %w{ | / - \\ }
+
+    t = Thread.new { block.call }
+    while t.alive?
+      print "#{desc} [#{chars[0]}]"
+      sleep 0.1
+      print "\r"
+
+      chars.push chars.shift
+    end
+
+    t.join
+
+    puts "#{desc} [ok]"
+  end
+end

data/lib/elasticdot/command/config.rb

@@ -0,0 +1,70 @@
+class ElasticDot::Command::Config < ElasticDot::Command::Base
+  def self.set(vars, opts)
+    unless vars.size > 0 and vars.all? { |a| a.include?('=') }
+      puts "Usage: elasticdot config:set KEY1=VALUE1 [KEY2=VALUE2 ...]\nMust specify KEY and VALUE to set."
+      exit 1
+    end
+
+    vars = parse_vars! vars
+
+    find_app! opts
+
+    puts "Setting ENV vars..."
+
+    api.post "/apps/#{@app}/vars", vars: vars
+
+    vars.each { |k, v| puts "#{k}:\t#{v}" }
+
+    puts
+    puts 'Please use ps:restart command to restart your app when you\'re ready.'
+  end
+
+  def self.unset(vars, opts)
+    if vars.empty?
+      puts "Usage: elasticdot config:unset KEY1 [KEY2 ...]\nMust specify KEY to unset."
+      exit 1
+    end
+
+    find_app! opts
+
+    puts "Unsetting ENV vars..."
+
+    api.post "/apps/#{@app}/vars/unset", vars: vars
+
+    puts
+    puts 'Please use ps:restart command to restart your app when you\'re ready.'
+  end
+
+  def self.get(args, opts)
+    var = args.shift
+    find_app! opts
+
+    vars = api.get("/domains/#{@app}")['vars']
+
+    value = vars.select {|v| v['key_name'] == var }.first['value'] rescue nil
+
+    puts value if value
+  end
+
+  def self.list(opts)
+    find_app! opts
+
+    puts "=== #{@app} Config Vars"
+
+    vars = api.get("/domains/#{@app}")['vars']
+
+    vars.each {|v| puts "#{v['key_name']}:\t#{v['value']}" }
+  end
+
+  private
+  def self.parse_vars!(vars)
+    parsed_vars = {}
+
+    vars.each do |var|
+      k, v = var.split '=', 2
+      parsed_vars[k] = v || ''
+    end
+
+    parsed_vars
+  end
+end

data/lib/elasticdot/command/db.rb

@@ -0,0 +1,182 @@
+class ElasticDot::Command::Db < ElasticDot::Command::Base
+  require 'uri'
+
+  def self.promote(opts)
+    find_app! opts
+    find_db!  opts
+
+    spinner "Promoting database..." do
+      info = api.post "/databases/#{@db}/promote", app: @app
+    end
+
+    spinner "Restarting dots..." do
+      loop do
+        sleep 3
+        info = api.get "/domains/#{@app}"
+        break if info['status'] == 'active'
+      end
+    end
+  end
+
+  def self.dump(opts)
+    unless which 'mysqldump'
+      puts 'MySQL client is not installed.'
+      puts 'Please install it to proceed.'
+      exit 1
+    end
+
+    find_db! opts
+
+    info = api.get("/databases/#{@db}")
+
+    uri = URI.parse info['uri']
+
+    system "mysqldump --opt -c -u#{info['user']} -p#{info['pass']} -h#{uri.host} -P#{uri.port} #{info['name']}"
+  end
+
+  def self.console(opts)
+    unless which 'mysql'
+      puts 'MySQL client is not installed.'
+      puts 'Please install it to proceed.'
+      exit 1
+    end
+
+    find_db! opts
+
+    info = api.get("/databases/#{@db}")
+
+    uri = URI.parse info['uri']
+
+    puts 'Attaching... '
+    system "mysql -f -u#{info['user']} -p#{info['pass']} -h#{uri.host} -P#{uri.port} #{info['name']}"
+  end
+
+  def self.import(args, opts)
+    unless which 'mysql'
+      puts 'MySQL client is not installed.'
+      puts 'Please install it to proceed.'
+      exit 1
+    end
+
+    find_db! opts
+
+    dump = args.shift
+    unless dump
+      puts 'Please specify a dump file.'
+      exit 1
+    end
+
+    unless File.exists? dump
+      puts "#{dump}: no such file or directory"
+      exit 1
+    end
+
+    info = api.get("/databases/#{@db}")
+
+    uri = URI.parse info['uri']
+
+    spinner 'Importing...' do
+      system "mysql -f -u#{info['user']} -p#{info['pass']} -h#{uri.host} -P#{uri.port} #{info['name']} < #{dump}"
+    end
+  end
+
+  def self.create(opts)
+    find_plan! opts
+
+    params = {plan: @plan}
+
+    if conf = opts[:conf]
+      unless File.exists? conf
+        puts "#{conf}: no such file or directory"
+        exit 1
+      end
+
+      f = File.read conf
+
+      params.merge!(conf: f)
+    end
+
+    info = api.post "/databases", params
+
+    spinner "Database #{info['identifier']} is provisioning..." do
+      until info['status'] == 'active'
+        sleep 3
+        info = api.get("/databases/#{info['identifier']}")
+      end
+    end
+  end
+
+  def self.destroy(opts)
+    find_db! opts
+
+    print "Destroying database #{@db}... "
+
+    info = api.delete("/databases/#{@db}")
+
+    puts 'done'
+  end
+
+  def self.info(opts)
+    find_db! opts
+
+    db  = api.get("/databases/#{@db}")
+
+    puts "=== Database #{db['identifier']}"
+    puts "Plan:           \t#{db['plan']['name']}"
+    puts "Nodes:          \t#{db['plan']['nodes']}" unless db['plan']['shared']
+    puts "Version:        \t#{db['version']}"
+    puts "Status:         \t#{db['status']}"
+    puts "Name:           \t#{db['name']}"
+    puts "User:           \t#{db['user']}"
+    puts "Password:       \t#{db['pass']}"
+    puts "URI:            \t#{db['uri']}"
+    puts "Tables:         \t#{db['tables']}"
+    puts "Disk Space Used:\t#{db['space_used']}"
+    puts "AVG CPU Load:   \t#{db['cpu_load']}"
+    puts "Created at:     \t#{db['created_at']}"
+  end
+
+  def self.list(opts)
+    puts "=== database list"
+
+    list = api.get("/databases")
+
+    list.each {|db| puts db['identifier'] }
+  end
+
+  private
+  def self.find_db!(opts)
+    @db  = opts[:db]
+    return true if @db
+
+    app   = opts[:app]
+    app ||= extract_app_in_dir
+
+    unless app
+      puts 'No db specified.'
+      puts 'Specify at least option --app or --database.'
+      exit 1
+    end
+
+    info = api.get "/domains/#{app}"
+
+    unless info['db']
+      puts 'This app has no database associated.'
+      puts 'Specify --database option.'
+      exit 1
+    end
+
+    @db = info['db']['identifier']
+
+    true
+  end
+
+  def self.find_plan!(opts)
+    @plan = opts[:plan]
+    return true if @plan
+
+    puts 'No plan specified.'
+    puts 'Specify which plan to use with -p, --plan PLAN.'
+    exit 1
+  end
+end

data/lib/elasticdot/command/domains.rb

@@ -0,0 +1,55 @@
+class ElasticDot::Command::Domains < ElasticDot::Command::Base
+  def self.add(args, opts)
+    domain = args.shift
+    validate_domain! 'add', domain
+
+    app    = opts[:app]
+    find_app! opts
+
+    puts "Adding #{domain} to #{@app}..."
+
+    api.post "/domains/#{@app}/aliases", alias: domain
+  end
+
+  def self.remove(args, opts)
+    domain = args.shift
+    validate_domain! 'remove', 'domain'
+
+    app    = opts[:app]
+    find_app! opts
+
+    puts "Removing #{domain} from #{@app}..."
+
+    api.delete "/domains/#{@app}/aliases/#{domain}"
+  end
+
+  def self.clear(opts)
+    find_app! opts
+
+    domains = api.get("/domains/#{@app}")['aliases']
+
+    puts "Removing all domain names from #{@app}..."
+    domains.each do |d|
+      next if d['factory']
+      api.delete "/domains/#{@app}/aliases/#{d['name']}"
+    end
+  end
+
+  def self.list(opts)
+    find_app! opts
+
+    domains = api.get("/domains/#{@app}")['aliases']
+
+    puts "=== #{@app} Domain Names"
+    domains.each {|d| puts d['name'] }
+  end
+
+  private
+  def self.validate_domain!(m, d)
+    return true if d
+
+    puts "Usage: elasticdot domains:#{m} DOMAIN"
+    puts "Must specify DOMAIN to add."
+    exit 1
+  end
+end

data/lib/elasticdot/command/help.rb

@@ -0,0 +1,106 @@
+class ElasticDot::Command::Help < ElasticDot::Command::Base
+  def self.root_help
+    puts <<-HELP
+Usage: elasticdot COMMAND [--app APP] [command-specific-options]
+
+Primary help topics, type "elasticdot help TOPIC" for more details:
+
+  apps      #  manage apps
+  keys      #  manage authentication keys
+  config    #  manage app config vars
+  domains   #  manage custom domains
+  db        #  manage databases
+  addons    #  manage addon resources
+
+Additional topics:
+
+  help         #  list commands and display help
+  version      #  display version
+    HELP
+  end
+
+  def self.apps
+    puts <<-HELP
+Apps commands:
+
+  apps:create [NAME]      # create a new app
+  apps:destroy            # permanently destroy an app
+  apps:info               # show detailed app information
+  apps:open               # open the app in a web browser
+  apps:list               # show app list
+    HELP
+  end
+
+  def self.addons
+    puts <<-HELP
+Addons commands:
+
+  addons:list                           #  list all available addons
+  addons:add ADDON                      #  install an addon
+  addons:remove ADDON1 [ADDON2 ...]     #  uninstall one or more addons
+    HELP
+  end
+
+  def self.domains
+    puts <<-HELP
+Domains commands:
+
+  domains:add DOMAIN       #  add a custom domain to an app
+  domains:clear            #  remove all custom domains from an app
+  domains:remove DOMAIN    #  remove a custom domain from an app
+    HELP
+  end
+
+  def self.keys
+    puts <<-HELP
+Keys commands:
+
+  keys:add [KEY]     #  add a key for the current user
+  keys:clear         #  remove all authentication keys from the current user
+  keys:remove KEY    #  remove a key from the current user
+    HELP
+  end
+
+  def self.config
+    puts <<-HELP
+Config commands:
+
+  config:get KEY                               #  display a config value for an app
+  config:set KEY1=VALUE1 [KEY2=VALUE2 ...]     #  set one or more config vars
+  config:unset KEY1 [KEY2 ...]                 #  unset one or more config vars
+    HELP
+  end
+
+  def self.ps
+    puts <<-HELP
+PS commands:
+
+  ps:resize  web=TIER                     #  resize dot to the given tier
+  ps:scale   web=N [mode=scaling|manual]  #  scale dots by the given amount
+  ps:stop                                 #  stop all dots
+  ps:restart                              #  restart all dots
+    HELP
+  end
+
+  def self.db
+    puts <<-HELP
+DB commands:
+
+  db:promote  #  sets DATABASE as your DATABASE_URL
+  db:dump     #  print DATABASE dump to stdout
+  db:console  #  open mysql console for DATABASE
+  db:import   #  import dump file to DATABASE
+  db:create   #  create new database
+  db:destroy  #  destroy DATABASE
+  db:info     #  show info for DATABASE
+  db:list     #  list all databases
+    HELP
+  end
+
+  def self.method_missing(m, *args, &block)
+    unless self.respond_to? m
+      puts "Invalid command: #{m}"
+      exit 1
+    end
+  end
+end

data/lib/elasticdot/command/keys.rb

@@ -0,0 +1,93 @@
+class ElasticDot::Command::Keys < ElasticDot::Command::Base
+  def self.add
+    associate_or_generate_ssh_key
+  end
+
+  def self.remove(keys, opts)
+    rkeys = api.get('/stats')['profile']['keys']
+
+    keys.each do |k|
+      rk = rkeys.select {|rk| rk['content'] =~ /#{k}/ }.first
+
+      unless rk
+        puts "Key not found, skipping #{k}..."
+        next
+      end
+
+      api.delete "/account/keys/#{rk['id']}"
+    end
+  end
+
+  def self.clear
+    api.get('/stats')['profile']['keys'].each do |k|
+      api.delete "/account/keys/#{k['id']}"
+    end
+  end
+
+  def self.list
+    puts "=== #{api.email} Keys"
+    keys = api.get('/stats')['profile']['keys'].each do |k|
+      puts k['content']
+    end
+  end
+
+  private
+  def self.associate_or_generate_ssh_key
+    public_keys = Dir.glob("#{Dir.home}/.ssh/*.pub").sort
+
+    case public_keys.length
+    when 0 then
+      puts  "Could not find an existing public key."
+      print "Would you like to generate one? [Yn] "
+
+      if ask.strip.downcase == "y"
+        puts "Generating new SSH public key."
+        generate_ssh_key("id_rsa")
+        associate_key("#{Dir.home}/.ssh/id_rsa.pub")
+      end
+    when 1 then
+      puts "Found existing public key: #{public_keys.first}"
+      associate_key(public_keys.first)
+    else
+      puts "Found the following SSH public keys:"
+      public_keys.each_with_index do |key, index|
+        puts "#{index+1}) #{File.basename(key)}"
+      end
+
+      print "Which would you like to use with your ElasticDot account? "
+      choice = ask.to_i - 1
+      chosen = public_keys[choice]
+      if choice == -1 || chosen.nil?
+        puts "Invalid choice"
+        exit 1
+      end
+
+      associate_key(chosen)
+    end
+  end
+
+  def self.generate_ssh_key(keyfile)
+    ssh_dir = File.join(Dir.home, ".ssh")
+    unless File.exists?(ssh_dir)
+      FileUtils.mkdir_p ssh_dir
+      File.chmod(0700, ssh_dir)
+    end
+
+    output = `ssh-keygen -t rsa -N "" -f \"#{Dir.home}/.ssh/#{keyfile}\" 2>&1`
+    if ! $?.success?
+      puts "Could not generate key: #{output}"
+      exit 1
+    end
+  end
+
+  def self.associate_key(key)
+    puts "Uploading SSH public key #{key}"
+
+    if File.exists?(key)
+      api.post '/account/keys', ssh_key: File.read(key)
+    else
+      puts "Could not upload SSH public key: key file '" + key + "' does not exist"
+      exit 1
+    end
+  end
+end

data/lib/elasticdot/command/logs.rb

@@ -0,0 +1,22 @@
+class ElasticDot::Command::Logs < ElasticDot::Command::Base
+  def self.list(opts)
+    find_app! opts
+
+    max_id = nil
+
+    begin
+      res = api.get "/apps/#{@app}/logs?max_id=#{max_id}"
+      max_id, events = res['max_id'], res['events']
+      events.each {|e| puts e }
+      sleep 2
+    end while opts[:follow]
+  end
+
+  private
+  def self.apps_info(app)
+    info = api.get "/domains/#{app}"
+
+    app_tier = info['production'] ? 'production' : 'development'
+    {app_tier: app_tier, scaling: info['scaling'], tier: info['dot_tier']['name'], dots: info['min_dots'] }
+  end
+end

data/lib/elasticdot/command/ps.rb

@@ -0,0 +1,139 @@
+class ElasticDot::Command::Ps < ElasticDot::Command::Base
+  def self.resize(settings, opts)
+    find_app! opts
+
+    params = apps_info @app
+
+    web = nil
+    settings.each do |s|
+      p, v = s.split('=',2)
+      web = v and break if p == 'web'
+    end
+
+    unless web
+      puts 'At the moment you can only resize web processes'
+      exit 1
+    end
+
+    params[:tier] = web
+
+    api.put "/websites/#{@app}/scaling", params
+
+    spinner "Resizing dots and restarting specified processes..." do
+      loop do
+        sleep 3
+        info = api.get "/domains/#{@app}"
+        break if info['status'] == 'active'
+      end
+    end
+  end
+
+  def self.scale(settings, opts)
+    find_app! opts
+
+    params = apps_info @app
+
+    web, mode = nil
+    settings.each do |s|
+      p, v = s.split('=',2)
+      web  = v if p == 'web'
+      mode = v if p == 'mode'
+    end
+
+    unless web
+      puts 'Usage: elasticdot ps:scale web=N [mode=auto|manual]'
+      exit 1
+    end
+
+    params[:scaling] = mode if mode
+    params[:dots]    = web
+
+    api.put "/websites/#{@app}/scaling", params
+    info = apps_info @app
+
+    spinner "Scaling web processes..." do
+      loop do
+        sleep 3
+        info = api.get "/domains/#{@app}"
+        break if info['status'] == 'active'
+      end
+    end
+
+    puts "Now running #{info[:dots]} dots"
+  end
+
+  def self.list(opts)
+    require 'time'
+
+    find_app! opts
+
+    loop do
+
+      info = api.get("/domains/#{@app}")
+
+      tier = info['dot_tier']
+      dots = info['dots']
+
+      puts "=== web (#{tier['name']}): #{info['procfile']}"
+      dots.each_with_index do |dot, i|
+        now     = Time.now
+        elapsed = now - Time.parse(dot['started_at'])
+        since   = time_ago(now - elapsed)
+
+        puts "web.#{i+1}: up #{since} cpu: #{dot['cpu_load']}%"
+      end
+
+      break unless opts[:follow]
+      sleep 2
+      system 'clear'
+    end
+  end
+
+  def self.restart(opts)
+    find_app! opts
+
+    api.post "/apps/#{@app}/restart"
+
+    spinner 'Restarting dots...' do
+      loop do
+        sleep 3
+        info = api.get "/domains/#{@app}"
+        break if info['status'] == 'active'
+      end
+    end
+  end
+
+  def self.stop(opts)
+    find_app! opts
+
+    spinner "Stopping dots..." do
+      api.post "/apps/#{@app}/stop"
+    end
+  end
+
+  private
+  def self.apps_info(app)
+    info = api.get "/domains/#{@app}"
+
+    app_tier = info['production'] ? 'production' : 'development'
+    {app_tier: app_tier, scaling: info['scaling'], tier: info['dot_tier']['name'], dots: info['min_dots'] }
+  end
+
+  def self.time_ago(since)
+    if since.is_a?(String)
+      since = Time.parse(since)
+    end
+
+    elapsed = Time.now - since
+
+    message = since.strftime("%Y/%m/%d %H:%M:%S")
+    if elapsed <= 60
+      message << " (~ #{elapsed.floor}s ago)"
+    elsif elapsed <= (60 * 60)
+      message << " (~ #{(elapsed / 60).floor}m ago)"
+    elsif elapsed <= (60 * 60 * 25)
+      message << " (~ #{(elapsed / 60 / 60).floor}h ago)"
+    end
+    message
+  end
+end

data/lib/elasticdot/command/services.rb

@@ -0,0 +1,42 @@
+class ElasticDot::Command::Services < ElasticDot::Command::Base
+  def self.create(args, opts)
+    info = api.post '/domains', domain: args[0], type: 'service'
+
+    if info['error']
+      puts info['error']
+      exit 1
+    end
+
+    puts "Creating service app #{info['app_name']}... done"
+    puts info['app_repo']
+
+    create_git_remote 'elasticdot', info['app_repo']
+  end
+
+  def self.destroy(opts)
+    find_app! opts
+
+    spinner "Destroying app #{@app}..." do
+      api.delete "/domains/#{@app}"
+    end
+  end
+
+  def self.info(opts)
+    find_app! opts
+
+    h = api.get "/domains/#{@app}"
+
+    puts "=== #{@app}"
+    puts
+    puts "Git URL:\t#{h['git_repo']}"
+    puts "Owner Email:\t#{h['owner_email']}"
+    puts "Region:\t\tEU"
+    #   puts "Slug Size:\t#{h['slug_size']}"
+  end
+
+  def self.list
+    apps = api.get "/apps?type=service"
+    puts '=== My Services'
+    apps.each { |app| puts app }
+  end
+end

data/lib/elasticdot/initializers/string.rb

@@ -0,0 +1,13 @@
+class String
+  def constantize
+    names = self.split('::')
+    names.shift if names.empty? || names.first.empty?
+
+    constant = Object
+    names.each do |name|
+      constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
+    end
+    constant
+  end
+end
+

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: elasticdot
+version: !ruby/object:Gem::Version
+  version: 1.3.3
+  prerelease: 
+platform: ruby
+authors:
+- ElasticDot
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: netrc
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.7.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.7.7
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.1
+- !ruby/object:Gem::Dependency
+  name: launchy
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.4.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.4.2
+description: ElasticDot Command Line Interface
+email: info@elasticdot.com
+executables:
+- elasticdot
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/elasticdot
+- lib/elasticdot.rb
+- lib/elasticdot/api.rb
+- lib/elasticdot/cli.rb
+- lib/elasticdot/command.rb
+- lib/elasticdot/command/addons.rb
+- lib/elasticdot/command/alias.rb
+- lib/elasticdot/command/apps.rb
+- lib/elasticdot/command/auth.rb
+- lib/elasticdot/command/base.rb
+- lib/elasticdot/command/config.rb
+- lib/elasticdot/command/db.rb
+- lib/elasticdot/command/domains.rb
+- lib/elasticdot/command/help.rb
+- lib/elasticdot/command/keys.rb
+- lib/elasticdot/command/logs.rb
+- lib/elasticdot/command/ps.rb
+- lib/elasticdot/command/services.rb
+- lib/elasticdot/initializers/string.rb
+homepage: http://elasticdot.com
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: ElasticDot CLI
+test_files: []