win32-eventlog 0.4.2

data/lib/win32/mc.rb

@@ -0,0 +1,104 @@
+module Win32
+   class MCError < StandardError; end
+   class MC
+      VERSION = '0.1.2'
+		
+      attr_accessor :mc_file, :res_file, :dll_file
+		
+		# Accepts three file names as arguments and returns an MC object.  The
+      # +mc_file+ is the name of the .mc file to be used to ultimately
+      # generate the .dll file.
+      #
+      # If +res_file+ or +dll_file+ are not specified, then the basename
+      # of +mc_file+ is used to generate their names, with .res and .dll
+      # extensions, respectively.
+      # 
+      def initialize(mc_file, res_file=nil, dll_file=nil)
+         @mc_file = mc_file
+			
+         if res_file
+            @res_file = res_file
+         else
+            @res_file = File.basename(mc_file, '.mc') + '.res'
+         end
+			
+         if dll_file
+            @dll_file = dll_file
+         else
+            @dll_file = File.basename(mc_file, '.mc') + '.dll'
+         end
+      end
+		
+		# Uses the message compiler (mc) program to generate the .h and .rc
+		# files based on the .mc (message category) file.  This method must
+		# be called before MC#create_res_file or MC#create_dll_file.
+		# 
+      def create_header
+         system("mc #{@mc_file}")
+      end
+		
+		# Creates the .res (resource) file from the .rc file generated by the
+		# MC#create_header method.  Raises an MCError if the .rc file is not
+		# found.
+      # 
+      def create_res_file
+         rc_file = File.basename(@mc_file, '.mc') + '.rc'
+         unless File.exists?(rc_file)
+            raise MCError, "No .rc file found: #{@rc_file}"
+         end
+         system("rc -r -fo #{@res_file} #{rc_file}")
+      end
+		
+		# Creates the .dll file from the .res file generated by the
+		# MC#create_res_file method.  Raises an MCError if the .res file is not
+		# found.
+		# 
+      def create_dll_file
+         unless File.exists?(@res_file)
+			   raise MCError, "No .res file found: #{@res_file}"
+         end
+         system("link -dll -noentry -out:#{@dll_file} #{@res_file}")
+      end
+		
+		# A shortcut for MC#create_header + MC#create_res_file +
+		# MC#create_dll_file.
+		# 
+      def create_all
+         create_header
+         create_res_file
+         create_dll_file
+      end
+		
+		# Delete .h, .rc and .res files created from the corresponding
+		# .mc file (but *not* the .dll file).  This also deletes all MSG*.bin
+		# files in the current directory.
+		#
+      def clean
+         base = File.basename(@mc_file, '.mc')
+         %w/.h .rc .res/.each do |ext|
+            file = base + ext
+            File.delete(file) if File.exists?(file)
+         end
+         Dir["MSG*.bin"].each do |binfile|
+            File.delete(binfile)
+         end
+      end
+   end
+end
+
+if $0 == __FILE__
+	include Win32
+	
+	mc_file = ARGV[0]
+	
+	unless mc_file
+		msg = "Usage: ruby mc.rb 'filename.mc'"
+		raise MCError, msg
+	end
+	
+	m = MC.new(mc_file)
+	m.create_header
+	m.create_res_file
+	m.create_dll_file
+	puts "MC finished"
+end

data/lib/win32/test.rb

@@ -0,0 +1,8 @@
+$:.unshift Dir.pwd
+require 'eventlog'
+
+include Win32
+
+EventLog.open('System').tail{ |log|
+   p log
+}

data/test/foo.mc

@@ -0,0 +1,24 @@
+MessageId=0x1
+SymbolicName=CATEGORY_HELLO
+Language=English
+Foohello
+.
+
+MessageId=0x2
+SymbolicName=CATEGORY_WORLD
+Language=English
+Fooworld
+.
+
+MessageId=0x3
+SymbolicName=FOO_ERROR
+Language=English
+Foo error: %1
+.
+
+MessageId=0x4
+SymbolicName=FOO_WARN
+Language=English
+Foo warning: %1
+.
+

data/test/tc_eventlog.rb

