zillabyte-cli 0.0.16 → 0.0.17

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MDRiNDYwNjlhZDQwYjc4NGNiNDZlNDkzYjE2NGNjZDhjYzMyNTdlMA==
+    ODVkNDFiMGFlMjc2OWM5MzU2NmY3MzdjZWJiYzIwY2RkNWU2MTdlYQ==
   data.tar.gz: !binary |-
-    YTUzMjI0MGQxYTkyZjE4ODQ0MDU4ODg3MTBkNWM0ZDliNGEwNWQ2NA==
-!binary "U0hBNTEy":
+    ZGI4OTFhZTY3N2E2NDhhZDNmNjBhNTFhNTExZTg4ODgzMTcwYjk3Zg==
+SHA512:
   metadata.gz: !binary |-
-    MmE4Y2RhZWY0ODE2ZTQ2MWIzMTgxMjk1Yzg4NzU0NzhhZWE2YzE2MWJhYzU5
-    ZTJmZjE0NGJmNTBlMjBhOTQ2YTVjNTZlNGQ1ODMzOGMwYTU4N2M4MjhiZTIy
-    MzlkYjc2ZmU2OTM2MjJlMTU1NTQxMDRiMzRmMTYwYTY2YTVhY2U=
+    YWJkZDg3ZGQ2N2E4N2UxNDY4MTRmMDUwNjZhMWY2NjEyNzE1NDE5YWFjNzY0
+    MTRkZTQwZjU1NDUxMmVkMTM2ODE5YWMwNzQ4MzU1ZDE3MWE5ZjQ2MTNjZGY0
+    YmFlOTc5YmJjNzg3OTY4NGVjNGM0YTc3YjU4NTE4YmI1YjIyMmM=
   data.tar.gz: !binary |-
-    ZjAxMzlmOTEyYjI4ZTk2MmU2MWE1NThjMTQ5ODg4MmUxMjc1NDMzMmYxMjYz
-    ZmFlYWEyZjFlNTFmOGIwYTBhZDVkZWI5ZjZkNjI5NDBiMWExOGIzNDY3MTk0
-    ZGY5Yzc4Y2FjMTZhNDY0NTg2M2Q3ZTIwZjg1ZjA3MzA3Y2Y1YmQ=
+    ZmMyZDU5Yzg5NjNlOWQyM2UyZTBlMjA3MThhN2M2M2VkMWI3YzYyOGRhMGQz
+    ZmI5OWM4NDNlNGYyOWFjMDdkNjRlYzM5NTA5MjFjNzlkZGI5MDdlODk1NTA3
+    MzI0N2RjMjQzMWZmNzJkMjA1MTUzYzlhODgwMGE5OWY4ZGMxZWQ=

data/lib/#zillabyte-cli.rb#

@@ -0,0 +1,5 @@
+require "zillabyte-cli/version"
+require "zillabyte/api"
+require "zillabyte/cli"
+require "zillabyte/common"
+require "zillabyte/queries"

data/lib/zillabyte/api/{flows.rb → apps.rb}

@@ -1,10 +1,10 @@
 require 'net/http'
 require 'zillabyte/cli/config'
 
-class Zillabyte::API::Flows < Zillabyte::API::Base
+class Zillabyte::API::Apps < Zillabyte::API::Base
 
 
-  # GET /flows
+  # GET /apps
   def list(options = {})
 
     options = {
@@ -93,7 +93,7 @@ class Zillabyte::API::Flows < Zillabyte::API::Base
     )
     res.body
   end
-  
+
   def run_forever(id, options ={})
     res = @api.request(
       :expects => 200,
@@ -104,14 +104,22 @@ class Zillabyte::API::Flows < Zillabyte::API::Base
     res.body
   end
   
-  
+  def cycles_poll(id, options={})
+    res = @api.request(
+      :expects => 200,
+      :method => :get,
+      :path => "/flows/#{id}/cycles/cycles_poll",
+      :body => options.to_json
+    )
+    res.body
+  end
   
   
   # GET /flows/id
-  def pull_to_directory(id, dir, progress = nil, options = {})
+  def pull_to_directory(id, dir, session = nil, options = {})
     
     # Get the resource. note query params
-    progress.display "downloading ##{id}" if progress
+    session.display "downloading ##{id}" if session
     res = @api.request(
       :expects  => 200,
       :method   => :get,
@@ -123,13 +131,13 @@ class Zillabyte::API::Flows < Zillabyte::API::Base
     hash = res.body
     unless hash['status'] == 'error'
       if(hash['tar'])
-        progress.display "unpacking to #{dir}" if progress
+        session.display "unpacking to #{dir}" if session
         tar = StringIO.new(Base64.decode64(hash['tar']))
         hash.delete('tar')
         Zillabyte::Common::Tar.untar(tar, dir)
 #If you get an uri instead of the tar, then download the file directly from s3
       elsif(hash['uri'])
-        progress.display "downloading ##{id} to #{dir}" if progress
+        session.display "downloading ##{id} to #{dir}" if session
         uri = URI(hash['uri'])
         try_again = 1
         while(try_again)
@@ -155,16 +163,18 @@ class Zillabyte::API::Flows < Zillabyte::API::Base
   
   
   
-  # POST /flows
-  def push_directory(dir, progress = nil, options = {})
+  # POST /apps
+  #
+  def push_directory(dir, session = nil, options = {})
     
+    type = options[:type]
     # Get the meta info
     options[:local_flag] = 1
-    hash = Zillabyte::API::Flows.get_rich_meta_info_from_script(dir, progress, options)
+    hash = Zillabyte::API::Apps.get_rich_meta_info_from_script(dir, session, options)
     if hash.nil?
-      error "unable to extract flow meta information"
+      error("unable to extract app meta information", type)
     end
-        
+
     # Tar up everything... 
     hash['ignore_files'] ||= []
     hash['ignore_files'] << "info_to_ruby.in"
@@ -172,9 +182,9 @@ class Zillabyte::API::Flows < Zillabyte::API::Base
     
     top_dir = hash['top_dir'] || "."
     ignore_files = hash['ignore_files'] || []
-    progress.display("packaging directory... ", false) if progress
+    session.display("packaging directory... ", false) if session && type.nil?
     tar = Zillabyte::Common::Tar.tar(top_dir, ignore_files)
-    progress.display("done") if progress
+    session.display("done") if session && type.nil?
 
     hash.delete('pwd')
 
@@ -184,7 +194,7 @@ class Zillabyte::API::Flows < Zillabyte::API::Base
 #      :tar => Base64.encode64(tar.read)
     }.merge(options)
     
-    progress.display("uploading #{tar.size} bytes... ", false) if progress
+    session.display("uploading #{tar.size} bytes... ", false) if session && type.nil?
     res = @api.request(
       :expects  => 200,
       :method   => :post,
@@ -211,24 +221,26 @@ class Zillabyte::API::Flows < Zillabyte::API::Base
       end
       res.body.delete('uri')
     end
-    progress.display("done")
+    session.display("done")if session && type.nil?
     res.body
     
   end
 
 ####################################################IMPORTANT####################################################
 #                                                                                                               #
-# get_rich_meta_info_from_script only works with zillabyte flows:push now! The pipe "info_to_ruby.in" is        #
+# get_rich_meta_info_from_script only works with zillabyte apps:push now! The pipe "info_to_ruby.in" is        #
 # hardcoded as the meta info passing pipe, so if 2 processes are trying to access it simultaneously there might #
 # be problems since it gets created/destroyed within this script (attempting to create a fifo that already      #
 # exists or deleting a fifo that still has information in it may occur).                                        #
 #                                                                                                               #
 ####################################################IMPORTANT####################################################
-  def self.get_rich_meta_info_from_script(dir, progress = nil, options = {}) 
-    hash = Zillabyte::CLI::Config.get_config_info(dir, progress, options)
+  def self.get_rich_meta_info_from_script(dir, session = nil, options = {})
+    hash = Zillabyte::CLI::Config.get_config_info(dir, session, options)
     if hash.nil?
       return {"status" => "error", "error" => "invalid_directory", "error_message" => "The specified directory (#{dir}) does not appear to contain a valid Zillabyte configuration file."}
     end
+
+    type = options[:type]
     
     full_script = File.join(dir, hash['script'])
     command = nil
@@ -250,16 +262,16 @@ class Zillabyte::API::Flows < Zillabyte::API::Base
 #      command = "#{Zillabyte::API::CASPERJS_BIN} #{Zillabyte::API::API_CLIENT_JS}  \"#{full_script}\" --info"
       command = "cd \"#{dir}\"; NODE_PATH=~/zb1/multilang/js/src/lib #{Zillabyte::API::NODEJS_BIN} \"#{full_script}\" #{arg}"
     else
-      progress.error "unsupported language: #{hash["language"]}" if progress
+      session.error "unsupported language: #{hash["language"]}" if session
       return nil
     end
 
-    results = Zillabyte::Command::Flows.get_info(command, info_file, options)
+    results = Zillabyte::Command::Apps.get_info(command, info_file, options)
 
     begin
       meta = JSON.parse(results.split("\n").first.strip)   # Throws error if invalid json
     rescue Exception => e
-      progress.error "the underlying flow did not return a valid result.  command: #{command} error: #{e.message}" if progress
+      session.error("the underlying app did not return a valid result.  command: #{command} error: #{e.message}", type) if session
       exit
     end
       

data/lib/zillabyte/api/data.rb

@@ -12,7 +12,18 @@ class Zillabyte::API::Data < Zillabyte::API::Base
     )
     res.body
   end
-  
+ 
+  def show(id, method, options = {})
+    res = @api.request(
+      :expects  => 200,
+      :method   => method,
+      :path     => "/relations/#{CGI.escape(id)}/samples",
+      :body     => options.to_json
+    )
+
+    res.body
+  end 
+
   def pull(id, options = {})
     res = @api.request(
       :expects  => 200,

data/lib/zillabyte/api/logs.rb

@@ -5,7 +5,7 @@ class Zillabyte::API::Logs < Zillabyte::API::Base
 
 
   # GET /flows/ID/logs
-  def get(flow_id, operation_id, options = {}, &block)
+  def get(app_id, operation_id, options = {}, &block)
     
     options = {
     }.merge(options)
@@ -13,7 +13,7 @@ class Zillabyte::API::Logs < Zillabyte::API::Base
     res = @api.request({
       :expects  => 200,
       :method   => :get,
-      :path     => "/flows/#{flow_id}/logs/#{operation_id}/stream",
+      :path     => "/flows/#{app_id}/logs/#{operation_id}/stream",
       :body     => options.to_json
     }, &block)
 
@@ -23,7 +23,7 @@ class Zillabyte::API::Logs < Zillabyte::API::Base
   
   
   
-  def get_startup(flow_id, operation_id, options = {}, &block)
+  def get_startup(app_id, operation_id, options = {}, &block)
     
     options = {
     }.merge(options)
@@ -31,7 +31,7 @@ class Zillabyte::API::Logs < Zillabyte::API::Base
     res = @api.request({
       :expects  => 200,
       :method   => :get,
-      :path     => "/flows/#{flow_id}/logs/#{operation_id}/startup",
+      :path     => "/flows/#{app_id}/logs/#{operation_id}/startup",
       :body     => options.to_json
     }, &block)
 

data/lib/zillabyte/api/queries.rb

@@ -2,7 +2,7 @@ class Zillabyte::API::Queries < Zillabyte::API::Base
 
 
   # GET /sxp
-  def sxp(expression, options = {})
+  def sxp(expression, method, options = {})
 
     options = {
       'sxp' => expression
@@ -10,7 +10,7 @@ class Zillabyte::API::Queries < Zillabyte::API::Base
     
     res = request(
       :expects  => 200,
-      :method   => :post,
+      :method   => method,
       :path     => "/query_sxp",
       :body     => options.to_json
     )
@@ -35,7 +35,7 @@ class Zillabyte::API::Queries < Zillabyte::API::Base
 
 
   # GET /sql
-  def sql(expression, options = {})
+  def sql(expression, method, options = {})
 
     options = {
       'sql' => expression
@@ -43,7 +43,7 @@ class Zillabyte::API::Queries < Zillabyte::API::Base
     
     res = request(
       :expects  => 200,
-      :method   => :post,
+      :method   => method,
       :path     => "/query_sql",
       :body     => options.to_json
     )
@@ -57,12 +57,21 @@ class Zillabyte::API::Queries < Zillabyte::API::Base
   def agnostic(expression, options = {})
     case expression
     when Array
-      return sxp(expression, options)
+      res = sxp(expression, :post, options)
     when String
-      return sql(expression, options)
+      res = sql(expression, :post, options)
+      col_aliases = res["column_aliases"] #save the column aliases
     else
       throw "unknown expression type: #{expression}"
     end
+
+    options[:job_id] = res["job_id"]
+    res = {'status' => nil}
+    while(res['status'] != 'completed')
+      res = sql(expression, :get, options)
+    end
+    res["return"]["column_aliases"] = col_aliases if col_aliases #send the column aliases back too
+    res["return"]
   end
   
 

data/lib/zillabyte/api/zillalogs.rb

@@ -21,7 +21,7 @@ class Zillabyte::API::Zillalogs < Zillabyte::API::Base
   
   
   # GET /zillalogs/id
-  def find(id, progress = nil, options = {})
+  def find(id, session = nil, options = {})
     
     # Get the resource
     res = @api.request(

data/lib/zillabyte/api.rb

@@ -39,8 +39,7 @@ class Zillabyte::API
 
   def initialize(options={})
     options = OPTIONS.merge(options)
-
-    @progress = options.delete(:progress)
+    @session = options.delete(:session)
     @api_key = options.delete(:api_key) || ENV['ZILLABYTE_API_KEY']
     
     options[:headers] = HEADERS.merge({ 
@@ -49,7 +48,6 @@ class Zillabyte::API
 
     @options = options.clone
     @options[:bubble_exceptions] = ENV['BUBBLE_EXCEPTIONS'] || false
-
     @connection = Excon.new("#{options[:scheme]}://#{options[:host]}", options)
 
   end
@@ -61,6 +59,17 @@ class Zillabyte::API
   
 
   def request(params, &block)
+
+    if @session.nil?
+      error "no session associated with request"
+    end
+
+    type = nil
+    if @options
+      type = @options[:type]
+    end
+
+
     begin
       
       # If a block is given, then we assume we're streaming (i.e. for logs)
@@ -88,16 +97,14 @@ class Zillabyte::API
               next if json_record.strip == ""
               
               if json_record.start_with?("HTTP/1.1 50")
-                puts "internal server error (code 500)"
-                exit(1)
+                @session.error("internal server error (code 500)", type)
               end
               
               # Offer all the json records to the listening block
               begin
                 block.call(JSON.parse(json_record))
               rescue JSON::ParserError => e
-                error "unable to parse logs"
-                exit(1)
+                @session.error("unable to parse logs", type)
               end
               
             end
@@ -107,47 +114,46 @@ class Zillabyte::API
       
       # Execute the request
       response = @connection.request(params)
-      
+
+
     rescue Excon::Errors::HTTPStatusError => error
-      if @progress
+
         
-        # Show helpful error message
-        if error.response.body
-          begin
-            hash = JSON.parse(error.response.body)
-            if hash['error_message']
-              @progress.error hash['error_message']
-            end
-          rescue JSON::ParserError => e
-            # Trickle to generic message below
+      # Show helpful error message
+      if error.response.body
+        begin
+          hash = JSON.parse(error.response.body)
+          if hash['error_message']
+            @session.error(hash['error_message'], type)
           end
+        rescue JSON::ParserError => e
+          # Trickle to generic message below
         end
-        
-        @progress.error "internal server error"
-        
       end
+
+
+      @session.error("internal server error:: #{error}", type)
+        
       raise error
     end
-    
+   
     if response.body && !response.body.empty?
       # decompress_response!(response)
       begin
         response.body = JSON.parse(response.body)
       rescue Exception => e
         raise e if @options[:bubble_exceptions]
-        @progress.error "unknown server response: \n #{response.body}" if @progress
+        @session.error("unknown server response: \n #{response.body}", type)
       end
     end
     
     # Errors?
     if response.body.is_a?(Hash)
       if response.body["status"] == "error"
-        if @progress
-          if response.body["error"] == "authentication_error"
-            @progress.error "authentication error. run 'zillabyte login'"
-          else
-            @progress.error response.body["error_message"] 
-          end
+        if response.body["error"] == "authentication_error"
+          @session.error("authentication error. run 'zillabyte login'", type)
+        else
+          @session.error(response.body["error_message"],type)
         end
       end
     end
@@ -174,10 +180,10 @@ class Zillabyte::API
   end
   alias_method :query, :queries
   
-  def flows
-    @_flows ||= ::Zillabyte::API::Flows.new(self)
+  def apps
+    @_apps ||= ::Zillabyte::API::Apps.new(self)
   end
-  alias_method :flow, :flows
+  alias_method :app, :apps
   
   def metrics
     @_metrics ||= ::Zillabyte::API::Metrics.new(self)
@@ -194,7 +200,6 @@ class Zillabyte::API
   end
   alias_method :source, :sources
   
-  
   def collectors
     @_collectors ||= ::Zillabyte::API::Collectors.new(self)
   end
@@ -204,12 +209,9 @@ class Zillabyte::API
     @_rules ||= ::Zillabyte::API::SemanticTags.new(self)
   end
   alias_method :zillalog, :zillalogs
-  
-  
-  
-  
-  
+
   def self.load
+    require File.join(File.dirname(__FILE__), "api", "base.rb")
     Dir[File.join(File.dirname(__FILE__), "api", "*.rb")].sort.each do |file|
       require file
     end

data/lib/zillabyte/auth.rb

@@ -136,7 +136,7 @@ class Zillabyte::Auth
     end
 
     def valid_credentials?(auth_token)
-      api = Zillabyte::API.new(:api_key => auth_token, :progress => self)
+      api = Zillabyte::API.new(:api_key => auth_token, :session => self)
       response = api.request(
         :expects  => 200,
         :method   => :get,
@@ -148,24 +148,32 @@ class Zillabyte::Auth
 
     def ask_for_and_save_credentials
       if not read_credentials.nil?
-        display "Your credentials already exist. Re-enter them? [Y/n]"
-        $stdout.flush()
-        if ask == 'Y' 
-          
-        else
+        display "Your credentials already exist. Re-enter them? [y/N] ", false
+
+        input = ask
+
+        if !(input.downcase == "y" || input.downcase == "yes")
           exit 1
         end
       end
-      begin 
-        puts "Enter your Zillabyte credentials."
+
+      begin
+        current_command = Zillabyte::Command.current_command  
+        msg = "Enter your Zillabyte credentials"
+        msg += " (or press enter to continue as an anonymous user)." if current_command == "relations" 
+        puts msg
         print "Auth Token: "
         $stdout.flush()
         auth_token = ask
         print "\n"
-        if not valid_credentials?(auth_token)
-          raise Zillabyte::Auth::InvalidCredentialsException
+        if current_command == "relations" and auth_token == ""
+          display "No auth token provided, continuing as anonymous user. Note that you will only be shown publicly available listings."
         else
-          write_credentials(auth_token)
+          if not valid_credentials?(auth_token)
+            raise Zillabyte::Auth::InvalidCredentialsException
+          else
+            write_credentials(auth_token)
+          end
         end
       rescue Zillabyte::Auth::InvalidCredentialsException => e
         display "Authentication failed."

data/lib/zillabyte/cli/#logs.rb#

@@ -0,0 +1,12 @@
+require "zillabyte/cli/base"
+
+# manage custom logs
+#
+class Zillabyte::Command::Logs < Zillabyte::Command::Base
+
+
+
+  
+  
+
+end