pcp-client 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9b54b2bb443dc46522c23c6dd86a444ac6cd12fd
+  data.tar.gz: 2df868e9976252c6e01d912dc0df0e35c6d6d780
+SHA512:
+  metadata.gz: 241e5b58d9565e9a2c8feb30dabf421a9e5631b980140629d93dd84a418a0ebbd300c4ef5bdb290e0173d118bdce6e1d5753cb16a084748621be7d1dcf8878b9
+  data.tar.gz: 215de150101529209af1c283e542ad75093ad13f6559ac44613617557a25b59a4d3a974080334df3862e881be72ac1eae67f9f41e887e3636934b8a82e89b715

data/lib/pcp.rb

@@ -0,0 +1,3 @@
+# Puppet Communication Protocol
+module PCP
+end

data/lib/pcp/client.rb

@@ -0,0 +1,162 @@
+require 'eventmachine-le'
+require 'faye/websocket'
+require 'pcp/message'
+require 'logger'
+
+module PCP
+  # Manages a client connection to a pcp broker
+  class Client
+    # Read the @identity property
+    #
+    # @api public
+    # @return [String]
+    attr_accessor :identity
+
+    # Set a proc that will be used to handle messages
+    #
+    # @api public
+    # @return [Proc]
+    attr_accessor :on_message
+
+    # Construct a new disconnected client
+    #
+    # @api public
+    # @param params [Hash<Symbol,Object>]
+    # @return a new client
+    def initialize(params = {})
+      @server = params[:server] || 'wss://localhost:8142/pcp'
+      @ssl_key = params[:ssl_key]
+      @ssl_cert = params[:ssl_cert]
+      @logger = Logger.new(STDOUT)
+      @logger.level = params[:loglevel] || Logger::WARN
+      @connection = nil
+      type = params[:type] || "ruby-pcp-client-#{$$}"
+      @identity = make_identity(@ssl_cert, type)
+      @on_message = params[:on_message]
+      @associated = false
+    end
+
+    # Connect to the server
+    #
+    # @api public
+    # @param seconds [Numeric]
+    # @return [true,false,nil]
+    def connect(seconds = 0)
+      mutex = Mutex.new
+      associated_cv = ConditionVariable.new
+
+      @logger.debug { [:connect, @server] }
+      @connection = Faye::WebSocket::Client.new(@server, nil, {:tls => {:private_key_file => @ssl_key,
+                                                                        :cert_chain_file => @ssl_cert,
+                                                                        :ssl_version => :TLSv1}})
+
+      @connection.on :open do |event|
+        begin
+          @logger.info { [:open] }
+          send(associate_request)
+        rescue Exception => e
+          @logger.error { [:open_exception, e] }
+        end
+      end
+
+      @connection.on :message do |event|
+        begin
+          message = ::PCP::Message.new(event.data)
+          @logger.debug { [:message, :decoded, message] }
+
+          if message[:message_type] == 'http://puppetlabs.com/associate_response'
+            mutex.synchronize do
+              @associated = JSON.load(message.data)["success"]
+              associated_cv.signal
+            end
+          elsif @on_message
+            @on_message.call(message)
+          end
+        rescue Exception => e
+          @logger.error { [:message_exception, e] }
+        end
+      end
+
+      @connection.on :close do |event|
+        begin
+          @logger.info { [:close, event.code, event.reason] }
+          mutex.synchronize do
+            @associated = false
+            associated_cv.signal
+          end
+        rescue Exception => e
+          @logger.error { [:close_exception, e] }
+        end
+      end
+
+      @connection.on :error do |event|
+        @logger.error { [:error, event] }
+        @associated = false
+      end
+
+      begin
+        Timeout::timeout(seconds) do
+          mutex.synchronize do
+            associated_cv.wait(mutex)
+            return @associated
+          end
+        end
+      rescue Timeout::Error
+        return nil
+      end
+    end
+
+    # Is the client associated with the server
+    #
+    # @api public
+    # @return [true,false]
+    def associated?
+      @associated
+    end
+
+    # Send a message to the server
+    #
+    # @api public
+    # @param message [PCP::Message]
+    # @return unused
+    def send(message)
+      @logger.debug { [:send, message] }
+      message[:sender] = identity
+      @connection.send(message.encode)
+    end
+
+    private
+
+    # Get the common name from an X509 certficate in file
+    #
+    # @api private
+    # @param [String] file
+    # @return [String]
+    def get_common_name(file)
+      raw = File.read file
+      cert = OpenSSL::X509::Certificate.new raw
+      cert.subject.to_a.assoc('CN')[1]
+    end
+
+    # Make the PCP Uri for this client
+    #
+    # @api private
+    # @param cert [String]
+    # @param type [String]
+    # @return [String]
+    def make_identity(cert, type)
+      cn = get_common_name(cert)
+      "pcp://#{cn}/#{type}"
+    end
+
+    # Make an association request message for this client
+    #
+    # @api private
+    # @return [PCP::Message]
+    def associate_request
+      Message.new({:message_type => 'http://puppetlabs.com/associate_request',
+                   :sender => @identity,
+                   :targets => ['pcp:///server']}).expires(3)
+    end
+  end
+end

data/lib/pcp/message.rb

@@ -0,0 +1,165 @@
+require 'json'
+require 'securerandom'
+require 'time'
+require 'pcp/protocol'
+
+module PCP
+  # Represent a message that can be sent via PCP::Client
+  class Message
+    # Read access to the @envelope property
+    #
+    # @api public
+    # @return [Hash<Symbol,Object>]
+    attr_reader :envelope
+
+    # Construct a new message or decode one
+    #
+    # @api public
+    # @param envelope_or_bytes [Hash<Symbol,Object>,Array<Integer>]
+    #   When supplied a Hash it is taken as being a collection of
+    #   envelope fields.
+    #   When supplied an Array it is taken as being an array of
+    #   byte values, a message in wire format.
+    # @return a new object
+    def initialize(envelope_or_bytes = {})
+      @chunks = ['', '']
+
+      case envelope_or_bytes
+      when Array
+        # it's bytes
+        decode(envelope_or_bytes)
+      when Hash
+        # it's an envelope
+        default_envelope = {:id => SecureRandom.uuid}
+        @envelope = default_envelope.merge(envelope_or_bytes)
+      else
+        raise ArgumentError, "Unhandled type"
+      end
+    end
+
+    # Set the expiry of the message
+    #
+    # @api public
+    # @param seconds [Numeric]
+    # @return the object itself
+    def expires(seconds)
+      @envelope[:expires] = (Time.now + seconds).utc.iso8601
+      self
+    end
+
+    # Set an envelope field
+    #
+    # @api public
+    # @param key [Symbol]
+    # @param value
+    # @return value
+    def []=(key, value)
+      @envelope[key] = value
+    end
+
+    # Get an envelope field
+    #
+    # @api public
+    # @param key [Symbol]
+    # @return value associated with that key
+    def [](key)
+      @envelope[key]
+    end
+
+    # Get the content of the data chunk
+    #
+    # @api public
+    # @return current content of the data chunk
+    def data
+      @chunks[0]
+    end
+
+    # Sets the content for the data chunk
+    #
+    # @api public
+    # @param value
+    # @return value
+    def data=(value)
+      @chunks[0] = value
+    end
+
+    # Get the content of the debug chunk
+    #
+    # @api public
+    # @return current content of the debug chunk
+    def debug
+      @chunks[1]
+    end
+
+    # Sets the content for the debug chunk
+    #
+    # @api public
+    # @param value
+    # @return value
+    def debug=(value)
+      @chunks[1] = value
+    end
+
+    # Encodes the message as an array of byte values
+    #
+    # @api public
+    # @return [Array<Integer>]
+    def encode
+      chunks = []
+
+      @chunks.each_index do |i|
+        chunks << frame_chunk(i + 2, @chunks[i])
+      end
+
+      RSchema.validate!(PCP::Protocol::Envelope, envelope)
+
+      [1, frame_chunk(1, envelope.to_json), chunks].flatten
+    end
+
+    private
+
+    # Decodes an array of bytes into the message
+    #
+    # @api private
+    # @param bytes [Array<Integer>]
+    # @return ignore
+    def decode(bytes)
+      version = bytes.shift
+
+      unless version == 1
+        raise "Can only handle type 1 messages"
+      end
+
+      while bytes.size > 0
+        type = bytes.shift
+        size = bytes.take(4).pack('C*').unpack('N')[0]
+        bytes = bytes.drop(4)
+
+        body = bytes.take(size).pack('C*')
+        bytes = bytes.drop(size)
+
+        if type == 1
+          parsed = JSON.parse(body)
+          @envelope = {}
+          parsed.each do |k,v|
+            @envelope[k.to_sym] = v
+          end
+          RSchema.validate!(PCP::Protocol::Envelope, @envelope)
+        else
+          @chunks[type - 2] = body
+        end
+      end
+    end
+
+    # Frames a piece of data as a message chunk of given type
+    #
+    # @api private
+    # @param type [Integer]
+    # @param body [String]
+    # @return [Array<Integer>]
+    def frame_chunk(type, body)
+      size = [body.bytesize].pack('N').unpack('C*')
+      [type, size, body.bytes.to_a].flatten
+    end
+  end
+end

data/lib/pcp/protocol.rb

@@ -0,0 +1,45 @@
+require 'rschema'
+
+module PCP
+  # Definitions of RSchema schemas for protocol definitions
+  module Protocol
+    # A [String] that represents a time according to ISO8601
+    ISO8601 = RSchema.schema do
+      predicate do |t|
+        begin
+          t.is_a?(String) && Time.parse(t)
+        rescue ArgumentError
+          # Time.parse raises an ArgumentError if the time isn't parsable
+          false
+        end
+      end
+    end
+
+    # A [String] that is a message id
+    MessageId = RSchema.schema do
+      predicate do |id|
+        id.is_a?(String) && id.match(%r{^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$})
+      end
+    end
+
+    # A [String] that is a PCP uri
+    Uri = RSchema.schema do
+      predicate do |uri|
+        uri.is_a?(String) && uri.match(%r{^pcp://([^/]*)/[^/]+$})
+      end
+    end
+
+    # A [Hash] that complies to the properties of an Envelope
+    Envelope = RSchema.schema do
+      {
+        :id => MessageId,
+        optional(:'in-reply-to') => MessageId,
+        :sender => Uri,
+        :targets => [Uri],
+        :message_type => String,
+        :expires => ISO8601,
+        optional(:destination_report) => boolean,
+      }
+    end
+  end
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: pcp-client
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Puppet Labs
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-01-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: eventmachine-le
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: faye-websocket
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: rschema
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+description: See https://github.com/puppetlabs/pcp-specifications
+email: puppet@puppetlabs.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/pcp.rb
+- lib/pcp/client.rb
+- lib/pcp/message.rb
+- lib/pcp/protocol.rb
+homepage: https://github.com/puppetlabs/ruby-pcp-client
+licenses:
+- ASL 2.0
+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.2.5
+signing_key: 
+specification_version: 4
+summary: Client library for PCP
+test_files: []
+has_rdoc: