staf4ruby 0.1.0

data/lib/staf4ruby.rb

@@ -0,0 +1,564 @@
+#!/usr/bin/env ruby
+##############################################################################
+# Copyright (c) 2013 Spectra Logic corp
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/epl-v10.html
+##############################################################################
+
+
+$:.unshift File.dirname(File.expand_path(__FILE__))
+require 'staf4ruby_ext'
+
+# STAF bindings for Ruby
+
+
+module Staf
+  class STAFException < StandardError
+  end
+
+  class STAFResult
+    Ok                          = 0
+    InvalidAPI                  = 1
+    UnknownService              = 2
+    InvalidHandle               = 3
+    HandleAlreadyExists         = 4
+    HandleDoesNotExist          = 5
+    UnknownError                = 6
+    InvalidRequestString        = 7
+    InvalidServiceResult        = 8
+    REXXError                   = 9
+    BaseOSError                 = 10
+    ProcessAlreadyComplete      = 11
+    ProcessNotComplete          = 12
+    VariableDoesNotExist        = 13
+    UnResolvableString          = 14
+    InvalidResolveString        = 15
+    NoPathToMachine             = 16
+    FileOpenError               = 17
+    FileReadError               = 18
+    FileWriteError              = 19
+    FileDeleteError             = 20
+    STAFNotRunning              = 21
+    CommunicationError          = 22
+    TrusteeDoesNotExist         = 23
+    InvalidTrustLevel           = 24
+    AccessDenied                = 25
+    STAFRegistrationError       = 26
+    ServiceConfigurationError   = 27
+    QueueFull                   = 28
+    NoQueueElement              = 29
+    NotifieeDoesNotExist        = 30
+    InvalidAPILevel             = 31
+    ServiceNotUnregisterable    = 32
+    ServiceNotAvailable         = 33
+    SemaphoreDoesNotExist       = 34
+    NotSemaphoreOwner           = 35
+    SemaphoreHasPendingRequests = 36
+    Timeout                     = 37
+    JavaError                   = 38
+    ConverterError              = 39
+    MoveError                   = 40
+    InvalidObject               = 41
+    InvalidParm                 = 42
+    RequestNumberNotFound       = 43
+    InvalidAsynchOption         = 44
+    RequestNotComplete          = 45
+    ProcessAuthenticationDenied = 46
+    InvalidValue                = 47
+    DoesNotExist                = 48
+    AlreadyExists               = 49
+    DirectoryNotEmpty           = 50
+    DirectoryCopyError          = 51
+    DiagnosticsNotEnabled       = 52
+    HandleAuthenticationDenied  = 53
+    HandleAlreadyAuthenticated  = 54
+    InvalidSTAFVersion          = 55
+    RequestCancelled            = 56
+    CreateThreadError           = 57
+    MaximumSizeExceeded         = 58
+    MaximumHandlesExceeded      = 59
+    NotRequester                = 60
+
+    attr_reader :rc, :result, :resultContext, :resultObj
+
+    def initialize(rc, result, doUnmarshallResult)
+      @rc = rc
+      @result = result
+      if doUnmarshallResult
+        @resultContext = Staf::unmarshall(@result)
+        @resultObj = @resultContext.rootObject
+      else
+        @resultContext = nil
+        @resultObj = nil
+      end
+    end
+  end
+
+  class STAFHandle
+    # STAFHandle types
+
+    Standard = 0
+    Static   = 1
+
+    # Modes for submit call
+
+    Synchronous   = 0
+    FireAndForget = 1
+    Queue         = 2
+    Retain        = 3
+    QueueRetain   = 4
+
+    attr_reader :doUnmarshallResult
+    attr_reader :handleType
+
+    def initialize(handleNameOrNumber, handleType = Standard)
+      @handleType = handleType
+      @doUnmarshallResult = true
+
+      if (handleType == Standard)
+        if (not handleNameOrNumber.is_a? String)
+          raise TypeError.new('A string is required if using standard handle type')
+        end
+        rc, @handle = Staf::register(handleNameOrNumber)
+        if rc != STAFResult::Ok
+          raise STAFException.new(rc)
+        end
+      else
+        if (not handleNameOrNumber.is_a? Integer)
+          raise TypeError.new('An integer is required if using static handle type')
+        end
+        @handle = handleNameOrNumber
+      end
+    end
+
+    # Set the doUnmarshallResult attribute.  For compatibility with the Python
+    # bindings, accept other-than-boolean values and check their truthiness.
+    def setDoUnmarshallResult(value)
+      if value.is_a? Fixnum
+        @doUnmarshallResult = (value != 0)
+      elsif value.is_a? String
+        @doUnmarshallResult = (value != "")
+      else
+        @doUnmarshallResult = value
+      end
+    end
+
+    def submit(location, service, request, mode = Synchronous)
+      rc, result = Staf::submit(@handle, mode, location, service, request)
+      STAFResult.new(rc, result, @doUnmarshallResult)
+    end
+
+    def unregister()
+      if (@handleType == Standard)
+        rc = Staf::unregister(@handle)
+        if (rc != STAFResult::Ok)
+          raise STAFException.new(rc)
+        end
+        @handle = 0
+      end
+      0
+    end
+
+  end
+
+  # Marshalling constants
+  UNMARSHALLING_DEFAULTS = 0
+  IGNORE_INDIRECT_OBJECTS = 1
+  MARSHALLED_DATA_MARKER = '@SDT/'
+  NONE_MARKER            = '@SDT/$0:0:'
+  SCALAR_MARKER          = '@SDT/$'
+  SCALAR_MARKER_REGEX    = '@SDT/\$' # Version of LIST_MARKER for regexes
+  SCALAR_STRING_MARKER   = '@SDT/$S'
+  LIST_MARKER            = '@SDT/['
+  LIST_MARKER_REGEX      = '@SDT/\[' # Version of LIST_MARKER for regexes
+  MAP_MARKER             = '@SDT/{'
+  MC_INSTANCE_MARKER     = '@SDT/%'
+  CONTEXT_MARKER         = '@SDT/*'
+  CONTEXT_MARKER_REGEX   = '@SDT/\*'
+
+
+  class STAFMapClassDefinition
+    attr_reader :mapClassDef
+
+    def initialize(name = nil, mapClassDef = nil)
+      # @mapClassDef[keys] is an array of key=>value pairs.  It would seem to
+      # be more useful to just make it a hash of key=>value pairs, but this is
+      # how the python bindings do it.  It's not completely equivalent, because
+      # this way preserves order and allows for duplicate keys. 
+      if mapClassDef.nil? and name.nil?
+        @mapClassDef = {"name" => "", "keys" => []}
+      elsif not name.nil?
+        @mapClassDef = {"name" => name, 'keys' => []}
+      else
+        @mapClassDef = mapClassDef
+      end
+    end
+
+    def createInstance
+      {"staf-map-class-name" => @mapClassDef["name"]}
+    end
+
+    def addKey(keyName, displayName = nil)
+      theKey = {"key" => keyName}
+      if displayName
+        theKey['display-name'] = displayName
+      end
+      @mapClassDef["keys"] << theKey
+    end
+
+    def setKeyProperty(keyName, property, value)
+      @mapClassDef['keys'].each do |key|
+        if key['key'] == keyName
+          key[property] = value
+        end
+      end
+    end
+
+    def keys
+      @mapClassDef["keys"]
+    end
+
+    def name
+      @mapClassDef["name"]
+    end
+
+#     def to_s
+#       formatObject @mapClassDef
+#     end
+#     
+#     def inspect
+#       to_s
+#     end
+
+  end
+
+  class STAFMarshallingContext
+    attr_accessor :rootObject
+    attr_reader :mapClassMap
+
+    def initialize(obj=nil, mapClassMap=nil)
+      if mapClassMap.nil?
+        @mapClassMap = {}
+      else
+        @mapClassMap = mapClassMap
+      end
+      @rootObject = obj
+    end
+
+    def isMarshalledData(someData)
+      Staf::isMarshalledData(someData)
+    end
+
+    def getMapClassDefinition(mapClassName)
+      STAFMapClassDefinition.new(nil, @mapClassMap[mapClassName])
+    end
+
+    def getPrimaryObject
+      if @mapClassMap.size == 0
+        @rootObject
+      else
+        self
+      end
+    end
+
+    def hasMapClassDefinition(mapClassName)
+      @mapClassMap.keys.include? mapClassName
+    end
+
+    def marshall
+      Staf::marshall(self, self)
+    end
+
+    def mapClassDefinitionIterator
+      @mapClassMap.keys
+    end
+
+    def setMapClassDefinition(mapClassDef)
+      @mapClassMap[mapClassDef.name()] = mapClassDef.mapClassDef
+    end
+
+#     def to_s
+#       formatObject(@rootObject, self)
+#     end
+
+#     def inspect
+#       to_s
+#     end
+  end
+
+  def self.isMarshalledData(someData)
+    someData =~ /\A@SDT\//
+  end
+
+  def self.marshall(object, context=nil)
+    # General Marshalling function
+
+    return NONE_MARKER if object.nil?
+    if object.is_a? Array
+      listData = object.collect do |item|
+        marshall(item, context)
+      end.join
+      return "#{LIST_MARKER}#{object.size}:#{listData.size}:#{listData}"
+    elsif object.is_a? Hash
+      # If a staf-map-class-name key exists in the map, make sure that
+      # it's map class definition is provided in the marshalling context.
+      # If it's not, then treat the map as a plain map object.
+      isMapClass = false
+      mapClassName = ""
+      if not context.nil? and context.is_a? STAFMarshallingContext and \
+         object.has_key?('staf-map-class-name')
+        mapClassName = object['staf-map-class-name']
+        if context.hasMapClassDefinition(mapClassName)
+          isMapClass = true
+        end
+      end
+
+      if isMapClass
+        mapClass = context.getMapClassDefinition(mapClassName)
+        mapData = ":#{mapClassName.size}:#{mapClassName}"
+        mapData << mapClass.keys.collect do |key|
+          marshall(object[key['key']], context)
+        end.join
+        return "#{MC_INSTANCE_MARKER}:#{mapData.size}:#{mapData}"
+      else
+        mapData = object.keys.collect do |key|
+          ":#{key.to_s.size}:#{key.to_s}#{marshall(object[key], context)}"
+        end.join
+        return "#{MAP_MARKER}:#{mapData.size}:#{mapData}"
+      end
+    elsif object.is_a? STAFMarshallingContext
+      if object.mapClassMap.keys.size == 0
+        return marshall(object.rootObject, context)
+      else
+        contextMap = { 'map-class-map' => object.mapClassMap}
+        # Note: We can't simply put the root object as a map key like
+        #       "root-object" and then marshall the whole map, as in
+        #       the unmarshalling routines, we need to be able to
+        #       unmarshall the root object in the context of the
+        #       map-class-map.
+        mcData = (marshall(contextMap, context) +
+                  marshall(object.rootObject, object))
+        return "#{CONTEXT_MARKER}:#{mcData.size}:#{mcData}"
+      end
+    end
+
+    return "#{SCALAR_STRING_MARKER}:#{object.to_s.size}:#{object.to_s}"
+  end
+
+
+  # General unmarshalling function
+  #   Unmarshalls the input data string and returns a marshalling context.
+  #   Unlike the Python version, this function does not catch exceptions
+
+  def self.unmarshall(data, context = nil, flags = UNMARSHALLING_DEFAULTS)
+    # TODO: implement me
+    if context.nil?
+      context = STAFMarshallingContext.new
+    end
+
+    if data =~ /\A#{NONE_MARKER}/
+      return STAFMarshallingContext.new
+    elsif data =~ /\A#{SCALAR_MARKER_REGEX}/
+      # @SDT/$S:<string length>:<String>
+      colonIndex = data.index(":", SCALAR_MARKER.size)
+      return STAFMarshallingContext.new(data) unless colonIndex
+      dataIndex = colonIndex + 1
+      colonIndex = data.index(':', dataIndex)
+      return STAFMarshallingContext.new(data) unless colonIndex
+      stringLength = data[dataIndex..colonIndex - 1].to_i
+      dataIndex = colonIndex + 1
+      if stringLength != (data.size - dataIndex)
+        return STAFMarshallingContext.new(data)
+      end
+      theString = data[dataIndex..-1]
+      if (theString =~ /\A#{MARSHALLED_DATA_MARKER}/) and \
+        ((flags & IGNORE_INDIRECT_OBJECTS) != IGNORE_INDIRECT_OBJECTS)
+        return unmarshall(theString, context, flags)
+      else
+        return STAFMarshallingContext.new(theString)
+      end
+    elsif data =~ /\A#{LIST_MARKER_REGEX}/
+      # @SDT/[<number-of-items>:<array-length>:<SDT-Any-1>...<SDT-Any-n>
+      # Get number-of-items in the list
+      colonIndex = data.index(":", LIST_MARKER.size)
+      return STAFMarshallingContext.new(data) unless colonIndex
+      numItems = data[LIST_MARKER.size..colonIndex - 1].to_i
+      # Get array length
+      dataIndex = colonIndex + 1
+      colonIndex = data.index(":", dataIndex)
+      return STAFMarshallingContext.new(data) unless colonIndex
+      arrayLength = data[dataIndex..colonIndex-1].to_i
+      dataIndex = colonIndex + 1
+      if arrayLength != data.size - dataIndex
+        return STAFMarshallingContext.new(data)
+      end
+
+      # Create an array for the data
+      myArray = []
+      for i in (1..numItems).to_a
+        # Get the next item in the list and unmarshall it and add it
+        # to the list
+        colonIndex1 = data.index(":", dataIndex)
+        return STAFMarshallingContext.new(data) unless colonIndex1
+        colonIndex2 = data.index(":", colonIndex1 + 1)
+        return STAFMarshallingContext.new(data) unless colonIndex2
+        itemLength = data[colonIndex1 + 1..colonIndex2 - 1].to_i
+        myArray << (unmarshall(data[dataIndex..colonIndex2 + itemLength],
+                               context, flags).getPrimaryObject)
+        dataIndex = colonIndex2 + itemLength + 1
+      end
+      return STAFMarshallingContext.new(myArray)
+    elsif data =~ /\A#{MAP_MARKER}/
+      # @SDT/{:<map-length>::<key-1-length>:<key-1><SDT-Any>
+      #                     ...
+      #                     :<key-n-length>:<key-1><SDT-Any>
+
+      # Get map-length
+      colonIndex = data.index(":", MAP_MARKER.size)
+      return STAFMarshallingContext.new(data) unless colonIndex
+      dataIndex = colonIndex + 1
+      colonIndex = data.index(":", dataIndex)
+      return STAFMarshallingContext.new(data) unless colonIndex
+      mapLength = data[dataIndex..colonIndex].to_i
+      dataIndex = colonIndex + 1
+      if mapLength != data.size - dataIndex
+        return STAFMarshallingContext.new(data)
+      end
+
+      # Create the hash of data
+      myhash = {}
+      while dataIndex < data.size
+        # Get the key first
+        keyColonIndex1 = data.index(":", dataIndex)
+        return STAFMarshallingContext.new(data) unless keyColonIndex1
+        keyColonIndex2 = data.index(":", keyColonIndex1 + 1)
+        return STAFMarshallingContext.new(data) unless keyColonIndex2
+        keyLength = data[keyColonIndex1 + 1..keyColonIndex2 - 1].to_i
+        key = data[keyColonIndex2 + 1..keyColonIndex2 + keyLength]
+        dataIndex = keyColonIndex2 + 1 + keyLength
+
+        # Now, get the object
+        colonIndex1 = data.index(":", dataIndex)
+        return STAFMarshallingContext.new(data) unless colonIndex1
+        colonIndex2 = data.index(":", colonIndex1 + 1)
+        return STAFMarshallingcontext.new(data) unless colonIndex2
+        itemLength = data[colonIndex1 + 1..colonIndex2-1].to_i
+        myhash[key] = unmarshall(data[dataIndex..colonIndex2 + itemLength],
+                                 context, flags).getPrimaryObject
+        dataIndex = colonIndex2 + itemLength + 1
+      end
+      return STAFMarshallingContext.new(myhash)
+    elsif data =~ /\A#{MC_INSTANCE_MARKER}/
+      # @SDT/%:<map-class-instance-length>::<map-class-name-length>:
+      #     <map-class-name><SDT-Any-value-1>...<SDT-Any-value-n>
+
+      # Get the map-class-instance-length
+      colonIndex = data.index(":", MC_INSTANCE_MARKER.size)
+      return STAFMarshallingContext.new(data) unless colonIndex
+      dataIndex = colonIndex + 1
+      colonIndex = data.index(":", dataIndex)
+      return STAFMarshallingContext.new(data) unless colonIndex
+      mapClassInstanceLength = data[dataIndex  .. colonIndex - 1].to_i
+      dataIndex = colonIndex + 1
+      if mapClassInstanceLength != data.size - dataIndex
+        return STAFMarshallingContext.new(data)
+      end
+
+      # get map-class-name-length
+      colonIndex = data.index(":", dataIndex)
+      return STAFMarshallingContext.new(data) unless colonIndex
+      dataIndex = colonIndex + 1
+      colonIndex = data.index(":", dataIndex)
+      return STAFMarshallingContext.new(data) unless colonIndex
+      mapClassNameLength = data[dataIndex .. colonIndex - 1].to_i
+
+      # Get map-class-name
+      dataIndex = colonIndex + 1
+      mapClassName = data[dataIndex .. dataIndex + mapClassNameLength - 1]
+      dataIndex = dataIndex + mapClassNameLength
+
+      # Create a hash and add the staf-map-class-name key and value to the hash
+      myHash = {'staf-map-class-name' => mapClassName}
+
+      # Unmarshall all of the actual keys and add to the map
+      mapClass = context.getMapClassDefinition(mapClassName)
+      keys = mapClass.keys
+      keyIndex = 0
+
+      while dataIndex < data.size
+        colonIndex = data.index(":", dataIndex)
+        return STAFMarshallingContext.new(data) unless colonIndex
+        colonIndex2 = data.index(":", colonIndex + 1)
+        return STAFMarshallingContext.new(data) unless colonIndex2
+        itemLength = data[colonIndex + 1 .. colonIndex2].to_i
+        myHash[keys[keyIndex]['key']] = unmarshall(
+          data[dataIndex .. colonIndex2 + itemLength],
+          context, flags).getPrimaryObject
+        dataIndex = colonIndex2 + itemLength + 1
+        keyIndex += 1
+      end
+
+      return STAFMarshallingContext.new(myHash)
+
+    elsif data =~ /\A#{CONTEXT_MARKER_REGEX}/
+      # @SDT/*:<context-length>:
+      #       @SDT/{:<mapClassLength>:<mapClassData><rootObject>
+
+      # Get context-length
+      colonIndex = data.index(":", CONTEXT_MARKER.size)
+      return STAFMarshallingContext.new(data) unless colonIndex
+      contextIndex = data.index(":", colonIndex + 1)
+      return STAFMarshallingContext.new(data) unless contextIndex
+      contextLength = data[colonIndex + 1 .. contextIndex - 1].to_i
+      contextIndex += 1
+      if contextLength != data.size - contextIndex
+        return STAFMarshallingContext.new(data)
+      end
+
+      # Get mapClassLength
+      colonIndex = data.index(":", contextIndex)
+      return STAFMarshallingContext.new(data) unless colonIndex
+      mapIndex = contextIndex
+      mapDataIndex = data.index(":", colonIndex + 1)
+      return STAFMarshallingContext.new(data) unless mapDataIndex
+      mapLength = data[colonIndex + 1 .. mapDataIndex - 1].to_i
+      mapDataIndex += 1
+
+      if mapLength > data.size - mapDataIndex
+        return STAFMarshallingContext.new(data)
+      end
+
+      # Create a new marshalling context with the map classes and root object
+      contextMap = unmarshall(data[mapIndex..mapDataIndex + mapLength - 1],
+                              context, flags).getPrimaryObject()
+      mapClassMap = contextMap['map-class-map']
+      newContext = STAFMarshallingContext.new(nil, mapClassMap)
+      colonIndex = data.index(":", mapDataIndex + mapLength)
+      return STAFMarshallingContext.new(data) unless colonIndex
+      rootObjIndex = mapDataIndex + mapLength
+      rootObjDataIndex = data.index(":", colonIndex + 1)
+      return STAFMarshallingContext.new(data) unless rootObjDataIndex
+
+      rootObjLength = data[colonIndex + 1 .. rootObjDataIndex - 1].to_i
+      rootObjDataIndex = rootObjDataIndex + 1
+      if rootObjLength > data.size - rootObjDataIndex
+        return STAFMarshallingContext.new(data)
+      end
+
+      newContext.rootObject = \
+        unmarshall(data[rootObjIndex .. rootObjDataIndex + rootObjLength - 1],
+                   newContext, flags).getPrimaryObject()
+
+      return newContext
+    elsif data =~ /\A#{MARSHALLED_DATA_MARKER}/
+      return STAFMarshallingContext.new(data)
+    end
+
+    # Shouldn't get here
+    STAFMarshallingContext.new(data)
+  end
+
+
+end