zillabyte-cli 0.0.9

data/lib/zillabyte/api/zillalogs.rb

@@ -0,0 +1,66 @@
+
+class Zillabyte::API::Zillalogs < Zillabyte::API::Base
+
+
+  # GET /zillalogs
+  def list(options = {})
+
+    options = {
+      # TODO
+    }.merge(options)
+    
+    res = @api.request(
+      :expects  => 200,
+      :method   => :get,
+      :path     => "/zillalogs"
+    )
+    
+    res.body
+
+  end
+  
+  
+  # GET /zillalogs/id
+  def find(id, progress = nil, options = {})
+    
+    # Get the resource
+    res = @api.request(
+      :expects  => 200,
+      :method   => :get,
+      :path     => "/zillalogs/#{id}"
+    )
+    
+    res.body
+    
+  end
+  
+  
+  
+  
+  # POST /zillalogs
+  def save(id, name, zillalog, options = {})
+    
+    options = {
+      :name => name,
+      :zillalog => zillalog
+    }.merge(options)
+    
+    options[:id] = id if id
+    
+    res = @api.request(
+      :expects  => 200,
+      :method   => :post,
+      :path     => "/zillalogs",
+      :body     => options.to_json
+    )
+
+    res.body
+    
+  end
+  
+  
+
+  protected
+  
+
+end

data/lib/zillabyte/api.rb

@@ -0,0 +1,170 @@
+# load('zillabyte/helpers.rb') # reload helpers after possible inject_loadpath
+# load('zillabyte/updater.rb') # reload updater after possible inject_loadpath
+
+require "base64"
+require "excon"
+# require "securerandom"
+require "uri"
+require "zlib"
+require "active_support/core_ext/object/to_query.rb"
+require 'json'
+
+
+# workaround for rescue/reraise to define errors in command.rb failing in 1.8.6
+if RUBY_VERSION =~ /^1.8.6/
+  # require('zillabyte-api')
+  require('rest_client')
+end
+
+class Zillabyte::API
+
+  HEADERS = {
+    'Accept'                => 'application/json',
+    'Content-Type'          => 'application/json',
+    # 'Accept-Encoding'       => 'gzip',
+    'User-Agent'            => "zillabyte/#{Zillabyte::CLI::VERSION}",
+    'X-Ruby-Version'        => RUBY_VERSION,
+    'X-Ruby-Platform'       => RUBY_PLATFORM
+  }
+
+  OPTIONS = {
+    :headers  => {},
+    :host     => ENV['ZILLABYTE_API_HOST'] || 'api.zillabyte.com',
+    :port     => (ENV['ZILLABYTE_API_PORT'] || '80').to_i,
+    :nonblock => false,
+    :scheme   => 'http'
+  }
+
+  
+
+  def initialize(options={})
+    options = OPTIONS.merge(options)
+
+    @progress = options.delete(:progress)
+    @api_key = options.delete(:api_key) || ENV['ZILLABYTE_API_KEY']
+    
+    options[:headers] = HEADERS.merge({ 
+      'Authorization' => "auth_token #{@api_key}",
+    }).merge(options[:headers])
+
+    @options = options.clone
+    @options[:bubble_exceptions] = ENV['BUBBLE_EXCEPTIONS'] || false
+
+    @connection = Excon.new("#{options[:scheme]}://#{options[:host]}", options)
+    
+  end
+  
+  
+  def host
+    @options[:host]
+  end
+  
+
+  def request(params, &block)
+    begin
+# The @connection object handles connections to api.zillabyte.com via Excon, this sends a command to the Rails api code
+# with parameters in params (one of which contains the path to the method to be run in the form of a url, e.g. if the
+# :path parameter is set to /functions/#{id}?tar=1, then the show method in functions_controller.rb will be automatically
+# called...it will have it's own set of parameters which correspond to the items in the query string).
+      response = @connection.request(params, &block)
+    rescue Excon::Errors::HTTPStatusError => error
+      @progress.error "internal server error" if @progress
+      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
+      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
+        end
+      end
+    end
+    
+
+    # reset (non-persistent) connection
+    @connection.reset
+
+    response
+  end
+  
+  
+  def data
+    @_data ||= ::Zillabyte::API::Data.new(self)
+  end
+  
+  def logs
+    @_logs ||= ::Zillabyte::API::Logs.new(self)
+  end
+  
+  
+  def queries
+    @_queries ||= ::Zillabyte::API::Queries.new(self)
+  end
+  alias_method :query, :queries
+  
+  def flows
+    @_flows ||= ::Zillabyte::API::Flows.new(self)
+  end
+  alias_method :flow, :flows
+  
+  def metrics
+    @_metrics ||= ::Zillabyte::API::Metrics.new(self)
+  end
+  alias_method :metric, :metrics
+  
+  def zillalogs
+    @_rules ||= ::Zillabyte::API::Zillalogs.new(self)
+  end
+  alias_method :zillalog, :zillalogs
+  
+  def sources
+    @_sources ||= ::Zillabyte::API::Sources.new(self)
+  end
+  alias_method :source, :sources
+  
+  
+  def collectors
+    @_collectors ||= ::Zillabyte::API::Collectors.new(self)
+  end
+  alias_method :collector, :collectors
+  
+  def semantic_tags
+    @_rules ||= ::Zillabyte::API::SemanticTags.new(self)
+  end
+  alias_method :zillalog, :zillalogs
+  
+  
+  
+  
+  
+  def self.load
+    Dir[File.join(File.dirname(__FILE__), "api", "*.rb")].sort.each do |file|
+      require file
+    end
+    
+    Dir[File.join(File.dirname(__FILE__), "api", "helpers", "*.rb")].sort.each do |file|
+      require file
+    end
+  end
+
+
+end
+
+
+# Load all helpers...
+Zillabyte::API.load()

data/lib/zillabyte/auth.rb

@@ -0,0 +1,155 @@
+require "cgi"
+require "zillabyte/helpers"
+
+require "netrc"
+
+class Zillabyte::Auth
+  class << self
+    include Zillabyte::Helpers
+
+    attr_accessor :credentials
+
+
+
+
+    def get_credentials!
+      
+    end
+
+
+    def login
+      delete_credentials
+      get_credentials
+    end
+
+    def logout
+      delete_credentials
+    end
+
+    # just a stub; will raise if not authenticated
+    # def check
+    #   api.get_user
+    # end
+
+    def default_host
+      ENV['ZILLABYTE_API_HOST'] || 'api.zillabyte.com'
+    end
+
+    def host
+      default_host
+    end
+
+    def reauthorize
+      @credentials = ask_for_and_save_credentials
+    end
+
+    # def user    # :nodoc:
+    #   get_credentials[0]
+    # end
+
+    # def password    # :nodoc:
+#       get_credentials[1]
+#     end
+
+    def api_key
+      get_credentials
+    end
+
+    def get_credentials    # :nodoc:
+      @credentials ||= (read_credentials || ask_for_and_save_credentials)
+    end
+
+    def delete_credentials
+      netrc.delete(host)
+      netrc.save
+      @credentials = nil
+    end
+
+    def netrc_path
+      default = Netrc.default_path
+      encrypted = default + ".gpg"
+      if File.exists?(encrypted)
+        encrypted
+      else
+        default
+      end
+    end
+
+    def netrc   # :nodoc:
+      @netrc ||= begin
+        Netrc.read(netrc_path)
+      rescue => error
+        if error.message =~ /^Permission bits for/
+          perm = File.stat(netrc_path).mode & 0777
+          abort("Permissions #{perm} for '#{netrc_path}' are too open. You should run `chmod 0600 #{netrc_path}` so that your credentials are NOT accessible by others.")
+        else
+          raise error
+        end
+      end
+    end
+
+    def read_credentials
+      if ENV['ZILLABYTE_API_KEY']
+        ENV['ZILLABYTE_API_KEY']
+      else
+        # read netrc credentials if they exist
+        if netrc
+          if netrc[host]
+            netrc[host][1]
+          else
+            nil
+          end
+        end
+      end
+    end
+
+    def write_credentials
+      FileUtils.mkdir_p(File.dirname(netrc_path))
+      FileUtils.touch(netrc_path)
+      netrc[host] = ["login", self.credentials]
+      netrc.save
+    end
+
+    def echo_off
+      with_tty do
+        system "stty -echo"
+      end
+    end
+
+    def echo_on
+      with_tty do
+        system "stty echo"
+      end
+    end
+
+    def ask_for_credentials
+      puts "Enter your Zillabyte credentials."
+      print "Email: "
+      $stdout.flush()
+      email = ask
+      print "Auth Token: "
+      $stdout.flush()
+      auth_token = ask
+      print "\n" 
+      
+      auth_token
+      
+    end
+
+    def ask_for_and_save_credentials
+      begin
+        @credentials = ask_for_credentials
+        write_credentials
+        # check
+      end
+      @credentials
+    end
+
+    def retry_login?
+      @login_attempts ||= 0
+      @login_attempts += 1
+      @login_attempts < 3
+    end
+
+  end
+end

data/lib/zillabyte/cli/auth.rb

@@ -0,0 +1,33 @@
+require "zillabyte/cli/base"
+
+# manage zillabyte accounts
+#
+class Zillabyte::Command::Auth < Zillabyte::Command::Base
+
+
+
+  # auth:login
+  #
+  # Sets the Zillabyte Auth token
+  #
+  def login
+    Zillabyte::Auth.login
+  end
+  
+  alias_command "login", "auth:login"
+  
+  
+  
+  # auth:logout
+  #
+  # Sets the Zillabyte Auth token
+  #
+  def logout
+    Zillabyte::Auth.logout
+  end
+  
+  alias_command "logout", "auth:logout"
+  
+  
+
+end

data/lib/zillabyte/cli/base.rb

@@ -0,0 +1,161 @@
+require "fileutils"
+require "zillabyte/api"
+require "zillabyte/command"
+
+class Zillabyte::Command::Base
+  include Zillabyte::Helpers
+
+  def self.namespace
+    self.to_s.split("::").last.downcase
+  end
+
+  attr_reader :args
+  attr_reader :options
+
+  def initialize(args=[], options={})
+    @args = args
+    @options = options
+  end
+
+
+protected
+
+  def self.inherited(klass)
+    unless klass == Zillabyte::Command::Base
+      help = extract_help_from_caller(caller.first)
+
+      Zillabyte::Command.register_namespace(
+        :name => klass.namespace,
+        :description => help.first
+      )
+    end
+  end
+
+  def self.method_added(method)
+    return if self == Zillabyte::Command::Base
+    return if private_method_defined?(method)
+    return if protected_method_defined?(method)
+
+    help = extract_help_from_caller(caller.first)
+    resolved_method = (method.to_s == "index") ? nil : method.to_s
+    command = [ self.namespace, resolved_method ].compact.join(":")
+    banner = extract_banner(help) || command
+
+    Zillabyte::Command.register_command(
+      :klass       => self,
+      :method      => method,
+      :namespace   => self.namespace,
+      :command     => command,
+      :banner      => banner.strip,
+      :help        => help.join("\n"),
+      :summary     => extract_summary(help),
+      :description => extract_description(help),
+      :options     => extract_options(help)
+    )
+
+    alias_command command.gsub(/_/, '-'), command if command =~ /_/
+  end
+  
+  
+
+  #
+  # Parse the caller format and identify the file and line number as identified
+  # in : http://www.ruby-doc.org/core/classes/Kernel.html#M001397.  This will
+  # look for a colon followed by a digit as the delimiter.  The biggest
+  # complication is windows paths, which have a colon after the drive letter.
+  # This regex will match paths as anything from the beginning to a colon
+  # directly followed by a number (the line number).
+  #
+  # Examples of the caller format :
+  # * c:/Ruby192/lib/.../lib/zillabyte/cli/addons.rb:8:in `<module:Command>'
+  # * c:/Ruby192/lib/.../zillabyte-2.0.1/lib/zillabyte/cli/pg.rb:96:in `<class:Pg>'
+  # * /Users/ph7/...../xray-1.1/lib/xray/thread_dump_signal_handler.rb:9
+  #
+  def self.extract_help_from_caller(line)
+    # pull out of the caller the information for the file path and line number
+    if line =~ /^(.+?):(\d+)/
+      extract_help($1, $2)
+    else
+      raise("unable to extract help from caller: #{line}")
+    end
+  end
+  
+  def self.extract_help(file, line_number)
+    buffer = []
+    lines = Zillabyte::Command.files[file]
+
+    (line_number.to_i-2).downto(0) do |i|
+      line = lines[i]
+      case line[0..0]
+        when ""
+        when "#"
+          buffer.unshift(line[1..-1])
+        else
+          break
+      end
+    end
+
+    buffer
+  end
+  
+
+  def self.extract_banner(help)
+    help.first
+  end
+
+  def self.extract_summary(help)
+    extract_description(help).split("\n")[2].to_s.split("\n").first
+  end
+
+  def self.extract_description(help)
+    help.reject do |line|
+      line =~ /^\s+-(.+)#(.+)/
+    end.join("\n")
+  end
+
+  def self.extract_options(help)
+    r = help.select do |line|
+      line =~ /^\s+-(.+)#(.+)/
+    end.inject([]) do |options, line|
+      args = line.split('#', 2).first
+      args = args.split(/,\s*/).map {|arg| arg.strip}.sort.reverse
+      name = args.last.split(' ', 2).first[2..-1]
+      options << { :name => name, :args => args }
+    end
+  end
+  
+  
+  def self.alias_command(new, old)
+    raise "no such command: #{old}" unless Zillabyte::Command.commands[old]
+    Zillabyte::Command.command_aliases[new] = old
+  end
+  
+  
+  def shift_argument
+    Zillabyte::Command.shift_argument
+  end
+
+  def validate_arguments!
+    Zillabyte::Command.validate_arguments!
+  end
+  
+  def api
+    @__api ||= Zillabyte::API.new(:api_key => Zillabyte::Auth.api_key, :progress => self)
+  end  
+  
+  
+  
+  def progress
+    self
+  end
+  
+  
+end
+
+
+
+module Zillabyte::Command
+  unless const_defined?(:BaseWithApp)
+    BaseWithApp = Base
+  end
+end

