xsrb 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 464c4bdf14e7cf84d74d07e4dccfaba34058b60f
+  data.tar.gz: 1dd6eda8bb0c16767511ae203096e0a07804b672
+SHA512:
+  metadata.gz: 7d063acdbee201dbd0101dcf03b83de240ab7dab3bb797e3016e240dee45e9dfccd3ff92bec3e6be66fcfd2a9e2bae3ff62300b5172ffd834ddb369add69bdbf
+  data.tar.gz: d66fee09e9bc180f4fe4e31407f82266b2a9c566392a516337c1b812e5a75749c1b585a020587bee48280fff7355e3739307106910770a0426db83355efa01f2

data/lib/xsrb/client.rb

@@ -0,0 +1,8 @@
+module XenStore
+  # Client provides high-level interaction with XenStore
+  class Client
+    def initialize(transport = nil)
+      @transport = transport || XenStore::Connection::UnixSocketConnection.new
+    end
+  end
+end

data/lib/xsrb/connection.rb

@@ -0,0 +1,59 @@
+require 'xsrb/exceptions'
+require 'xsrb/utils'
+
+module XenStore
+  module Connection
+    # Generic class which implements a connection which send Packets to a
+    # XenStore daemon.
+    class PacketConnection
+      def initialize(transport)
+        @transport = transport
+      end
+
+      # Serialize a +Packet+ and send over the wire to XenStored
+      #
+      # @param pkt [Packet] The +Packet+ of data to send to xenstored.
+      def send(pkt)
+        data = pkt.pack
+        @transport.send data
+      end
+
+      # Receive a +Packet+ from XenStored
+      #
+      # @return [Packet] The latest packet received from XenStore.
+      #                  Will block until either a packet is received
+      #                  or an error occurs.
+      def recv
+        header = @transport.recv Packet.header_size
+
+        op, rq_id, tx_id, len = header.unpack('IIII')
+        if len > 4096
+          raise XenStore::Exceptions::InvalidPayload,
+                "Payload too large (#{l})"
+        end
+
+        body = @transport.recv len
+        Packet.new(op, body, rq_id, tx_id)
+      end
+    end
+
+    # A +PacketConnection+ implementation which communicates with XenStored over
+    # a UNIX socket.
+    class UnixSocketConnection < PacketConnection
+      def initialize(path = nil)
+        @path = path || XenStore::Utils.unix_socket_path
+        transport = XenStore::Transport::UnixSocketTransport.new @path
+        super(transport)
+      end
+    end
+
+    # A +PacketConnection+ implementation
+    class XenBusConnection < PacketConnection
+      def initialize(path = nil)
+        @path = path || XenStore::Utils.xenbus_path
+        transport = XenStore::Transport::XenBusTransport.new @path
+        super(transport)
+      end
+    end
+  end
+end

data/lib/xsrb/exceptions.rb

@@ -0,0 +1,18 @@
+module XenStore
+  module Exceptions
+    class XenStoreException < StandardError
+    end
+
+    class InvalidPermission < XenStoreException
+    end
+
+    class InvalidPath < XenStoreException
+    end
+
+    class InvalidPayload < XenStoreException
+    end
+
+    class InvalidOperation < XenStoreException
+    end
+  end
+end

data/lib/xsrb/packet.rb

@@ -0,0 +1,55 @@
+module XenStore
+  # An individual Packet of data sent to XenStore.
+  class Packet
+    def initialize(op, payload, rq_id, tx_id = 0)
+      if payload.length > 4096
+        raise XenStore::Exceptions::InvalidPayload,
+              "Payload too large (#{l}): #{payload}"
+      end
+
+      @op       = check_op op
+      @rq_id    = rq_id
+      @tx_id    = tx_id
+      @payload  = payload.to_s + XenStore::NUL
+    end
+
+    # Convert to a binary representation for transport to the xenstored
+    #
+    # @return [String] A binary version of the +Packet+.
+    def pack
+      packdata = [@op, @rq_id, @tx_id, @payload.length]
+      packdata.pack('IIII') + @payload
+    end
+
+    class << self
+      # Check if the provided operation is valid and raise a
+      # +XenStore::Exceptions::InvalidOperation+ exception if not.
+      #
+      # @param op Should be either a symbol or a uint. If a symbol
+      #           then it will be used as a key to lookup the value
+      #           in the +XenStore::OPERATIONS+ hash.
+      def check_op(op)
+        if op.is_a? Symbol
+          unless XenStore::OPERATIONS.key? op
+            raise XenStore::Exceptions::InvalidOperation, op.to_s
+          end
+
+          XenStore::OPERATIONS[op]
+        else
+          unless XenStore::OPERATIONS.values.include? op
+            raise XenStore::Exceptions::InvalidOperation, op.to_s
+          end
+
+          op
+        end
+      end
+
+      # Get size of each packet header
+      #
+      # @return [Integer] The size in bytes of each Packet header.
+      def header_size
+        4 * (32 / 8)
+      end
+    end
+  end
+end

data/lib/xsrb/transport.rb

@@ -0,0 +1,70 @@
+require 'socket'
+
+module XenStore
+  # Module to hold various types of Transport which allow communication
+  # with XenStore in various ways.
+  module Transport
+    # A Transport implementation which communicates with XenStore over the
+    # special device on UNIX-like operating systems.
+    class XenBusTransport
+      def initialize(path = nil)
+        path ||= XenStore::Utils.xenbus_path
+        @file = File.open(path, 'wb')
+
+        # Ensure the file is closed when this object is garbage collected
+        ObjectSpace.define_finalizer(self, proc { @file.close })
+      end
+
+      def send(data)
+        size = data.length
+        # Errno::EPIPE if other end disconnects
+        size -= @file.write while size
+      end
+
+      def recv(size)
+        chunks = []
+        while size
+          chunk = @file.read(size)
+          raise Errno::ECONNRESET unless chunk
+
+          chunks << read
+          size -= read.length
+        end
+        chunks.join ''
+      end
+
+      def close
+        @file.close
+      end
+    end
+
+    # A Transport implementation which communicates with XenStore over a
+    # UNIX socket.
+    class UnixSocketTransport
+      def initialize(path = nil)
+        path ||= XenStore::Utils.unix_socket_path
+        @sock = UNIXSocket.new path
+
+        # Ensure the socket is closed when this object is garbage collected
+        ObjectSpace.define_finalizer(self, proc { @sock.close })
+      end
+
+      def send(data)
+        @sock.write(data)
+      end
+
+      def recv(size)
+        chunks = []
+        while size
+          chunks << @sock.read(size)
+          size -= chunks[-1].length
+        end
+        chunks.join ''
+      end
+
+      def close
+        @sock.close
+      end
+    end
+  end
+end

data/lib/xsrb/utils.rb

@@ -0,0 +1,164 @@
+require 'rbconfig'
+require 'pathname'
+
+require 'xsrb/exceptions'
+
+#
+module XenStore
+  # xs_wire.h uses uint32_t
+  MAX_UINT  = (2**32).freeze
+  NUL       = "\x00".freeze
+  CAPS_FILE = '/proc/xen/capabilities'.freeze
+
+  # Check whether we are in dom0
+  begin
+    CONTROL_D = File.open(CAPS_FILE, 'rb', &:read) == "control_d\n"
+  rescue Errno::ENOENT
+    CONTROL_D = false
+  end
+
+  OPERATIONS = {
+    debug:                  0,
+    directory:              1,
+    read:                   2,
+    get_perms:              3,
+    watch:                  4,
+    unwatch:                5,
+    transaction_start:      6,
+    transaction_end:        7,
+    introduce:              8,
+    release:                9,
+    get_domain_path:        10,
+    write:                  11,
+    mkdir:                  12,
+    rm:                     13,
+    set_perms:              14,
+    watch_event:            15,
+    error:                  16,
+    is_domain_introduced:   17,
+    resume:                 18,
+    set_target:             19,
+    restrict:               20,
+    reset_watches:          21,
+    invalid:                MAX_UINT
+  }.freeze
+
+  # XenStore::Utils implements utility methods which are unlikely
+  # to be required by users but are used by the rest of the module
+  module Utils
+    @reqid = -1
+
+    @path_regex       = Regexp.new '\A[a-zA-Z0-9\-/_@]+\x00?\z'
+    @watch_path_regex = Regexp.new '\A@(?:introduceDomain|releaseDomain)\x00?\z'
+    @perms_regex      = Regexp.new '\A[wrbn]\d+\z'
+
+    @errno_exception_map = Hash[
+      Errno.constants.collect do |n|
+        [Errno.const_get(n)::Errno, Errno.const_get(n)]
+      end.reverse
+    ].freeze
+
+    class << self
+      # Convert an error number or symbol to an Errno exception
+      #
+      # @param n [Integer, Symbol] An +Integer+ or +symbol+ representing the
+      #                            Errno exception to return.
+      # @return [Exception] The +Exception+ representing the provided type
+      #                     of error.
+      def error(n)
+        if n.is_a? Integer
+          @errno_exception_map[n]
+        else
+          Errno.send(n)
+        end
+      end
+
+      # Get the next request ID to contact XenStore with.
+      #
+      # @return [Integer] The next ID in the sequence.
+      def next_request_id
+        @reqid += 1
+
+        # Ensure no larger than uint32_t which is used in xs_wire.h
+        @reqid %= MAX_UINT
+      end
+
+      # Get the path of the XenStore unix socket.
+      #
+      # @return [String] The path to the XenStore unix socket.
+      def unix_socket_path
+        dp = '/var/run/xenstored'
+        ENV['XENSTORED_PATH'] || File.join(ENV['XENSTORED_RUNDIR'] || dp,
+                                           'socket')
+      end
+
+      # Raise an exception if the provided path is invalid.
+      #
+      # @param path [String] The XenStore path to check.
+      # @return [String] The valid path.
+      def valid_path?(path)
+        pathname = Pathname.new path
+        max_len = pathname.absolute? ? 3072 : 2048
+
+        if path.length > max_len
+          raise XenStore::Exceptions::InvalidPath,
+                "Path too long: #{path}"
+        end
+
+        unless @path_regex =~ path
+          raise XenStore::Exceptions::InvalidPath,
+                path.to_s
+        end
+
+        path
+      end
+
+      # Raise an exception if the provided XenStore watch path is invalid.
+      #
+      # @param path [String] The XenStore watch path to check.
+      # @return [String] The valid path.
+      def valid_watch_path?(path)
+        if path.starts_with?('@') && (@watch_path_regex !~ path)
+          raise XenStore::Exceptions::InvalidPath, path.to_s
+        end
+
+        valid_path? path
+      end
+
+      # Check if every member of a list of permissions strings is valid.
+      #
+      # @param perms [Array, String] An +Array+ of XenStore permissions
+      #                              specifications
+      # @return [Array] The list of permissions.
+      def valid_permissions?(perms)
+        perms = [perms] if perms.is_a? String
+        perms.each do |perm|
+          unless perm =~ @perms_regex
+            raise XenStore::Exceptions::InvalidPermission,
+                  "Invalid permission string: #{perm}"
+          end
+        end
+      end
+
+      # Get the XenBus path on this system
+      #
+      # @return [String] The path to the XenBus device
+      def xenbus_path
+        default = '/dev/xen/xenbus'
+        host_os = RbConfig::CONFIG['host_os']
+
+        case host_os
+        when 'netbsd'
+          '/kern/xen/xenbus'
+        when 'linux'
+          File.readable?('/dev/xen/xenbus') ? '/proc/xen/xenbus' : default
+        when /mswin|windows/i
+          raise NotImplementedError,
+                "OS '#{RbConfig::CONFIG['host_os']}' is not supported"
+        else
+          default
+        end
+      end
+    end
+  end
+end

data/lib/xsrb/version.rb

@@ -0,0 +1,3 @@
+module XenStore
+  VERSION = '0.0.1'.freeze
+end

data/lib/xsrb.rb

@@ -0,0 +1,16 @@
+require 'logging'
+
+require 'xsrb/version'
+require 'xsrb/utils'
+
+Logging.logger.root.level = :warn
+
+# Module XenStore implements XenStore access APIs on Ruby.
+# The implementation is modelled on the pyxs python module.
+module XenStore
+  autoload :Client,     'xsrb/client'
+  autoload :Connection, 'xsrb/connection'
+  autoload :Exceptions, 'xsrb/exceptions'
+  autoload :Packet,     'xsrb/packet'
+  autoload :Transport,  'xsrb/transport'
+end

metadata

@@ -0,0 +1,51 @@
+--- !ruby/object:Gem::Specification
+name: xsrb
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- joelnb
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-05-13 00:00:00.000000000 Z
+dependencies: []
+description: Pure Ruby XenStore Bindings based on pyxs (https://github.com/selectel/pyxs)
+email: joelnbarnham@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/xsrb.rb
+- lib/xsrb/client.rb
+- lib/xsrb/connection.rb
+- lib/xsrb/exceptions.rb
+- lib/xsrb/packet.rb
+- lib/xsrb/transport.rb
+- lib/xsrb/utils.rb
+- lib/xsrb/version.rb
+homepage: https://github.com/joelnb/xsrb
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.13
+signing_key: 
+specification_version: 4
+summary: Ruby XenStore API Bindings
+test_files: []