debox 0.0.1

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*~
+#*
+.#*

data/.rspec

@@ -0,0 +1 @@
+--colour

data/Gemfile

@@ -0,0 +1,15 @@
+source 'https://rubygems.org'
+gem 'json'
+gem 'netrc'
+gem 'highline'
+gem 'eventmachine'
+gem 'em-eventsource'
+
+# Specify your gem's dependencies in debox.gemspec
+gemspec
+
+group :test do
+  gem 'debox_server'
+  gem 'rspec'
+  gem 'thin'
+end

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Eloy Gomez
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# Debox
+
+Command line tool for Debox
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'debox'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install debox
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/bin/debox

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+
+require "pathname"
+bin_file = Pathname.new(__FILE__).realpath
+
+# add self to libpath
+$:.unshift File.expand_path("../../lib", bin_file)
+
+# start up the CLI
+require "debox"
+require "debox/cli"
+
+Debox::CLI.new(*ARGV).start

data/debox.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/debox/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Eloy Gomez"]
+  gem.email         = ["eloy@indeos.es"]
+  gem.description   = "CLI for debox"
+  gem.summary       = "Debox is a deploy manager"
+  gem.homepage      = "https://github.com/harlock/debox"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "debox"
+  gem.require_paths = ["lib"]
+  gem.version       = Debox::VERSION
+
+  gem.add_runtime_dependency 'json'
+  gem.add_runtime_dependency 'netrc'
+  gem.add_runtime_dependency 'highline'
+  gem.add_runtime_dependency 'eventmachine'
+  gem.add_runtime_dependency 'em-eventsource'
+end

data/lib/debox.rb

@@ -0,0 +1,9 @@
+require 'json'
+require 'tempfile'
+require 'digest/md5'
+require "debox/version"
+require "debox/config"
+require "debox/command"
+
+module Debox
+end

data/lib/debox/api.rb

@@ -0,0 +1,261 @@
+require "net/http"
+require 'base64'
+require 'eventmachine'
+require 'em-eventsource'
+
+module Debox
+  module API
+
+    # Return the api_key for the user
+    # @params:
+    #   :host
+    #   :user
+    #   :password
+    def self.api_key(opt)
+      get_raw '/v1/api_key', opt, skip_basic_auth: true
+    end
+
+    # apps
+    #----------------------------------------------------------------------
+    def self.apps
+      get '/v1/apps'
+    end
+
+    # users
+    #----------------------------------------------------------------------
+
+    # Create a new user
+    # @params:
+    #   :host
+    #   :user
+    #   :password
+    def self.users_create(opt)
+      post_raw '/v1/users/create', user: opt[:user], password: opt[:password]
+    end
+
+    def self.users_delete(opt)
+      delete_raw '/v1/users/destroy', user: opt[:user]
+    end
+
+    # Return existing users
+    def self.users
+      get '/v1/users'
+    end
+
+    # recipes
+    #----------------------------------------------------------------------
+
+    def self.recipes(opt)
+      get("/v1/recipes/#{opt[:app]}")
+    end
+
+    def self.recipes_new(opt)
+      get_raw("/v1/recipes/#{opt[:app]}/#{opt[:env]}/new").body
+    end
+
+    def self.recipes_show(opt)
+      get_raw("/v1/recipes/#{opt[:app]}/#{opt[:env]}").body
+    end
+
+    def self.recipes_create(opt)
+      post_raw "/v1/recipes/#{opt[:app]}/#{opt[:env]}", content: opt[:content]
+    end
+
+    def self.recipes_update(opt)
+      put_raw "/v1/recipes/#{opt[:app]}/#{opt[:env]}", content: opt[:content]
+    end
+
+    def self.recipes_destroy(opt)
+      delete_raw("/v1/recipes/#{opt[:app]}/#{opt[:env]}")
+    end
+
+    # Cap
+    #----------------------------------------------------------------------
+
+    def self.cap(opt, &block)
+      path = "/v1/cap/#{opt[:app]}"
+      path += "/#{opt[:env]}" if opt[:env]
+      path += "?task=#{opt[:task]}" if opt[:task]
+      get(path)
+    end
+
+    # Public key
+    #----------------------------------------------------------------------
+
+    def self.public_key
+      get_raw('/v1/public_key').body
+    end
+
+    # logs
+    #----------------------------------------------------------------------
+
+    def self.live(opt, &block)
+      path = "/v1/live/log/#{opt[:app]}"
+      path += "/#{opt[:env]}" if opt[:env]
+
+      # stream path, nil, { }, block
+      eventSource path, { }, block
+    end
+
+    def self.logs(opt)
+      path = "/v1/logs/#{opt[:app]}"
+      path += "/#{opt[:env]}" if opt[:env]
+      get path
+    end
+
+    def self.log(opt)
+      path = "/v1/log/#{opt[:app]}"
+      path += "/#{opt[:env]}" if opt[:env]
+      path += "?index=#{opt[:index]}" if opt[:index]
+      get_raw(path).body
+    end
+
+    private
+
+    # HTTP helpers
+    #----------------------------------------------------------------------
+
+    def self.post_raw(path, request_params=nil, options={})
+      run_request :post, path, request_params, options
+    end
+
+    def self.post(path, request_params=nil, options={})
+      JSON.parse post_raw(path, request_params, options).body, symbolize_names: true
+    end
+
+    def self.get_raw(path, request_params=nil, options={})
+      run_request :get, path, request_params, options
+    end
+
+    def self.get(path, request_params=nil, options={})
+      JSON.parse get_raw(path, request_params, options).body, symbolize_names: true
+    end
+
+    def self.put_raw(path, request_params=nil, options={})
+      run_request :put, path, request_params, options
+    end
+
+    def self.put(path, request_params=nil, options={})
+      JSON.parse put_raw(path, request_params, options).body, symbolize_names: true
+    end
+
+    def self.delete_raw(path, request_params=nil, options={})
+      run_request :delete, path, request_params, options
+    end
+
+    def self.delete(path, request_params=nil, options={})
+      JSON.parse delete_raw(path, request_params, options).body, symbolize_names: true
+    end
+
+
+    # Create a new Net::HTTP request
+    def self.new_request(type, path, request_params=nil, options={})
+      if type == :post
+        request = Net::HTTP::Post.new(path)
+      elsif type == :put
+        request = Net::HTTP::Put.new(path)
+      elsif type == :get
+        request = Net::HTTP::Get.new(path)
+      elsif type == :delete
+        request = Net::HTTP::Delete.new(path)
+      else
+        error_and_exit "Invalid request type: #{type}"
+      end
+
+      request.set_form_data(request_params) if request_params
+
+      if !options[:skip_basic_auth] && Debox::Config.logged_in?
+        request.basic_auth Debox.config[:user], Debox.config[:api_key]
+      end
+        return request
+    end
+
+    def self.is_valid_response?(response)
+      !response.code.match(/^20/).nil?
+    end
+
+    def self.check_errors(response)
+      unauthorized_error if response.code == "401"
+      server_error if response.code == "500"
+      not_found_error if response.code == "404"
+      error_and_exit("#{response.code}: #{response.body}") unless is_valid_response? response
+    end
+
+    # Run request
+    def self.run_request(type, path, request_params=nil, options={})
+      request = new_request type, path, request_params, options
+      http = Net::HTTP.new Debox.config[:host], Debox.config[:port]
+      response = http.request(request)
+      # Process errors
+      check_errors response
+      return response
+    end
+
+    # Run request and read run block with the chunk
+    def self.stream(path, request_params=nil, options={ }, block)
+      request = new_request :get, path, request_params, options
+      http = http_connection
+      http.request(request) do | response|
+        check_errors response
+        response.read_body do |chunk|
+          block.call chunk
+        end
+      end
+    end
+
+
+    def self.eventSource(path, query={ }, block)
+      host = "http://#{Debox.config[:host]}:#{Debox.config[:port]}"
+      auth = [Debox.config[:user], Debox.config[:api_key]].join(':')
+      headers = { 'Authorization' =>  "Basic #{Base64.strict_encode64 auth}" }
+
+      EM.run do
+        source = EventMachine::EventSource.new("#{host}#{path}", query, headers )
+        source.message do |m|
+          block.call m
+        end
+
+        source.error do |error|
+          puts "ERROR: #{error}"
+          EM.stop
+        end
+
+        source.on 'finish' do
+          puts "Job finished"
+          source.close
+          EM.stop
+        end
+
+        source.start
+      end
+
+    end
+
+
+    def self.http_connection
+      http = Net::HTTP.start(Debox.config[:host], Debox.config[:port])
+      # Set timeout to 30 min
+      http.read_timeout = 180000
+      return http
+    end
+
+    def self.unauthorized_error
+      error_and_exit "Access denied. Please login first."
+    end
+
+    def self.server_error
+      error_and_exit "Ups, something went wrong. Please, try later."
+    end
+
+    def self.not_found_error
+      error_and_exit "Ups, something went wrong (not found). Please, try to update your client."
+    end
+
+    def self.error_and_exit(msg)
+      raise DeboxServerException.new msg
+    end
+  end
+
+  class DeboxServerException < Exception
+  end
+end

