ubalo 0.1 → 0.2

data/bin/ubalo

@@ -1,6 +1,8 @@
 #!/usr/bin/env ruby
 
 require 'gli'
+include GLI
+
 require 'yaml'
 require 'fileutils'
 
@@ -8,63 +10,38 @@ require 'highline'
 hl = HighLine.new
 
 require 'ubalo'
-require 'ubalo/version'
-include GLI
-
-use_openstruct true
-
-class Ubalo
-  class << self
-    def config
-      if @config
-        @config
-      elsif File.exists?(config_path)
-        @config = YAML.load_file(config_path)
-      else
-        {}
-      end
-    end
-
-    def write_config new_config
-      h = config.merge(new_config)
-      File.open(config_path, 'w') do |f|
-        YAML.dump(h, f)
-      end
-      config
-    end
+include Ubalo
 
-    private
-    def config_path
-      File.expand_path("~/.ubalorc")
-    end
+module Ubalo
+  def config_filename
+    File.expand_path("~/.ubaloconfig")
   end
 end
 
-def ubalo
-  @ubalo
-end
+use_openstruct true
 
-def local_username
-  @local_username || raise(UbaloMessage, "Please re-login to obtain local username")
+logger = Util::Logger.new
+
+def connect_url
+  @connect_url
 end
 
-def normalize_pod_name(pod_name)
-  if pod_name
-    if pod_name[/\//]
-      pod_name
-    else
-      "#{local_username}/#{pod_name}"
-    end
-  else
-    raise UbaloMessage, "Please specify a pod name"
+def account
+  unless @account.authorized?
+    raise Ubalo::Error, "Could not find your credentials. Please run ubalo login."
   end
+  @account
 end
 
-def local_config
-  unless @local_config
-    raise UbaloMessage, "Please run this command from within a local pod directory"
+def pod_dir
+  @pod_dir
+end
+
+def pod
+  unless @pod
+    @pod = account.pod_or_create_by_name!(pod_dir.name)
   end
-  @local_config
+  @pod
 end
 
 program_desc 'Command-line access to ubalo.com.'
@@ -72,79 +49,74 @@ program_desc 'Command-line access to ubalo.com.'
 desc "Change the connect url"
 flag 'connect-url'
 
-desc "Prints the current version of the Ubalo gem"
-switch 'version'
+desc "Override the active pod"
+flag 'pod'
+
+desc "Override the active pod directory"
+flag 'pod-dir'
+
+desc 'Display version'
+command :version do |c|
+  c.action do |global_options,options,args|
+    puts Ubalo::VERSION
+  end
+end
 
 desc 'Display authentication information'
 command :whoami do |c|
   c.action do |global_options,options,args|
-    puts ubalo.whoami
+    puts "You are logged in as #{account.username}."
+  end
+end
+
+desc 'Enter username and password for access'
+command :login do |c|
+  c.desc "Username"
+  c.flag :username
+  c.desc "Password"
+  c.flag :password
+
+  c.action do |global_options,options,args|
+    unless options[:username] and options[:password]
+      puts "Please enter your Ubalo details for command-line access."
+    end
+
+    login = options[:username] || hl.ask("     login: "){|q| q.echo = true}
+    password = options[:password] || hl.ask("  password: "){|q| q.echo = false}
+
+    @account.authorize(login, password)
+    Util.append_config(Ubalo.config_filename, account.base_url, account.as_hash)
+    logger.puts "Success! Ready to use as #{account.username}."
   end
 end
 
 desc 'Display a list of available pods'
 command :pods do |c|
   c.action do |global_options,options,args|
-    pods = ubalo.pods
-    if pods.empty?
-      $stderr.puts "You do not currently have any pods."
-    else
-      pods.each do |pod|
-        puts Ubalo.format_pod(pod)
-      end
+    account.pods.each do |pod|
+      puts "#{pod.fullname}  #{pod.state}  updated #{Util.time_ago_in_words pod.updated_at}"
     end
   end
 end
 
 desc 'Display tasks'
 command :tasks do |c|
-  c.desc 'maximum number of tasks to display'
-  c.default_value 20
-  c.flag 'max'
-
   c.action do |global_options,options,args|
-    ubalo.tasks(options.max).reverse.each do |task|
-      puts Ubalo.format_task(task)
+    account.tasks.each do |task|
+      puts "#{task.label} (#{task.state})  #{task.pod_name}  #{Util.time_ago_in_words task.submitted_at}"
     end
   end
 end
 
-def process_download pod_response, destination_path=nil
-  name = pod_response.fetch('name')
-  fullname = pod_response.fetch('fullname')
-  pod_url = pod_response.fetch('url')
-  files_url = pod_response.fetch('archive').fetch('get_url')
-
-  destination_path ||= name
-
-  if File.exists?(destination_path)
-    raise UbaloMessage, "directory #{destination_path.inspect} already exists"
-  end
-
-  FileUtils.mkdir(destination_path)
-  FileUtils.mkdir(File.join(destination_path, ".ubalo"))
-
-  ubalo.retrieve_files(destination_path, files_url)
-
-  File.open(File.join(destination_path, ".ubalo", "config"), "w") do |f|
-    f.puts(YAML.dump("pod_url" => pod_url))
-  end
-
-  [fullname, destination_path]
-end
-
 desc 'Clone a pod to your computer'
 arg_name '<pod name>'
 command :clone do |c|
   c.action do |global_options,options,args|
-    pod_name = normalize_pod_name(args.shift)
-    destination_path = args.shift
-
-    $stderr.print "Fetching #{pod_name}..."
-    pod_response = ubalo.clone(pod_name)
-
-    fullname, destination_path = process_download(pod_response)
-    $stderr.puts " saved to #{destination_path}."
+    pod = account.pod_by_name!(args.shift)
+    pod_dir = PodDir.new(args.shift || pod.name)
+    logger.print "Fetching #{pod.fullname} to #{pod_dir.path}..."
+    pod.clone_to(pod_dir)
+    logger.puts " saved."
   end
 end
 
@@ -154,179 +126,123 @@ command :delete do |c|
   c.switch :force
 
   c.action do |global_options,options,args|
-    pod_name = normalize_pod_name(args.shift)
+    pod = account.pod_by_name!(args.shift)
 
     if options.force
-      ubalo.delete_pod(pod_name)
+      pod.delete!
     else
       hl.choose do |menu|
-        menu.prompt = "Are you sure you want to delete #{pod_name}? "
+        menu.prompt = "Are you sure you want to delete #{pod.fullname}? "
         menu.choice :yes do
-          $stderr.print "Deleting #{pod_name}..."
-          response = ubalo.delete_pod(pod_name)
-          $stderr.puts " done."
+          pod.delete!
         end
         menu.choice :no do
-          raise UbaloMessage, "Cancelled! No changes made to #{pod_name}."
+          raise Ubalo::Error, "Cancelled! No changes made to #{pod.fullname}."
         end
       end
     end
+    if pod.deleted?
+      logger.puts "Deleted #{pod.fullname}."
+    end
   end
 end
 
-desc 'Run a pod'
-arg_name '<pod name>'
-command :run do |c|
+desc 'Initialize this directory as a pod directory'
+command :init do |c|
+  c.desc "Pod name"
+  c.flag :name
+
   c.action do |global_options,options,args|
-    pod_name = normalize_pod_name(args.shift)
-    arg = args.join(" ")
-    $stderr.print "Running #{pod_name}..."
-
-    response = ubalo.submit_task(pod_name, arg)
-    task_label = response.fetch('label')
-    result = ubalo.wait_task(task_label)
-    ubalo.show_result(result)
+    name = options[:name] || hl.ask(" pod name: "){|q| q.echo = true}
+    pod = account.pod_or_create_by_name!(name)
+    pod_dir.write_name(pod.fullname)
+    logger.puts "Success! Next, run ubalo push."
   end
 end
 
-desc 'Submit a pod for running in the background'
-arg_name '<pod name>'
-command :submit do |c|
+desc 'Run a pod'
+command :run do |c|
   c.action do |global_options,options,args|
-    pod_name = normalize_pod_name(args.shift)
-
-    $stderr.print "Submitting #{pod_name}..."
-    result = ubalo.submit_task(pod_name, args.join(" "))
-    $stderr.puts " submitted."
-
-    ubalo.show_result(result)
+    logger.puts "Running #{pod.fullname}."
+    task = pod.run(nil)
+    logger.poll_on("Waiting for task #{task.label.inspect}") do
+      task.refresh!
+      task.complete?
+    end
+    puts task.printable_result
   end
 end
 
-desc 'Check or get the result of a task'
-arg_name '<task label>'
-command :check do |c|
+desc 'Run a pod in the background'
+command :submit do |c|
   c.action do |global_options,options,args|
-    task_label = args.first
-
-    $stderr.print "Checking task #{task_label}..."
-    result = ubalo.check_task(task_label)
-    $stderr.puts " found."
-
-    ubalo.show_result(result)
+    logger.print "Submitting #{pod.fullname}..."
+    task = pod.run(nil)
+    logger.puts " done."
+    puts task.printable_result
   end
 end
 
-desc 'Pushes a pod directory directly to Ubalo'
-command :push_to do |c|
+desc 'Get the status of a task'
+arg_name '<task label>'
+command :task do |c|
   c.action do |global_options,options,args|
-    pod_name = normalize_pod_name(args.shift)
-
-    # First ensure that the pod exists.
-    pod_url = "#{ubalo.base_url}/pods/#{pod_name}"
-    pod = ubalo.create_or_update(pod_url)
-
-    # Now push the files archive.
-    ubalo.push_files(pod_url)
+    unless label = args.shift
+      raise Ubalo::Error, "please specify a task label"
+    end
+    task = account.task_by_label!(label)
+    logger.print "Getting the status for task #{task.label.inspect}..."
+    task.refresh!
+    logger.puts " found."
+    puts task.printable_result
   end
 end
 
 desc 'Push files to Ubalo'
 command :push do |c|
   c.action do |global_options,options,args|
-    pod_url = local_config.fetch('pod_url')
-    pod = ubalo.create_or_update(pod_url)
-
-    ubalo.push_files(pod_url)
-  end
-end
-
-desc 'Enter username and password for access'
-command :login do |c|
-  c.desc "Username"
-  c.flag :username
-  c.desc "Password"
-  c.flag :password
-
-  c.action do |global_options,options,args|
-    unless options[:username] and options[:password]
-      puts "Please enter your Ubalo details for command-line access."
+    logger.print "Pushing files to #{pod.fullname.inspect}..."
+    pod.push_from(pod_dir)
+    logger.puts " done."
+    logger.poll_on("Waiting for #{pod.fullname.inspect} to compile") do
+      pod.refresh!
+      pod.compiled?
     end
-
-    login = options[:username] || hl.ask("     login: "){|q| q.echo = true}
-    password = options[:password] || hl.ask("  password: "){|q| q.echo = false}
-
-    response = ubalo.get_authorization(login, password)
-    ubalo.authorization = response.fetch('authorization')
-    username = response.fetch('username')
-
-    Ubalo.write_config(ubalo.base_url => {'authorization' => ubalo.authorization, 'username' => username})
-    puts "Success! Ready to use as #{username}."
   end
 end
 
-def unauthorized_command?(command)
-  command && [:login, :help].include?(command.name)
-end
-
 pre do |global,command,options,args|
-  config = Ubalo.config
-  connect_url = global['connect-url'] || config['connect-url'] || "https://ubalo.com"
+  @connect_url = ENV['UBALO_CONNECT_URL'] || "https://ubalo.com"
 
-  if global[:version]
-    print "Ubalo version #{Ubalo::VERSION}"
-    raise UbaloOKExit
-  end
-
-  # When logging in, don't use the authorization:
-  unless unauthorized_command?(command)
-    if host_config = config[connect_url]
-      @local_username = host_config['username']
-      authorization = host_config['authorization']
-    end
-  end
-
-  unless authorization or unauthorized_command?(command)
-    raise UbaloMessage, "No credentials found. Please run 'ubalo login'."
+  config = Util.read_config(Ubalo.config_filename)
+  if account_config = config[connect_url]
+    @account = Account.from_hash(account_config)
+  else
+    @account = Account.new(connect_url)
   end
 
-  local_config_filename = ".ubalo/config"
-  if File.exists?(local_config_filename)
-    full_path = File.expand_path(local_config_filename)
-    @local_config = YAML.load_file(full_path)
+  if pod_name = global['pod']
+    @pod = account.pod_or_create_by_name!(pod_name)
   end
 
-  @ubalo ||= Ubalo.login(authorization, connect_url)
+  @pod_dir = PodDir.new(global['pod-dir'] || ".")
 
   true
 end
 
 on_error do |exception|
-  puts
+  logger.complete_line
   case exception
-  when RestClient::BadRequest
-    $stderr.puts exception.inspect.sub('400 Bad Request', 'Error')
-    false  # no additional raise required.
-  when RestClient::ResourceNotFound
-    $stderr.puts exception.inspect
-    false  # no additional raise required.
-  when RestClient::Unauthorized, RestClient::Forbidden
-    $stderr.puts "Invalid credentials. Please run ubalo login."
-    true  # fall back to GLI's handling
-  when GLI::BadCommandLine
-    true  # fall back to GLI's handling
-  when UbaloOKExit
-    # Normal exit, preserving the correct exit code.
-    exit 0
-  when UbaloMessage
-    $stderr.puts "Error: #{exception.message}"
+  when Ubalo::Error, GLI::UnknownCommand
+    logger.complete_line
+    logger.puts "Error: #{exception.message}"
     exit 1
   when Interrupt
-    $stderr.puts "Cancelled!"
+    logger.complete_line
+    logger.puts "Cancelled!"
     exit 1
   else
-    $stderr.puts "Error! Unfortunately something went wrong. Please contact us: errors@ubalo.com."
-    raise  # and go on to raise
+    raise
   end
 end
 

data/lib/ubalo/account.rb

@@ -0,0 +1,93 @@
+module Ubalo
+  class Account
+    def self.from_hash(h)
+      account = new h.fetch(:base_url)
+      account.username = h.fetch(:username)
+      account.authorization = h.fetch(:authorization)
+      account
+    end
+
+    attr_accessor :username, :authorization
+    attr_reader :base_url
+
+    def initialize(base_url)
+      @base_url = base_url
+    end
+
+    def authorized?
+      !!@authorization
+    end
+
+    def request method, path = nil, options = {}
+      if authorization
+        options[:authorization] = authorization
+      end
+      Util.http_request(method, "#{@base_url}#{path}", options)
+    end
+
+    def authorize(login, password)
+      response = request(:post, "/user/authorization", :params => {:user => {:login => login, :password => password}})
+      @username = response.fetch("username")
+      @authorization = response.fetch("authorization")
+    rescue RestClient::BadRequest
+      raise Ubalo::Error, "Incorrect login or password"
+    end
+
+    def pod_from_json(pod_json)
+      Pod.create_with_json(self, pod_json)
+    end
+
+    def task_from_json(task_json)
+      Task.create_with_json(self, task_json)
+    end
+
+    def archive_from_json(archive_json)
+      PodArchive.create_with_json(self, archive_json)
+    end
+
+    def pods
+      request(:get, "/pods").map do |pod_json|
+        pod_from_json(pod_json)
+      end
+    end
+
+    def pod_by_name!(name)
+      pod_username, pod_name = Util.normalize_pod_name(username, name)
+      pod = Pod.new(self, pod_username, pod_name, {})
+      pod.refresh!
+    end
+
+    def pod_or_create_by_name!(name)
+      pod_username, pod_name = Util.normalize_pod_name(username, name)
+      pod = Pod.new(self, pod_username, pod_name, {})
+      pod.update!
+    end
+
+    def task_by_label!(label)
+      task = Task.new(self, label, {})
+      task.refresh!
+    end
+
+    def tasks
+      request(:get, "/tasks").map do |task_json|
+        task_from_json(task_json)
+      end
+    end
+
+    def as_hash
+      {
+        :base_url => @base_url,
+        :username => username,
+        :authorization => authorization
+      }
+    end
+
+    def inspect
+      "#<Account #{username} #{base_url} #{'authorized' if authorization}>"
+    end
+
+    def ==(other)
+      [base_url, username, authorization] == [base_url, other.username, other.authorization]
+    end
+  end
+end

data/lib/ubalo/pod.rb

@@ -0,0 +1,99 @@
+module Ubalo
+  class Pod
+    include Ubalo::Util
+
+    def self.create_with_json(account, json)
+      new(account, json.fetch('user').fetch('username'), json.fetch('name'), json)
+    end
+
+    attr_reader :username, :name, :state, :archive, :updated_at
+
+    def initialize(account, username, name, attributes)
+      @account = account
+      @username = username
+      @name = name
+      update_attributes(attributes)
+    end
+
+    def update!
+      update_attributes(request(:put))
+    rescue RestClient::ResourceNotFound
+      raise Ubalo::Error, "Could not update pod #{fullname.inspect}"
+    end
+
+    def refresh!
+      update_attributes(request(:get))
+    rescue RestClient::ResourceNotFound
+      raise Ubalo::Error, "Could not find pod #{fullname.inspect}"
+    end
+
+    def fullname
+      "#{@username}/#{@name}"
+    end
+
+    def tasks
+      request(:get, "/tasks").map do |task_json|
+        @account.task_from_json(task_json)
+      end
+    end
+
+    def run(arg)
+      params = {
+        :arg_content_type => UbaloJSON.content_type,
+        :arg => UbaloJSON.dump(arg)
+      }
+      @account.task_from_json(request(:post, "/tasks", :params => params))
+    end
+
+    def push_from(pod_dir)
+      new_archive.activate_from(pod_dir)
+      refresh!
+    end
+
+    def clone_to(pod_dir)
+      refresh!
+      archive.extract_to(pod_dir)
+      pod_dir.write_name(fullname)
+    end
+
+    def compiled?
+      state == 'compiled'
+    end
+
+    def delete!
+      request(:delete, nil, :parse => false)
+      @deleted = true
+    end
+
+    def deleted?
+      !!@deleted
+    end
+
+    def inspect
+      "#<Pod #{fullname.inspect} state=#{state.inspect}>"
+    end
+
+    def ==(other)
+      fullname == other.fullname
+    end
+
+    private
+    def update_attributes(attributes)
+      @state = attributes['state']
+      if archive_attr = attributes['archive']
+        @archive = @account.archive_from_json(archive_attr)
+      end
+      @updated_at = attributes['updated_at']
+      @deleted = false
+      self
+    end
+
+    def new_archive
+      @account.archive_from_json(request(:post, "/archives"))
+    end
+
+    def request method, path = nil, options = {}
+      @account.request(method, "/pods/#{fullname}#{path}", options)
+    end
+  end
+end