pagoda 0.3.2 → 0.5.0

data/lib/pagoda/cli/helpers/app.rb

@@ -0,0 +1,143 @@
+module Pagoda
+  module Command
+
+    class App < Base
+
+      def list
+        apps = client.app_list
+        unless apps.empty?
+          display
+          display "APPS"
+          display "//////////////////////////////////"
+          display
+          apps.each do |app|
+            display "- #{app[:name]}"
+          end
+        else
+          error ["looks like you haven't launched any apps", "type 'pagoda create' to create this project on pagodabox"]
+        end
+        display
+      end
+
+      def info
+        display
+        info = client.app_info(app)
+        error("What application are you looking for?") unless info.is_a?(Hash)
+        display "INFO - #{info[:name]}"
+        display "//////////////////////////////////"
+        display "name        :  #{info[:name]}"
+        display "clone url   :  git@pagodabox.com:#{info[:id]}.git"
+        display
+        display "owner"
+        display "   username :  #{info[:owner][:username]}"
+        display "   email    :  #{info[:owner][:email]}"
+        display
+        display "collaborators"
+        info[:collaborators].each do |collab|
+        display "   username :  #{collab[:username]}"
+        display "   email    :  #{collab[:email]}"
+        end
+        display
+        display "ssh_portal  :  #{info[:ssh] ? 'enabled' : 'disabled'}"
+        display
+      end
+
+      def rename
+        old_name = options[:old] || app
+        new_name = options[:new] || args.first
+        error "I need the new name" unless new_name
+        error "New name and existiong name cannot be the same" if new_name == old_name
+        client.app_update(old_name, {:name => new_name})
+        display "Successfully changed name to #{new_name}"
+      rescue
+        error "Given name was either invalid or already in use"
+      end
+
+      def init
+        id = client.app_info(args.first || app)[:id] rescue error("We could not find the application you were looking for")
+        create_git_remote(id, remote)
+      end
+
+      def clone
+        my_app = args.first || app
+        id = client.app_info(my_app)[:id]
+        display
+        git "clone git@git.pagodabox.com:#{id}.git #{my_app}"
+        Dir.chdir(my_app)
+        git "config --add pagoda.id #{id}"
+        Dir.chdir("..")
+        display
+        display "+> Repo has been added. Navigate to folder #{my_app}."
+      rescue
+        error "We were not able to access that app"
+      end
+
+      def create
+        name = args.first || app
+        if client.app_available?(name)
+          id = client.app_create(name)[:id]
+          display("Creating #{name}...", false)
+          loop_transaction(name)
+          d_remote = create_git_remote(id, remote)
+          display "#{name} created"
+          display "----------------------------------------------------"
+          display
+          display "LIVE URL    : http://#{name}.pagodabox.com"
+          display "ADMIN PANEL : http://dashboard.pagodabox.com/apps/#{name}"
+          display
+          display "----------------------------------------------------"
+          display
+          display "+> Use 'git push #{d_remote} --all' to push your code live"
+        else
+          error "App name (#{name}) is already taken"
+        end
+      end
+
+      def deploy
+        display
+        my_app = app
+        if client.app_info(my_app)[:active_transaction_id] == nil
+          begin
+            client.app_deploy(my_app, branch, commit)
+          rescue RestClient::Found => e
+            # do nothing because we found it HURRAY!
+          end
+          display "+> deploying current branch and commit...", true
+          loop_transaction
+        else
+          error "Your app is currently in transaction, Please try again later."          
+        end
+      end
+
+      def rollback
+        display
+        client.app_rollback(app)
+        display "+> undo..."
+        loop_transaction
+        display
+      end
+
+      def destroy
+        display
+        my_app = app
+        dname = display_name(my_app) # Make the app name look better
+        if options[:force]
+          display "+> Destroying #{dname}"
+          client.app_destroy(my_app)
+          display "+> #{dname} has been successfully destroyed. RIP #{dname}."
+          remove_app(my_app)
+        else
+          if confirm ["Are you totally completely sure you want to delete #{dname} forever and ever?", "THIS CANNOT BE UNDONE! (y/n)"]
+            display
+            display "+> Destroying #{dname}"
+            client.app_destroy(my_app)
+            display "+> #{dname} has been successfully destroyed. RIP #{dname}."
+            remove_app(my_app)
+          end
+        end
+        display
+      end
+      
+    end
+  end  
+end

data/lib/pagoda/cli/helpers/base.rb

@@ -0,0 +1,199 @@
+require 'pagoda-client'
+
+module Pagoda
+  module Command
+
+    class Base
+      include Pagoda::Helpers
+
+      class << self
+        include Pagoda::Helpers
+        def ask_for_credentials
+          username = ask "Username: "
+          display "Password: ", false
+          password = running_on_windows? ? ask_for_password_on_windows : ask_for_password
+          # api_key =  Pagoda::Client.new(user, password).api_key
+          [username, password] # return
+        end
+
+        def ask_for_password
+          echo_off
+          password = ask
+          puts
+          echo_on
+          return password
+        end
+
+        def ask_for_password_on_windows
+          require "Win32API"
+          char = nil
+          password = ''
+          
+          while char = Win32API.new("crtdll", "_getch", [ ], "L").Call do
+            break if char == 10 || char == 13 # received carriage return or newline
+            if char == 127 || char == 8 # backspace and delete
+              password.slice!(-1, 1)
+            else
+              # windows might throw a -1 at us so make sure to handle RangeError
+              (password << char.chr) rescue RangeError
+            end
+          end
+          return password
+        end
+
+        def echo_off
+          silently(system("stty -echo"))
+        rescue
+        end
+
+        def echo_on
+          silently(system("stty echo"))
+        rescue
+        end
+                  
+      end
+      
+      attr_reader :client
+      attr_reader :globals
+      attr_reader :options
+      attr_reader :args
+
+      def initialize(globals, options, args)
+        @globals = globals
+        @options = options
+        @args = args
+      end
+
+      def user
+        globals[:username]
+      end
+
+      def password
+        globals[:password]
+      end
+
+      def client
+        @client ||= Pagoda::Client.new(user, password)
+      end
+
+      # protected
+      
+      def shell(cmd)
+        FileUtils.cd(Dir.pwd) {|d| return `#{cmd}`}
+      end
+      
+      def remote
+        options[:remote] || "pagoda"
+      end
+
+      def app(soft_fail=true)
+        if app = globals[:app] || options[:app]
+          app
+        elsif app = extract_app_from_git_config
+          app
+        elsif app = extract_app_from_remote
+          app
+        else
+          if soft_fail
+            display "I was unable to find your application name."
+            ask "what is the name of your application? "
+          else
+            error "Unable to find the app. please specify using -a or --app="
+          end
+        end
+      end
+      
+      def extract_app_from_git_config
+        remote = git("config pagoda.id")
+        if remote =~ /error: More than one value for the key pagoda.id/
+          git("config --unset-all pagoda.id") 
+          return nil
+        end
+        remote == "" ? nil : remote
+      end
+
+      def extract_app_from_remote
+        remotes = git_remotes
+        if remotes.length == 1
+          remotes.values.first
+        end
+      end
+
+      def git_remotes(base_dir=Dir.pwd)
+        remotes = {}
+        original_dir = Dir.pwd
+        Dir.chdir(base_dir)
+        git("remote -v").split("\n").each do |remote|
+          name, url, method = remote.split(/\s/)
+          if url =~ /^git@git.pagodabox.com:([\w\d-]+)\.git$/
+            remotes[name] = $1
+          end
+        end
+        Dir.chdir(original_dir)
+        remotes
+      end
+
+      def branch
+        options[:branch] || find_branch
+      end
+      
+      def commit
+        options[:commit] || find_commit
+      end
+      
+      def find_branch
+        if git("name-rev --refs=$(git symbolic-ref HEAD) --name-only HEAD") =~ /Could not get/
+          error "Cannot find your branch"
+        else
+          git("name-rev --refs=$(git symbolic-ref HEAD) --name-only HEAD")
+        end
+      end
+
+      def home_dir
+        File.expand_path("~")
+      end
+      
+      def find_commit
+        if git("rev-parse --verify HEAD") =~ /Could not get/
+          error "Cannot find your commit"
+        else
+          git("rev-parse --verify HEAD")
+        end
+      end
+      
+      def extract_git_clone_url(remote="pagoda")
+        git("config remote.#{remote}.url")
+      end
+      
+      def locate_app_root(dir=Dir.pwd)
+        return dir if File.exists? "#{dir}/.git/config"
+        parent = dir.split('/')[0..-2].join('/')
+        return false if parent.empty?
+        locate_app_root(parent)
+      end
+
+      def loop_transaction(app_name = nil)
+        use_app = app_name || app
+        transaction_id = client.app_info(use_app)[:active_transaction_id]
+        if transaction_id
+          log_stream_length = 0
+          display("",true,0)
+          while true
+            start = Time.now
+            active = client.transaction_info(use_app, transaction_id)
+            unless active[:log_stream].length == log_stream_length
+              display( active[:log_stream][log_stream_length..-1].join("\n"),true,0)
+              log_stream_length = active[:log_stream].length
+            end
+            break unless active[:state] == "incomplete"
+            sleep(Time.now - start) if (Time.now - start) > 0
+          end
+        end
+        display('',true,0)
+        display( "Complete!",true,0)
+        display('',true,0)
+      end
+    end
+
+  end
+end

data/lib/pagoda/cli/helpers/key.rb

@@ -0,0 +1,69 @@
+
+module Pagoda
+  module Command
+
+    class Key < Base
+
+      def generate_key_and_push
+        display 
+        display "+> Generating a ssh key pair"
+        display 
+        if running_on_windows?
+          display "It appears you are running on windows"
+          display "the best way to generate a key is with an external tool"
+          display "We suggest using 'PuTTY'"
+        else
+          (options[:file] ?  `ssh-keygen -f #{options[:file]}` : `ssh-keygen`)
+          display
+          push_existing_key
+        end
+      end
+
+      def push_existing_key
+        if file_path = options[:file] || args.first
+          unless file_path[0] == '/'
+            file_path = Dir.pwd << '/' << file_path
+          end
+          unless file_path.end_with?(".pub")
+            file_path << ".pub"
+          end
+          if File.exists?(file_path)
+            send_key_file(file_path)
+          else
+            error "file given '#{file_path}' does not exist"
+          end
+        else
+          if File.exists?("#{home_dir}/.ssh/id_rsa.pub") || File.exists?("~/.ssh/id_dsa.pub")
+            if File.exists?("#{home_dir}/.ssh/id_rsa.pub")
+              send_key_file("#{home_dir}/.ssh/id_rsa.pub")
+            end
+
+            if File.exists?("#{home_dir}/.ssh/id_dsa.pub")
+              send_key_file("#{home_dir}/.ssh/id_dsa.pub")
+            end
+          else
+            display "It appears you do not have a public key."
+            display "One should be generated with either id-rsa.pub or id-rsa.pub"
+            display "in the #{home_dir}/.ssh folder."
+            display "Or you could specify the file 'pagoda key:gen ~/.ssh/my_awesome_key.pub"
+          end
+        end
+      end
+
+      def send_key_file(file)
+        key = File.read(file).strip
+        if key =~ /^ssh-(?:dss|rsa) [A-Za-z0-9+\/]+/
+          client.user_add_key(key)
+          display "+> Pushing ssh key to Pagoda Box"
+          display "+> done"
+        else
+          error "that key is not the correct format"
+        end
+      rescue RestClient::UnprocessableEntity
+        error "It Appears this key is already in use"
+      end
+
+    end
+
+  end
+end

data/lib/pagoda/cli/helpers/tunnel.rb

