log4ever 0.0.9 → 0.1.0

data/lib/log4r/evernote/lib/thrift/server/nonblocking_server.rb

@@ -1,305 +0,0 @@
-# 
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements. See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership. The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License. You may obtain a copy of the License at
-# 
-#   http://www.apache.org/licenses/LICENSE-2.0
-# 
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied. See the License for the
-# specific language governing permissions and limitations
-# under the License.
-# 
-
-require 'logger'
-require 'thread'
-
-module Thrift
-  # this class expects to always use a FramedTransport for reading messages
-  class NonblockingServer < BaseServer
-    def initialize(processor, server_transport, transport_factory=nil, protocol_factory=nil, num=20, logger=nil)
-      super(processor, server_transport, transport_factory, protocol_factory)
-      @num_threads = num
-      if logger.nil?
-        @logger = Logger.new(STDERR)
-        @logger.level = Logger::WARN
-      else
-        @logger = logger
-      end
-      @shutdown_semaphore = Mutex.new
-      @transport_semaphore = Mutex.new
-    end
-
-    def serve
-      @logger.info "Starting #{self}"
-      @server_transport.listen
-      @io_manager = start_io_manager
-
-      begin
-        loop do
-          break if @server_transport.closed?
-          begin
-            rd, = select([@server_transport], nil, nil, 0.1)
-          rescue Errno::EBADF => e
-            # In Ruby 1.9, calling @server_transport.close in shutdown paths causes the select() to raise an
-            # Errno::EBADF. If this happens, ignore it and retry the loop.
-            break
-          end
-          next if rd.nil?
-          socket = @server_transport.accept
-          @logger.debug "Accepted socket: #{socket.inspect}"
-          @io_manager.add_connection socket
-        end
-      rescue IOError => e
-      end
-      # we must be shutting down
-      @logger.info "#{self} is shutting down, goodbye"
-    ensure
-      @transport_semaphore.synchronize do
-        @server_transport.close
-      end
-      @io_manager.ensure_closed unless @io_manager.nil?
-    end
-
-    def shutdown(timeout = 0, block = true)
-      @shutdown_semaphore.synchronize do
-        return if @is_shutdown
-        @is_shutdown = true
-      end
-      # nonblocking is intended for calling from within a Handler
-      # but we can't change the order of operations here, so lets thread
-      shutdown_proc = lambda do
-        @io_manager.shutdown(timeout)
-        @transport_semaphore.synchronize do
-          @server_transport.close # this will break the accept loop
-        end
-      end
-      if block
-        shutdown_proc.call
-      else
-        Thread.new &shutdown_proc
-      end
-    end
-
-    private
-
-    def start_io_manager
-      iom = IOManager.new(@processor, @server_transport, @transport_factory, @protocol_factory, @num_threads, @logger)
-      iom.spawn
-      iom
-    end
-
-    class IOManager # :nodoc:
-      DEFAULT_BUFFER = 2**20
-      
-      def initialize(processor, server_transport, transport_factory, protocol_factory, num, logger)
-        @processor = processor
-        @server_transport = server_transport
-        @transport_factory = transport_factory
-        @protocol_factory = protocol_factory
-        @num_threads = num
-        @logger = logger
-        @connections = []
-        @buffers = Hash.new { |h,k| h[k] = '' }
-        @signal_queue = Queue.new
-        @signal_pipes = IO.pipe
-        @signal_pipes[1].sync = true
-        @worker_queue = Queue.new
-        @shutdown_queue = Queue.new
-      end
-
-      def add_connection(socket)
-        signal [:connection, socket]
-      end
-
-      def spawn
-        @iom_thread = Thread.new do
-          @logger.debug "Starting #{self}"
-          run
-        end
-      end
-
-      def shutdown(timeout = 0)
-        @logger.debug "#{self} is shutting down workers"
-        @worker_queue.clear
-        @num_threads.times { @worker_queue.push [:shutdown] }
-        signal [:shutdown, timeout]
-        @shutdown_queue.pop
-        @signal_pipes[0].close
-        @signal_pipes[1].close
-        @logger.debug "#{self} is shutting down, goodbye"
-      end
-
-      def ensure_closed
-        kill_worker_threads if @worker_threads
-        @iom_thread.kill
-      end
-
-      private
-      
-      def run
-        spin_worker_threads
-
-        loop do
-          rd, = select([@signal_pipes[0], *@connections])
-          if rd.delete @signal_pipes[0]
-            break if read_signals == :shutdown
-          end
-          rd.each do |fd|
-            begin
-              if fd.handle.eof?
-                remove_connection fd
-              else
-                read_connection fd
-              end
-            rescue Errno::ECONNRESET
-              remove_connection fd
-            end
-          end
-        end
-        join_worker_threads(@shutdown_timeout)
-      ensure
-        @shutdown_queue.push :shutdown
-      end
-
-      def read_connection(fd)
-        @buffers[fd] << fd.read(DEFAULT_BUFFER)
-        while(frame = slice_frame!(@buffers[fd]))
-          @logger.debug "#{self} is processing a frame"
-          @worker_queue.push [:frame, fd, frame]
-        end
-      end
-
-      def spin_worker_threads
-        @logger.debug "#{self} is spinning up worker threads"
-        @worker_threads = []
-        @num_threads.times do
-          @worker_threads << spin_thread
-        end
-      end
-
-      def spin_thread
-        Worker.new(@processor, @transport_factory, @protocol_factory, @logger, @worker_queue).spawn
-      end
-
-      def signal(msg)
-        @signal_queue << msg
-        @signal_pipes[1].write " "
-      end
-
-      def read_signals
-        # clear the signal pipe
-        # note that since read_nonblock is broken in jruby,
-        # we can only read up to a set number of signals at once
-        sigstr = @signal_pipes[0].readpartial(1024)
-        # now read the signals
-        begin
-          sigstr.length.times do
-            signal, obj = @signal_queue.pop(true)
-            case signal
-            when :connection
-              @connections << obj
-            when :shutdown
-              @shutdown_timeout = obj
-              return :shutdown
-            end
-          end
-        rescue ThreadError
-          # out of signals
-          # note that in a perfect world this would never happen, since we're
-          # only reading the number of signals pushed on the pipe, but given the lack
-          # of locks, in theory we could clear the pipe/queue while a new signal is being
-          # placed on the pipe, at which point our next read_signals would hit this error
-        end
-      end
-
-      def remove_connection(fd)
-        # don't explicitly close it, a thread may still be writing to it
-        @connections.delete fd
-        @buffers.delete fd
-      end
-
-      def join_worker_threads(shutdown_timeout)
-        start = Time.now
-        @worker_threads.each do |t|
-          if shutdown_timeout > 0
-            timeout = (start + shutdown_timeout) - Time.now
-            break if timeout <= 0
-            t.join(timeout)
-          else
-            t.join
-          end
-        end
-        kill_worker_threads
-      end
-
-      def kill_worker_threads
-        @worker_threads.each do |t|
-          t.kill if t.status
-        end
-        @worker_threads.clear
-      end
-
-      def slice_frame!(buf)
-        if buf.length >= 4
-          size = buf.unpack('N').first
-          if buf.length >= size + 4
-            buf.slice!(0, size + 4)
-          else
-            nil
-          end
-        else
-          nil
-        end
-      end
-
-      class Worker # :nodoc:
-        def initialize(processor, transport_factory, protocol_factory, logger, queue)
-          @processor = processor
-          @transport_factory = transport_factory
-          @protocol_factory = protocol_factory
-          @logger = logger
-          @queue = queue
-        end
-
-        def spawn
-          Thread.new do
-            @logger.debug "#{self} is spawning"
-            run
-          end
-        end
-
-        private
-
-        def run
-          loop do
-            cmd, *args = @queue.pop
-            case cmd
-            when :shutdown
-              @logger.debug "#{self} is shutting down, goodbye"
-              break
-            when :frame
-              fd, frame = args
-              begin
-                otrans = @transport_factory.get_transport(fd)
-                oprot = @protocol_factory.get_protocol(otrans)
-                membuf = MemoryBufferTransport.new(frame)
-                itrans = @transport_factory.get_transport(membuf)
-                iprot = @protocol_factory.get_protocol(itrans)
-                @processor.process(iprot, oprot)
-              rescue => e
-                @logger.error "#{Thread.current.inspect} raised error: #{e.inspect}\n#{e.backtrace.join("\n")}"
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/log4r/evernote/lib/thrift/server/simple_server.rb

@@ -1,43 +0,0 @@
-# 
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements. See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership. The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License. You may obtain a copy of the License at
-# 
-#   http://www.apache.org/licenses/LICENSE-2.0
-# 
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied. See the License for the
-# specific language governing permissions and limitations
-# under the License.
-#
-
-module Thrift
-  class SimpleServer < BaseServer
-    def serve
-      begin
-        @server_transport.listen
-        loop do
-          client = @server_transport.accept
-          trans = @transport_factory.get_transport(client)
-          prot = @protocol_factory.get_protocol(trans)
-          begin
-            loop do
-              @processor.process(prot, prot)
-            end
-          rescue Thrift::TransportException, Thrift::ProtocolException
-          ensure
-            trans.close
-          end
-        end
-      ensure
-        @server_transport.close
-      end
-    end
-  end
-end

data/lib/log4r/evernote/lib/thrift/server/thread_pool_server.rb

@@ -1,75 +0,0 @@
-# 
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements. See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership. The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License. You may obtain a copy of the License at
-# 
-#   http://www.apache.org/licenses/LICENSE-2.0
-# 
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied. See the License for the
-# specific language governing permissions and limitations
-# under the License.
-# 
-
-require 'thread'
-
-module Thrift
-  class ThreadPoolServer < BaseServer
-    def initialize(processor, server_transport, transport_factory=nil, protocol_factory=nil, num=20)
-      super(processor, server_transport, transport_factory, protocol_factory)
-      @thread_q = SizedQueue.new(num)
-      @exception_q = Queue.new
-      @running = false
-    end
-
-    ## exceptions that happen in worker threads will be relayed here and
-    ## must be caught. 'retry' can be used to continue. (threads will
-    ## continue to run while the exception is being handled.)
-    def rescuable_serve
-      Thread.new { serve } unless @running
-      @running = true
-      raise @exception_q.pop
-    end
-
-    ## exceptions that happen in worker threads simply cause that thread
-    ## to die and another to be spawned in its place.
-    def serve
-      @server_transport.listen
-
-      begin
-        loop do
-          @thread_q.push(:token)
-          Thread.new do
-            begin
-              loop do
-                client = @server_transport.accept
-                trans = @transport_factory.get_transport(client)
-                prot = @protocol_factory.get_protocol(trans)
-                begin
-                  loop do
-                    @processor.process(prot, prot)
-                  end
-                rescue Thrift::TransportException, Thrift::ProtocolException => e
-                ensure
-                  trans.close
-                end
-              end
-            rescue => e
-              @exception_q.push(e)
-            ensure
-              @thread_q.pop # thread died!
-            end
-          end
-        end
-      ensure
-        @server_transport.close
-      end
-    end
-  end
-end

data/lib/log4r/evernote/lib/thrift/server/threaded_server.rb

@@ -1,47 +0,0 @@
-# 
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements. See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership. The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License. You may obtain a copy of the License at
-# 
-#   http://www.apache.org/licenses/LICENSE-2.0
-# 
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied. See the License for the
-# specific language governing permissions and limitations
-# under the License.
-#
-
-require 'thread'
-
-module Thrift
-  class ThreadedServer < BaseServer
-    def serve
-      begin
-        @server_transport.listen
-        loop do
-          client = @server_transport.accept
-          trans = @transport_factory.get_transport(client)
-          prot = @protocol_factory.get_protocol(trans)
-          Thread.new(prot, trans) do |p, t|
-            begin
-              loop do
-                @processor.process(p, p)
-              end
-            rescue Thrift::TransportException, Thrift::ProtocolException
-            ensure
-              t.close
-            end
-          end
-        end
-      ensure
-        @server_transport.close
-      end
-    end
-  end
-end

data/lib/log4r/evernote/lib/thrift/struct.rb

@@ -1,237 +0,0 @@
-# 
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements. See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership. The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License. You may obtain a copy of the License at
-# 
-#   http://www.apache.org/licenses/LICENSE-2.0
-# 
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied. See the License for the
-# specific language governing permissions and limitations
-# under the License.
-# 
-
-require 'set'
-
-module Thrift
-  module Struct
-    def initialize(d={}, &block)
-      # get a copy of the default values to work on, removing defaults in favor of arguments
-      fields_with_defaults = fields_with_default_values.dup
-      
-      # check if the defaults is empty, or if there are no parameters for this 
-      # instantiation, and if so, don't bother overriding defaults.
-      unless fields_with_defaults.empty? || d.empty?
-        d.each_key do |name|
-          fields_with_defaults.delete(name.to_s)
-        end
-      end
-      
-      # assign all the user-specified arguments
-      unless d.empty?
-        d.each do |name, value|
-          unless name_to_id(name.to_s)
-            raise Exception, "Unknown key given to #{self.class}.new: #{name}"
-          end
-          Thrift.check_type(value, struct_fields[name_to_id(name.to_s)], name) if Thrift.type_checking
-          instance_variable_set("@#{name}", value)
-        end
-      end
-      
-      # assign all the default values
-      unless fields_with_defaults.empty?
-        fields_with_defaults.each do |name, default_value|
-          instance_variable_set("@#{name}", (default_value.dup rescue default_value))
-        end
-      end
-      
-      yield self if block_given?
-    end
-
-    def fields_with_default_values
-      fields_with_default_values = self.class.instance_variable_get(:@fields_with_default_values)
-      unless fields_with_default_values
-        fields_with_default_values = {}
-        struct_fields.each do |fid, field_def|
-          unless field_def[:default].nil?
-            fields_with_default_values[field_def[:name]] = field_def[:default]
-          end
-        end
-        self.class.instance_variable_set(:@fields_with_default_values, fields_with_default_values)
-      end
-      fields_with_default_values
-    end
-    
-    def inspect(skip_optional_nulls = true)
-      fields = []
-      each_field do |fid, field_info|
-        name = field_info[:name]
-        value = instance_variable_get("@#{name}")
-        unless skip_optional_nulls && field_info[:optional] && value.nil?
-          fields << "#{name}:#{inspect_field(value, field_info)}"
-        end
-      end
-      "<#{self.class} #{fields.join(", ")}>"
-    end
-
-    def read(iprot)
-      iprot.read_struct_begin
-      loop do
-        fname, ftype, fid = iprot.read_field_begin
-        break if (ftype == Types::STOP)
-        handle_message(iprot, fid, ftype)
-        iprot.read_field_end
-      end
-      iprot.read_struct_end
-      validate
-    end
-
-    def write(oprot)
-      validate
-      oprot.write_struct_begin(self.class.name)
-      each_field do |fid, field_info|
-        name = field_info[:name]
-        type = field_info[:type]
-        value = instance_variable_get("@#{name}")
-        unless value.nil?
-          if is_container? type
-            oprot.write_field_begin(name, type, fid)
-            write_container(oprot, value, field_info)
-            oprot.write_field_end
-          else
-            oprot.write_field(name, type, fid, value)
-          end
-        end
-      end
-      oprot.write_field_stop
-      oprot.write_struct_end
-    end
-
-    def ==(other)
-      return false if other.nil?
-      each_field do |fid, field_info|
-        name = field_info[:name]
-        return false unless other.respond_to?(name) && self.send(name) == other.send(name)
-      end
-      true
-    end
-
-    def eql?(other)
-      self.class == other.class && self == other
-    end
-
-    # This implementation of hash() is inspired by Apache's Java HashCodeBuilder class.
-    def hash
-      total = 17
-      each_field do |fid, field_info|
-        name = field_info[:name]
-        value = self.send(name)
-        total = (total * 37 + value.hash) & 0xffffffff
-      end
-      total
-    end
-
-    def differences(other)
-      diffs = []
-      unless other.is_a?(self.class)
-        diffs << "Different class!"
-      else
-        each_field do |fid, field_info|
-          name = field_info[:name]
-          diffs << "#{name} differs!" unless self.instance_variable_get("@#{name}") == other.instance_variable_get("@#{name}")
-        end
-      end
-      diffs
-    end
-
-    def self.field_accessor(klass, field_info)
-      field_name_sym = field_info[:name].to_sym
-      klass.send :attr_reader, field_name_sym
-      klass.send :define_method, "#{field_info[:name]}=" do |value|
-        Thrift.check_type(value, field_info, field_info[:name]) if Thrift.type_checking
-        instance_variable_set("@#{field_name_sym}", value)
-      end
-    end
-
-    def self.generate_accessors(klass)
-      klass::FIELDS.values.each do |field_info|
-        field_accessor(klass, field_info)
-        qmark_isset_method(klass, field_info)
-      end
-    end
-
-    def self.qmark_isset_method(klass, field_info)
-      klass.send :define_method, "#{field_info[:name]}?" do
-        !self.send(field_info[:name].to_sym).nil?
-      end
-    end
-
-    def <=>(other)
-      if self.class == other.class
-        each_field do |fid, field_info|
-          v1 = self.send(field_info[:name])
-          v1_set = !v1.nil?
-          v2 = other.send(field_info[:name])
-          v2_set = !v2.nil?
-          if v1_set && !v2_set
-            return -1
-          elsif !v1_set && v2_set
-            return 1
-          elsif v1_set && v2_set
-            cmp = v1 <=> v2
-            if cmp != 0
-              return cmp
-            end
-          end
-        end
-        0
-      else
-        self.class <=> other.class
-      end
-    end
-
-    protected
-
-    def self.append_features(mod)
-      if mod.ancestors.include? ::Exception
-        mod.send :class_variable_set, :'@@__thrift_struct_real_initialize', mod.instance_method(:initialize)
-        super
-        # set up our custom initializer so `raise Xception, 'message'` works
-        mod.send :define_method, :struct_initialize, mod.instance_method(:initialize)
-        mod.send :define_method, :initialize, mod.instance_method(:exception_initialize)
-      else
-        super
-      end
-    end
-
-    def exception_initialize(*args, &block)
-      if args.size == 1 and args.first.is_a? Hash
-        # looks like it's a regular Struct initialize
-        method(:struct_initialize).call(args.first)
-      else
-        # call the Struct initializer first with no args
-        # this will set our field default values
-        method(:struct_initialize).call()
-        # now give it to the exception
-        self.class.send(:class_variable_get, :'@@__thrift_struct_real_initialize').bind(self).call(*args, &block) if args.size > 0
-        # self.class.instance_method(:initialize).bind(self).call(*args, &block)
-      end
-    end
-
-    def handle_message(iprot, fid, ftype)
-      field = struct_fields[fid]
-      if field and field[:type] == ftype
-        value = read_field(iprot, field)
-        instance_variable_set("@#{field[:name]}", value)
-      else
-        iprot.skip(ftype)
-      end
-    end
-  end
-end