pcp-client 0.3.0 → 0.5.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 4bbadd16844a443623b6d9d1389b580960b17592
-  data.tar.gz: cfe1c97388dbab0db4496b316f57961cc6e30d9d
+SHA256:
+  metadata.gz: c8712776d17a4fffc25f012a1471bb56de3af9db2edbfe9c770cae53fc6de82c
+  data.tar.gz: 7e53fc42f88e35bf7d2d2051188d9672d39ac82ed568d3fab0ddacc666666a00
 SHA512:
-  metadata.gz: d006505e2bfdee5de658da1a1dff1215d3a483ce4e7326815f8229b39f9acf61597686ad7c4a83e1e0d46e712aa8420742387743792df3212ef760bbeb25947d
-  data.tar.gz: ef1ab13ddaeffda48954bc65c8d7b1d28c62037667dad6d40708eb79c37c69544767cd41198778cf690bd35b547d759665020897f82774aa7c85c31af5a30f04
+  metadata.gz: ccc042e29255ca1d5c3d4951d35126bbb7383c87c966c62c23beaee21e15fcc507784a900c09b7cf6b77e4833f2116f636eca468e263379dd5c73dca5c71a92c
+  data.tar.gz: cfa9f803edb4339b4ab5d9fbc77c64c2c13fe669920391f5f63b0876dcf073d0f8105a7be4079a72a683e7f79c96e63da8ab9f7e0a8ab9188bd4a22e72da3892

data/bin/pcp-ping

@@ -0,0 +1,112 @@
+#!/usr/bin/env ruby
+require 'pcp/client'
+require 'optparse'
+
+ssl_key = '../pcp-broker/test-resources/ssl/private_keys/client01.example.com.pem'
+ssl_cert = '../pcp-broker/test-resources/ssl/certs/client01.example.com.pem'
+ssl_ca_cert = '../pcp-broker/test-resources/ssl/ca/ca_crt.pem'
+debug = false
+server = 'wss://localhost:8142/pcp'
+
+OptionParser.new do |opts|
+  opts.on("-d",  "--debug", "Run noisily") { |v| debug = v }
+  opts.on("--ssl_key FILE", "Use this ssl key") { |v| ssl_key = v }
+  opts.on("--ssl_cert FILE", "Use this ssl cert") { |v| ssl_cert = v }
+  opts.on("--ssl_ca_cert FILE", "Use this ssl ca cert") { |v| ssl_ca_cert = v }
+  opts.on("--server URL", "Server to connect to") { |v| server = v }
+end.parse!
+
+start_time = Time.now.to_f
+
+Thread.new { EM.run }
+Thread.pass until EM.reactor_running?
+
+client = PCP::Client.new({:ssl_key => ssl_key,
+                          :ssl_cert => ssl_cert,
+                          :ssl_ca_cert => ssl_ca_cert,
+                          :loglevel => debug ? Logger::DEBUG : Logger::WARN,
+                          :server => server,
+                         })
+
+# Record the expected set of destinations from the destination_report,
+# then all the responses from the rpc_blocking_response
+mutex = Mutex.new
+have_responses = ConditionVariable.new
+responses = {}
+expected = nil
+ping_time = nil
+
+client.on_message = proc do |message|
+  mutex.synchronize do
+    case message[:message_type]
+    when 'http://puppetlabs.com/destination_report'
+      expected = JSON.load(message.data)['targets']
+    when 'http://puppetlabs.com/rpc_blocking_response'
+      sender = message[:sender]
+      time = Time.now.to_f - ping_time
+      responses[sender] = time
+      puts '%-55s %0.2f seconds' % [sender, time]
+    else
+      p [:unexpected_message, message]
+    end
+
+    have_responses.signal
+  end
+end
+
+client.connect
+
+if !client.associated?
+  puts "Didn't connect to broker."
+  exit 1
+end
+
+connect_time = Time.now.to_f - start_time
+puts "Connected to broker in %0.2f seconds." % [connect_time]
+puts
+
+ping = ::PCP::Message.new(:message_type => 'http://puppetlabs.com/rpc_blocking_request',
+                          :targets => ['pcp://*/agent'],
+                          :destination_report => true)
+
+ping.data = {:transaction_id => ping[:id],
+             :module => 'echo',
+             :action => 'echo',
+             :params => {:argument => 'echo'}}.to_json
+
+ping.expires(3)
+
+ping_time = Time.now.to_f
+client.send(ping)
+
+begin
+  Timeout::timeout(3) do
+    done = false
+    loop do
+      mutex.synchronize do
+        have_responses.wait(mutex)
+        if expected && expected.all? { |from| responses.include?(from) }
+          # Have all responses we expect, bail
+          run_time = Time.now.to_f - start_time
+          puts
+          puts "Received all responses in %0.2f seconds." % [run_time]
+          done = true
+        end
+      end
+      break if done
+    end
+  end
+rescue Timeout::Error
+  puts
+  if expected
+    puts "Received %d/%d responses.  Following nodes were missing" % [responses.keys.size, expected.size]
+    puts
+    expected.select { |from| !responses.include?(from) }.each do |missing|
+      puts "    #{missing}"
+    end
+  else
+    puts "Didn't get destination report, not sure how many responses to expect.  We got %d." % [responses.keys.size]
+  end
+end
+
+EM.stop

data/lib/pcp-client/version.rb

@@ -0,0 +1,4 @@
+class PCPClient
+  VERSION = '0.5.3'.freeze
+end
+

data/lib/pcp/client.rb

@@ -2,6 +2,7 @@ require 'eventmachine'
 require 'faye/websocket'
 require 'pcp/message'
 require 'logger'
+require 'openssl'
 
 module PCP
   # Manages a client connection to a pcp broker
@@ -27,12 +28,14 @@ module PCP
       @server = params[:server] || 'wss://localhost:8142/pcp'
       @ssl_key = params[:ssl_key]
       @ssl_cert = params[:ssl_cert]
+      @ssl_ca_cert = params[:ssl_ca_cert]
       @logger = params[: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]
+      @max_message_size = params[:max_message_size] || 64*1024*1024
       @associated = false
     end
 
@@ -50,55 +53,68 @@ module PCP
       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", "TLSv1_1", "TLSv1_2"]}})
-
-      @connection.on :open do |event|
-        begin
-          @logger.info { [:open] }
-          send(associate_request)
-        rescue Exception => e
-          @logger.error { [:open_exception, e] }
+      @logger.debug { [:connect, :scheduling] }
+      EM.next_tick do
+        @logger.debug { [:connect, @server] }
+
+        start_tls_options = {
+          :ssl_version => ["TLSv1", "TLSv1_1", "TLSv1_2"],
+          :private_key_file => @ssl_key,
+          :cert_chain_file => @ssl_cert,
+          :root_cert_file => @ssl_ca_cert,
+          :verify_peer => true,
+          :fail_if_no_peer_cert => true,
+        }
+
+        @connection = Faye::WebSocket::Client.new(@server, nil, {:tls => start_tls_options,
+                                                                 :ping => 30,
+                                                                 :max_length => @max_message_size})
+
+        @connection.on :open do |event|
+          begin
+            @logger.info { [:open] }
+            send(associate_request)
+          rescue Exception => e
+            @logger.error { [:open_exception, e] }
+          end
         end
-      end
 
-      @connection.on :message do |event|
-        begin
-          message = ::PCP::Message.new(event.data)
-          @logger.debug { [:message, :decoded, message] }
+        @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
 
-          if message[:message_type] == 'http://puppetlabs.com/associate_response'
+        @connection.on :close do |event|
+          begin
+            @logger.info { [:close, event.code, event.reason] }
             mutex.synchronize do
-              @associated = JSON.load(message.data)["success"]
+              @associated = false
               associated_cv.signal
             end
-          elsif @on_message
-            @on_message.call(message)
+          rescue Exception => e
+            @logger.error { [:close_exception, e] }
           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] }
+        @connection.on :error do |event|
+          @logger.error { [:error, event] }
+          @associated = false
         end
       end
 
-      @connection.on :error do |event|
-        @logger.error { [:error, event] }
-        @associated = false
-      end
-
       if !EM.reactor_running?
         @logger.debug { [:no_eventmachine_reactor,
                          "Eventmachine reactor is not running" ] }
@@ -141,17 +157,24 @@ module PCP
     # @param message [PCP::Message]
     # @return unused
     def send(message)
-      @logger.debug { [:send, message] }
-      message[:sender] = identity
-      @connection.send(message.encode)
+      EM.next_tick do
+        @logger.debug { [:send, message] }
+        if message[:expires].nil?
+          message.expires(3)
+        end
+        message[:sender] = identity
+        @connection.send(message.encode)
+      end
     end
 
     # Disconnect the client
     # @api public
     # @return unused
     def close
-      @logger.debug { [:close] }
-      @connection.close
+      EM.next_tick do
+        @logger.debug { [:close] }
+        @connection.close
+      end
     end
 
     private

data/lib/pcp/message.rb

@@ -111,11 +111,19 @@ module PCP
         chunks << frame_chunk(i + 2, @chunks[i])
       end
 
-      RSchema.validate!(PCP::Protocol::Envelope, envelope)
+      validate
 
       [1, frame_chunk(1, envelope.to_json), chunks].flatten
     end
 
+    # Validate the data in message against schema
+    #
+    # @api public
+    # @return ignore
+    def validate
+      RSchema.validate!(PCP::Protocol::Envelope, envelope)
+    end
+
     private
 
     # Decodes an array of bytes into the message
@@ -144,7 +152,7 @@ module PCP
           parsed.each do |k,v|
             @envelope[k.to_sym] = v
           end
-          RSchema.validate!(PCP::Protocol::Envelope, @envelope)
+          validate
         else
           @chunks[type - 2] = body
         end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pcp-client
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.5.3
 platform: ruby
 authors:
 - Puppet Labs
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-05 00:00:00.000000000 Z
+date: 2021-06-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: eventmachine
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.10'
+        version: 0.11.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.10'
+        version: 0.11.0
 - !ruby/object:Gem::Dependency
   name: rschema
   requirement: !ruby/object:Gem::Requirement
@@ -54,10 +54,13 @@ dependencies:
         version: '1.3'
 description: See https://github.com/puppetlabs/pcp-specifications
 email: puppet@puppetlabs.com
-executables: []
+executables:
+- pcp-ping
 extensions: []
 extra_rdoc_files: []
 files:
+- bin/pcp-ping
+- lib/pcp-client/version.rb
 - lib/pcp.rb
 - lib/pcp/client.rb
 - lib/pcp/message.rb
@@ -82,10 +85,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.2.5
+rubygems_version: 3.0.8
 signing_key: 
 specification_version: 4
 summary: Client library for PCP
 test_files: []
-has_rdoc: