win32-service 0.6.1 → 0.7.0

data/lib/win32/service.rb

@@ -23,7 +23,8 @@ module Win32
       include Windows::Process
       include Windows::Security
       include Windows::MSVCRT::String
-      include Windows::MSVCRT::Buffer     
+      include Windows::MSVCRT::Buffer
+           
       extend Windows::Error
       extend Windows::Service
       extend Windows::File
@@ -32,7 +33,8 @@ module Win32
       extend Windows::MSVCRT::String
       extend Windows::MSVCRT::Buffer
       
-      VERSION = '0.6.1'
+      # The version of the win32-service library
+      VERSION = '0.7.0'
       
       # SCM security and access rights
       
@@ -227,10 +229,14 @@ module Win32
 
       # :startdoc: #
       
-      # Creates a new service with +service_name+ on +host+, or the local host
-      # if no host is specified. The +options+ parameter is a hash that can
-      # contain any of the following parameters, and their default values:
+      # Creates a new service with the specified +options+. A +service_name+
+      # must be specified or an ArgumentError is raised. A +host+ option may
+      # be specified. If no host is specified the local machine is used.
       #
+      # Possible Options:
+      #
+      # * service_name           => nil (you must specify)
+      # * host                   => nil (optional)
       # * display_name           => service_name
       # * desired_access         => Service::ALL_ACCESS
       # * service_type           => Service::WIN32_OWN_PROCESS |
@@ -252,7 +258,9 @@ module Win32
       # Example:
       #
       #    # Configure everything
-      #    Service.new('some_service', nil, 
+      #    Service.new(
+      #       :service_name       => 'some_service',
+      #       :host               => 'localhost',
       #       :service_type       => Service::WIN32_OWN_PROCESS,
       #       :description        => 'A custom service I wrote just for fun',
       #       :start_type         => Service::AUTO_START,
@@ -265,10 +273,7 @@ module Win32
       #       :display_name       => 'This is some service',
       #    )
       #
-      def initialize(service_name, host=nil, options={})
-         raise TypeError unless service_name.is_a?(String)
-         raise TypeError if host && !host.is_a?(String)
-         
+      def initialize(options={})        
          unless options.is_a?(Hash)
             raise ArgumentError, 'options parameter must be a hash'
          end
@@ -294,7 +299,9 @@ module Win32
             'failure_reboot_message' => nil,
             'failure_command'        => nil,
             'failure_actions'        => nil,
-            'failure_delay'          => 0            
+            'failure_delay'          => 0,
+            'host'                   => nil,
+            'service_name'           => nil            
          }
 
          # Validate the hash options
@@ -305,6 +312,16 @@ module Win32
             end
             opts[key] = value
          }
+         
+         unless opts['service_name']
+            raise ArgumentError, 'No service_name specified'            
+         end
+         
+         service_name = opts.delete('service_name')
+         host = opts.delete('host')
+         
+         raise TypeError unless service_name.is_a?(String)
+         raise TypeError if host && !host.is_a?(String)
 
          handle_scm = OpenSCManager(host, 0, SC_MANAGER_CREATE_SERVICE)
 
@@ -408,10 +425,11 @@ module Win32
       # Examples:
       #
       #    # Configure only the display name
-      #    Service.configure('some_service', nil, :display_name => 'Test 33')
+      #    Service.configure(:service_name => 'some_service', :display_name => 'Test 33')
       #
       #    # Configure everything
-      #    Service.configure('some_service', nil, 
+      #    Service.configure(
+      #       :service_name       => 'some_service'
       #       :service_type       => Service::WIN32_OWN_PROCESS,
       #       :start_type         => Service::AUTO_START,
       #       :error_control      => Service::ERROR_NORMAL,
@@ -424,9 +442,7 @@ module Win32
       #       :description        => 'A custom service I wrote just for fun'
       #    )
       #
-      def self.configure(service, host=nil, options={})
-         raise TypeError unless service.is_a?(String)
-         
+      def self.configure(options={})    
          unless options.is_a?(Hash)
             raise ArgumentError, 'options parameter must be a hash'
          end
@@ -450,7 +466,9 @@ module Win32
             'failure_reboot_message' => nil,
             'failure_command'        => nil,
             'failure_actions'        => nil,
-            'failure_delay'          => 0
+            'failure_delay'          => 0,
+            'service_name'           => nil,
+            'host'                   => nil
          }
 
          # Validate the hash options
@@ -461,6 +479,16 @@ module Win32
             end
             opts[key] = value
          }
+         
+         unless opts['service_name']
+            raise ArgumentError, 'No service_name specified'            
+         end
+         
+         service = opts.delete('service_name')
+         host = opts.delete('host')
+
+         raise TypeError unless service.is_a?(String)
+         raise TypeError unless host.is_a?(String) if host
 
          handle_scm = OpenSCManager(host, 0, SC_MANAGER_CONNECT)
 
@@ -861,9 +889,9 @@ module Win32
          CloseServiceHandle(handle_scs)
          CloseServiceHandle(handle_scm)
 
-         binary_path_name   = 0.chr * 260
-         load_order_group   = 0.chr * 260
-         dependencies       = 0.chr * 260
+         binary_path_name   = 0.chr * 1024
+         load_order_group   = 0.chr * 1024
+         dependencies       = 0.chr * 1024
          service_start_name = 0.chr * 260
          display_name       = 0.chr * 260
 
@@ -1095,15 +1123,15 @@ module Win32
             config_buf = get_config_info(handle_scs)
 
             if config_buf != ERROR_FILE_NOT_FOUND
-               binary_path = 0.chr * 260
+               binary_path = 0.chr * 1024
                strcpy(binary_path, config_buf[12,4].unpack('L').first)
                binary_path = binary_path.unpack('Z*')[0]
 
-               load_order = 0.chr * 260
+               load_order = 0.chr * 1024
                strcpy(load_order, config_buf[16,4].unpack('L').first)
                load_order = load_order.unpack('Z*')[0]
             
-               start_name = 0.chr * 260
+               start_name = 0.chr * 1024
                strcpy(start_name, config_buf[28,4].unpack('L').first)
                start_name = start_name.unpack('Z*')[0]
             
@@ -1114,7 +1142,7 @@ module Win32
 
                deps = get_dependencies(config_buf[24,4].unpack('L').first)
 
-               description = 0.chr * 1024
+               description = 0.chr * 2048
                buf = get_config2_info(handle_scs, SERVICE_CONFIG_DESCRIPTION) 
 
                strcpy(description, buf[0,4].unpack('L').first)

data/test/{tc_daemon.rb → test_win32_daemon.rb}

@@ -7,6 +7,9 @@
 # These tests are rather limited, since the acid test is to install
 # your daemon as a service and see how it behaves.
 #########################################################################
+require 'rubygems'
+gem 'test-unit'
+
 require 'win32/daemon'
 require 'test/unit'
 include Win32
@@ -17,7 +20,7 @@ class TC_Daemon < Test::Unit::TestCase
    end
    
    def test_version
-      assert_equal('0.6.1', Daemon::VERSION)
+      assert_equal('0.7.0', Daemon::VERSION)
    end
    
    def test_constructor

data/test/{tc_service.rb → test_win32_service.rb}

@@ -3,6 +3,9 @@
 # 
 # Test case for the Win32::Service class.
 ##########################################################################
+require 'rubygems'
+gem 'test-unit'
+
 require 'win32/service'
 require 'socket'
 require 'test/unit'
@@ -20,19 +23,7 @@ class TC_Win32_Service < Test::Unit::TestCase
    end
 
    def test_version
-      assert_equal('0.6.1', Win32::Service::VERSION)
-   end
-
-   def test_service_configure
-      assert_respond_to(Win32::Service, :configure)
-   end
-   
-   def test_service_configure_expected_errors
-      assert_raise(ArgumentError){ Win32::Service.configure }
-      assert_raise(ArgumentError){ Win32::Service.configure('bogus') }
-      assert_raise(ArgumentError){ Win32::Service.configure('bogus', 'bogus') }
-      assert_raise(Win32::Service::Error){ Win32::Service.configure('x', nil, :description => 'Test') }
-      assert_raise(Win32::Service::Error){ Win32::Service.configure('x', 'y', :description => 'Test') }      
+      assert_equal('0.7.0', Win32::Service::VERSION)
    end
    
    def test_services_basic
@@ -41,7 +32,7 @@ class TC_Win32_Service < Test::Unit::TestCase
       assert_nothing_raised{ Win32::Service.services(nil) }
       assert_nothing_raised{ Win32::Service.services(nil, 'network') }
    end
-   
+      
    def test_services_non_block_form
       assert_nothing_raised{ @services = Win32::Service.services }
       assert_kind_of(Array, @services)

data/test/test_win32_service_configure.rb

@@ -0,0 +1,86 @@
+#######################################################################
+# test_win32_service_configure.rb
+#
+# Test suite that validates the Service.configure method.
+#######################################################################
+require 'rubygems'
+gem 'test-unit'
+
+require 'win32/service'
+require 'test/unit'
+
+class TC_Service_Configure < Test::Unit::TestCase
+   def self.startup
+      @@service = "notepad_service"
+      @@command = "C:\\windows\\system32\\notepad.exe"
+            
+      Win32::Service.new(
+         :service_name     => @@service,
+         :binary_path_name => @@command
+      )
+   end
+   
+   def config_info
+      Win32::Service.config_info(@@service)
+   end
+   
+   def full_info
+      service = nil
+      Win32::Service.services{ |s|
+         if s.service_name == @@service
+            service = s
+            break
+         end
+      }
+      service
+   end
+   
+   def service_configure(opt)
+      options = {:service_name => @@service}
+      options = options.merge(opt)
+      assert_nothing_raised{ Win32::Service.configure(options) }    
+   end
+   
+   def setup
+      @info = Win32::Service.config_info(@@service)
+   end
+   
+   def test_service_configure_basic
+      assert_respond_to(Win32::Service, :configure)
+   end
+   
+   def test_service_type
+      assert_equal('own process, interactive', config_info.service_type)
+      service_configure(:service_type => Win32::Service::WIN32_SHARE_PROCESS)      
+      assert_equal('share process', config_info.service_type)
+   end
+   
+   def test_description
+      assert_equal('', full_info.description)
+      service_configure(:description => 'test service')     
+      assert_equal('test service', full_info.description)
+   end
+   
+   def test_start_type
+      assert_equal('demand start', config_info.start_type)
+      service_configure(:start_type => Win32::Service::DISABLED)
+      assert_equal('disabled', config_info.start_type)      
+   end
+   
+   def test_service_configure_expected_errors
+      assert_raise(ArgumentError){ Win32::Service.configure }
+      assert_raise(ArgumentError){ Win32::Service.configure('bogus') }
+      assert_raise(ArgumentError){ Win32::Service.configure({}) }
+      assert_raise(ArgumentError){ Win32::Service.configure(:binary_path_name => 'notepad.exe') }
+   end
+   
+   def teardown
+      @info = nil
+   end
+   
+   def self.shutdown
+      Win32::Service.delete(@@service) if Win32::Service.exists?(@@service)
+      @@service = nil
+      @@command = nil      
+   end   
+end

data/test/test_win32_service_create.rb

@@ -0,0 +1,103 @@
+########################################################################
+# tc_service_create.rb
+#
+# Test case for the Service.create method. This test case will create
+# a dummy (notepad) service. It won't actually run of course.
+########################################################################
+require 'rubygems'
+gem 'test-unit'
+
+require 'win32/service'
+require 'test/unit'
+
+class TC_Service_Create < Test::Unit::TestCase
+   def self.startup
+      @@service1 = "notepad_service1"
+      @@service2 = "notepad_service2"
+      @@command  = "C:\\windows\\system32\\notepad.exe"
+      
+      Win32::Service.new(
+         :service_name     => @@service1,
+         :binary_path_name => @@command
+      )
+      
+      Win32::Service.new(
+         :service_name     => @@service2,
+         :display_name     => 'Notepad Test',
+         :desired_access   => Win32::Service::ALL_ACCESS,
+         :service_type     => Win32::Service::WIN32_OWN_PROCESS,
+         :start_type       => Win32::Service::DISABLED,
+         :error_control    => Win32::Service::ERROR_IGNORE,
+         :binary_path_name => @@command,
+         :load_order_group => 'Network',
+         :dependencies     => 'W32Time',
+         :description      => 'Test service. Please delete me'
+      )
+   end
+   
+   def setup
+      @info1 = Win32::Service.config_info(@@service1)
+      @info2 = Win32::Service.config_info(@@service2)
+   end
+
+   def test_new_basic
+      assert_respond_to(Win32::Service, :new)
+   end
+   
+   def test_create_alias
+      assert_respond_to(Win32::Service, :create)
+      assert_equal(Win32::Service.method(:create), Win32::Service.method(:new))
+   end
+   
+   # Sanity test to ensure the services were actually created. If this test
+   # fails, the results for other tests are meaningless.
+   #
+   def test_service_created
+      assert_true(Win32::Service.exists?(@@service1))
+      assert_true(Win32::Service.exists?(@@service2))
+   end
+   
+   def test_service_configuration_info
+      assert_equal('own process, interactive', @info1.service_type)
+      assert_equal('demand start', @info1.start_type)
+      assert_equal('normal', @info1.error_control)
+      assert_equal(@@command, @info1.binary_path_name)
+      assert_equal('', @info1.load_order_group)
+      assert_equal(0, @info1.tag_id)
+      assert_equal([], @info1.dependencies)
+      assert_equal('LocalSystem', @info1.service_start_name)
+      assert_equal('notepad_service1', @info1.display_name)
+   end
+  
+   def test_service_configuration_info_multiple_options  
+      assert_equal('own process', @info2.service_type)
+      assert_equal('disabled', @info2.start_type)
+      assert_equal('ignore', @info2.error_control)
+      assert_equal(@@command, @info2.binary_path_name)
+      assert_equal('Network', @info2.load_order_group)
+      assert_equal(0, @info2.tag_id)
+      assert_equal(['W32Time'], @info2.dependencies)
+      assert_equal('LocalSystem', @info2.service_start_name)
+      assert_equal('Notepad Test', @info2.display_name)      
+   end
+
+   def test_create_expected_errors
+      assert_raise(ArgumentError){ Win32::Service.new }
+      assert_raise(ArgumentError){ Win32::Service.new(:binary_path_name => 'test.exe') }
+      assert_raise(ArgumentError){ Win32::Service.new(:bogus => 'test.exe') }
+   end
+
+   def teardown
+      @info1 = nil
+      @info2 = nil
+   end
+   
+   def self.shutdown
+      Win32::Service.delete(@@service1) if Win32::Service.exists?(@@service1)
+      Win32::Service.delete(@@service2) if Win32::Service.exists?(@@service2)
+
+      @@service1 = nil
+      @@service2 = nil
+      @@command  = nil
+   end
+end

data/test/{tc_service_info.rb → test_win32_service_info.rb}

@@ -3,13 +3,19 @@
 #
 # Test case for the Struct::ServiceInfo structure.
 ########################################################################
+require 'rubygems'
+gem 'test-unit'
+
 require 'win32/service'
 require 'test/unit'
 
 class TC_Struct_ServiceInfo < Test::Unit::TestCase
+   def self.startup
+      @@services = Win32::Service.services      
+   end
+   
    def setup
-      @services = Win32::Service.services
-      @service_info = @services[0]
+      @service_info = @@services[0]
 
       @error_controls = [
          'critical',
@@ -162,9 +168,12 @@ class TC_Struct_ServiceInfo < Test::Unit::TestCase
    end
 
    def teardown
-      @services = nil
       @types    = nil
       @states   = nil
       @controls = nil
    end
+   
+   def self.shutdown
+      @@services = nil
+   end
 end