microwave 0.1004.4 → 0.1004.5

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

@@ -1,198 +0,0 @@
-#
-# 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
-          # 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 #{@new_resource.service_name}")
-            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 #{@new_resource.service_name}")
-          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 #{@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

@@ -1,146 +0,0 @@
-#
-# 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 "#{@new_resource} 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 "#{@new_resource} 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

@@ -1,197 +0,0 @@
-#
-# 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?(Array(@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.debug "#{@new_resource} checkout destination #{@new_resource.destination} already exists or is a non-empty directory - nothing to do"
-        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.debug "#{@new_resource} export destination #{@new_resource.destination} already exists or is a non-empty directory - nothing to do"
-        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
-        c = scm :update, @new_resource.svn_arguments, verbose, authentication, "-r#{revision_int}", @new_resource.destination
-        Chef::Log.debug "#{@new_resource} updated working copy #{@new_resource.destination} to revision #{@new_resource.revision}"
-				c
-      end
-
-      def checkout_command
-        c = scm :checkout, @new_resource.svn_arguments, verbose, authentication,
-            "-r#{revision_int}", @new_resource.repository, @new_resource.destination
-        Chef::Log.info "#{@new_resource} checked out #{@new_resource.repository} at revision #{@new_resource.revision} to #{@new_resource.destination}"
-				c
-      end
-
-      def export_command
-        args = ["--force"]
-        args << @new_resource.svn_arguments << verbose << authentication <<
-            "-r#{revision_int}" << @new_resource.repository << @new_resource.destination
-        c = scm :export, *args
-        Chef::Log.info "#{@new_resource} exported #{@new_resource.repository} at revision #{@new_resource.revision} to #{@new_resource.destination}"
-				c
-      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 "#{@new_resource} 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