hmx_client 0.0.5 → 0.0.6

data/lib/hmx/command/fountain.rb

@@ -0,0 +1,46 @@
+require "hmx/command/base"
+require 'date'
+
+module HmxClient::Command
+
+  # Manipulate hmx fountains (auto id generators)
+  #
+  class Fountain < Base
+
+    # fountain
+    #
+    # Lists all of the fountains and their values 
+    def index
+      fountainState = hmx.getFountainState([])
+      # fountainState is a map of fountainName => value
+      # Flip this into an array of "name" => name, "value" => value
+      objs = []
+      fountainState.each_pair do | key, value |
+                  objs << { "name" => key, "value" => value }
+                  end 
+      cols = [ 'name', 'value' ]
+      headers = [ 'Fountain', 'Value' ]
+      display_table(objs, cols, headers)
+    end
+
+    # fountain:set 
+    #
+    # Sets the new id for the fountain 
+    #
+    def set 
+      unless args.size > 1
+        raise CommandFailed, "Usage: hmx fountain:set <fountainId> <newValue>"
+      end
+      hmx.setFountainId(args)
+    end
+    # fountain:get
+    #
+    # Increments and returns a fountain value
+    def get
+       unless args.size > 0
+        raise CommandFailed, "Usage: hmx fountain:get <fountainId>"
+      end
+      display hmx.getFountain(args)
+    end    
+  end
+end

data/lib/hmx/command/get.rb

@@ -0,0 +1,20 @@
+require "hmx/command/base"
+
+module HmxClient::Command
+
+  # Get full document from hmx 
+  #
+  class Get < Base
+
+    # get 
+    #
+    # get a document from hmx, given its display name 
+    #
+    def index
+      unless args.size > 0
+        raise CommandFailed, "Usage: hmx get displayname" 
+      end
+      dout JSON.pretty_generate(hmx.getData(args))  
+    end
+  end
+end

data/lib/hmx/command/getContent.rb

@@ -0,0 +1,20 @@
+require "hmx/command/base"
+
+module HmxClient::Command
+
+  # Get document content from hmx
+  #
+  class GetContent < Base
+
+    # getContent 
+    #
+    # get the data part of a document from hmx, given its display name 
+    #
+    def index
+      unless args.size > 0
+        raise CommandFailed, "Usage: hmx getContent displayname" 
+      end
+      dout hmx.getContent(args)
+    end
+  end
+end

data/lib/hmx/command/help.rb

