tingyun_rpm 1.0.6

data/lib/ting_yun/support/system_info.rb

@@ -0,0 +1,206 @@
+# encoding: utf-8
+
+require 'rbconfig'
+
+module TingYun
+  module Support
+    module SystemInfo
+      def self.ruby_os_identifier
+        RbConfig::CONFIG['target_os']
+      end
+
+      def self.clear_processor_info
+        @processor_info = nil
+      end
+
+      def self.get_processor_info
+        if @processor_info.nil?
+          case ruby_os_identifier
+
+            when /darwin/
+              @processor_info = {
+                  :num_physical_packages  => sysctl_value('hw.packages').to_i,
+                  :num_physical_cores     => sysctl_value('hw.physicalcpu_max').to_i,
+                  :num_logical_processors => sysctl_value('hw.logicalcpu_max').to_i
+              }
+              # in case those don't work, try backup values
+              if @processor_info[:num_physical_cores] <= 0
+                @processor_info[:num_physical_cores] = sysctl_value('hw.physicalcpu').to_i
+              end
+              if @processor_info[:num_logical_processors] <= 0
+                @processor_info[:num_logical_processors] = sysctl_value('hw.logicalcpu').to_i
+              end
+              if @processor_info[:num_logical_processors] <= 0
+                @processor_info[:num_logical_processors] = sysctl_value('hw.ncpu').to_i
+              end
+
+            when /linux/
+              cpuinfo = proc_try_read('/proc/cpuinfo')
+              @processor_info = cpuinfo ? parse_cpuinfo(cpuinfo) : {}
+
+            when /freebsd/
+              @processor_info = {
+                  :num_physical_packages  => nil,
+                  :num_physical_cores     => nil,
+                  :num_logical_processors => sysctl_value('hw.ncpu').to_i
+              }
+          end
+
+          # give nils for obviously wrong values
+          @processor_info.keys.each do |key|
+            value = @processor_info[key]
+            if value.is_a?(Numeric) && value <= 0
+              @processor_info[key] = nil
+            end
+          end
+        end
+
+        @processor_info
+      rescue
+        {}
+      end
+
+      def self.sysctl_value(name)
+        # make sure to redirect stderr so we don't spew if the name is unknown
+        `sysctl -n #{name} 2>/dev/null`
+      end
+
+      def self.parse_cpuinfo(cpuinfo)
+        # Build a hash of the form
+        #   { [phys_id, core_id] => num_logical_processors_on_this_core }
+        cores = Hash.new(0)
+        phys_id = core_id = nil
+
+        total_processors = 0
+
+        cpuinfo.split("\n").map(&:strip).each do |line|
+          case line
+            when /^processor\s*:/
+              cores[[phys_id, core_id]] += 1 if phys_id && core_id
+              phys_id = core_id = nil # reset these values
+              total_processors += 1
+            when /^physical id\s*:(.*)/
+              phys_id = $1.strip.to_i
+            when /^core id\s*:(.*)/
+              core_id = $1.strip.to_i
+          end
+        end
+        cores[[phys_id, core_id]] += 1 if phys_id && core_id
+
+        num_physical_packages  = cores.keys.map(&:first).uniq.size
+        num_physical_cores     = cores.size
+        num_logical_processors = cores.values.reduce(0,:+)
+
+        if num_physical_cores == 0
+          num_logical_processors = total_processors
+
+          if total_processors == 1
+            # Some older, single-core processors might not list ids,
+            # so we'll just mark them all 1.
+            num_physical_packages = 1
+            num_physical_cores    = 1
+          else
+            # We have no way of knowing how many packages or cores
+            # we have, even though we know how many processors there are.
+            num_physical_packages = nil
+            num_physical_cores    = nil
+          end
+        end
+
+        {
+            :num_physical_packages  => num_physical_packages,
+            :num_physical_cores     => num_physical_cores,
+            :num_logical_processors => num_logical_processors
+        }
+      end
+
+      def self.num_physical_packages ; get_processor_info[:num_physical_packages ] end
+      def self.num_physical_cores    ; get_processor_info[:num_physical_cores    ] end
+      def self.num_logical_processors
+        processor_count = get_processor_info[:num_logical_processors]
+
+        if processor_count.nil?
+          TingYun::Agent.logger.warn("Failed to determine processor count, assuming 1")
+          processor_count = 1
+        end
+
+        processor_count
+      end
+
+      def self.processor_arch
+        RbConfig::CONFIG['target_cpu']
+      end
+
+      def self.os_version
+        proc_try_read('/proc/version')
+      end
+
+      def self.docker_container_id
+        return unless ruby_os_identifier =~ /linux/
+
+        cgroup_info = proc_try_read('/proc/self/cgroup')
+        return unless cgroup_info
+
+        parse_docker_container_id(cgroup_info)
+      end
+
+      def self.parse_docker_container_id(cgroup_info)
+        cpu_cgroup = parse_cgroup_ids(cgroup_info)['cpu']
+        return unless cpu_cgroup
+
+        case cpu_cgroup
+          # docker native driver w/out systemd (fs)
+          when %r{^/docker/([0-9a-f]+)$}                      then $1
+          # docker native driver with systemd
+          when %r{^/system\.slice/docker-([0-9a-f]+)\.scope$} then $1
+          # docker lxc driver
+          when %r{^/lxc/([0-9a-f]+)$}                         then $1
+          # not in any cgroup
+          when '/'                                            then nil
+          # in a cgroup, but we don't recognize its format
+          else
+            TingYun::Agent.logger.debug("Ignoring unrecognized cgroup ID format: '#{cpu_cgroup}'")
+            nil
+        end
+      end
+
+      def self.parse_cgroup_ids(cgroup_info)
+        cgroup_ids = {}
+
+        cgroup_info.split("\n").each do |line|
+          parts = line.split(':')
+          next unless parts.size == 3
+          _, subsystems, cgroup_id = parts
+          subsystems = subsystems.split(',')
+          subsystems.each do |subsystem|
+            cgroup_ids[subsystem] = cgroup_id
+          end
+        end
+
+        cgroup_ids
+      end
+
+      # A File.read against /(proc|sysfs)/* can hang with some older Linuxes.
+      # See https://bugzilla.redhat.com/show_bug.cgi?id=604887, RUBY-736, and
+      # https://github.com/opscode/ohai/commit/518d56a6cb7d021b47ed3d691ecf7fba7f74a6a7
+      # for details on why we do it this way.
+      def self.proc_try_read(path)
+        return nil unless File.exist?(path)
+        content = ''
+        File.open(path) do |f|
+          loop do
+            begin
+              content << f.read_nonblock(4096)
+            rescue EOFError
+              break
+            rescue Errno::EWOULDBLOCK, Errno::EAGAIN
+              content = nil
+              break # don't select file handle, just give up
+            end
+          end
+        end
+        content
+      end
+    end
+  end
+end

data/lib/ting_yun/support/timer_lib.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+# This code was borrowed from the system_timer gem under the terms
+# of the Ruby license.  It has been slightly modified.
+
+# Defines the constant TimerLib to the appropriate timeout library
+module TingYun #:nodoc:
+  module Support
+
+    begin
+      # Try to use the SystemTimer gem instead of Ruby's timeout library
+      # when running on Ruby 1.8.x. See:
+      #   http://ph7spot.com/articles/system_timer
+      # We don't want to bother trying to load SystemTimer on jruby,
+      # ruby 1.9+ and rbx.
+      if !defined?(RUBY_ENGINE) || (RUBY_ENGINE == 'ruby' && RUBY_VERSION < '1.9.0')
+        require 'system_timer'
+        TimerLib = SystemTimer
+      else
+        require 'timeout'
+        TimerLib = Timeout
+      end
+    rescue LoadError
+      require 'timeout'
+      TimerLib = Timeout
+    end
+  end
+
+end

data/lib/ting_yun/support/version_number.rb

@@ -0,0 +1,70 @@
+# encoding: utf-8
+
+module TingYun
+  module Support
+    class VersionNumber
+
+      include Comparable
+
+      attr_reader :parts
+
+      def initialize(version_string)
+        version_string ||= '1.0.0'
+        @parts = version_string.split('.').map { |n| n =~ /^\d+$/ ? n.to_i : n }
+      end
+
+      def major_version;
+        @parts[0];
+      end
+
+      def minor_version;
+        @parts[1];
+      end
+
+      def tiny_version;
+        @parts[2];
+      end
+
+      def <=>(other)
+        other = self.class.new(other) if other.is_a? String
+        self.class.compare(self.parts, other.parts)
+      end
+
+      def to_s
+        @parts.join(".")
+      end
+
+      def hash
+        @parts.hash
+      end
+
+      def eql? other
+        (self <=> other) == 0
+      end
+
+      private
+
+      def self.compare(parts1, parts2)
+        a, b = parts1.first, parts2.first
+        case
+          when a.nil? && b.nil? then
+            0
+          when a.nil? then
+            b.is_a?(Fixnum) ? -1 : 1
+          when b.nil? then
+            -compare(parts2, parts1)
+          when a.to_s == b.to_s then
+            compare(parts1[1..-1], parts2[1..-1])
+          when a.is_a?(String) then
+            b.is_a?(Fixnum) ? -1 : (a <=> b)
+          when b.is_a?(String) then
+            -compare(parts2, parts1)
+          else # they are both fixnums, not nil
+            a <=> b
+        end
+      end
+
+
+    end
+  end
+end

