ubalo 0.1 → 0.2

data/lib/ubalo/pod_archive.rb

@@ -0,0 +1,54 @@
+module Ubalo
+  class PodArchive
+    def self.create_with_json(account, json)
+      new(account, json.fetch('label'), json)
+    end
+
+    attr_reader :label, :put_url, :get_url
+
+    def initialize(account, label, attributes)
+      @account = account
+      @label = label
+      update_attributes(attributes)
+    end
+
+    def activate_from(pod_dir)
+      with_temp_archive do |archive_name|
+        pod_dir.make_archive(archive_name)
+        Util.put_targz(put_url, archive_name)
+        request(:put, "/activate")
+      end
+    end
+
+    def extract_to(pod_dir)
+      with_temp_archive do |archive_name|
+        Util.get_targz(get_url, archive_name)
+        pod_dir.extract_archive(archive_name)
+      end
+    end
+
+    def inspect
+      "#<PodArchive #{label.inspect}>"
+    end
+
+    def ==(other)
+      label == other.label
+    end
+
+    private
+    def update_attributes(attributes)
+      @get_url = attributes['get_url']
+      @put_url = attributes['put_url']
+    end
+
+    def request method, path = nil, options = {}
+      update_attributes(@account.request(method, "/archives/#{label}#{path}", options))
+    end
+
+    def with_temp_archive
+      Dir.mktmpdir do |dir|
+        yield File.join(dir, "ubalo-files.tar.gz")
+      end
+    end
+  end
+end

data/lib/ubalo/pod_dir.rb

@@ -0,0 +1,81 @@
+require 'zlib'
+require 'archive/tar/minitar'
+require 'fileutils'
+
+module Ubalo
+  class PodDir
+    attr_reader :path
+
+    def initialize(path)
+      @path = path
+    end
+
+    def name
+      in_path do
+        File.read("Ubalopod").strip
+      end
+    rescue Errno::ENOENT
+      raise Ubalo::Error, "Please run this command from a pod directory"
+    end
+
+    def write_name(name)
+      in_path do
+        File.open("Ubalopod", "w") do |f|
+          f.puts name
+        end
+      end
+    end
+
+    def manifest
+      in_path do
+        Dir.glob('{.**,**}').map do |path|
+          next if ignore_patterns.any? do |pattern|
+            File.fnmatch?(pattern, path, File::FNM_DOTMATCH)
+          end
+          path
+        end.compact
+      end
+    end
+
+    def make_archive archive_name
+      in_path do
+        raise Ubalo::Error, "no files to push" if manifest.empty?
+        archive = Zlib::GzipWriter.new(File.open(archive_name, 'wb'))
+        Archive::Tar::Minitar.pack(manifest, archive)
+      end
+    end
+
+    def extract_archive archive_name
+      in_path do
+        archive = Zlib::GzipReader.new(File.open(archive_name, 'rb'))
+        Archive::Tar::Minitar.unpack(archive, ".")
+      end
+    end
+
+    def inspect
+      "#<PodDir path=#{path.inspect}>"
+    end
+
+    private
+    def ignore_patterns
+      return @ignore_patterns if @ignore_patterns
+
+      ignore_filename = in_path{File.expand_path(".ubaloignore")}
+      if File.exist?(ignore_filename)
+        @ignore_patterns = File.read(ignore_filename).each_line.map(&:strip)
+      else
+        @ignore_patterns = []
+      end
+
+      @ignore_patterns += %w{. .. Ubalopod}
+    end
+
+    def in_path
+      epath = File.expand_path(path)
+      FileUtils.mkdir_p(epath) unless File.directory?(epath)
+      Dir.chdir(epath) do
+        yield
+      end
+    end
+  end
+end

data/lib/ubalo/task.rb

@@ -0,0 +1,87 @@
+module Ubalo
+  class Task
+    attr_reader :label, :state, :pod_name, :arg, :output, :submitted_at
+
+    def self.create_with_json(account, json)
+      new(account, json.fetch('label'), json)
+    end
+
+    def initialize(account, label, attributes)
+      @account = account
+      @label = label
+      update_attributes(attributes)
+    end
+
+    def refresh!
+      update_attributes(request(:get))
+    rescue RestClient::ResourceNotFound
+      raise Ubalo::Error, "Could not find task #{label.inspect}"
+    end
+
+    def pending?
+      %w{waiting running}.include?(state)
+    end
+
+    def complete?
+      state == 'exited'
+    end
+
+    def inspect
+      "#<Task #{label.inspect} state=#{state.inspect}>"
+    end
+
+    def ==(other)
+      label == other.label
+    end
+
+    def printable_result
+      s = ""
+      s << " label: #{label}\n"
+      s << "   pod: #{pod_name}\n"
+      if arg
+        s << "   arg:\n"
+        s << Util.indent(arg.pretty_inspect)
+      end
+      s << " state: #{state}\n"
+
+      if container_process
+        s << "status: #{container_process.fetch('exit_result')}\n"
+
+        if stdout = container_process.fetch('stdout') and stdout.length > 0
+          s << "stdout:\n"
+          s << Util.indent(stdout)
+        end
+
+        if stderr = container_process.fetch('stderr') and stderr.length > 0
+          s << "stderr:\n"
+          s << Util.indent(stderr)
+        end
+      end
+
+      if output
+        s << "output:\n"
+        s << printable_task_content('output', output)
+      end
+      s
+    end
+
+    private
+    attr_reader :container_process
+
+    def update_attributes(attributes)
+      @state = attributes['state']
+      @arg = attributes['arg']
+      @pod_name = attributes['pod_name']
+      @container_process = attributes['container_process']
+      @submitted_at = attributes['submitted_at']
+
+      @arg = Util.decode_content(attributes['arg']) if attributes['arg']
+      @output = Util.decode_content(attributes['outputs']) if attributes['outputs']
+      self
+    end
+
+    def request method, path = nil, options = {}
+      @account.request(method, "/tasks/#{label}#{path}", options)
+    end
+  end
+end

data/lib/ubalo/util.rb

@@ -0,0 +1,189 @@
+require 'json'
+
+module Ubalo
+  module Util
+    class UbaloJSON
+      class << self
+        def content_type
+          "application/json; schema=ubalo-data"
+        end
+
+        def dump(obj)
+          JSON.dump('data' => obj)
+        end
+
+        def load(data)
+          JSON.load(data)['data']
+        end
+      end
+    end
+
+    class Logger
+      def initialize
+        @incomplete_line = false
+      end
+
+      def print(str)
+        @incomplete_line = true
+        $stderr.print(str)
+      end
+
+      def puts(str)
+        @incomplete_line = false
+        $stderr.print(str + "\n")
+      end
+
+      def complete_line
+        $stderr.print("\n") if @incomplete_line
+        @incomplete_line = false
+      end
+
+      def poll_on(message)
+        self.print message
+        600.times do
+          if result = yield
+            self.puts " done."
+            return result
+          end
+          self.print '.'
+          sleep 0.5
+        end
+
+        self.puts
+        raise UbaloError, "timed-out polling on #{message}"
+      end
+    end
+
+    class << self
+      def normalize_pod_name(default_username, pod_name)
+        if pod_name.include?("/")
+          username, pod_name = (pod_name or "").split '/', 2
+        else
+          username, pod_name = default_username, pod_name
+        end
+      end
+
+      def put_targz(url, archive_name)
+        response = RestClient.put(url, File.open(archive_name, 'rb'), :content_type => 'application/x-tar', :content_encoding => 'x-gzip')
+
+        unless response.code == 200
+          raise UbaloError, "could not upload pod files"
+        end
+      end
+
+      def get_targz(url, archive_name)
+        RestClient.get(url) do |response,*_|
+          if response.code == 200
+            File.open(archive_name, "wb") do |f|
+              f.write response
+            end
+          else
+            raise UbaloError, "failed to download pod files"
+          end
+        end
+      end
+
+      def http_request(method, url, options)
+        params = options.delete(:params) || {}
+
+        headers = {:accept => :json, 'X-Ubalo-Version' => Ubalo::VERSION}
+
+        if authorization = options.delete(:authorization)
+          headers.merge!(:authorization => authorization)
+        end
+
+        if debug_mode?
+          $stderr.puts "about to #{method.inspect} to #{url.inspect} with #{options.inspect}"
+        end
+
+        resource = RestClient::Resource.new url, :timeout => 60
+        case method
+        when :get
+          response = resource.get headers.merge(:params => params)
+        when :post
+          response = resource.post params, headers
+        when :put
+          response = resource.put params, headers
+        when :delete
+          response = resource.delete headers
+        else
+          raise "don't understand request method #{method.inspect}"
+        end
+
+        if options.delete(:parse) == false
+          response
+        else
+          JSON.load(response)
+        end
+      end
+
+      def pluralize count, word
+        if count == 1
+          "#{count} #{word}"
+        else
+          "#{count} #{word}s"
+        end
+      end
+
+      def time_ago_in_words time
+        seconds = Time.now - Time.parse(time)
+        case
+        when seconds < 60
+          "#{pluralize(seconds.floor, "second")} ago"
+        when seconds/60 < 60
+          "#{pluralize((seconds/60).floor, "minute")} ago"
+        when seconds/60/60 < 24
+          "#{pluralize((seconds/60/60).floor, "hour")} ago"
+        else
+          "#{pluralize((seconds/60/60/24).floor, "day")} ago"
+        end
+      end
+
+      def indent str, amount=2
+        if str
+          str.each_line.map do |l|
+            " "*amount + l
+          end.join
+        else
+          ""
+        end
+      end
+
+      def decode_content encoded
+        data = encoded.fetch('data')
+        content_type = encoded.fetch('content_type')
+        if content_type == UbaloJSON.content_type
+          s = UbaloJSON.load(data)
+        else
+          raise UbaloError, "cannot understand content of this type"
+        end
+      end
+
+      def read_config(filename)
+        if File.exists?(filename)
+          YAML.load_file(filename)
+        else
+          {}
+        end
+      end
+
+      def append_config(filename, key, key_config)
+        config = read_config(filename)
+        config[key] = key_config
+        write_config(filename, config)
+      end
+
+      def write_config(filename, config)
+        File.open(filename, 'w') do |f|
+          YAML.dump(config, f)
+        end
+      end
+
+      private
+      def debug_mode?
+        ENV['UBALO_DEBUG'] == 'true'
+      end
+
+    end
+  end
+end

data/lib/ubalo/version.rb

@@ -1,5 +1,5 @@
-class Ubalo
+module Ubalo
   unless const_defined?('VERSION')
-    VERSION = "0.1"
+    VERSION = "0.2"
   end
 end