@@ -0,0 +1,114 @@
+require "hmx/command/base"
+
+# list commands and display help
+#
+class HmxClient::Command::Help < HmxClient::Command::Base
+
+  PRIMARY_NAMESPACES = %w( config query get view)
+
+  # help [COMMAND]
+  #
+  # list available commands or display help for a specific command
+  #
+  def index
+    if command = args.shift
+      help_for_command(command)
+    else
+      help_for_root
+    end
+  end
+
+  alias_command "-h", "help"
+  alias_command "--help", "help"
+
+  def self.usage_for_command(command)
+    command = new.send(:commands)[command]
+    "Usage: hmx #{command[:banner]}" if command
+  end
+
+private
+
+  def commands_for_namespace(name)
+    HmxClient::Command.commands.values.select do |command|
+      command[:namespace] == name && command[:command] != name
+    end
+  end
+
+  def namespaces
+    namespaces = HmxClient::Command.namespaces
+    namespaces
+  end
+
+  def commands
+    commands = HmxClient::Command.commands
+    HmxClient::Command.command_aliases.each do |new, old|
+      commands[new] = commands[old].dup
+      commands[new][:banner] = "#{new} #{commands[new][:banner].split(" ", 2)[1]}"
+      commands[new][:command] = new
+      commands[new][:namespace] = nil
+    end
+    commands
+  end
+
+  def primary_namespaces
+    PRIMARY_NAMESPACES.map { |name| namespaces[name] }.compact
+  end
+
+  def additional_namespaces
+    (namespaces.values - primary_namespaces).sort_by { |n| n[:name] }
+  end
+
+  def summary_for_namespaces(namespaces)
+    size = longest(namespaces.map { |n| n[:name] })
+    namespaces.each do |namespace|
+      name = namespace[:name]
+      namespace[:description] ||= legacy_help_for_namespace(name)
+      puts "  %-#{size}s  # %s" % [ name, namespace[:description] ]
+    end
+  end
+
+  def help_for_root
+    puts "Usage: hmx COMMAND [command-specific-options]"
+    puts
+    puts "Primary help topics, type \"hmx help TOPIC\" for more details:"
+    puts
+    summary_for_namespaces(primary_namespaces)
+    puts
+    puts "Additional topics:"
+    puts
+    summary_for_namespaces(additional_namespaces)
+    puts
+  end
+
+  def help_for_namespace(name)
+    namespace_commands = commands_for_namespace(name)
+
+    unless namespace_commands.empty?
+      size = longest(namespace_commands.map { |c| c[:banner] })
+      namespace_commands.sort_by { |c| c[:banner].to_s }.each do |command|
+        next if command[:help] =~ /DEPRECATED/
+        command[:summary] ||= legacy_help_for_command(command[:command])
+        puts "  %-#{size}s  # %s" % [ command[:banner], command[:summary] ]
+      end
+    end
+  end
+
+  def help_for_command(name)
+    command = commands[name]
+
+    if command
+      if command[:help].strip.length > 0
+        puts "Usage: hmx #{command[:banner]}"
+        puts command[:help].split("\n")[1..-1].join("\n")
+        puts
+      end
+    end
+
+    unless commands_for_namespace(name).empty?
+      puts "Additional commands, type \"hmx help COMMAND\" for more details:"
+      puts
+      help_for_namespace(name)
+      puts
+    end
+  end
+end

data/lib/hmx/command/query.rb

@@ -0,0 +1,22 @@
+require "hmx/command/base"
+
+module HmxClient::Command
+
+  # Perform queries against data in hmx 
+  #
+  class Query < Base
+
+    # query
+    #
+    # query for documents in a type
+    #
+    # TYPENAME 
+    #
+    def index
+      unless args.size > 0
+        raise CommandFailed, "Usage: hmx query <typeName> [<key>=<value>, [<key2>=<value2>...]]"
+      end
+      display hmx.query(args.shift, nil)  
+    end
+  end
+end

data/lib/hmx/command/session.rb

@@ -0,0 +1,35 @@
+require "hmx/command/base"
+require 'date'
+
+module HmxClient::Command
+
+  # Display and manage session information for hmx 
+  #
+  class Session < Base
+
+    # session
+    #
+    # List the sessions and their status on hmx
+    def index
+      displayNames = hmx.query('sys.session', nil)
+      objs = []
+      displayNames.each do | name |
+         data = hmx.getContent([name]) 
+         dval = JSON.parse(data)
+         dval["MXSession"]["validUntil"] = Time.at(dval["MXSession"]["validUntil"] / 1000).to_datetime.strftime
+         objs << dval["MXSession"]
+      end
+      cols = [ 'sessionId', 'userId', 'authenticated','validUntil' ]
+      headers = [ 'Session', 'Username', 'Authenticated', 'ValidUntil' ]
+      display_table(objs, cols, headers)
+    end
+
+    # session:expire
+    #
+    # Forces the expiry of any old sessions 
+    #
+    def expire
+      display hmx.expireSessions([])
+    end
+  end
+end

data/lib/hmx/command/task.rb

@@ -0,0 +1,32 @@
+require "hmx/command/base"
+require 'date'
+
+module HmxClient::Command
+
+  # Display and manage tasks in hmx 
+  #
+  class Task < Base
+
+    # task 
+    #
+    # List all of the tasks
+    def index
+      tasks = hmx.getAllTasks([])
+      objs = []
+      tasks.each do | t | 
+          task = hmx.getTask([t])
+          objs << task
+      end
+      headers = [ "TaskId", "TaskType", "TaskState", "GroupId" ]
+      cols = [ "taskId", "taskType", "taskState", "group" ] 
+      display_table(objs, cols, headers)
+    end
+    # task:purge
+    #
+    # Purge completed tasks
+    def purge
+      hmx.purgeTasks([])
+      display "Purge complete"
+    end
+   end
+end

data/lib/hmx/command/type.rb

@@ -0,0 +1,45 @@
+require "hmx/command/base"
+require 'date'
+
+module HmxClient::Command
+
+  # Display and manage type information in hmx 
+  #
+  class Type < Base
+
+    # type
+    #
+    # Display information about a HMX type
+    def index
+      puts JSON.pretty_generate(hmx.getType(args.shift))
+    end
+
+    # type:create
+    #
+    # Create a type with default settings - no triggers, no entitlements 
+    def create
+       typeInfo = { "name" => args.shift, "triggers" => [], "typeNature" => "CONTENT", "typeIndexScript" => "", "typeAspect" => "JSONDOCUMENT" }
+       hmx.updateType(typeInfo)       
+       puts "Done..."
+    end
+   
+    # type:clone-ent
+    #
+    # Clone the entitlements from one type to another
+    # 
+    # <srcType> <targType>
+    def clone
+         # We basically load the documents for sys.ent/type/[source]/query and sys.ent/type/[source]/query and copy them to the target
+         sourceType = args.shift
+         targetType = args.shift
+         arr = JSON.parse(hmx.getContent(["sys.ent/type/#{ sourceType }/get"]))
+         arr["MXEntitlement"]["entitlementPath"] = "type/#{ targetType }/get"
+         hmx.putSimpleData([ "sys.ent/type/#{ targetType}/get", JSON.generate(arr)])
+
+         arr = JSON.parse(hmx.getContent(["sys.ent/type/#{ sourceType }/query"]))
+         arr["MXEntitlement"]["entitlementPath"] = "type/#{ targetType }/query"
+         hmx.putSimpleData([ "sys.ent/type/#{ targetType}/query", JSON.generate(arr)])
+         puts "Done..."
+    end
+  end
+end

data/lib/hmx/command/user.rb

@@ -0,0 +1,68 @@
+require "hmx/command/base"
+
+module HmxClient::Command
+
+  # Manipulate user entities in hmx
+  #
+  class User < Base
+
+    # user 
+    #
+    # manipulate user enties in hMX 
+    #
+    #
+    def index
+      unless args.size > 0
+        raise CommandFailed, "Usage: hmx user <userId>"
+      end
+      userName = args.shift
+      dout JSON.pretty_generate(hmx.getData(["sys.user/#{userName}"]))
+    end
+
+    # user:list
+    #
+    # Lists all of the users in the system
+
+    def list
+      views = hmx.query("sys.user", nil)
+      views.each { | v |
+                 display v.rpartition('/')[2]
+                } 
+    end
+
+    # user:get
+    #
+    # Retrieves the definition of a user
+    #
+    def get
+       index
+    end
+
+    # user:password
+    #
+    # Sets the password for a user
+    #
+    def password
+      unless args.size > 1
+        raise CommandFailed, "Usage: hmx user:password <userId> <newPassword>"
+      end
+      user = args.shift
+      userName = "sys.user/#{user}"
+      password = Digest::MD5.hexdigest(args.shift)
+      dataDocument = hmx.getData([userName])
+      dataDocument['document']['MXUser']['hashPassword'] = password
+      display hmx.putData([JSON.generate(dataDocument)])
+    end
+
+    # user:delete
+    # 
+    # Removes a user
+    #
+    def delete
+      # We also need to remove the user reference from any groups they belong to (sys.entgroup)
+      # We should be clever and use a custom view for that purpose
+      # something like
+      # (fn[param] (fn[x] (contains (param "user" (.get x '(:document :MXEntitlementGroup :users ))))))
+    end
+   end
+end

data/lib/hmx/command/view.rb

