uae-common 0.0.1

data/lib/uae/common.rb

@@ -0,0 +1,111 @@
+require 'fileutils'
+require 'socket'
+
+module UAE
+
+  # 获取本机ip
+  def self.local_ip(route)
+    orig, Socket.do_not_reverse_lookup = Socket.do_not_reverse_lookup, true
+    UDPSocket.open {|s| s.connect(route, 1); s.addr.last }
+  ensure
+    Socket.do_not_reverse_lookup = orig
+  end
+
+  # 获取一个uuid
+  def self.secure_uuid
+    result = File.open('/dev/urandom') { |x| x.read(16).unpack('H*')[0] }
+  end
+
+  # 获取一个随机端口
+  def self.grab_ephemeral_port
+    socket = TCPServer.new('0.0.0.0', 0)
+    socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, true)
+    Socket.do_not_reverse_lookup = true
+    port = socket.addr[1]
+    socket.close
+    return port
+  end
+
+  def self.process_running?(pid)
+    return false unless pid && (pid > 0)
+    output = %x[ps -o rss= -p #{pid}]
+    return true if ($? == 0 && !output.empty?)
+    # fail otherwise..
+    return false
+  end
+
+  class PidFile
+    class ProcessRunningError < StandardError
+    end
+
+    def initialize(pid_file, create_parents=true)
+      @pid_file = pid_file
+      @dirty = true
+      write(create_parents)
+    end
+
+    # Removes the created pidfile
+    def unlink()
+      return unless @dirty
+
+      # Swallowing exception here is fine. Removing the pid files is a courtesy.
+      begin
+        File.unlink(@pid_file)
+        @dirty = false
+      rescue
+      end
+      self
+    end  
+
+    # Removes the created pidfile upon receipt of the supplied signals
+    def unlink_on_signals(*sigs)
+      return unless @dirty
+
+      sigs.each do |s|
+        Signal.trap(s) { unlink() }
+      end
+      self
+    end
+
+    def unlink_at_exit()
+      at_exit { unlink() }
+      self
+    end
+
+    def to_s()
+      @pid_file
+    end
+
+    protected
+
+    # Atomically writes the pidfile.
+    # NB: This throws exceptions if the pidfile contains the pid of another running process.
+    #
+    # +create_parents+  If true, all parts of the path up to the file's dirname will be created.
+    #
+    def write(create_parents=true)
+      FileUtils.mkdir_p(File.dirname(@pid_file)) if create_parents
+
+      # Protip from Wilson: binary mode keeps things sane under Windows
+      # Closing the fd releases our lock
+      File.open(@pid_file, 'a+b', 0644) do |f|
+        f.flock(File::LOCK_EX)
+
+        # Check if process is already running
+        pid = f.read().strip().to_i()
+        if pid == Process.pid()
+          return
+        elsif UAE.process_running?(pid)
+          raise ProcessRunningError.new("Process already running (pid=%d)." % (pid))
+        end
+
+        # We're good to go, write our pid
+        f.truncate(0)
+        f.rewind()
+        f.write("%d\n" % (Process.pid()))
+        f.flush()
+      end
+    end
+  end # class PidFile
+
+end

data/lib/uae/component.rb

@@ -0,0 +1,171 @@
+# Copyright (c) 2009-2011 VMware, Inc.
+require "eventmachine"
+require 'thin'
+require "yajl"
+require "nats/client"
+require "base64"
+require 'set'
+
+module UAE
+
+  RACK_JSON_HDR = { 'Content-Type' => 'application/json' }
+  RACK_TEXT_HDR = { 'Content-Type' => 'text/plaintext' }
+
+  class Varz
+    def initialize(logger)
+      @logger = logger
+    end
+
+    def call(env)
+      @logger.debug "varz access"
+      varz = Yajl::Encoder.encode(Component.updated_varz, :pretty => true, :terminator => "\n")
+      [200, { 'Content-Type' => 'application/json', 'Content-Length' => varz.length.to_s }, varz]
+    rescue => e
+      @logger.error "varz error #{e.inspect} #{e.backtrace.join("\n")}"
+      raise e
+    end
+  end
+
+  class Healthz
+    def initialize(logger)
+      @logger = logger
+    end
+
+    def call(env)
+      @logger.debug "healthz access"
+      healthz = Component.updated_healthz
+      [200, { 'Content-Type' => 'application/json', 'Content-Length' => healthz.length.to_s }, healthz]
+    rescue => e
+      @logger.error "healthz error #{e.inspect} #{e.backtrace.join("\n")}"
+      raise e
+    end
+  end
+
+  # Common component setup for discovery and monitoring
+  class Component
+
+    # We will suppress these from normal varz reporting by default.
+    CONFIG_SUPPRESS = Set.new([:mbus, :service_mbus, :keys, :database_environment, :mysql, :password])
+
+    class << self
+
+      attr_reader   :varz
+      attr_accessor :healthz
+
+      def updated_varz
+        @last_varz_update ||= 0
+        if Time.now.to_f - @last_varz_update >= 1
+          # Snapshot uptime
+          @varz[:uptime] = UAE.uptime_string(Time.now - @varz[:start])
+
+          # Grab current cpu and memory usage.
+          rss, pcpu = `ps -o rss=,pcpu= -p #{Process.pid}`.split
+          @varz[:mem] = rss.to_i
+          @varz[:cpu] = pcpu.to_f
+
+          @last_varz_update = Time.now.to_f
+        end
+        varz
+      end
+
+      def updated_healthz
+        @last_healthz_update ||= 0
+        if Time.now.to_f - @last_healthz_update >= 1
+          # ...
+          @last_healthz_update = Time.now.to_f
+        end
+
+        healthz
+      end
+
+      def start_http_server(host, port, auth, logger)
+        http_server = Thin::Server.new(host, port, :signals => false) do
+          Thin::Logging.silent = true
+          use Rack::Auth::Basic do |username, password|
+            [username, password] == auth
+          end
+          map '/healthz' do
+            run Healthz.new(logger)
+          end
+          map '/varz' do
+            run Varz.new(logger)
+          end
+        end
+        http_server.start!
+      end
+
+      def uuid
+        @discover[:uuid]
+      end
+
+      def register(opts)
+        uuid = UAE.secure_uuid
+        type = opts[:type]
+        index = opts[:index]
+        uuid = "#{index}-#{uuid}" if index
+        host = opts[:host] || UAE.local_ip
+        port = opts[:port] || UAE.grab_ephemeral_port
+        nats = opts[:nats] || NATS
+        auth = [opts[:user] || UAE.secure_uuid, opts[:password] || UAE.secure_uuid]
+        logger = opts[:logger] || Logger.new(nil)
+
+        # Discover message limited
+        @discover = {
+          :type => type,
+          :index => index,
+          :uuid => uuid,
+          :host => "#{host}:#{port}",
+          :credentials => auth,
+          :start => Time.now
+        }
+
+        # Varz is customizable
+        @varz = @discover.dup
+        @varz[:config] = sanitize_config(opts[:config]) if opts[:config]
+
+        @healthz = "ok\n".freeze
+
+        # Next steps require EM
+        raise "EventMachine reactor needs to be running" if !EventMachine.reactor_running?
+
+        # Startup the http endpoint for /varz and /healthz
+        start_http_server(host, port, auth, logger)
+
+        # Listen for discovery requests
+        nats.subscribe('vcap.component.discover') do |msg, reply|
+          update_discover_uptime
+          nats.publish(reply, @discover.to_json)
+        end
+
+        # Also announce ourselves on startup..
+        nats.publish('vcap.component.announce', @discover.to_json)
+      end
+
+      def update_discover_uptime
+        @discover[:uptime] = UAE.uptime_string(Time.now - @discover[:start])
+      end
+
+      def clear_level(h)
+        h.each do |k, v|
+          if CONFIG_SUPPRESS.include?(k.to_sym)
+            h.delete(k)
+          else
+            clear_level(h[k]) if v.instance_of? Hash
+          end
+        end
+      end
+
+      def sanitize_config(config)
+        # Can't Marshal/Deep Copy logger instances that services use
+        if config[:logger]
+          config = config.dup
+          config.delete(:logger)
+        end
+        # Deep copy
+        config = Marshal.load(Marshal.dump(config))
+        clear_level(config)
+        config
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,47 @@
+--- !ruby/object:Gem::Specification
+name: uae-common
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- zhonggy
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-15 00:00:00.000000000 Z
+dependencies: []
+description: UAE common library
+email:
+- zhonggy@ucweb.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/uae/common.rb
+- lib/uae/component.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: It works for UAE project
+test_files: []