@@ -0,0 +1,228 @@
+###################################################
+# tc_eventlog.rb
+#
+# Test case for the win32-eventlog package.
+###################################################
+Dir.chdir('..') if File.basename(Dir.pwd) == 'test'
+$LOAD_PATH.unshift Dir.pwd
+$LOAD_PATH.unshift Dir.pwd + '/lib'
+Dir.chdir('test') rescue nil
+
+require 'test/unit'
+require 'win32/eventlog'
+require 'socket'
+include Win32
+
+print "\nRelax - this will take a few moments\n\n"
+
+class TC_EventLog < Test::Unit::TestCase
+   def setup
+      @log      = EventLog.new('Application')
+      @logfile  = 'temp.evt'
+      @bakfile  = 'C:\event_log.bak'
+      @hostname = Socket.gethostname
+      @records  = []
+      @last     = nil
+   end
+ 
+   def test_version
+      assert_equal('0.4.2', EventLog::VERSION)
+   end
+   
+   # Use the alias to validate it as well.
+   def test_constructor
+      assert_respond_to(EventLog, :open)
+      assert_nothing_raised{ EventLog.open }
+      assert_nothing_raised{ EventLog.open{ |log| } }
+      assert_nothing_raised{ EventLog.open('System') }
+      assert_nothing_raised{ EventLog.open('System', @hostname) }
+   end
+   
+   def test_constructor_expected_errors
+      assert_raises(EventLogError){ EventLog.new('System', @hostname, 'foo') }
+      assert_raises(TypeError){ EventLog.open(1) }
+      assert_raises(TypeError){ EventLog.open('System', 1) }
+   end
+   
+   def test_constructor_instance_variables
+      assert_nothing_raised{ @log = EventLog.new('Application', @hostname) }
+      assert_equal(@hostname, @log.server)
+      assert_equal('Application', @log.source)
+   end
+   
+   def test_open_backup
+      assert_respond_to(EventLog, :open_backup)
+      assert_nothing_raised{ EventLog.new('Application').backup(@bakfile) }
+      assert_nothing_raised{ @log = EventLog.open_backup(@bakfile) }
+      assert_kind_of(EventLog, @log)
+      assert_nothing_raised{ @log.read{ break } }
+      assert_nothing_raised{ @log.close }
+   end
+  
+   # Ensure that an Array is returned in non-block form and that none of the
+   # descriptions are nil.
+   # 
+   # The test for descriptions was added as a result of ruby-talk:116528.
+   # Thanks go to Joey Gibson for the spot.  The test for unique record
+   # numbers was added to ensure no dups.
+   # 
+   def test_class_read_verification
+      assert_nothing_raised{ @array = EventLog.read }
+      assert_kind_of(Array, @array)
+      
+      record_numbers = []
+      @array.each{ |log|
+         assert_not_nil(log.description)
+         assert_equal(false, record_numbers.include?(log.record_number))
+         record_numbers << log.record_number
+      }
+   end
+  
+   # I've added explicit breaks because an event log could be rather large.
+   # 
+   def test_class_read_basic    
+      assert_nothing_raised{ EventLog.read{ break } }    
+      assert_nothing_raised{ EventLog.read("Application"){ break } }
+      assert_nothing_raised{ EventLog.read("Application", nil){ break } }
+      assert_nothing_raised{ EventLog.read("Application", nil, nil){ break } }
+      assert_nothing_raised{ EventLog.read("Application", nil, nil, 10){ break } } 
+   end   
+   
+   def test_class_read_expected_errors   
+      assert_raises(ArgumentError){
+         EventLog.read("Application", nil, nil, nil, nil){}
+      }
+   end
+   
+   def test_read
+      flags = EventLog::FORWARDS_READ | EventLog::SEQUENTIAL_READ
+      assert_respond_to(@log, :read)
+      assert_nothing_raised{ @log.read{ break } }
+      assert_nothing_raised{ @log.read(flags){ break } }
+      assert_nothing_raised{ @log.read(flags, 500){ break } }
+   end
+   
+   def test_read_expected_errors
+      flags = EventLog::FORWARDS_READ | EventLog::SEQUENTIAL_READ
+      assert_raises(ArgumentError){ @log.read(flags, 500, 'foo') }
+   end
+   
+   def test_seek_read
+      flags = EventLog::SEEK_READ | EventLog::FORWARDS_READ
+      assert_nothing_raised{ @last = @log.total_records }
+      assert_nothing_raised{
+         @records = EventLog.read(nil, nil, flags, @last - 10)
+      }
+      assert_equal(11, @records.length)
+      assert_equal(@last, @records.last.record_number)
+   end
+   
+   def test_seek_read_backwards
+      flags = EventLog::SEEK_READ | EventLog::BACKWARDS_READ
+      assert_nothing_raised{ @records = EventLog.read(nil, nil, flags, 10) }
+      assert_equal(10, @records.length)
+      assert_equal(10, @records.first.record_number)
+      assert_equal(1, @records.last.record_number)
+   end
+  
+   def test_server
+      assert_respond_to(@log, :server)
+      assert_raises(NoMethodError){ @log.server = 'foo' }
+   end
+
+   def test_source
+      assert_respond_to(@log, :source)
+      assert_kind_of(String, @log.source)
+      assert_raises(NoMethodError){ @log.source = 'foo' }
+   end
+   
+   def test_file
+      assert_respond_to(@log, :file)
+      assert_nil(@log.file)
+      assert_raises(NoMethodError){ @log.file = 'foo' }
+   end 
+   
+   def test_backup
+      assert_respond_to(@log, :backup)
+      assert_nothing_raised{ @log.backup(@bakfile) }
+      assert(File.exists?(@bakfile))
+      assert_raises(EventLogError){ @log.backup(@bakfile) }
+   end
+   
+   # Since I don't want to actually clear anyone's event log, I can't really
+   # verify that it works.
+   # 
+   def test_clear
+      assert_respond_to(@log, :clear)
+   end
+   
+   def test_full
+      assert_respond_to(@log, :full?)
+      assert_nothing_raised{ @log.full? }
+   end
+      
+   def test_close
+      assert_respond_to(@log, :close)
+      assert_nothing_raised{ @log.close }
+   end
+   
+   def test_oldest_record_number
+      assert_respond_to(@log, :oldest_record_number)
+      assert_kind_of(Fixnum, @log.oldest_record_number)
+   end
+   
+   def test_total_records
+      assert_respond_to(@log, :total_records)
+      assert_kind_of(Fixnum, @log.total_records)
+   end
+   
+   # We can't test that this method actually executes properly since it goes
+   # into an endless loop.
+   # 
+   def test_tail
+      assert_respond_to(@log, :tail)
+      assert_raises(EventLogError){ @log.tail } # requires block
+   end
+   
+   # We can't test that this method actually executes properly since it goes
+   # into an endless loop.
+   # 
+   def test_notify_change
+      assert_respond_to(@log, :notify_change)
+      assert_raises(EventLogError){ @log.notify_change } # requires block
+   end
+   
+   # I can't really do more in depth testing for this method since there
+   # isn't an event source I can reliably and safely write to.
+   # 
+   def test_report_event
+      assert_respond_to(@log, :report_event)
+      assert_respond_to(@log, :write) # alias
+      assert_raises(ArgumentError){ @log.report_event }
+   end
+  
+   def test_read_event_constants
+      assert_not_nil(EventLog::FORWARDS_READ)
+      assert_not_nil(EventLog::BACKWARDS_READ)
+      assert_not_nil(EventLog::SEEK_READ)
+      assert_not_nil(EventLog::SEQUENTIAL_READ)
+   end
+
+   def test_event_type_constants
+      assert_not_nil(EventLog::SUCCESS)
+      assert_not_nil(EventLog::ERROR)
+      assert_not_nil(EventLog::WARN)
+      assert_not_nil(EventLog::INFO)
+      assert_not_nil(EventLog::AUDIT_SUCCESS)
+      assert_not_nil(EventLog::AUDIT_FAILURE)
+   end
+   
+   def teardown
+      @log.close rescue nil
+      File.delete(@bakfile) rescue nil
+      @logfile  = nil
+      @hostname = nil
+      @records  = nil
+      @last     = nil
+   end
+end

data/test/tc_mc.rb

@@ -0,0 +1,49 @@
+############################################################################
+# tc_mc.rb
+#
+# Test suite for the win32-mc package.  The tests need to run in a specific
+# order, hence the numerics added to the method names.
+############################################################################
+Dir.chdir('..') if File.basename(Dir.pwd) == 'test'
+$LOAD_PATH.unshift Dir.pwd
+$LOAD_PATH.unshift Dir.pwd + '/lib'
+Dir.chdir('test') rescue nil
+
+require 'test/unit'
+require 'win32/mc'
+include Win32
+
+class TC_Win32_MC < Test::Unit::TestCase
+   def setup
+      @mc = MC.new('foo.mc')
+   end
+   
+   def test_01_version
+      assert_equal('0.1.2', MC::VERSION)
+   end
+
+   def test_02_create_header
+      assert_respond_to(@mc, :create_header)
+      assert_nothing_raised{ @mc.create_header }
+   end
+
+   def test_03_create_res_file
+      assert_respond_to(@mc, :create_res_file)
+      assert_nothing_raised{ @mc.create_res_file }
+   end
+   
+   def test_04_create_dll_file
+      assert_respond_to(@mc, :create_dll_file)
+      assert_nothing_raised{ @mc.create_dll_file }
+   end
+   
+   def test_05_clean
+      assert_respond_to(@mc, :clean)
+      assert_nothing_raised{ @mc.clean }
+   end
+
+   def teardown
+      @mc = nil
+      File.delete('foo.dll') rescue nil
+   end
+end

data/test/ts_all.rb

@@ -0,0 +1,7 @@
+Dir.chdir('..') if File.basename(Dir.pwd) == 'test'
+$LOAD_PATH.unshift Dir.pwd
+$LOAD_PATH.unshift Dir.pwd + '/lib'
+Dir.chdir('test') rescue nil
+
+require 'tc_eventlog'
+require 'tc_mc'

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.0
+specification_version: 1
+name: win32-eventlog
+version: !ruby/object:Gem::Version 
+  version: 0.4.2
+date: 2006-08-06 00:00:00 -06:00
+summary: Interface for the MS Windows Event Log.
+require_paths: 
+- lib
+email: djberg96@gmail.com
+homepage: http://www.rubyforge.org/projects/win32utils
+rubyforge_project: 
+description: Interface for the MS Windows Event Log.
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Daniel J. Berger
+files: 
+- lib/win32/eventlog.rb
+- lib/win32/mc.rb
+- lib/win32/test.rb
+- test/CVS
+- test/foo.mc
+- test/tc_eventlog.rb
+- test/tc_mc.rb
+- test/ts_all.rb
+- CHANGES
+- CVS
+- MANIFEST
+- README
+- doc/tutorial.txt
+test_files: 
+- test/ts_all.rb
+rdoc_options: []
+
+extra_rdoc_files: 
+- README
+- CHANGES
+- doc/tutorial.txt
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: windows-pr
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.5.0
+    version: