TrueCar-chef 0.10.0.beta.3

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

@@ -0,0 +1,85 @@
+#
+# 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/upstart.rb

@@ -0,0 +1,192 @@
+#
+# 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
+          
+          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
+        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
+              @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
+              @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
+            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 #{@new_resource.service_name}")
+            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 #{@new_resource.service_name}")
+            end
+          end
+        end
+
+        def restart_service
+          if @new_resource.restart_command
+            super
+          else
+            run_command_with_systems_locale(:command => "/sbin/restart #{@new_resource.service_name}")
+          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 #{@new_resource.service_name}")
+          end
+        end
+
+        # https://bugs.launchpad.net/upstart/+bug/94065
+
+        def enable_service
+          Chef::Log.warn("#{@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.warn("#{@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 #{@new_resource.service_name}"
+          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,146 @@
+#
+# Author:: Nuo Yan <nuo@opscode.com>
+# Author:: Bryan McLellan <btm@loftninjas.org>
+# 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.
+#
+
+# pick up popen4 from chef/mixin/command/windows
+require 'chef/mixin/command'
+require 'chef/provider/service/simple'
+
+class Chef::Provider::Service::Windows < Chef::Provider::Service::Simple
+
+  def initialize(new_resource, run_context)
+    super
+    @init_command = "sc"
+  end
+
+  def io_popen(command)
+    io = IO.popen(command)
+    entries = io.readlines
+    io.close
+    entries
+  end
+
+  def load_current_resource
+    @current_resource = Chef::Resource::Service.new(@new_resource.name)
+    @current_resource.service_name(@new_resource.service_name)
+    begin
+      # Check if service is running
+      status = popen4("#{@init_command} query #{@new_resource.service_name}") do |pid, stdin, stdout, stderr|
+        stdout.each_line do |line|
+          raise Chef::Exceptions::Service, "Service #{@new_resource.service_name} does not exist.\n#{stdout}\n" if line =~ /FAILED 1060/
+          @current_resource.running true if line =~/RUNNING/
+        end
+      end
+
+      # Check if service is enabled
+      status = popen4("#{@init_command} qc #{@new_resource.service_name}") do |pid, stdin, stdout, stderr|
+        stdout.each_line do |line|
+          raise Chef::Exceptions::Service, "Service #{@new_resource.service_name} does not exist.\n#{stdout}\n" if line =~ /FAILED 1060/
+          @current_resource.enabled true if line =~/AUTO_START/
+        end
+      end
+
+      Chef::Log.debug "#{@new_resource}: running: #{@current_resource.running}"
+    rescue Exception => e
+      raise Chef::Exceptions::Service, "Exception determining state of service #{@new_resource.service_name}: #{e.message}"
+    end
+    @current_resource
+  end
+
+  def start_service
+    begin
+      if @new_resource.start_command
+        popen4(@new_resource.start_command) do |pid, stdin, stdout, stderr|
+          Chef::Log.debug stdout.readlines
+        end
+      else
+        popen4("#{@init_command} start #{@new_resource.service_name}") do |pid, stdin, stdout, stderr|
+          output = stdout.readlines
+          Chef::Log.debug output.join
+          output.join =~ /RUNNING/ || output.join =~ /START_PENDING/ ? true : false
+        end
+      end
+    rescue Exception => e
+      raise Chef::Exceptions::Service, "Failed to start service #{@new_resource.service_name}: #{e.message}"
+    end
+  end
+
+  def stop_service
+    begin
+      if @new_resource.stop_command
+        Chef::Log.debug "stopping service using the given stop_command"
+        popen4(@new_resource.stop_command) do |pid, stdin, stdout, stderr|
+          Chef::Log.debug stdout.readlines
+        end
+      else
+        popen4("#{@init_command} stop #{@new_resource.service_name}") do |pid, stdin, stdout, stderr|
+          output = stdout.readlines
+          Chef::Log.debug output.join
+          raise Chef::Exceptions::Service, "Service #{@new_resource.service_name} has dependencies and cannot be stopped.\n" if output.join =~ /FAILED 1051/
+          output.join =~ /1/
+        end
+      end
+    rescue Exception => e
+      raise Chef::Exceptions::Service, "Failed to start service #{@new_resource.service_name}: #{e.message}"
+    end
+  end
+
+  def restart_service
+    begin
+      if @new_resource.restart_command
+        Chef::Log.debug "restarting service using the given restart_command"
+        popen4(@new_resource.restart_command) do |pid, stdin, stdout, stderr|
+          Chef::Log.debug stdout.readlines
+        end
+      else
+        stop_service
+        sleep 1
+        start_service
+      end
+    rescue Exception => e
+      raise Chef::Exceptions::Service, "Failed to start service #{@new_resource.service_name}: #{e.message}"
+    end
+  end
+
+  def enable_service()
+    begin
+      popen4("#{@init_command} config #{@new_resource.service_name} start= #{determine_startup_type}") do |pid, stdin, stdout, stderr|
+        stdout.readlines.join =~ /SUCCESS/
+      end
+    rescue Exception => e
+      raise Chef::Exceptions::Service, "Failed to start service #{@new_resource.service_name}: #{e.message}"
+    end
+  end
+
+  def disable_service()
+    begin
+      popen4("#{@init_command} config #{@new_resource.service_name} start= disabled") do |pid, stdin, stdout, stderr|
+        stdout.readlines.join =~ /SUCCESS/
+      end
+    rescue Exception => e
+      raise Chef::Exceptions::Service, "Failed to start service #{@new_resource.service_name}: #{e.message}"
+    end
+  end
+
+  private
+
+  def determine_startup_type
+    {:automatic => 'auto', :mannual => 'demand'}[@new_resource.startup_type]
+  end
+
+end

data/lib/chef/provider/subversion.rb

@@ -0,0 +1,194 @@
+#
+# Author:: Daniel DeLeo (<dan@kallistec.com>)
+# Copyright:: Copyright (c) 2008 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/log'
+require 'chef/provider'
+require 'chef/mixin/command'
+require 'fileutils'
+
+class Chef
+  class Provider
+    class Subversion < Chef::Provider
+
+      include Chef::Mixin::Command
+
+      def load_current_resource
+        @current_resource = Chef::Resource::Subversion.new(@new_resource.name)
+
+        unless [:export, :force_export].include?(@new_resource.action.first)
+          if current_revision = find_current_revision
+            @current_resource.revision current_revision
+          end
+        end
+      end
+
+      def action_checkout
+        assert_target_directory_valid!
+        if target_dir_non_existant_or_empty?
+          run_command(run_options(:command => checkout_command))
+          @new_resource.updated_by_last_action(true)
+        else
+          Chef::Log.info "Taking no action, checkout destination #{@new_resource.destination} already exists or is a non-empty directory"
+        end
+      end
+
+      def action_export
+        assert_target_directory_valid!
+        if target_dir_non_existant_or_empty?
+          run_command(run_options(:command => export_command))
+          @new_resource.updated_by_last_action(true)
+        else
+          Chef::Log.info "Taking no action, export destination #{@new_resource.destination} already exists or is a non-empty directory"
+        end
+      end
+
+      def action_force_export
+        assert_target_directory_valid!
+        run_command(run_options(:command => export_command))
+        @new_resource.updated_by_last_action(true)
+      end
+
+      def action_sync
+        assert_target_directory_valid!
+        if ::File.exist?(::File.join(@new_resource.destination, ".svn"))
+          current_rev = find_current_revision
+          Chef::Log.debug "#{@new_resource} current revision: #{current_rev} target revision: #{revision_int}"
+          unless current_revision_matches_target_revision?
+            run_command(run_options(:command => sync_command))
+            Chef::Log.info "#{@new_resource} updated to revision: #{revision_int}"
+            @new_resource.updated_by_last_action(true)
+          end
+        else
+          action_checkout
+          @new_resource.updated_by_last_action(true)
+        end
+      end
+
+      def sync_command
+        Chef::Log.info "Updating working copy #{@new_resource.destination} to revision #{@new_resource.revision}"
+        scm :update, @new_resource.svn_arguments, verbose, authentication, "-r#{revision_int}", @new_resource.destination
+      end
+
+      def checkout_command
+        Chef::Log.info "checking out #{@new_resource.repository} at revision #{@new_resource.revision} to #{@new_resource.destination}"
+        scm :checkout, @new_resource.svn_arguments, verbose, authentication,
+            "-r#{revision_int}", @new_resource.repository, @new_resource.destination
+      end
+
+      def export_command
+        Chef::Log.info "exporting #{@new_resource.repository} at revision #{@new_resource.revision} to #{@new_resource.destination}"
+        args = ["--force"]
+        args << @new_resource.svn_arguments << verbose << authentication <<
+            "-r#{revision_int}" << @new_resource.repository << @new_resource.destination
+        scm :export, *args
+      end
+
+      # If the specified revision isn't an integer ("HEAD" for example), look
+      # up the revision id by asking the server
+      # If the specified revision is an integer, trust it.
+      def revision_int
+        @revision_int ||= begin
+          if @new_resource.revision =~ /^\d+$/
+            @new_resource.revision
+          else
+            command = scm(:info, @new_resource.repository, @new_resource.svn_info_args, authentication, "-r#{@new_resource.revision}")
+            status, svn_info, error_message = output_of_command(command, run_options)
+            handle_command_failures(status, "STDOUT: #{svn_info}\nSTDERR: #{error_message}")
+            extract_revision_info(svn_info)
+          end
+        end
+      end
+
+      alias :revision_slug :revision_int
+
+      def find_current_revision
+        return nil unless ::File.exist?(::File.join(@new_resource.destination, ".svn"))
+        command = scm(:info)
+        status, svn_info, error_message = output_of_command(command, run_options(:cwd => cwd))
+
+        unless [0,1].include?(status.exitstatus)
+          handle_command_failures(status, "STDOUT: #{svn_info}\nSTDERR: #{error_message}")
+        end
+        extract_revision_info(svn_info)
+      end
+
+      def current_revision_matches_target_revision?
+        (!@current_resource.revision.nil?) && (revision_int.strip.to_i == @current_resource.revision.strip.to_i)
+      end
+
+      def run_options(run_opts={})
+        run_opts[:user] = @new_resource.user if @new_resource.user
+        run_opts[:group] = @new_resource.group if @new_resource.group
+        run_opts
+      end
+
+      private
+
+      def cwd
+        @new_resource.destination
+      end
+
+      def verbose
+        "-q"
+      end
+
+      def extract_revision_info(svn_info)
+        begin
+          repo_attrs = YAML.load(svn_info)
+        rescue ArgumentError
+          # YAML doesn't appreciate input like "svn: '/tmp/deploydir' is not a working copy\n"
+          return nil
+        end
+        raise "Could not parse `svn info` data: #{svn_info}" unless repo_attrs.kind_of?(Hash)
+        rev = (repo_attrs['Last Changed Rev'] || repo_attrs['Revision']).to_s
+        Chef::Log.debug "Resolved revision #{@new_resource.revision} to #{rev}"
+        rev
+      end
+
+      # If a username is configured for the SCM, return the command-line
+      # switches for that. Note that we don't need to return the password
+      # switch, since Capistrano will check for that prompt in the output
+      # and will respond appropriately.
+      def authentication
+        return "" unless @new_resource.svn_username
+        result = "--username #{@new_resource.svn_username} "
+        result << "--password #{@new_resource.svn_password} "
+        result
+      end
+
+      def scm(*args)
+        ['svn', *args].compact.join(" ")
+      end
+      
+      # TODO these methods are the same as the git provider...need to REFACTOR
+      # ...the subversion and git providers should extend from the same parent
+      def assert_target_directory_valid!
+        target_parent_directory = ::File.dirname(@new_resource.destination)
+        unless ::File.directory?(target_parent_directory)
+          msg = "Cannot clone #{@new_resource} to #{@new_resource.destination}, the enclosing directory #{target_parent_directory} does not exist"
+          raise Chef::Exceptions::MissingParentDirectory, msg
+        end
+      end
+
+      def target_dir_non_existant_or_empty?
+        !::File.exist?(@new_resource.destination) || Dir.entries(@new_resource.destination).sort == ['.','..']
+      end
+    end
+  end
+end