data/lib/ting_yun/ting_yun_service/connection.rb

@@ -0,0 +1,118 @@
+# encoding: utf-8
+# This file is distributed under Ting Yun's license terms.
+
+
+module TingYun
+  class TingYunService
+    module Connection
+      # Return a Net::HTTP connection object to make a call to the collector.
+      # We'll reuse the same handle for cases where we're using keep-alive, or
+      # otherwise create a new one.
+      def http_connection
+        if @in_session
+          establish_shared_connection
+        else
+          create_http_connection
+        end
+      end
+
+      def establish_shared_connection
+        unless @shared_tcp_connection
+          @shared_tcp_connection = create_and_start_http_connection
+        end
+        @shared_tcp_connection
+      end
+
+
+      def create_and_start_http_connection
+        conn = create_http_connection
+        start_connection(conn)
+        conn
+      end
+
+      def start_connection(conn)
+        TingYun::Agent.logger.debug("Opening TCP connection to #{conn.address}:#{conn.port}")
+        TingYun::Support::TimerLib.timeout(@request_timeout) { conn.start }
+        conn
+      end
+
+
+      def create_http_connection
+        if TingYun::Agent.config[:proxy_host]
+          TingYun::Agent.logger.debug("Using proxy server #{TingYun::Agent.config[:proxy_host]}:#{TingYun::Agent.config[:proxy_port]}")
+
+          proxy = Net::HTTP::Proxy(
+              TingYun::Agent.config[:proxy_host],
+              TingYun::Agent.config[:proxy_port],
+              TingYun::Agent.config[:proxy_user],
+              TingYun::Agent.config[:proxy_pass]
+          )
+          conn = proxy.new(@collector.name, @collector.port)
+        else
+          conn = Net::HTTP.new(@collector.name, @collector.port)
+        end
+
+        setup_connection_for_ssl(conn) if TingYun::Agent.config[:ssl]
+        setup_connection_timeouts(conn)
+        TingYun::Agent.logger.debug("Created net/http handle to #{conn.address}:#{conn.port}")
+
+        conn
+      end
+
+      def close_shared_connection
+        if @shared_tcp_connection
+          TingYun::Agent.logger.debug("Closing shared TCP connection to #{@shared_tcp_connection.address}:#{@shared_tcp_connection.port}")
+          @shared_tcp_connection.finish if @shared_tcp_connection.started?
+          @shared_tcp_connection = nil
+        end
+      end
+
+
+      def setup_connection_timeouts(conn)
+        # We use Timeout explicitly instead of this
+        conn.read_timeout = nil
+
+        if conn.respond_to?(:keep_alive_timeout) && TingYun::Agent.config[:aggressive_keepalive]
+          conn.keep_alive_timeout = TingYun::Agent.config[:keep_alive_timeout]
+        end
+      end
+
+      # One session with the service's endpoint.  In this case the session
+      # represents 1 tcp connection which may transmit multiple HTTP requests
+      # via keep-alive.
+      def session(&block)
+        raise ArgumentError, "#{self.class}#shared_connection must be passed a block" unless block_given?
+
+        begin
+          t0 = Time.now
+          @in_session = true
+          if TingYun::Agent.config[:aggressive_keepalive]
+            session_with_keepalive(&block)
+          else
+            session_without_keepalive(&block)
+          end
+        rescue *CONNECTION_ERRORS => e
+          elapsed = Time.now - t0
+          raise TingYun::Support::Exception::ServerConnectionException, "Recoverable error connecting to #{@collector} after #{elapsed} seconds: #{e}"
+        ensure
+          @in_session = false
+        end
+      end
+
+      def session_with_keepalive(&block)
+        establish_shared_connection
+        block.call
+      end
+
+      def session_without_keepalive(&block)
+        begin
+          establish_shared_connection
+          block.call
+        ensure
+          close_shared_connection
+        end
+      end
+
+    end
+  end
+end

data/lib/ting_yun/ting_yun_service/http.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+# This file is distributed under Ting Yun's license terms.
+
+require 'zlib'
+require 'net/https'
+require 'net/http'
+require 'ting_yun/ting_yun_service/ssl'
+require 'ting_yun/ting_yun_service/request'
+require 'ting_yun/ting_yun_service/connection'
+
+module TingYun
+  class TingYunService
+    module Http
+
+      include Ssl
+      include Request
+      include Connection
+
+      def remote_method_uri(method)
+        params = {'licenseKey'=> @license_key,'version' => @data_version}
+        params[:appSessionKey] = @appSessionKey if @appSessionKey
+        uri = "/" + method.to_s
+        uri << '?' + params.map do |k,v|
+          next unless v
+          "#{k}=#{v}"
+        end.compact.join('&')
+        uri
+      end
+
+      # Decompresses the response from the server, if it is gzip
+      # encoded, otherwise returns it verbatim
+      def decompress_response(response)
+        if response['content-encoding'] == 'gzip'
+          Zlib::GzipReader.new(StringIO.new(response.body)).read
+        else
+          response.body
+        end
+      end
+    end
+  end
+end

data/lib/ting_yun/ting_yun_service/request.rb

@@ -0,0 +1,90 @@
+# encoding: utf-8
+# This file is distributed under Ting Yun's license terms.
+require 'ting_yun/support/exception'
+
+module TingYun
+  class TingYunService
+    module Request
+
+      #Posts to the specified server, retry every minute if ServerConnectionException
+      def send_request(opts)
+        request = Net::HTTP::Post.new(opts[:uri], 'CONTENT-ENCODING' => opts[:encoding], 'HOST' => opts[:collector].name)
+        request['user-agent'] = user_agent
+        request.content_type = "application/octet-stream"
+        request.body = opts[:data]
+        response = nil
+        max_attempts = 2
+        attempts = 0
+        begin
+          attempts += 1
+          conn = http_connection
+          TingYun::Agent.logger.debug "Sending request to #{opts[:collector]}#{opts[:uri]}"
+          TingYun::Support::TimerLib.timeout(@request_timeout) do
+            response = conn.request(request)
+          end
+        rescue *CONNECTION_ERRORS => e
+          close_shared_connection
+          if attempts < max_attempts
+            TingYun::Agent.logger.debug("Retrying request to #{opts[:collector]}#{opts[:uri]} after #{e}")
+            retry
+          else
+            raise TingYun::Support::Exception::ServerConnectionException, "Recoverable error talking to #{@collector} after #{attempts} attempts: #{e}"
+          end
+        end
+        TingYun::Agent.logger.debug "Received response, status: #{response.code}, encoding: '#{response['content-encoding']}'"
+
+
+        case response
+          when Net::HTTPSuccess
+            true # do nothing
+          when Net::HTTPServiceUnavailable
+            raise TingYun::Support::Exception::ServerConnectionException, "Service unavailable (#{response.code}): #{response.message}"
+          when Net::HTTPGatewayTimeOut
+            raise TingYun::Support::Exception::ServerConnectionException, "Gateway timeout (#{response.code}): #{response.message}"
+          when Net::HTTPRequestEntityTooLarge
+            raise TingYun::Support::Exception::UnrecoverableServerException, '413 Request Entity Too Large'
+          when Net::HTTPUnsupportedMediaType
+            raise TingYun::Support::Exception::UnsupportedMediaType, '415 Unsupported Media Type'
+          else
+            raise TingYun::Support::Exception::ServerConnectionException, "Unexpected response from server (#{response.code}): #{response.message}"
+        end
+        response
+      end
+
+
+
+      def compress_request_if_needed(data)
+        encoding = 'identity'
+        if data.size > 64*1024
+          data = TingYun::Support::Serialize::Encoders::Compressed.encode(data)
+          encoding = 'deflate'
+        end
+        check_post_size(data)
+        [data, encoding]
+      end
+
+      def check_post_size(post)
+        return if post.size < TingYun::Agent.config[:post_size_limit]
+        TingYun::Agent.logger.debug "Tried to send too much data: #{post.size} bytes"
+        raise TingYun::Support::Exception::UnrecoverableServerException.new('413 Request Entity Too Large')
+      end
+
+      def user_agent
+        ruby_description = ''
+        # note the trailing space!
+        ruby_description << "(ruby #{::RUBY_VERSION} #{::RUBY_PLATFORM}) " if defined?(::RUBY_VERSION) && defined?(::RUBY_PLATFORM)
+        zlib_version = ''
+        zlib_version << "zlib/#{Zlib.zlib_version}" if defined?(::Zlib) && Zlib.respond_to?(:zlib_version)
+        "NBS Newlens Agent/#{TingYun::VERSION::STRING} #{ruby_description}#{zlib_version}"
+      end
+
+      def valid_to_marshal?(data)
+        @marshaller.dump(data)
+        true
+      rescue StandardError, SystemStackError => e
+        TingYun::Agent.logger.warn("Unable to marshal environment report on connect.", e)
+        false
+      end
+    end
+  end
+end

