summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rwxr-xr-xchef-bin/bin/chef-service-manager37
-rwxr-xr-xchef-bin/bin/chef-windows-service33
-rw-r--r--lib/chef/application/windows_service.rb338
-rw-r--r--lib/chef/application/windows_service_manager.rb205
-rw-r--r--spec/functional/resource/windows_service_spec.rb105
-rw-r--r--spec/functional/win32/service_manager_spec.rb220
-rw-r--r--spec/spec_helper.rb5
-rw-r--r--spec/support/chef_helpers.rb16
-rw-r--r--spec/support/shared/functional/execute_resource.rb4
-rw-r--r--spec/support/shared/functional/win32_service.rb57
-rw-r--r--spec/support/shared/functional/windows_script.rb4
-rw-r--r--spec/unit/windows_service_spec.rb118
12 files changed, 6 insertions, 1136 deletions
diff --git a/chef-bin/bin/chef-service-manager b/chef-bin/bin/chef-service-manager
index dcaae80141..336b1c4715 100755
--- a/chef-bin/bin/chef-service-manager
+++ b/chef-bin/bin/chef-service-manager
@@ -1,38 +1,3 @@
#!/usr/bin/env ruby
#
-# ./chef-service-manager - Control chef-service on Windows platforms.
-#
-# Author:: Serdar Sutay (serdar@chef.io)
-# Copyright:: Copyright 2013-2018, Chef Software Inc.
-# License:: Apache License, Version 2.0
-#
-# Licensed 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.
-
-$:.unshift(File.join(__dir__, "..", "lib"))
-require "chef"
-require "chef/application/windows_service_manager"
-require "chef-utils/dist" unless defined?(ChefUtils::Dist)
-
-if Chef::Platform.windows?
- chef_client_service = {
- service_name: ChefUtils::Dist::Infra::CLIENT,
- service_display_name: "#{ChefUtils::Dist::Infra::PRODUCT} Service",
- service_description: "Runs #{ChefUtils::Dist::Infra::PRODUCT} on regular, configurable intervals.",
- service_file_path: File.expand_path("../chef-windows-service", $PROGRAM_NAME),
- delayed_start: true,
- dependencies: ["Winmgmt"],
- }
- Chef::Application::WindowsServiceManager.new(chef_client_service).run
-else
- puts "chef-service-manager is only available on Windows platforms."
-end
+puts "As of Chef Infra Client 17 the chef-service-manager is no longer available. Please run Chef Infra Client as a scheduled task instead for more reliable operation with lower memory and CPU overhead."
diff --git a/chef-bin/bin/chef-windows-service b/chef-bin/bin/chef-windows-service
index ce1a30baae..e84cbe2e7a 100755
--- a/chef-bin/bin/chef-windows-service
+++ b/chef-bin/bin/chef-windows-service
@@ -1,34 +1,3 @@
#!/usr/bin/env ruby
#
-# Author:: Jay Mundrawala (<jdm@chef.io>)
-#
-# Copyright:: 2014-2018, Chef Software, Inc.
-#
-# Licensed 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.
-#
-
-# Note:
-# The file is used by appbundler to generate a ruby file that
-# we can execute using the correct gems. The batch file we
-# generate will call that file, and will be registered as
-# a windows service.
-
-$:.unshift(File.join(__dir__, "..", "lib"))
-require "chef"
-require "chef/application/windows_service"
-
-if Chef::Platform.windows?
- Chef::Application::WindowsService.mainloop
-else
- puts "chef-windows-service is only available on Windows platforms."
-end
+puts "As of Chef Infra Client 17 the chef-windows-service is no longer available. Please run Chef Infra Client as a scheduled task instead for more reliable operation with lower memory and CPU overhead."
diff --git a/lib/chef/application/windows_service.rb b/lib/chef/application/windows_service.rb
deleted file mode 100644
index 8975556f75..0000000000
--- a/lib/chef/application/windows_service.rb
+++ /dev/null
@@ -1,338 +0,0 @@
-#
-# Author:: Christopher Maier (<maier@lambda.local>)
-# Copyright:: Copyright (c) Chef Software Inc.
-# License:: Apache License, Version 2.0
-#
-# Licensed 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_relative "../../chef"
-require_relative "../monologger"
-require_relative "../application"
-require_relative "../client"
-require_relative "../config"
-require_relative "../handler/error_report"
-require_relative "../log"
-require_relative "../http"
-require "mixlib/cli" unless defined?(Mixlib::CLI)
-require "socket" unless defined?(Socket)
-require "uri" unless defined?(URI)
-require "win32/daemon"
-require_relative "../mixin/shell_out"
-require "chef-utils/dist" unless defined?(ChefUtils::Dist)
-
-class Chef
- class Application
- class WindowsService < ::Win32::Daemon
- include Mixlib::CLI
- include Chef::Mixin::ShellOut
-
- option :config_file,
- short: "-c CONFIG",
- long: "--config CONFIG",
- default: "#{Chef::Config.etc_chef_dir}/client.rb",
- description: "The configuration file to use for #{ChefUtils::Dist::Infra::PRODUCT} runs."
-
- option :log_location,
- short: "-L LOGLOCATION",
- long: "--logfile LOGLOCATION",
- description: "Set the log file location."
-
- option :splay,
- short: "-s SECONDS",
- long: "--splay SECONDS",
- description: "The splay time for running at intervals, in seconds.",
- proc: lambda { |s| s.to_i }
-
- option :interval,
- short: "-i SECONDS",
- long: "--interval SECONDS",
- description: "Set the number of seconds to wait between #{ChefUtils::Dist::Infra::PRODUCT} runs.",
- proc: lambda { |s| s.to_i }
-
- DEFAULT_LOG_LOCATION ||= "#{Chef::Config.c_chef_dir}/client.log".freeze
-
- def service_init
- @service_action_mutex = Mutex.new
- @service_signal = ConditionVariable.new
-
- reconfigure
- Chef::Log.info("#{ChefUtils::Dist::Infra::CLIENT} Service initialized")
- end
-
- def service_main(*startup_parameters)
- # Chef::Config is initialized during service_init
- # Set the initial timeout to splay sleep time
- timeout = rand Chef::Config[:splay]
-
- while running?
- # Grab the service_action_mutex to make a chef-client run
- @service_action_mutex.synchronize do
-
- Chef::Log.info("Next #{ChefUtils::Dist::Infra::CLIENT} run will happen in #{timeout} seconds")
- @service_signal.wait(@service_action_mutex, timeout)
-
- # Continue only if service is RUNNING
- next if state != RUNNING
-
- # Reconfigure each time through to pick up any changes in the client file
- Chef::Log.info("Reconfiguring with startup parameters")
- reconfigure(startup_parameters)
- timeout = Chef::Config[:interval]
-
- # Honor splay sleep config
- timeout += rand Chef::Config[:splay]
-
- # run chef-client only if service is in RUNNING state
- next if state != RUNNING
-
- Chef::Log.info("#{ChefUtils::Dist::Infra::CLIENT} service is starting a #{ChefUtils::Dist::Infra::CLIENT} run...")
- run_chef_client
- rescue SystemExit => e
- # Do not raise any of the errors here in order to
- # prevent service crash
- Chef::Log.error("#{e.class}: #{e}")
- rescue Exception => e
- Chef::Log.error("#{e.class}: #{e}")
-
- end
- end
-
- # Daemon class needs to have all the signal callbacks return
- # before service_main returns.
- Chef::Log.trace("Giving signal callbacks some time to exit...")
- sleep 1
- Chef::Log.trace("Exiting service...")
- end
-
- ################################################################################
- # Control Signal Callback Methods
- ################################################################################
-
- def service_stop
- run_warning_displayed = false
- Chef::Log.info("STOP request from operating system.")
- loop do
- # See if a run is in flight
- if @service_action_mutex.try_lock
- # Run is not in flight. Wake up service_main to exit.
- @service_signal.signal
- @service_action_mutex.unlock
- break
- else
- unless run_warning_displayed
- Chef::Log.info("Currently a #{ChefUtils::Dist::Infra::PRODUCT} run is happening on this system.")
- Chef::Log.info("Service will stop when run is completed.")
- run_warning_displayed = true
- end
-
- Chef::Log.trace("Waiting for #{ChefUtils::Dist::Infra::PRODUCT} run...")
- sleep 1
- end
- end
- Chef::Log.info("Service is stopping....")
- end
-
- def service_pause
- Chef::Log.info("PAUSE request from operating system.")
-
- # We don't need to wake up the service_main if it's waiting
- # since this is a PAUSE signal.
-
- if @service_action_mutex.locked?
- Chef::Log.info("Currently a #{ChefUtils::Dist::Infra::PRODUCT} run is happening.")
- Chef::Log.info("Service will pause once it's completed.")
- else
- Chef::Log.info("Service is pausing....")
- end
- end
-
- def service_resume
- # We don't need to wake up the service_main if it's waiting
- # since this is a RESUME signal.
-
- Chef::Log.info("RESUME signal received from the OS.")
- Chef::Log.info("Service is resuming....")
- end
-
- def service_shutdown
- Chef::Log.info("SHUTDOWN signal received from the OS.")
-
- # Treat shutdown similar to stop.
-
- service_stop
- end
-
- ################################################################################
- # Internal Methods
- ################################################################################
-
- private
-
- # Initializes Chef::Client instance and runs it
- def run_chef_client
- # The chef client will be started in a new process. We have used shell_out to start the chef-client.
- # The log_location and config_file of the parent process is passed to the new chef-client process.
- # We need to add the --no-fork, as by default it is set to fork=true.
-
- Chef::Log.info "Starting #{ChefUtils::Dist::Infra::CLIENT} in a new process"
- # Pass config params to the new process
- config_params = " --no-fork"
- config_params += " -c #{Chef::Config[:config_file]}" unless Chef::Config[:config_file].nil?
- # log_location might be an event logger and if so we cannot pass as a command argument
- # but shed no tears! If the logger is an event logger, it must have been configured
- # as such in the config file and chef-client will use that when no arg is passed here
- config_params += " -L #{resolve_log_location}" if resolve_log_location.is_a?(String)
-
- # Starts a new process and waits till the process exits
-
- result = shell_out(
- "#{ChefUtils::Dist::Infra::CLIENT}.bat #{config_params}",
- timeout: Chef::Config[:windows_service][:watchdog_timeout],
- logger: Chef::Log
- )
- Chef::Log.trace (result.stdout).to_s
- Chef::Log.trace (result.stderr).to_s
- rescue Mixlib::ShellOut::CommandTimeout => e
- Chef::Log.error "#{ChefUtils::Dist::Infra::CLIENT} timed out\n(#{e})"
- Chef::Log.error(<<-EOF)
- Your #{ChefUtils::Dist::Infra::CLIENT} run timed out. You can increase the time #{ChefUtils::Dist::Infra::CLIENT} is given
- to complete by configuring windows_service.watchdog_timeout in your client.rb.
- EOF
- rescue Mixlib::ShellOut::ShellCommandFailed => e
- Chef::Log.warn "Not able to start #{ChefUtils::Dist::Infra::CLIENT} in new process (#{e})"
- rescue => e
- Chef::Log.error e
- ensure
- # Once process exits, we log the current process' pid
- Chef::Log.info "Child process exited (pid: #{Process.pid})"
- end
-
- def apply_config(config_file_path)
- Chef::Config.from_file(config_file_path)
- Chef::Config.merge!(config)
- end
-
- # Lifted from Chef::Application, with addition of optional startup parameters
- # for playing nicely with Windows Services
- def reconfigure(startup_parameters = [])
- configure_chef startup_parameters
- configure_logging
-
- Chef::Config[:chef_server_url] = config[:chef_server_url] if config.key? :chef_server_url
- unless Chef::Config[:exception_handlers].any? { |h| Chef::Handler::ErrorReport === h }
- Chef::Config[:exception_handlers] << Chef::Handler::ErrorReport.new
- end
-
- Chef::Config[:interval] ||= 1800
- end
-
- # Lifted from application.rb
- # See application.rb for related comments.
-
- def configure_logging
- Chef::Log.init(MonoLogger.new(resolve_log_location))
- if want_additional_logger?
- configure_stdout_logger
- end
- Chef::Log.level = resolve_log_level
- end
-
- def configure_stdout_logger
- stdout_logger = MonoLogger.new(STDOUT)
- stdout_logger.formatter = Chef::Log.logger.formatter
- Chef::Log.loggers << stdout_logger
- end
-
- # Based on config and whether or not STDOUT is a tty, should we setup a
- # secondary logger for stdout?
- def want_additional_logger?
- ( Chef::Config[:log_location] != STDOUT ) && STDOUT.tty? && !Chef::Config[:daemonize]
- end
-
- # Use of output formatters is assumed if `force_formatter` is set or if
- # `force_logger` is not set
- def using_output_formatter?
- Chef::Config[:force_formatter] || !Chef::Config[:force_logger]
- end
-
- def auto_log_level?
- Chef::Config[:log_level] == :auto
- end
-
- def resolve_log_location
- # STDOUT is the default log location, but makes no sense for a windows service
- Chef::Config[:log_location] == STDOUT ? DEFAULT_LOG_LOCATION : Chef::Config[:log_location]
- end
-
- # if log_level is `:auto`, convert it to :warn (when using output formatter)
- # or :info (no output formatter). See also +using_output_formatter?+
- def resolve_log_level
- if auto_log_level?
- if using_output_formatter?
- :warn
- else
- :info
- end
- else
- Chef::Config[:log_level]
- end
- end
-
- def configure_chef(startup_parameters)
- # Bit of a hack ahead:
- # It is possible to specify a service's binary_path_name with arguments, like "foo.exe -x argX".
- # It is also possible to specify startup parameters separately, either via the Services manager
- # or by using the registry (I think).
-
- # In order to accommodate all possible sources of parameterization, we first parse any command line
- # arguments. We then parse any startup parameters. This works, because Mixlib::CLI reuses its internal
- # 'config' hash; thus, anything in startup parameters will override any command line parameters that
- # might be set via the service's binary_path_name
- #
- # All these parameters then get layered on top of those from Chef::Config
-
- parse_options # Operates on ARGV by default
- parse_options startup_parameters
-
- begin
- case config[:config_file]
- when %r{^(http|https)://}
- Chef::HTTP.new("").streaming_request(config[:config_file]) { |f| apply_config(f.path) }
- else
- ::File.open(config[:config_file]) { |f| apply_config(f.path) }
- end
- rescue Errno::ENOENT
- Chef::Log.warn("*****************************************")
- Chef::Log.warn("Did not find config file: #{config[:config_file]}. Using command line options instead.")
- Chef::Log.warn("*****************************************")
-
- Chef::Config.merge!(config)
- rescue SocketError
- Chef::Application.fatal!("Error getting config file #{Chef::Config[:config_file]}")
- rescue Chef::Exceptions::ConfigurationError => error
- Chef::Application.fatal!("Error processing config file #{Chef::Config[:config_file]} with error #{error.message}")
- rescue Exception => error
- Chef::Application.fatal!("Unknown error processing config file #{Chef::Config[:config_file]} with error #{error.message}")
- end
- end
-
- end
- end
-end
-
-# To run this file as a service, it must be called as a script from within
-# the Windows Service framework. In that case, kick off the main loop!
-if __FILE__ == $0
- Chef::Application::WindowsService.mainloop
-end
diff --git a/lib/chef/application/windows_service_manager.rb b/lib/chef/application/windows_service_manager.rb
deleted file mode 100644
index 4f0de26411..0000000000
--- a/lib/chef/application/windows_service_manager.rb
+++ /dev/null
@@ -1,205 +0,0 @@
-#
-# Author:: Seth Chisamore (<schisamo@chef.io>)
-# Copyright:: Copyright (c) Chef Software Inc.
-# License:: Apache License, Version 2.0
-#
-# Licensed 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.
-#
-
-if RUBY_PLATFORM.match?(/mswin|mingw32|windows/)
- require "win32/service"
-end
-require_relative "../config"
-require "mixlib/cli" unless defined?(Mixlib::CLI)
-require "chef-utils/dist" unless defined?(ChefUtils::Dist)
-
-class Chef
- class Application
- #
- # This class is used to create and manage a windows service.
- # Service should be created using Daemon class from
- # win32/service gem.
- # For an example see: Chef::Application::WindowsService
- #
- # Outside programs are expected to use this class to manage
- # windows services.
- #
- class WindowsServiceManager
- include Mixlib::CLI
-
- option :action,
- short: "-a ACTION",
- long: "--action ACTION",
- default: "status",
- description: "Action to carry out on #{ChefUtils::Dist::Infra::SHORT}-service (install, uninstall, status, start, stop, pause, or resume)."
-
- option :config_file,
- short: "-c CONFIG",
- long: "--config CONFIG",
- default: "#{ChefConfig::Config.c_chef_dir}/client.rb",
- description: "The configuration file to use for #{ChefUtils::Dist::Infra::PRODUCT} runs."
-
- option :log_location,
- short: "-L LOGLOCATION",
- long: "--logfile LOGLOCATION",
- description: "Set the log file location for #{ChefUtils::Dist::Infra::SHORT}-service."
-
- option :help,
- short: "-h",
- long: "--help",
- description: "Show this help message.",
- on: :tail,
- boolean: true,
- show_options: true,
- exit: 0
-
- option :version,
- short: "-v",
- long: "--version",
- description: "Show #{ChefUtils::Dist::Infra::PRODUCT} version.",
- boolean: true,
- proc: lambda { |v| puts "#{ChefUtils::Dist::Infra::PRODUCT}: #{::Chef::VERSION}" },
- exit: 0
-
- def initialize(service_options)
- # having to call super in initialize is the most annoying
- # anti-pattern :(
- super()
-
- raise ArgumentError, "Service definition is not provided" if service_options.nil?
-
- required_options = %i{service_name service_display_name service_description service_file_path}
-
- required_options.each do |req_option|
- unless service_options.key?(req_option)
- raise ArgumentError, "Service definition doesn't contain required option #{req_option}"
- end
- end
-
- @service_name = service_options[:service_name]
- @service_display_name = service_options[:service_display_name]
- @service_description = service_options[:service_description]
- @service_file_path = service_options[:service_file_path]
- @service_start_name = service_options[:run_as_user]
- @password = service_options[:run_as_password]
- @delayed_start = service_options[:delayed_start]
- @dependencies = service_options[:dependencies]
- end
-
- def run(params = ARGV)
- parse_options(params)
-
- case config[:action]
- when "install"
- if service_exists?
- puts "Service #{@service_name} already exists on the system."
- else
- ruby = File.join(RbConfig::CONFIG["bindir"], "ruby")
-
- opts = ""
- opts << " -c #{config[:config_file]}" if config[:config_file]
- opts << " -L #{config[:log_location]}" if config[:log_location]
-
- # Quote the full paths to deal with possible spaces in the path name.
- # Also ensure all forward slashes are backslashes
- cmd = "\"#{ruby}\" \"#{@service_file_path}\" #{opts}".gsub(File::SEPARATOR, File::ALT_SEPARATOR)
-
- ::Win32::Service.new(
- service_name: @service_name,
- display_name: @service_display_name,
- description: @service_description,
- # Prior to 0.8.5, win32-service creates interactive services by default,
- # and we don't want that, so we need to override the service type.
- service_type: ::Win32::Service::SERVICE_WIN32_OWN_PROCESS,
- start_type: ::Win32::Service::SERVICE_AUTO_START,
- binary_path_name: cmd,
- service_start_name: @service_start_name,
- password: @password,
- dependencies: @dependencies
- )
- unless @delayed_start.nil?
- ::Win32::Service.configure(
- service_name: @service_name,
- delayed_start: @delayed_start
- )
- end
- puts "Service '#{@service_name}' has successfully been installed."
- end
- when "status"
- if !service_exists?
- puts "Service #{@service_name} doesn't exist on the system."
- else
- puts "State of #{@service_name} service is: #{current_state}"
- end
- when "start"
- # TODO: allow override of startup parameters here?
- take_action("start", RUNNING)
- when "stop"
- take_action("stop", STOPPED)
- when "uninstall", "delete"
- take_action("stop", STOPPED)
- unless service_exists?
- puts "Service #{@service_name} doesn't exist on the system."
- else
- ::Win32::Service.delete(@service_name)
- puts "Service #{@service_name} deleted"
- end
- when "pause"
- take_action("pause", PAUSED)
- when "resume"
- take_action("resume", RUNNING)
- end
- end
-
- private
-
- # Just some state constants
- STOPPED = "stopped".freeze
- RUNNING = "running".freeze
- PAUSED = "paused".freeze
-
- def service_exists?
- ::Win32::Service.exists?(@service_name)
- end
-
- def take_action(action = nil, desired_state = nil)
- if service_exists?
- if current_state != desired_state
- ::Win32::Service.send(action, @service_name)
- wait_for_state(desired_state)
- puts "Service '#{@service_name}' is now '#{current_state}'."
- else
- puts "Service '#{@service_name}' is already '#{desired_state}'."
- end
- else
- puts "Cannot '#{action}' service '#{@service_name}'"
- puts "Service #{@service_name} doesn't exist on the system."
- end
- end
-
- def current_state
- ::Win32::Service.status(@service_name).current_state
- end
-
- # Helper method that waits for a status to change its state since state
- # changes aren't usually instantaneous.
- def wait_for_state(desired_state)
- while current_state != desired_state
- puts "One moment... #{current_state}"
- sleep 1
- end
- end
-
- end
- end
-end
diff --git a/spec/functional/resource/windows_service_spec.rb b/spec/functional/resource/windows_service_spec.rb
deleted file mode 100644
index 4c0c3acb58..0000000000
--- a/spec/functional/resource/windows_service_spec.rb
+++ /dev/null
@@ -1,105 +0,0 @@
-#
-# Author:: Chris Doherty (<cdoherty@chef.io>)
-# Copyright:: Copyright (c) Chef Software Inc.
-# License:: Apache License, Version 2.0
-#
-# Licensed 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 "spec_helper"
-
-describe Chef::Resource::WindowsService, :windows_only, :system_windows_service_gem_only do
-
- include_context "using Win32::Service"
-
- let(:username) { "service_spec_user" }
- let(:qualified_username) { "#{ENV["COMPUTERNAME"]}\\#{username}" }
- let(:password) { "1a2b3c4X!&narf" }
-
- let(:user_resource) do
- r = Chef::Resource::User::WindowsUser.new(username, run_context)
- r.username(username)
- r.password(password)
- r.comment("temp spec user")
- r
- end
-
- let(:global_service_file_path) do
- "#{ENV["WINDIR"]}\\temp\\#{File.basename(test_service[:service_file_path])}"
- end
-
- let(:service_params) do
-
- id = "#{$$}_#{rand(1000)}"
-
- test_service.merge( {
- run_as_user: qualified_username,
- run_as_password: password,
- service_name: "spec_service_#{id}",
- service_display_name: "windows_service spec #{id}}",
- service_description: "Test service for running the windows_service functional spec.",
- service_file_path: global_service_file_path,
- } )
- end
-
- let(:manager) do
- Chef::Application::WindowsServiceManager.new(service_params)
- end
-
- let(:service_resource) do
- r = Chef::Resource::WindowsService.new(service_params[:service_name], run_context)
- %i{run_as_user run_as_password}.each { |prop| r.send(prop, service_params[prop]) }
- r
- end
-
- let(:run_context) do
- Chef::RunContext.new(Chef::Node.new, {}, Chef::EventDispatch::Dispatcher.new)
- end
-
- before do
- user_resource.run_action(:create)
-
- # the service executable has to be outside the current user's home
- # directory in order for the logon user to execute it.
- FileUtils.copy_file(test_service[:service_file_path], global_service_file_path)
-
- # if you don't make the file executable by the service user, you'll get
- # the not-very-helpful "service did not respond fast enough" error.
-
- # #mode may break in a post-Windows 8.1 release, and have to be replaced
- # with the rights stuff in the file resource.
- file = Chef::Resource::File.new(global_service_file_path, run_context)
- file.mode("0777")
-
- file.run_action(:create)
-
- manager.run(%w{--action install})
- end
-
- after do
- user_resource.run_action(:remove)
- manager.run(%w{--action uninstall})
- File.delete(global_service_file_path)
- end
-
- describe "logon as a service" do
- it "successfully runs a service as another user" do
- service_resource.run_action(:start)
- end
-
- it "grants the user the log on as service right" do
- service_resource.run_action(:start)
- expect(Chef::ReservedNames::Win32::Security.get_account_right(qualified_username)).to include("SeServiceLogonRight")
- end
- end
-end
diff --git a/spec/functional/win32/service_manager_spec.rb b/spec/functional/win32/service_manager_spec.rb
deleted file mode 100644
index 5746283b78..0000000000
--- a/spec/functional/win32/service_manager_spec.rb
+++ /dev/null
@@ -1,220 +0,0 @@
-#
-# Author:: Serdar Sutay (<serdar@chef.io>)
-# Copyright:: Copyright (c) Chef Software Inc.
-# License:: Apache License, Version 2.0
-#
-# Licensed 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 "spec_helper"
-if ChefUtils.windows?
- require "chef/application/windows_service_manager"
-end
-
-#
-# ATTENTION:
-# This test creates a windows service for testing purposes and runs it
-# as Local System (or an otherwise specified user) on windows boxes.
-# This test will fail if you run the tests inside a Windows VM by
-# sharing the code from your host since Local System account by
-# default can't see the mounted partitions.
-# Run this test by copying the code to a local VM directory or setup
-# Local System account to see the maunted partitions for the shared
-# directories.
-#
-
-describe "Chef::Application::WindowsServiceManager", :windows_only, :system_windows_service_gem_only do
-
- include_context "using Win32::Service"
-
- context "with invalid service definition" do
- it "throws an error when initialized with no service definition" do
- expect { Chef::Application::WindowsServiceManager.new(nil) }.to raise_error(ArgumentError)
- end
-
- it "throws an error with required missing options" do
- %i{service_name service_display_name service_description service_file_path}.each do |key|
- service_def = test_service.dup
- service_def.delete(key)
-
- expect { Chef::Application::WindowsServiceManager.new(service_def) }.to raise_error(ArgumentError)
- end
- end
- end
-
- context "with valid definition" do
- before(:each) do
- @service_manager_output = [ ]
- # Uncomment below lines to debug this test
- # original_puts = $stdout.method(:puts)
- allow($stdout).to receive(:puts) do |message|
- @service_manager_output << message
- # original_puts.call(message)
- end
- end
-
- after(:each) do
- cleanup
- end
-
- context "when service doesn't exist" do
- it "default => should say service don't exist" do
- service_manager.run
-
- expect(@service_manager_output.grep(/doesn't exist on the system/).length).to be > 0
- end
-
- it "install => should install the service" do
- service_manager.run(["-a", "install"])
-
- expect(test_service_exists?).to be_truthy
- end
-
- it "other actions => should say service doesn't exist" do
- %w{delete start stop pause resume uninstall}.each do |action|
- service_manager.run(["-a", action])
- expect(@service_manager_output.grep(/doesn't exist on the system/).length).to be > 0
- @service_manager_output = [ ]
- end
- end
- end
-
- context "when service exists" do
- before(:each) do
- service_manager.run(["-a", "install"])
- end
-
- it "should have an own-process, non-interactive type" do
- status = ::Win32::Service.status("spec-service")
- expect(status[:service_type]).to eq("own process")
- expect(status[:interactive]).to be_falsey
- end
-
- it "install => should say service already exists" do
- service_manager.run(["-a", "install"])
- expect(@service_manager_output.grep(/already exists/).length).to be > 0
- end
-
- context "and service is stopped" do
- %w{delete uninstall}.each do |action|
- it "#{action} => should remove the service", :volatile do
- service_manager.run(["-a", action])
- expect(test_service_exists?).to be_falsey
- end
- end
-
- it "default, status => should say service is stopped" do
- service_manager.run([ ])
- expect(@service_manager_output.grep(/stopped/).length).to be > 0
- @service_manager_output = [ ]
-
- service_manager.run(["-a", "status"])
- expect(@service_manager_output.grep(/stopped/).length).to be > 0
- end
-
- it "start should start the service", :volatile do
- service_manager.run(["-a", "start"])
- expect(test_service_state).to eq("running")
- expect(File.exist?(test_service_file)).to be_truthy
- end
-
- it "stop should not affect the service" do
- service_manager.run(["-a", "stop"])
- expect(test_service_state).to eq("stopped")
- end
-
- %w{pause resume}.each do |action|
- it "#{action} => should raise error" do
- expect { service_manager.run(["-a", action]) }.to raise_error(SystemCallError)
- end
- end
-
- context "and service is started", :volatile do
- before(:each) do
- service_manager.run(["-a", "start"])
- end
-
- %w{delete uninstall}.each do |action|
- it "#{action} => should remove the service", :volatile do
- service_manager.run(["-a", action])
- expect(test_service_exists?).to be_falsey
- end
- end
-
- it "default, status => should say service is running" do
- service_manager.run([ ])
- expect(@service_manager_output.grep(/running/).length).to be > 0
- @service_manager_output = [ ]
-
- service_manager.run(["-a", "status"])
- expect(@service_manager_output.grep(/running/).length).to be > 0
- end
-
- it "stop should stop the service" do
- service_manager.run(["-a", "stop"])
- expect(test_service_state).to eq("stopped")
- end
-
- it "pause should pause the service" do
- service_manager.run(["-a", "pause"])
- expect(test_service_state).to eq("paused")
- end
-
- it "resume should have no affect" do
- service_manager.run(["-a", "resume"])
- expect(test_service_state).to eq("running")
- end
- end
-
- context "and service is paused", :volatile do
- before(:each) do
- service_manager.run(["-a", "start"])
- service_manager.run(["-a", "pause"])
- end
-
- actions = %w{delete uninstall}
- actions.each do |action|
- it "#{action} => should remove the service" do
- service_manager.run(["-a", action])
- expect(test_service_exists?).to be_falsey
- end
- end
-
- it "default, status => should say service is paused" do
- service_manager.run([ ])
- expect(@service_manager_output.grep(/paused/).length).to be > 0
- @service_manager_output = [ ]
-
- service_manager.run(["-a", "status"])
- expect(@service_manager_output.grep(/paused/).length).to be > 0
- end
-
- it "stop should stop the service" do
- service_manager.run(["-a", "stop"])
- expect(test_service_state).to eq("stopped")
- end
-
- it "pause should not affect the service" do
- service_manager.run(["-a", "pause"])
- expect(test_service_state).to eq("paused")
- end
-
- it "start should raise an error" do
- expect { service_manager.run(["-a", "start"]) }.to raise_error(::Win32::Service::Error)
- end
-
- end
- end
- end
- end
-end
diff --git a/spec/spec_helper.rb b/spec/spec_helper.rb
index 52f17788bb..95a4c62a77 100644
--- a/spec/spec_helper.rb
+++ b/spec/spec_helper.rb
@@ -159,12 +159,7 @@ RSpec.configure do |config|
config.filter_run_excluding windows_powershell_no_dsc_only: true if windows_powershell_dsc?
config.filter_run_excluding windows_domain_joined_only: true unless windows_domain_joined?
config.filter_run_excluding windows_not_domain_joined_only: true if windows_domain_joined?
- # We think this line was causing rspec tests to not run on the Jenkins windows
- # testers. If we ever fix it we should restore it.
- # config.filter_run_excluding :windows_service_requires_assign_token => true if !STDOUT.isatty && !windows_user_right?("SeAssignPrimaryTokenPrivilege")
- config.filter_run_excluding windows_service_requires_assign_token: true
config.filter_run_excluding solaris_only: true unless solaris?
- config.filter_run_excluding system_windows_service_gem_only: true unless system_windows_service_gem?
config.filter_run_excluding unix_only: true unless unix?
config.filter_run_excluding linux_only: true unless linux?
config.filter_run_excluding aix_only: true unless aix?
diff --git a/spec/support/chef_helpers.rb b/spec/support/chef_helpers.rb
index 6a0ca878cd..3738c4a41e 100644
--- a/spec/support/chef_helpers.rb
+++ b/spec/support/chef_helpers.rb
@@ -40,22 +40,6 @@ def make_tmpname(prefix_suffix, n = nil)
path << suffix
end
-# This is a helper to determine if the ruby in the PATH contains
-# win32/service gem. windows_service_manager tests create a windows
-# service that starts with the system ruby and requires this gem.
-def system_windows_service_gem?
- windows_service_gem_check_command = %{ruby -r "win32/daemon" -e ":noop" > #{File::NULL} 2>&1}
- if defined?(Bundler)
- Bundler.with_unbundled_env do
- # This returns true if the gem can be loaded
- system(windows_service_gem_check_command)
- end
- else
- # This returns true if the gem can be loaded
- system(windows_service_gem_check_command)
- end
-end
-
# This is a helper to canonicalize paths that we're using in the file
# tests.
def canonicalize_path(path)
diff --git a/spec/support/shared/functional/execute_resource.rb b/spec/support/shared/functional/execute_resource.rb
index 9d1c29dfac..3f870d0fb6 100644
--- a/spec/support/shared/functional/execute_resource.rb
+++ b/spec/support/shared/functional/execute_resource.rb
@@ -68,7 +68,7 @@ shared_context "a command that can be executed as an alternate user" do
end
shared_examples_for "an execute resource that supports alternate user identity" do
- context "when running on Windows", :windows_only, :windows_service_requires_assign_token do
+ context "when running on Windows", :windows_only do
include_context "a command that can be executed as an alternate user"
@@ -102,7 +102,7 @@ shared_examples_for "an execute resource that supports alternate user identity"
end
shared_examples_for "a resource with a guard specifying an alternate user identity" do
- context "when running on Windows", :windows_only, :windows_service_requires_assign_token do
+ context "when running on Windows", :windows_only do
include_context "alternate user identity"
let(:resource_command_property) { :command }
diff --git a/spec/support/shared/functional/win32_service.rb b/spec/support/shared/functional/win32_service.rb
deleted file mode 100644
index 890c28de2c..0000000000
--- a/spec/support/shared/functional/win32_service.rb
+++ /dev/null
@@ -1,57 +0,0 @@
-
-require "chef/application/windows_service_manager"
-
-shared_context "using Win32::Service" do
- # Some helper methods.
-
- def test_service_exists?
- ::Win32::Service.exists?("spec-service")
- end
-
- def test_service_state
- ::Win32::Service.status("spec-service").current_state
- end
-
- def service_manager
- Chef::Application::WindowsServiceManager.new(test_service)
- end
-
- def cleanup
- # Uninstall if the test service is installed.
- if test_service_exists?
-
- # We can only uninstall when the service is stopped.
- if test_service_state != "stopped"
- ::Win32::Service.send("stop", "spec-service")
- sleep 1 while test_service_state != "stopped"
- end
-
- ::Win32::Service.delete("spec-service")
- end
-
- # Delete the test_service_file if it exists
- if File.exist?(test_service_file)
- File.delete(test_service_file)
- end
- end
-
- # Definition for the test-service
-
- let(:test_service) do
- {
- service_name: "spec-service",
- service_display_name: "Spec Test Service",
- service_description: "Service for testing Chef::Application::WindowsServiceManager.",
- service_file_path: File.expand_path(File.join(__dir__, "../../platforms/win32/spec_service.rb")),
- delayed_start: true,
- }
- end
-
- # Test service creates a file for us to verify that it is running.
- # Since our test service is running as Local System we should look
- # for the file it creates under SYSTEM temp directory
-
- let(:test_service_file) do
- "#{ENV["SystemDrive"]}\\windows\\temp\\spec_service_file"
- end
-end
diff --git a/spec/support/shared/functional/windows_script.rb b/spec/support/shared/functional/windows_script.rb
index 151ad2387c..9f328f0b92 100644
--- a/spec/support/shared/functional/windows_script.rb
+++ b/spec/support/shared/functional/windows_script.rb
@@ -168,11 +168,11 @@ shared_context Chef::Resource::WindowsScript do
resource.run_action(:run)
end
- context "the script is executed with the identity of the current user", :windows_service_requires_assign_token do
+ context "the script is executed with the identity of the current user" do
it_behaves_like "a script that cannot be accessed by other users if they are not administrators"
end
- context "the script is executed with an alternate non-admin identity", :windows_service_requires_assign_token do
+ context "the script is executed with an alternate non-admin identity" do
include_context "alternate user identity"
before do
diff --git a/spec/unit/windows_service_spec.rb b/spec/unit/windows_service_spec.rb
deleted file mode 100644
index 02a795426d..0000000000
--- a/spec/unit/windows_service_spec.rb
+++ /dev/null
@@ -1,118 +0,0 @@
-#
-# Author:: Mukta Aphale (<mukta.aphale@clogeny.com>)
-# Copyright:: Copyright (c) Chef Software Inc.
-# License:: Apache License, Version 2.0
-#
-# Licensed 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 "spec_helper"
-if ChefUtils.windows?
- require "chef/application/windows_service"
-end
-
-describe "Chef::Application::WindowsService", :windows_only do
- let(:shell_out_result) { double("shellout", stdout: nil, stderr: nil) }
- let(:config_options) do
- {
- log_location: STDOUT,
- config_file: "test_config_file",
- log_level: :info,
- }
- end
- let(:timeout) { 7200 }
- let(:shellout_options) do
- {
- timeout: timeout,
- logger: Chef::Log,
- }
- end
-
- before do
- monologger = instance_double("MonoLogger", :level= => nil, :add => nil, :formatter= => nil, :formatter => nil)
- allow(MonoLogger).to receive(:new).and_return(monologger)
-
- Chef::Config.merge!(config_options)
- allow(subject).to receive(:configure_chef)
- allow(subject).to receive(:parse_options)
- allow(subject).to receive(:running?).and_return(true, false)
- allow(subject).to receive(:state).and_return(4)
- subject.service_init
- end
-
- subject { Chef::Application::WindowsService.new }
-
- it "passes DEFAULT_LOG_LOCATION to chef-client instead of STDOUT" do
- expect(subject).to receive(:shell_out).with(
- "chef-client.bat --no-fork -c test_config_file -L #{Chef::Application::WindowsService::DEFAULT_LOG_LOCATION}",
- shellout_options
- ).and_return(shell_out_result)
- subject.service_main
- end
-
- context "has a log location configured" do
- let(:tempfile) { Tempfile.new "log_file" }
- let(:config_options) do
- {
- log_location: tempfile.path,
- config_file: "test_config_file",
- log_level: :info,
- }
- end
-
- after do
- tempfile.unlink
- end
-
- it "uses the configured log location" do
- expect(subject).to receive(:shell_out).with(
- "chef-client.bat --no-fork -c test_config_file -L #{tempfile.path}",
- shellout_options
- ).and_return(shell_out_result)
- subject.service_main
- end
-
- context "configured to Event Logger" do
- let(:config_options) do
- {
- log_location: Chef::Log::WinEvt.new,
- config_file: "test_config_file",
- log_level: :info,
- }
- end
-
- it "does not pass log location to new process" do
- expect(subject).to receive(:shell_out).with(
- "chef-client.bat --no-fork -c test_config_file",
- shellout_options
- ).and_return(shell_out_result)
- subject.service_main
- end
- end
- end
-
- context "configures a watchdog timeout" do
- let(:timeout) { 10 }
-
- before do
- Chef::Config[:windows_service][:watchdog_timeout] = 10
- end
-
- it "passes watchdog timeout to new process" do
- expect(subject).to receive(:shell_out).with(
- "chef-client.bat --no-fork -c test_config_file -L #{Chef::Application::WindowsService::DEFAULT_LOG_LOCATION}",
- shellout_options
- ).and_return(shell_out_result)
- subject.service_main
- end
- end
-end