data/lib/debox/cli.rb

@@ -0,0 +1,111 @@
+class Debox::CLI
+  include Debox::Utils
+
+  def initialize(*args)
+    @args = args
+    option_parser.parse! args
+  end
+
+  # Run the command requested in the command line
+  def run_command(args)
+    Debox::Command.load
+    given_command = args.shift.strip rescue "help"
+    if given_command == 'help' || options[:show_help]
+      help_and_exit
+    end
+    command = Debox::Command.get_command given_command
+    unless command
+      puts "Invalid command #{given_command}"
+      help_and_error
+    end
+
+    Debox::Config.merge_command_line_options! options
+    Debox::Command.run(command, options, args)
+  end
+
+  # Prepare the console and run the command
+  def start
+    begin
+      $stdin.sync = true if $stdin.isatty
+      $stdout.sync = true if $stdout.isatty
+
+      # Run the commands
+      run_command @args
+
+    rescue Interrupt => error
+      puts 'stty icanon echo, Command cancelled.'
+      puts error.backtrace
+    rescue => error
+      puts error
+      puts "--------------------------------------------------------------------------------"
+      puts error.backtrace
+      exit(1)
+    end
+  end
+
+  def option_parser
+    @option_parser ||= new_option_parser
+  end
+
+  private
+
+  def help_show
+    puts "Usage: debox command [options]"
+    puts "Commands:"
+    Debox::Command.commands.values.each do |cmd|
+      puts help_content cmd
+    end
+    puts option_parser.help
+  end
+
+  def help_content(cmd)
+    help = cmd[:help]
+    command = cmd[:command]
+    params_str = help[:params].join ' '
+    opt_params_str = help[:opt_params].map { |p| "[#{p}]"}.join ' '
+    help_text = help[:text]
+    command_str = "    #{command} #{params_str} #{opt_params_str}".ljust(50)
+    "#{command_str} # #{help_text}"
+  end
+
+  def help_and_exit
+    help_show
+    exit 0
+  end
+
+
+  def help_and_error
+    help_show
+    exit 1
+  end
+
+  def options
+    @options ||= {}
+  end
+
+
+  def new_option_parser
+    OptionParser.new do |opts|
+      opts.banner = "Options:"
+      opts.on("-h", "--host SERVER_HOST", "Debox server url") do |host|
+        options[:host] = host
+        # If host option, set default port unless defined
+        options[:port] = 80 unless options[:port]
+      end
+
+      opts.on("-p", "--port PORT", "Debox server port") do |port|
+        options[:port] = port
+      end
+
+      opts.on("-u", "--user EMAIL", "User name") do |u|
+        options[:user] = u
+      end
+
+      opts.on("-?", "--help", "Show this help") do |v|
+        options[:show_help] = true
+      end
+
+    end
+  end
+
+end