data/lib/ting_yun/ting_yun_service/ssl.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+# This file is distributed under Ting Yun's license terms.
+require 'ting_yun/support/path'
+require 'ting_yun/support/exception'
+
+module TingYun
+  class TingYunService
+    module Ssl
+
+      def setup_connection_for_ssl(conn)
+        # Jruby 1.6.8 requires a gem for full ssl support and will throw
+        # an error when use_ssl=(true) is called and jruby-openssl isn't
+        # installed
+        conn.use_ssl     = true
+        conn.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        conn.cert_store  = ssl_cert_store
+      rescue StandardError, LoadError
+        msg = "Agent is configured to use SSL, but SSL is not available in the environment. "
+        msg << "Either disable SSL in the agent configuration, or install SSL support."
+        raise TingYun::Support::Exception::UnrecoverableAgentException.new(msg)
+      end
+
+      def ssl_cert_store
+        path = cert_file_path
+        if !@ssl_cert_store || path != @cached_cert_store_path
+          TingYun::Agent.logger.debug("Creating SSL certificate store from file at #{path}")
+          @ssl_cert_store = OpenSSL::X509::Store.new
+          @ssl_cert_store.add_file(path)
+          @cached_cert_store_path = path
+        end
+        @ssl_cert_store
+      end
+
+      def cert_file_path
+        if path_override = TingYun::Agent.config[:ca_bundle_path]
+          TingYun::Agent.logger.warn("Couldn't find CA bundle from configured ca_bundle_path: #{path_override}") unless File.exist? path_override
+          path_override
+        else
+          File.expand_path(File.join(TingYun::Support::Path.ting_yun_root, 'cert', 'cacert.pem'))
+        end
+      end
+
+    end
+  end
+end