data/lib/zillabyte/cli/config.rb

@@ -0,0 +1,63 @@
+require 'yaml'
+
+module Zillabyte
+
+  module CLI
+
+    module Config
+
+      DEFAULT_CONFIG_FILE = "zillabyte.conf.yaml"
+      
+      ################################################################################
+
+      def self.get_config_info(dir, progress = nil, options = {})
+        
+        conf_file = nil
+        if options[:config_file] and File.exists?(options[:config_file])
+          conf_file = options[:config_file]   
+        else
+          conf_file = File.join(dir, options[:config_file] || DEFAULT_CONFIG_FILE)
+        end
+        
+        return nil unless File.exists?(conf_file)
+        hash = YAML.load_file(conf_file)
+        
+        # set other fields on the configuraiton
+        hash['pwd'] = dir
+        
+        # The top_dir and rel_home_dir allows us to package up dependencies that
+        # belong to sibling directories (e.g. the collectors directory)
+        top_dir = File.expand_path(hash['top_dir'] || ".", dir)
+        top_path = Pathname.new(top_dir)
+        rel_dir = Pathname.new(dir).relative_path_from(top_path).to_s
+        ignore_files = if hash.has_key?("ignore_files")
+          ignore_files = hash["ignore_files"]
+          ignore_files_array = ignore_files.respond_to?(:to_a) ? ignore_files.to_a() : [ignore_files]
+          ignore_files_array.map { |path_arg|
+            # It's annoying to fail because of an improperly specified path, though that would be my preference,
+            # so we just warn.  It would be nice if APIDock covered what exceptions can be raised, too--we probably
+            # don't want to catch all of them.
+            begin
+              path_string = path_arg.to_s()
+              path = Pathname.new(File.expand_path(path_string))
+              path.relative_path_from(top_path).to_s()
+            rescue Exception => e
+              progress.error e.message() + "\n" + e.backtrace.join("\n") if progress
+              nil
+            end
+          }.compact()
+        else
+          []
+        end
+        hash["rel_dir"] = rel_dir
+        hash['top_dir'] = top_dir
+        hash["home_dir"] = dir
+        hash["ignore_files"] = ignore_files
+        
+        # Get the config  
+        return hash
+        
+      end
+    end
+  end
+end

data/lib/zillabyte/cli/counters.rb

@@ -0,0 +1,61 @@
+# require "zillabyte/cli/base"
+# 
+# # manage custom executables
+# #
+# class Zillabyte::Command::Metrics < Zillabyte::Command::Base
+# 
+#   
+#   # metrics
+#   #
+#   #
+#   def index
+#     self.list
+#   end
+# 
+#   
+#   
+#   
+#   # metrics
+#   #
+#   # list custom metrics
+#   #
+#   def list
+#     
+#     
+#     headings = []
+#     rows = api.metrics.list.map do |row|
+#       headings = row.keys if headings.size == 0
+#       row.values_at *headings
+#     end
+#     display "metrics:\n" + Terminal::Table.new(:headings => headings, :rows => rows).to_s
+# 
+#   end
+#   
+# 
+# 
+# 
+# 
+#   # metrics:show NAME
+#   #
+#   # shows the latest metric
+#   #
+#   # -t, --tail  # continuously watches for new results
+#   #
+#   def show
+#     
+#     opts = {}
+#     name = options[:name] || shift_argument 
+#     
+#     if name.nil?
+#       error "no name given"
+#     end
+#     
+#     res = api.metrics.show(name)
+#     puts res
+#   
+#   end
+#   
+# 
+# 
+# 
+# end