chef 10.28.2-x86-mingw32

data/lib/chef/provider/service/solaris.rb

@@ -0,0 +1,86 @@
+#
+# Author:: Toomas Pelberg (<toomasp@gmx.net>)
+# Copyright:: Copyright (c) 2010 Opscode, 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 'chef/provider/service'
+require 'chef/mixin/command'
+
+class Chef
+  class Provider
+    class Service
+      class Solaris < Chef::Provider::Service
+
+        def initialize(new_resource, run_context=nil)
+          super
+          @init_command = "/usr/sbin/svcadm"
+          @status_command = "/bin/svcs -l"
+        end
+        
+
+        def load_current_resource
+          @current_resource = Chef::Resource::Service.new(@new_resource.name)
+          @current_resource.service_name(@new_resource.service_name)
+          unless ::File.exists? "/bin/svcs"
+            raise Chef::Exceptions::Service, "/bin/svcs does not exist!"
+          end
+          @status = service_status.enabled
+          @current_resource
+        end
+
+        def enable_service
+          run_command(:command => "#{@init_command} enable #{@new_resource.service_name}")
+          return service_status.enabled
+        end
+
+        def disable_service
+          run_command(:command => "#{@init_command} disable #{@new_resource.service_name}")
+          return service_status.enabled
+        end
+
+        alias_method :stop_service, :disable_service
+        alias_method :start_service, :enable_service
+
+        def reload_service
+          run_command(:command => "#{@init_command} refresh #{@new_resource.service_name}")
+        end
+
+        def restart_service
+          disable_service
+          return enable_service
+        end
+
+        def service_status
+          status = popen4("#{@status_command} #{@current_resource.service_name}") do |pid, stdin, stdout, stderr|
+            stdout.each do |line|
+              case line
+              when /state\s+online/
+                @current_resource.enabled(true)
+                @current_resource.running(true)
+              end
+            end
+          end
+          unless @current_resource.enabled
+            @current_resource.enabled(false)
+            @current_resource.running(false)
+          end
+          @current_resource
+        end
+
+      end
+    end
+  end
+end

data/lib/chef/provider/service/systemd.rb

@@ -0,0 +1,115 @@
+#
+# Author:: Stephen Haynes (<sh@nomitor.com>)
+# Copyright:: Copyright (c) 2011 Opscode, 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 'chef/provider/service'
+require 'chef/provider/service/simple'
+require 'chef/mixin/command'
+
+class Chef::Provider::Service::Systemd < Chef::Provider::Service::Simple
+  def load_current_resource
+    @current_resource = Chef::Resource::Service.new(@new_resource.name)
+    @current_resource.service_name(@new_resource.service_name)
+    @status_check_success = true
+
+    if @new_resource.status_command
+      Chef::Log.debug("#{@new_resource} you have specified a status command, running..")
+
+      begin
+        if run_command_with_systems_locale(:command => @new_resource.status_command) == 0
+          @current_resource.running(true)
+        end
+      rescue Chef::Exceptions::Exec
+        @status_check_success = false
+        @current_resource.running(false)
+        @current_resource.enabled(false)
+        nil
+      end
+    else
+      @current_resource.running(is_active?)
+    end
+
+    @current_resource.enabled(is_enabled?)
+    @current_resource
+  end
+
+  def define_resource_requirements
+    shared_resource_requirements
+    requirements.assert(:all_actions) do |a|
+      a.assertion { @status_check_success } 
+      # We won't stop in any case, but in whyrun warn and tell what we're doing.
+      a.whyrun ["Failed to determine status of #{@new_resource}, using command #{@new_resource.status_command}.",
+        "Assuming service would have been installed and is disabled"]
+    end
+  end
+
+  def start_service
+    if @current_resource.running
+      Chef::Log.debug("#{@new_resource} already running, not starting")
+    else
+      if @new_resource.start_command
+        super
+      else
+        run_command_with_systems_locale(:command => "/bin/systemctl start #{@new_resource.service_name}")
+      end
+    end
+  end
+
+  def stop_service
+    unless @current_resource.running
+      Chef::Log.debug("#{@new_resource} not running, not stopping")
+    else
+      if @new_resource.stop_command
+        super
+      else
+        run_command_with_systems_locale(:command => "/bin/systemctl stop #{@new_resource.service_name}")
+      end
+    end
+  end
+
+  def restart_service
+    if @new_resource.restart_command
+      super
+    else
+      run_command_with_systems_locale(:command => "/bin/systemctl restart #{@new_resource.service_name}")
+    end
+  end
+
+  def reload_service
+    if @new_resource.reload_command
+      super
+    else
+      run_command_with_systems_locale(:command => "/bin/systemctl reload #{@new_resource.service_name}")
+    end
+  end
+
+  def enable_service
+    run_command_with_systems_locale(:command => "/bin/systemctl enable #{@new_resource.service_name}")
+  end 
+
+  def disable_service
+    run_command_with_systems_locale(:command => "/bin/systemctl disable #{@new_resource.service_name}")
+  end 
+
+  def is_active?
+    run_command_with_systems_locale({:command => "/bin/systemctl is-active #{@new_resource.service_name}", :ignore_failure => true}) == 0
+  end
+
+  def is_enabled?
+    run_command_with_systems_locale({:command => "/bin/systemctl is-enabled #{@new_resource.service_name}", :ignore_failure => true}) == 0
+  end
+end

data/lib/chef/provider/service/upstart.rb

@@ -0,0 +1,232 @@
+#
+# Author:: Bryan McLellan <btm@loftninjas.org>
+# Copyright:: Copyright (c) 2010 Bryan McLellan
+# 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 'chef/provider/service'
+require 'chef/provider/service/simple'
+require 'chef/mixin/command'
+require 'chef/util/file_edit'
+
+class Chef
+  class Provider
+    class Service
+      class Upstart < Chef::Provider::Service::Simple
+        UPSTART_STATE_FORMAT = /\w+ \(?(\w+)\)?[\/ ](\w+)/
+       
+        # Upstart does more than start or stop a service, creating multiple 'states' [1] that a service can be in.
+        # In chef, when we ask a service to start, we expect it to have started before performing the next step
+        # since we have top down dependencies. Which is to say we may follow witha resource next that requires
+        # that service to be running. According to [2] we can trust that sending a 'goal' such as start will not
+        # return until that 'goal' is reached, or some error has occured.
+        #
+        # [1] http://upstart.ubuntu.com/wiki/JobStates
+        # [2] http://www.netsplit.com/2008/04/27/upstart-05-events/
+
+        def initialize(new_resource, run_context)
+          # TODO: re-evaluate if this is needed after integrating cookbook fix
+          raise ArgumentError, "run_context cannot be nil" unless run_context
+          super
+          
+          run_context.node
+          
+          @job = @new_resource.service_name
+          
+          if @new_resource.parameters
+            @new_resource.parameters.each do |key, value|
+              @job << " #{key}=#{value}"
+            end
+          end
+          
+          platform, version = Chef::Platform.find_platform_and_version(run_context.node)
+          if platform == "ubuntu" && (8.04..9.04).include?(version.to_f)
+            @upstart_job_dir = "/etc/event.d"
+            @upstart_conf_suffix = ""
+          else
+            @upstart_job_dir = "/etc/init"
+            @upstart_conf_suffix = ".conf"
+          end
+
+          @command_success = true # new_resource.status_command= false, means upstart used 
+          @config_file_found = true 
+          @upstart_command_success = true
+        end
+
+        def define_resource_requirements
+          # Do not call super, only call shared requirements
+          shared_resource_requirements
+          requirements.assert(:all_actions) do |a|
+            if !@command_success
+              whyrun_msg = @new_resource.status_command ? "Provided status command #{@new_resource.status_command} failed." : 
+                "Could not determine upstart state for service"
+            end
+            a.assertion { @command_success }
+            # no failure here, just document the assumptions made. 
+            a.whyrun "#{whyrun_msg} Assuming service installed and not running." 
+          end
+
+          requirements.assert(:all_actions) do |a| 
+            a.assertion  { @config_file_found } 
+            # no failure here, just document the assumptions made. 
+            a.whyrun "Could not find #{@upstart_job_dir}/#{@new_resource.service_name}#{@upstart_conf_suffix}. Assuming service is disabled." 
+          end
+        end
+
+        def load_current_resource
+          @current_resource = Chef::Resource::Service.new(@new_resource.name)
+          @current_resource.service_name(@new_resource.service_name)
+
+          # Get running/stopped state
+          # We do not support searching for a service via ps when using upstart since status is a native
+          # upstart function. We will however support status_command in case someone wants to do something special.
+          if @new_resource.status_command
+            Chef::Log.debug("#{@new_resource} you have specified a status command, running..")
+
+            begin
+              if run_command_with_systems_locale(:command => @new_resource.status_command) == 0
+                @current_resource.running true
+              end
+            rescue Chef::Exceptions::Exec
+              @command_success = false
+              @current_resource.running false
+              nil
+            end
+          else
+            begin
+              if upstart_state == "running"
+                @current_resource.running true
+              else
+                @current_resource.running false
+              end
+            rescue Chef::Exceptions::Exec
+              @command_success = false
+              @current_resource.running false
+              nil
+            end
+          end
+          # Get enabled/disabled state by reading job configuration file
+          if ::File.exists?("#{@upstart_job_dir}/#{@new_resource.service_name}#{@upstart_conf_suffix}")
+            Chef::Log.debug("#{@new_resource} found #{@upstart_job_dir}/#{@new_resource.service_name}#{@upstart_conf_suffix}")
+            ::File.open("#{@upstart_job_dir}/#{@new_resource.service_name}#{@upstart_conf_suffix}",'r') do |file|
+              while line = file.gets
+                case line
+                when /^start on/
+                  Chef::Log.debug("#{@new_resource} enabled: #{line.chomp}")
+                  @current_resource.enabled true
+                  break
+                when /^#start on/
+                  Chef::Log.debug("#{@new_resource} disabled: #{line.chomp}")
+                  @current_resource.enabled false
+                  break
+                end
+              end
+            end
+          else
+            @config_file_found = false
+            Chef::Log.debug("#{@new_resource} did not find #{@upstart_job_dir}/#{@new_resource.service_name}#{@upstart_conf_suffix}")
+            @current_resource.enabled false
+          end
+
+          @current_resource
+        end
+
+        def start_service
+          # Calling start on a service that is already started will return 1
+          # Our 'goal' when we call start is to ensure the service is started
+          if @current_resource.running
+            Chef::Log.debug("#{@new_resource} already running, not starting")
+          else
+            if @new_resource.start_command
+              super
+            else
+              run_command_with_systems_locale(:command => "/sbin/start #{@job}")
+            end
+          end
+        end
+
+        def stop_service
+          # Calling stop on a service that is already stopped will return 1
+          # Our 'goal' when we call stop is to ensure the service is stopped
+          unless @current_resource.running
+            Chef::Log.debug("#{@new_resource} not running, not stopping")
+          else
+            if @new_resource.stop_command
+              super
+            else
+              run_command_with_systems_locale(:command => "/sbin/stop #{@job}")
+            end
+          end
+        end
+
+        def restart_service
+          if @new_resource.restart_command
+            super
+          # Upstart always provides restart functionality so we don't need to mimic it with stop/sleep/start.
+          # Older versions of upstart would fail on restart if the service was currently stopped, check for that. LP:430883
+          else @new_resource.supports[:restart]
+            if @current_resource.running
+              run_command_with_systems_locale(:command => "/sbin/restart #{@job}")
+            else
+              start_service
+            end
+          end
+        end
+
+        def reload_service
+          if @new_resource.reload_command
+            super
+          else
+            # upstart >= 0.6.3-4 supports reload (HUP)
+            run_command_with_systems_locale(:command => "/sbin/reload #{@job}")
+          end
+        end
+
+        # https://bugs.launchpad.net/upstart/+bug/94065
+
+        def enable_service
+          Chef::Log.debug("#{@new_resource} upstart lacks inherent support for enabling services, editing job config file")
+          conf = Chef::Util::FileEdit.new("#{@upstart_job_dir}/#{@new_resource.service_name}#{@upstart_conf_suffix}")
+          conf.search_file_replace(/^#start on/, "start on")
+          conf.write_file
+        end
+
+        def disable_service
+          Chef::Log.debug("#{@new_resource} upstart lacks inherent support for disabling services, editing job config file")
+          conf = Chef::Util::FileEdit.new("#{@upstart_job_dir}/#{@new_resource.service_name}#{@upstart_conf_suffix}")
+          conf.search_file_replace(/^start on/, "#start on")
+          conf.write_file
+        end
+
+        def upstart_state
+          command = "/sbin/status #{@job}"
+          status = popen4(command) do |pid, stdin, stdout, stderr|
+            stdout.each_line do |line|
+              # rsyslog stop/waiting
+              # service goal/state
+              # OR
+              # rsyslog (stop) waiting
+              # service (goal) state
+              line =~ UPSTART_STATE_FORMAT
+              data = Regexp.last_match
+              return data[2]
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/chef/provider/service/windows.rb

@@ -0,0 +1,163 @@
+#
+# Author:: Nuo Yan <nuo@opscode.com>
+# Author:: Bryan McLellan <btm@loftninjas.org>
+# Author:: Seth Chisamore <schisamo@opscode.com>
+# Copyright:: Copyright (c) 2010-2011 Opscode, 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 'chef/mixin/shell_out'
+require 'chef/provider/service/simple'
+if RUBY_PLATFORM =~ /mswin|mingw32|windows/
+  require 'win32/service'
+end
+
+class Chef::Provider::Service::Windows < Chef::Provider::Service
+
+  include Chef::Mixin::ShellOut
+
+  RUNNING = 'running'
+  STOPPED = 'stopped'
+  AUTO_START = 'auto start'
+  DISABLED = 'disabled'
+
+  def whyrun_supported?
+    false
+  end
+
+  def load_current_resource
+    @current_resource = Chef::Resource::Service.new(@new_resource.name)
+    @current_resource.service_name(@new_resource.service_name)
+    @current_resource.running(current_state == RUNNING)
+    Chef::Log.debug "#{@new_resource} running: #{@current_resource.running}"
+    @current_resource.enabled(start_type == AUTO_START)
+    Chef::Log.debug "#{@new_resource} enabled: #{@current_resource.enabled}"
+    @current_resource
+  end
+
+  def start_service
+    if Win32::Service.exists?(@new_resource.service_name)
+      if current_state == RUNNING
+        Chef::Log.debug "#{@new_resource} already started - nothing to do"
+      else
+        if @new_resource.start_command
+          Chef::Log.debug "#{@new_resource} starting service using the given start_command"
+          shell_out!(@new_resource.start_command)
+        else
+          spawn_command_thread do
+            Win32::Service.start(@new_resource.service_name)
+            wait_for_state(RUNNING)
+          end
+        end
+        @new_resource.updated_by_last_action(true)
+      end
+    else
+        Chef::Log.debug "#{@new_resource} does not exist - nothing to do"
+    end
+  end
+
+  def stop_service
+    if Win32::Service.exists?(@new_resource.service_name)
+      if current_state == RUNNING
+        if @new_resource.stop_command
+          Chef::Log.debug "#{@new_resource} stopping service using the given stop_command"
+          shell_out!(@new_resource.stop_command)
+        else
+          spawn_command_thread do
+            Win32::Service.stop(@new_resource.service_name)
+            wait_for_state(STOPPED)
+          end
+        end
+        @new_resource.updated_by_last_action(true)
+      else
+        Chef::Log.debug "#{@new_resource} already stopped - nothing to do"
+      end
+    else
+      Chef::Log.debug "#{@new_resource} does not exist - nothing to do"
+    end
+  end
+
+  def restart_service
+    if Win32::Service.exists?(@new_resource.service_name)
+      if @new_resource.restart_command
+        Chef::Log.debug "#{@new_resource} restarting service using the given restart_command"
+        shell_out!(@new_resource.restart_command)
+      else
+        stop_service
+        start_service
+      end
+      @new_resource.updated_by_last_action(true)
+    else
+      Chef::Log.debug "#{@new_resource} does not exist - nothing to do"
+    end
+  end
+
+  def enable_service
+    if Win32::Service.exists?(@new_resource.service_name)
+      if start_type == AUTO_START
+        Chef::Log.debug "#{@new_resource} already enabled - nothing to do"
+      else
+        Win32::Service.configure(
+          :service_name => @new_resource.service_name,
+          :start_type => Win32::Service::AUTO_START
+        )
+        @new_resource.updated_by_last_action(true)
+      end
+    else
+      Chef::Log.debug "#{@new_resource} does not exist - nothing to do"
+    end
+  end
+
+  def disable_service
+    if Win32::Service.exists?(@new_resource.service_name)
+      if start_type == AUTO_START
+        Win32::Service.configure(
+          :service_name => @new_resource.service_name,
+          :start_type => Win32::Service::DISABLED
+        )
+        @new_resource.updated_by_last_action(true)
+      else
+        Chef::Log.debug "#{@new_resource} already disabled - nothing to do"
+      end
+    else
+      Chef::Log.debug "#{@new_resource} does not exist - nothing to do"
+    end
+  end
+
+  private
+  def current_state
+    Win32::Service.status(@new_resource.service_name).current_state
+  end
+
+  def start_type
+    Win32::Service.config_info(@new_resource.service_name).start_type
+  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)
+    sleep 1 until current_state == desired_state
+  end
+
+  # There ain't no party like a thread party...
+  def spawn_command_thread
+    worker = Thread.new do
+      yield
+    end
+    Timeout.timeout(60) do
+      worker.join
+    end
+  end
+end