@@ -0,0 +1,155 @@
+require "hmx/command/base"
+
+module HmxClient::Command
+
+  # Display the results of a view and list all views
+  #
+  class View < Base
+
+    # view 
+    #
+    # run a view in hmx, passing in a view name and an input to the filter function 
+    #
+    #
+    def index
+      unless args.size > 0
+        raise CommandFailed, "Usage: hmx view <viewName> <filterContext>" 
+      end
+      viewData = hmx.runView(args.shift, JSON.parse(args.shift))
+      resp = ''
+      viewData.each { | line | 
+                         line.each { | cell | resp = resp + "%20.20s\t" % cell }
+                         resp = resp + "\n"
+                    }
+      dout resp
+    end
+
+    # view:list
+    #
+    # Lists all of the views in the system
+
+    def list
+      views = hmx.query("sys.view", nil)
+      views.each { | v |
+                 display v.rpartition('/')[2]
+                } 
+    end
+
+    # view:get
+    #
+    # Retrieves the definition of a view
+    #
+    def get
+       unless args.size > 0
+        raise CommandFailed, "Usage: hmx view:get <viewName>" 
+      end
+      typeName = "sys.view/#{args.shift}"
+      display "Retrieving #{ typeName }"
+      dout JSON.pretty_generate(hmx.getData([typeName]))
+    end
+
+    # view:create
+    #
+    # Create a new (initially blank) view.
+    # You will then need to call update to set the filter function, map function, query params and 
+    # result columns.
+    # 
+    # Views are based on types, for create define a name and the type
+    def create
+      unless args.size > 1
+        raise CommanFailed, "Usage: hmx view:create <viewName> <typeName>"
+      end
+      view = args.shift
+      viewName = "sys.view/#{view}"
+      typeName = args.shift
+      
+      dataDocument = { 
+                              "MXView" => {
+                                  :typeName => typeName,
+                                  :parameterNames => [],
+                                  :filterFn => "",
+                                  :mappingFn => "",
+                                  :resultColumns => [],
+                                  :viewName => view
+                              }
+                   }
+
+      dout JSON.pretty_generate(hmx.putSimpleData([viewName, JSON.generate(dataDocument)]))
+    end
+   
+    # view:updateFilter 
+    # 
+    # Set the filter function for a view
+    #
+    def updateFilter
+      unless args.size > 1
+       raise CommandFailed, "Usage: hmx view:updateFilter <viewName> <filterFn>"
+      end
+      view = args.shift
+      viewName = "sys.view/#{view}"
+      filterFn = args.shift
+
+      dataDocument = hmx.getData([viewName])
+      puts dataDocument
+      dataDocument['document']['MXView']['filterFn'] = filterFn
+      display hmx.putData([JSON.generate(dataDocument)])
+    end 
+    # view:updateMap 
+    # 
+    # Set the map function for a view
+    #
+    def updateMap
+      unless args.size > 1
+       raise CommandFailed, "Usage: hmx view:updateMap <viewName> <filterFn>"
+      end
+      view = args.shift
+      viewName = "sys.view/#{view}"
+      mapFn = args.shift
+      dataDocument = hmx.getData([viewName])
+      dataDocument['document']['MXView']['mappingFn'] = mapFn
+      display hmx.putData([JSON.generate(dataDocument)])
+    end 
+    # view:updateParam 
+    # 
+    # Set the parameter names for a view
+    #
+    def updateParam
+      unless args.size > 1
+       raise CommandFailed, "Usage: hmx view:updateParam <viewName> <param> [<param2> ...]"
+      end
+      view = args.shift
+      viewName = "sys.view/#{view}"
+      dataDocument = hmx.getData([viewName])
+      dataDocument['document']['MXView']['parameterNames'] = args
+      display hmx.putData([JSON.generate(dataDocument)])
+    end 
+    # view:updateResult 
+    # 
+    # Set the result names for a view
+    #
+    def updateResult
+      unless args.size > 1
+       raise CommandFailed, "Usage: hmx view:updateResult <viewName> <param> [<param2> ...]"
+      end
+      view = args.shift
+      viewName = "sys.view/#{view}"
+
+      dataDocument = hmx.getData([viewName])
+      dataDocument['document']['MXView']['resultColumns'] = args
+      display hmx.putData([JSON.generate(dataDocument)])
+    end 
+    # view:delete
+    #
+    # Delete a view definition
+    #
+    def delete
+      unless args.size >0 
+       raise CommandFailed, "Usage: hmx view:delete <viewName>"
+      end
+      view = args.shift
+      viewName = "sys.view/#{view}"
+      display hmx.deleteData(viewName)
+    end 
+    
+  end
+end

data/lib/hmx/command.rb

@@ -0,0 +1,140 @@
+require "optparse"
+require "hmx/helpers"
+
+module HmxClient
+   module Command
+     class InvalidCommand < RuntimeError; end
+     class CommandFailed < RuntimeError; end
+
+     extend HmxClient::Helpers
+
+     def self.load
+       Dir[File.join(File.dirname(__FILE__), "command", "*.rb")].each do | file |
+           require file
+       end
+     end
+
+     def self.commands
+       @@command ||= {}
+     end
+
+     def self.command_aliases
+       @@command_aliases ||= {}
+     end
+
+     def self.namespaces
+       @@namespaces ||= {}
+     end
+
+     def self.register_command(command)
+       commands[command[:command]] = command
+     end
+
+     def self.register_namespace(namespace)
+       namespaces[namespace[:name]] = namespace
+     end
+
+     def self.current_command
+       @current_command
+     end
+
+     def self.current_args
+       @current_args
+     end
+
+     def self.current_options
+       @current_options
+     end
+
+     def self.global_options
+       @global_options ||= []
+     end
+
+     def self.global_option(name, *args) 
+       global_options << { :name => name, :args => args }
+     end
+
+     global_option :debug, "--debug", "-d"
+     global_option :fileIn, "--file-in FILE", "-i"
+     global_option :fileOut, "--file-out FILE", "-o"
+
+     def self.prepare_run(cmd, args=[])
+       command = parse(cmd)
+       
+       unless command
+	 error " ! #{cmd} is not a hmx command. See 'hmx help'."
+         return
+       end
+
+       @current_command = cmd
+       opts = {}
+       invalid_options = []
+       
+       parser = OptionParser.new do | parser |
+          global_options.each do | global_option |
+            parser.on(*global_option[:args]) do | value |
+              opts[global_option[:name]] = value
+            end
+          end
+          command[:options].each do | name, option |
+            parser.on("-#{option[:short]}", "--#{option[:long]}", option[:desc]) do | value |
+               opts[name.gsub("-","_").to_sym] = value
+            end
+          end
+       end
+
+       begin
+         parser.order!(args) do |nonopt|
+           invalid_options << nonopt
+         end
+       rescue OptionParser::InvalidOption => ex
+         invalid_options << ex.args.first
+         retry
+       end
+ 
+       raise OptionParser::ParseError if opts[:help]
+
+       args.concat(invalid_options)
+
+       @current_args = args
+       @current_options = opts
+ 
+       [ command[:klass].new(args.dup, opts.dup), command[:method] ]
+    end
+
+    def self.debug?
+      @current_options.has_key?(:debug)
+    end
+
+    def self.fileIn
+      @current_options[:fileIn]
+    end
+
+    def self.fileOut
+      @current_options[:fileOut]
+    end
+
+    def self.run(cmd, arguments=[])
+      object, method = prepare_run(cmd, arguments.dup)
+      object.send(method)
+    rescue InvalidCommand
+      error "Unknown command. Run 'hmx help' for usage information."
+    rescue CommandFailed => e
+      error e.message
+    rescue OptionParser::ParseError => ex
+      commands[cmd] ? run("help", [cmd]) : run("help")
+    rescue Interrupt => e
+      error "\n[cancelled]"
+    end
+
+    def self.parse(cmd)
+      commands[cmd] || commands[command_aliases[cmd]]
+    end
+
+    def self.extract_error(body, options={})
+      default_error = block_given ? yield : "Internal server error"
+    end
+  end
+end
+
+