hmx_client 0.0.5 → 0.0.6

data/bin/hmx

@@ -1,4 +1,11 @@
 #!/usr/bin/env ruby
+begin
+   require 'Win32/Console/ANSI' if RUBY_PLATFORM =~ /mingw32/
+rescue Exception => e
+   puts e.message
+end
+
+require 'cli-colorize'
 
 lib = File.expand_path(File.dirname(__FILE__) + '/../lib')
 $LOAD_PATH.unshift(lib) if File.directory?(lib) && !$LOAD_PATH.include?(lib)
@@ -10,32 +17,17 @@ require 'hmx_client'
 include HmxClient
 
 $stdout.sync = true
+$folder = nil
+$file = nil
+$outFile = nil
 $debug = false
 
-options = {
-  :api => 'http://localhost:9999',
-  :user => 'amkimian',
-  :password => 'password'
-}
-
-ARGV.options do |o|
-  o.on("-a apiUrl", "--api") { |api| options[:api] = api }
-  o.on("-u user", "--user") { |user| options[:user] = user }
-  o.on("-d", "--debug") { $debug = true }
-  o.parse!
-end
-
 begin
   args = ARGV.dup
   ARGV.clear
-  h = Client.new(args, options).run!
-  puts "Hello mum" if $debug
-rescue Client::CommandInvalid
-  abort File.read(__FILE__).split('__END__').last
+  command = args.shift.strip rescue 'help'
+  HmxClient::Command.load
+  HmxClient::Command.run(command, args)
+rescue HmxException => info
+  abort "General HMX Exception - #{info.msg['message']}"
 end
-
-__END__
-Usage: hmx [OPTIONS] command
-       
-       hmx test alan
-

data/lib/hmx/client.rb

@@ -4,9 +4,8 @@ module HmxClient
   class Client
     FILE = File.expand_path("~/.hmxConfig")
 
-    def initialize(args, options)
+    def initialize(args)
       @args = args
-      @options = options
       loadConfig!
     end
 
@@ -14,13 +13,17 @@ module HmxClient
 
     def loadConfig!
 	# Load the config from the save file
-        @config = {}
-        @config = Marshal.load(File.read(FILE)) if File.exist?(FILE)
+        @config = if File.exist?(FILE)
+	            File.open(FILE) { |file| Marshal.load(file) }
+		  else
+		     {}
+		  end
+       RestClient.proxy = @config[:proxy] if @config.has_key?(:proxy)
     end
     def storeConfig(keyName, keyValue)
        # Update the config hashMap and persist it
        @config[keyName] = keyValue
-       File.open(FILE, 'w+') { |f| f.write(Marshal.dump(@config)) }
+       File.open(FILE, 'w+') { |f| Marshal.dump(@config, f) }
     end
     def run!
       command = @args.shift || @options[:command]
@@ -46,33 +49,119 @@ module HmxClient
          storeConfig(:api, @args.shift)
        when "partition"
          storeConfig(:partition, @args.shift)
+       when "proxy"
+	 proxy = @args.shift
+         storeConfig(:proxy, proxy)
+         RestClient.proxy =  proxy
        else
          abort "Unknown config command"
       end
     end
+    def genout(content)
+      puts content
+      File.open($outFile, 'w') { | f | puts "And writing to #{$outFile} "
+                                    f.write(content) } unless $outFile.nil?
+    end
     def get
       h = getapi
-      puts h.getData(@args.shift)
+      genout JSON.pretty_generate(h.getData(@args))
     end      
     def getData
       h = getapi
-      puts h.getContent(@args.shift)
+      genout h.getContent(@args)
     end
     def putSimpleData
       h = getapi
-      puts h.putSimpleData(@args.shift, @args.shift)
+      genout JSON.pretty_generate(h.putSimpleData(@args))
+    end
+    def put
+      h = getapi
+      genout JSON.pretty_generate(h.putData(@args))
     end
     def query
       h = getapi
-      puts h.query(@args.shift, nil)
-    end
-    def test
-      case check = @args.shift
-        when "alan"
-          puts "Test Alan complete"
-        else
-          abort "Unknown test command"
-      end
+      genout h.query(@args.shift, nil)
+    end
+    def view
+      h = getapi
+      viewData = h.runView(@args.shift, JSON.parse(@args.shift))
+      resp = ''
+      viewData.each { | line | 
+                         line.each { | cell | resp = resp + "%20.20s\t" % cell }
+                         resp = resp + "\n"
+                    }
+      genout resp
+    end
+    # Take all of the documents for a type and put it into the folder passed, one per file
+    def dumpType
+      h = getapi
+      displayNames = h.query(@args.shift, nil)
+      puts displayNames
+      displayNames.each { | displayName | 
+                                fileName = $folder + "/" + displayName
+                                puts "FileName will be #{ fileName } "
+                                Dir.mkdir(File.dirname(fileName)) if !Dir.exist?(File.dirname(fileName))
+                                puts "DisplayName is #{ displayName } "
+                                File.open(fileName, 'w') { |f| f.write(h.getData([displayName])) } }
+    end
+    # Take all of the documents in a folder for a type (the opposite of dumpType above)
+    # and simply put them back in
+    def loadType
+      h = getapi
+      typeName = @args.shift
+      folderName = $folder + "/" + typeName
+      Dir.foreach(folderName) { | f | 
+				   puts "Working with #{ f }"
+                                   fullFile = folderName + "/" + f
+                                   if (File.file?(fullFile))
+                                      content = File.open(fullFile) { | h | 
+						c = '';
+						while(line = h.gets) 
+							c = c + line
+						end
+					        c
+                                                }
+                                      puts "Content is #{ content } "
+                                      h.putData(JSON.parse(content))	
+				   end
+				}
+    end
+    def deleteData
+      h = getapi
+      h.deleteData(@args.shift)
+    end
+    def getTypes
+      h = getapi
+      genout JSON.pretty_generate(h.getTypes) 
+    end
+    def getType
+      h = getapi
+      genout JSON.pretty_generate(h.getType(@args.shift))
+    end
+    def getFn
+      h = getapi
+      genout h.getFn(@args)
+    end
+    def putFn
+      h = getapi
+      genout h.putFn(@args)
+    end
+    # Add a user, given a name (more can be added through a low level api)
+    def user
+      h = getapi
+      case command = @args.shift
+        when "add" 
+      	   username = @args.shift
+           password = Digest::MD5::hexdigest(@args.shift)
+
+           user = { "MXUser" => { "hashPassword" => password , "apiKey" => false, "userName" => username, "fullName" => username }}
+           genout JSON.pretty_generate(h.putSimpleData([ "sys.user/#{ username}", JSON.generate(user)]))
+       when "delete"
+           username = @args.shift
+           h.deleteData("sys.user/#{username}")
+       when "list"
+           puts h.query("sys.user", nil)
+       end
     end
   end
 end

data/lib/hmx/command/base.rb

@@ -0,0 +1,194 @@
+require "fileutils"
+require "hmx/command"
+require 'cli-colorize'
+require 'hmx/helpers'
+
+class HmxClient::Command::Base
+  include HmxClient::Helpers
+  include CLIColorize
+
+  def self.namespace
+    self.to_s.split("::").last.downcase
+  end
+
+  attr_reader :args
+  attr_reader :options
+
+  FILE = File.expand_path("~/.hmxConfig")
+
+  def initialize(args=[], options={})
+    @args = args
+    @options = options
+    loadConfig!
+  end
+
+  def loadConfig!
+	# Load the config from the save file
+        @config = if File.exist?(FILE)
+	            File.open(FILE) { |file| Marshal.load(file) }
+		  else
+		     {}
+		  end
+       RestClient.proxy = @config[:proxy] if @config.has_key?(:proxy)
+  end
+  def storeConfig(keyName, keyValue)
+       # Update the config hashMap and persist it
+       if (keyName == :password) 
+           keyValue = Digest::MD5.hexdigest(keyValue)
+       end
+       @config[keyName] = keyValue
+       writeConfig
+  end
+  def removeConfig(keyName)
+      @config.delete keyName
+      writeConfig
+  end
+  def writeConfig
+       File.open(FILE, 'w+') { |f| Marshal.dump(@config, f) }
+  end
+  def hmx
+    if @hmx.nil?
+    	@hmx = Hmx.new    
+    	@hmx.login(@config)
+        writeConfig
+    end
+    @hmx
+  end
+
+protected
+
+  def self.inherited(klass)
+    help = extract_help_from_caller(caller.first)
+    HmxClient::Command.register_namespace(
+      :name => klass.namespace,
+      :description => help.split("\n").first
+    )
+  end
+
+  def self.method_added(method)
+    return if self == HmxClient::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
+    default_command = [ self.namespace, resolved_method ].compact.join(":")
+    command = extract_command(help) || default_command
+    banner = extract_banner(help) || command
+    permute = !banner.index("*")
+    banner.gsub!("*", "")
+
+    HmxClient::Command.register_command(
+      :klass       => self,
+      :method      => method,
+      :namespace   => self.namespace,
+      :command     => command,
+      :banner      => banner,
+      :help        => help,
+      :summary     => extract_summary(help),
+      :description => extract_description(help),
+      :options     => extract_options(help),
+      :permute     => permute
+    )
+  end
+
+  def self.alias_command(new, old)
+    raise "no such command: #{old}" unless HmxClient::Command.commands[old]
+    HmxClient::Command.command_aliases[new] = old
+  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 color 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/heroku/command/addons.rb:8:in `<module:Command>'
+  # * c:/Ruby192/lib/.../heroku-2.0.1/lib/heroku/command/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+)/
+      return extract_help($1, $2)
+    end
+    raise "unable to extract help from caller: #{line}"
+  end
+
+  def self.extract_help(file, line)
+    buffer = []
+    lines  = File.read(file).split("\n")
+
+    catch(:done) do
+      (line.to_i-2).downto(0) do |i|
+        case lines[i].strip[0..0]
+          when "", "#" then buffer << lines[i]
+          else throw(:done)
+        end
+      end
+    end
+
+    buffer.map! do |line|
+      line.strip.gsub(/^#/, "")
+    end
+
+    buffer.reverse.join("\n").strip
+  end
+
+  def self.extract_command(help)
+    extract_banner(help).to_s.split(" ").first
+  end
+
+  def self.extract_banner(help)
+    help.split("\n").first
+  end
+
+  def self.extract_summary(help)
+    extract_description(help).split("\n").first
+  end
+
+  def self.extract_description(help)
+    lines = help.split("\n").map { |l| l.strip }
+    lines.shift
+    lines.reject do |line|
+      line =~ /^-(.+)#(.+)/
+    end.join("\n").strip
+  end
+
+  def self.extract_options(help)
+    help.split("\n").map { |l| l.strip }.select do |line|
+      line =~ /^-(.+)#(.+)/
+    end.inject({}) do |hash, line|
+      description = line.split("#", 2).last.strip
+      long  = line.match(/--([A-Za-z\- ]+)/)[1].strip
+      short = line.match(/-([A-Za-z ])/)[1].strip
+      hash.update(long.split(" ").first => { :desc => description, :short => short, :long => long })
+    end
+  end
+
+  def extract_option(name, default=true)
+    key = name.gsub("--", "").to_sym
+    return unless options[key]
+    value = options[key] || default
+    block_given? ? yield(value) : value
+  end
+
+  def confirm_mismatch?
+    options[:confirm] && (options[:confirm] != options[:app])
+  end
+
+  def dout(msg) 
+        if (!HmxClient::Command.fileOut.nil?)
+       	   realFile = File.expand_path(HmxClient::Command.fileOut)
+	   File.open(realFile, 'w') { | f | 
+               		display("Writing to #{ realFile }")
+               		f.write(msg) } 
+        end
+        puts colorize(msg, :yellow)
+        #display(green(msg))
+  end
+end
+

data/lib/hmx/command/bootstrap.rb

@@ -0,0 +1,18 @@
+require "hmx/command/base"
+require 'date'
+
+module HmxClient::Command
+
+  # Bootstrap a default configuration
+  #
+  class Bootstrap < Base
+
+    # bootstrap
+    #
+    # Bootstrap a default configuration into this partition
+    def index
+     hmx.bootstrap
+     puts "Done."
+    end
+ end
+end

data/lib/hmx/command/clone.rb

@@ -0,0 +1,77 @@
+require "hmx/command/base"
+require 'date'
+
+module HmxClient::Command
+
+  # Clone a partition or setup a partition from a clone
+  #
+  class Clone < Base
+
+    # clone
+    #
+    # Create a clone file for the current partition
+    def index
+      # Clone the type information
+      # Clone these built in types (i.e. the content)
+      # Clone other types as defined by the command line
+      extraTypes = args
+      types = [ 'sys.user', 'sys.config', 'sys.ent', 'sys.egroup', 'sys.trigger', 'sys.view' ]
+      extraTypes.each { | et | types << et }
+      types.each { | t | dumpTypeAndData(t) }
+    end
+
+    # clone:load
+    #
+    # Load a file that was created using hmx clone
+    # The file basically contains a series of types (documents separated by << >>)
+    # and data (separated by [[ ]])
+    def load
+	# We define the file as being the input file on the command line (--file-in)
+        if (HmxClient::Command.fileIn.nil?)
+           raise CommandFailed, "Usage: hmx clone:load --file-in=<filename>"
+        end
+        realFile = File.expand_path(HmxClient::Command.fileIn)
+        File.open(realFile, 'r') { | f | 
+                                 currentDoc = ''
+                                 isType = false
+                                 while(line = f.gets)
+                                    if (line[0] == '#') 
+                                    elsif (line[0] == '<' && line[1] == '<') 
+				       currentDoc = ''
+                                       isType = true
+                                    elsif (line[0] == '>' && line[1] == '>')
+                                       if isType
+                                          print '.'
+                                          hmx.updateType(JSON.parse(currentDoc))
+                                       end
+                                       currentDoc = ''
+                                    elsif (line[0] == '[' && line[1] == '[')
+                                       currentDoc = ''
+                                       isType = false
+                                    elsif (line[0] == ']' && line[1] == ']')
+                                       if (!isType)
+                                           print 'x'
+                                           hmx.putData([currentDoc])
+                                       end
+                                       currentDoc = ''
+                                    else
+                                       currentDoc = currentDoc + line
+                                    end 
+                                end
+                          }
+         puts ""
+         puts "Done"
+    end 
+
+protected 
+    def dumpTypeAndData(typeName)
+      puts "####### #{ typeName }  "
+      puts "<<"
+      puts JSON.generate(hmx.getType(typeName)) 
+      puts ">>"
+      puts "####### Data for #{ typeName } "
+      displayNames = hmx.query(typeName, nil)
+      displayNames.each { | d | puts("[["); puts JSON.generate(hmx.getData([d])); puts("]]") }
+    end
+  end
+end

data/lib/hmx/command/config.rb

@@ -0,0 +1,67 @@
+require "hmx/command/base"
+
+module HmxClient::Command
+
+  # Manage app config vars
+  #
+  class Config < Base
+
+    # config
+    #
+    # display the config vars for an app
+    #
+    # -s, --shell  # output config vars in shell format
+    #
+    def index
+      display_vars(@config, :long => true, :shell => false)
+    end
+
+    # config:add KEY1=VALUE1 ...
+    #
+    # add one or more config vars
+    #
+    def add
+      unless args.size > 0 and args.all? { |a| a.include?('=') }
+        raise CommandFailed, "Usage: hmx config:add <key>=<value> [<key2>=<value2> ...]"
+      end
+
+      args.inject({}) do |vars, arg|
+        key, value = arg.split('=', 2)
+        storeConfig(key.to_sym,value)
+      end
+
+      display_vars(@config, :indent => 2)
+    end
+
+    # config:remove KEY1 [KEY2 ...]
+    #
+    # remove a config var
+    #
+    def remove
+      raise CommandFailed, "Usage: hmx config:remove KEY1 [KEY2 ...]" if args.empty?
+
+      args.each do |key|
+	removeConfig(key.to_sym)
+        display_vars(@config, :indent => 2)
+      end
+    end
+
+    protected
+      def display_vars(vars, options={})
+        max_length = vars.map { |v| v[0].to_s.size }.max
+        vars.keys.sort.each do |key|
+          if options[:shell]
+            display "#{key}=#{vars[key]}"
+          else
+            spaces = ' ' * (max_length - key.to_s.size)
+            display "#{' ' * (options[:indent] || 0)}#{key}#{spaces} => #{format(vars[key], options)}"
+          end
+        end
+      end
+
+      def format(value, options)
+        return value if options[:long] || value.to_s.size < 36
+        value[0, 16] + '...' + value[-16, 16]
+      end
+  end
+end

data/lib/hmx/command/dump.rb

@@ -0,0 +1,67 @@
+require "hmx/command/base"
+
+module HmxClient::Command
+
+  # Dump data from a type in hmx and load it back again
+  #
+  class Dump < Base
+
+    # dump
+    #
+    # Dump data from hmx into the local filesystem. Used
+    # as a preface to a backup, or a change then restore
+    # 
+    # <typeName> <folderPath>
+    def index
+      unless args.size > 0
+        raise CommandFailed, "Usage: hmx dump <typeName> <folderPath>"
+      end
+      # The filenames will come from the name of the type and their displayName, appended onto 
+      # the folder path given. We will also attempt to create the folder path and the type
+      # sub folder 
+      typeName = args.shift
+      rootFolder = args.shift
+     
+      Dir.mkdir(rootFolder) if !Dir.exist?(rootFolder)
+      Dir.mkdir(rootFolder + "/" + typeName) if !Dir.exist?(rootFolder + "/" + typeName)
+      displayNames = hmx.query(typeName, nil)
+      displayNames.each { | displayName | 
+                        fileName = rootFolder + "/" + displayName
+                        display "Writing to #{ fileName }"
+                        File.open(fileName, 'w') { | f | f.write(JSON.pretty_generate(hmx.getData([displayName]))) }
+                        } 
+    end
+
+    # dump:load
+    #
+    # Load data that has previously been dumped using the main dump command
+    #
+    # <typeName> <folderPath>
+    #
+    # The real path for the files is in the folder formed by concatenating the typename to the rootFolder 
+    def load
+      unless args.size > 0
+        raise CommandFailed, "Usage: hmx dump:load <typeName> <folderPath>"
+      end
+      typeName = args.shift
+      rootFolder = args.shift
+
+      folderName = rootFolder + "/" + typeName
+      Dir.foreach(folderName) { | f | 
+                                   display "Loading #{ f } "
+                                   fullFile = folderName + "/" + f
+                                   if (File.file?(fullFile)) 
+                                      content = File.open(fullFile) { | h | 
+						c = '';
+						while(line = h.gets) 
+							c = c + line
+						end
+					        c
+                                                }
+                                      puts "Content is #{ content } "
+                                      hmx.putData([content])	
+                                   end
+                                }
+     end
+  end
+end

data/lib/hmx/command/fn.rb

@@ -0,0 +1,43 @@
+require "hmx/command/base"
+
+module HmxClient::Command
+
+  # Load and Save functions in hmx 
+  #
+  class Fn < Base
+
+    # fn
+    #
+    # Manipulate HMX functions 
+    #
+    #
+    def index
+      unless args.size > 0
+        raise CommandFailed, "Usage: hmx fn <fnName>" 
+      end
+      dout hmx.getFn([args.shift])
+    end
+
+    # fn:list
+    # 
+    # List all functions in HMX
+    #
+   def list
+      fns = hmx.query("fn", nil)
+      fns.each { | f |
+                   display f.rpartition('/')[2]
+               }
+   end
+
+   # fn:put
+   #
+   # Create or update a function
+   #
+   def put
+      unless args.size > 0
+        raise CommandFailed, "Usage: hmx fn:put <fnName> <f:function>" 
+      end
+      dout hmx.putFn(args)
+   end
+  end
+end