@@ -0,0 +1,36 @@
+require 'pagoda-tunnel'
+
+module Pagoda::Command
+  class Tunnel < Base
+
+    def run
+      user_input = options[:component] || args.first
+      component = {}
+      begin
+        if user_input =~ /^(web\d*)|(db\d*)|(cache\d*)|(worker\d*)$/
+          components = client.component_list(app)
+          components.delete_if {|x| x[:cuid] != user_input }
+          component = components[0]
+        else
+          component = client.component_info(app, user_input)
+        end
+      rescue
+        errors = []
+        errors << "Input unrecoginized"
+        errors << "try 'pagoda -a <appname> tunnel <component>'"
+        errors << "ie. 'pagoda -a app tunnel db1'"
+        error errors
+      end
+      if component[:tunnelable]
+        type = component[:_type]
+        component_id = component[:_id]
+        app_id = component[:app_id]
+        Pagoda::Tunnel.new(type, user, password, app_id, component_id).start
+      else
+        error "Either the component is not tunnelable or you do not have access"
+      end
+
+    end
+
+  end
+end

data/lib/pagoda/cli/helpers.rb

@@ -0,0 +1,127 @@
+module Pagoda
+  module Helpers
+    INDENT = "  "
+    
+    def home_directory
+      running_on_windows? ? ENV['USERPROFILE'] : ENV['HOME']
+    end
+
+    def running_on_windows?
+      RUBY_PLATFORM =~ /mswin32|mingw32/
+    end
+
+    def running_on_a_mac?
+      RUBY_PLATFORM =~ /-darwin\d/
+    end
+
+    def display(msg="", newline=true, level=1)
+      indent = build_indent(level)
+      if newline
+        (running_on_windows?) ? puts("#{indent}#{msg}") : puts("#{indent}#{msg}".green)
+      else
+        (running_on_windows?) ? print("#{indent}#{msg}") : print("#{indent}#{msg}".green)
+        STDOUT.flush
+      end
+    end
+    
+    def format_date(date)
+      date = Time.parse(date) if date.is_a?(String)
+      date.strftime("%Y-%m-%d %H:%M %Z")
+    end
+
+    def ask(message=nil, level=1)
+      (running_on_windows?) ? print("#{build_indent(level)}#{message}") : print("#{build_indent(level)}#{message}".blue)
+      STDOUT.flush
+      STDIN.gets.strip
+    end
+    
+    def confirm(message="Are you sure you wish to continue? (y/n)?", level=1)
+      return true if ARGV.include? "-f"
+      case message
+      when Array
+        count = message.length
+        iteration = 0
+        message.each do |m|
+          if iteration == count - 1
+            (running_on_windows?) ? display("#{m} ", false, level) : display("#{m} ".blue, false, level)
+          else
+            (running_on_windows?) ? display("#{m} ", false, level) : display("#{m} ".blue, true, level)
+          end
+          iteration += 1
+        end
+      when String
+        (running_on_windows?) ? display("#{message} ", false, level) : display("#{message} ".blue, false, level)
+      end
+      ask.downcase == 'y'
+    end
+
+    def error(msg, exit=true, level=1)
+      indent = build_indent(level)
+      STDERR.puts
+      case msg
+      when Array
+        (running_on_windows?) ? STDERR.puts("#{indent}** Error:") : STDERR.puts("#{indent}** Error:".red)
+        msg.each do |m|
+          (running_on_windows?) ? STDERR.puts("#{indent}** #{m}") : STDERR.puts("#{indent}** #{m}".red)
+        end
+      when String
+        (running_on_windows?) ? STDERR.puts("#{indent}** Error: #{msg}") : STDERR.puts("#{indent}** Error: #{msg}".red)
+      end
+      STDERR.puts
+      exit 1 if exit
+    end
+    
+    def has_git?
+      %x{ git --version }
+      $?.success?
+    end
+
+    def display_name(app)
+      client.app_info(app)[:name]
+    end
+
+    def git(args)
+      return "" unless has_git?
+      flattened_args = [args].flatten.compact.join(" ")
+      %x{ git #{flattened_args} 2>&1 }.strip
+    end
+
+    def create_git_remote(id, remote)
+      error "you do not have git installed on your computer" unless has_git?
+      if git('remote').split("\n").include?(remote)
+        display "Given remote (#{remote}) is already in use on this repo" 
+        remote = ask "what would you like to call the new remote? "
+      end
+      unless File.directory?(".git")
+        if confirm "git has not been initialized yet, would you like us to do this for you? (y/n)?"
+          display "git repo is being created in '#{Dir.pwd}'"
+          git "init"
+        else
+          error(["repo has not been initialized." , "try 'git init'"])
+        end
+      end
+      git "remote add #{remote} git@git.pagodabox.com:#{id}.git"
+      git "config --add pagoda.id #{id}"
+      display "Git remote #{remote} added"
+      remote
+    end
+
+    def remove_app(app)
+      remove_git_remote(app)
+    end
+
+    def remove_git_remote(app)
+      git "remote rm pagoda"
+      git "config --unset pagoda.id"
+    end
+
+    def build_indent(level=1)
+      indent = ""
+      level.times do
+        indent += INDENT
+      end
+      indent
+    end
+    
+  end
+end

data/lib/pagoda/cli/override.rb

@@ -0,0 +1,23 @@
+unless Object.respond_to? :tap
+  class Object
+    def tap
+      yield(self)
+      self
+    end
+  end
+end
+
+module GLI
+  def command(*names, &block)
+    command = Command.new([names].flatten,@@next_desc,@@next_arg_name,@@next_long_desc,@@skips_pre,@@skips_post)
+    commands[command.name] = command
+    command.instance_eval(&block)
+    # yield command
+    command.tap do |c|
+      c.desc "Help"
+      c.switch [:h, :help]
+    end
+    clear_nexts
+  end
+
+end

data/lib/pagoda/cli/version.rb

@@ -0,0 +1,5 @@
+module Pagoda
+  module CLI
+    VERSION = "0.5.0"
+  end
+end

data/lib/pagoda/cli.rb

@@ -0,0 +1,11 @@
+# Dir[File.join(".", "**/*.rb")].each { |f| print require f; puts f}
+require 'pagoda/cli/commands'
+require 'pagoda/cli/core_ext'
+require 'pagoda/cli/helpers'
+require 'pagoda/cli/helpers/base'
+
+module Pagoda
+  module CLI
+
+  end
+end

data/lib/pagoda-cli.rb

@@ -0,0 +1 @@
+require 'pagoda/cli'

data/pagoda.gemspec

@@ -1,29 +1,25 @@
 # -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "pagoda/version"
+require File.expand_path('../lib/pagoda/cli/version', __FILE__)
 
-Gem::Specification.new do |s|
-  s.name        = "pagoda"
-  s.version     = Pagoda::VERSION
-  s.platform    = Gem::Platform::RUBY
-  s.authors     = ["lyon hill"]
-  s.email       = ["hal@pagodabox.com"]
-  s.homepage    = "http://www.pagodabox.com/"
-  s.summary     = %q{Terminal client for interacting with the pagodabox}
-  s.description = %q{Terminal client for interacting with the pagodabox. This client does not contain full api functionality, just functionality that will enhance the workflow experience.}
+Gem::Specification.new do |gem|
+  gem.authors       = ["Lyon Hill"]
+  gem.email         = ["lyon@pagodabox.com"]
+  gem.summary       = %q{Pagoda Box CLI}
+  gem.description   = %q{Pagoda Box User facing interface to improve workflow with Pagoda Box}
+  gem.homepage      = "http://www.pagodabox.com"
 
-  s.rubyforge_project = "pagoda"
-  
-  s.add_development_dependency "rspec"
-  s.add_development_dependency "webmock"
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "pagoda"
+  gem.require_paths = ["lib"]
+  gem.version       = Pagoda::CLI::VERSION
 
-  s.add_dependency "crack"
-  s.add_dependency "iniparse"
-  s.add_dependency "json_pure"
-  s.add_dependency "rest-client"
+  gem.add_development_dependency "rspec"
+  gem.add_development_dependency "pry"
 
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
-end
+  gem.add_dependency "pagoda-client"
+  gem.add_dependency "pagoda-tunnel"
+  gem.add_dependency "rest-client"
+  gem.add_dependency "gli"
+end