poise-monit 1.0.0

data/lib/poise_monit/resources/monit_service.rb

@@ -0,0 +1,194 @@
+#
+# Copyright 2015, Noah Kantrowitz
+#
+# 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/resource/service'
+require 'chef/provider/service'
+require 'poise'
+
+
+module PoiseMonit
+  module Resources
+    # (see MonitService::Resource)
+    # @since 1.0.0
+    module MonitService
+      # Values from `monit status` that mean the service is disabled.
+      DISABLED_STATUSES = /^Not monitored$/
+      # Values from `monit status` that mean the service is running.
+      RUNNING_STATUSES = /^(Accessible|Running|Online with all services|Status ok|UP)$/
+      # Value from monit action subcommands that mean the service doesn't exist.
+      NO_SERVICE_ERROR = /There is no service/
+
+      # Default time to wait for a monit command to succeed.
+      DEFAULT_TIMEOUT = 20
+      # Default time to sleep between tries.
+      DEFAULT_WAIT = 1
+
+      # A `monit_service` resource to control Monit-based services.
+      #
+      # @provides monit_service
+      # @action enable
+      # @action disable
+      # @action start
+      # @action stop
+      # @action restart
+      # @example
+      #   monit_service 'httpd'
+      class Resource < Chef::Resource::Service
+        include Poise(parent: :monit)
+        provides(:monit_service)
+        actions(:enable, :disable, :start, :stop, :restart)
+
+        attribute(:monit_config_path, kind_of: [String, NilClass, FalseClass])
+
+        # Unsupported properties.
+        %w{pattern reload_command priority timeout parameters run_levels}.each do |name|
+          define_method(name) do |*args|
+            raise NoMethodError.new("Property #{name} is not supported on monit_service")
+          end
+        end
+
+        # Lie about supports.
+        # @api private
+        def supports(arg={})
+          {restart: true}
+        end
+      end
+
+      # The provider for `monit_service`.
+      #
+      # @see Resource
+      # @provides monit_service
+      class Provider < Chef::Provider::Service
+        include Poise
+        provides(:monit_service)
+
+        def load_current_resource
+          super
+          @current_resource = MonitService::Resource.new(new_resource.name).tap do |r|
+            r.service_name(new_resource.service_name)
+            if new_resource.monit_config_path && !::File.exist?(new_resource.monit_config_path)
+              Chef::Log.debug("[#{new_resource}] Config file #{new_resource.monit_config_path} does not exist, not checking status")
+              r.enabled(false)
+              r.running(false)
+            else
+              Chef::Log.debug("[#{new_resource}] Checking status for #{new_resource.service_name}")
+              status = find_monit_status
+              Chef::Log.debug("[#{new_resource}] Status is #{status.inspect}")
+              case status
+              when nil, false
+                # Unable to find a status at all.
+                r.enabled(false)
+                r.running(false)
+              when /^Does not exist/
+                # It is monitored but we don't know the status yet, assume the
+                # worst (run start and stop always).
+                r.enabled(true)
+                r.running(self.action != :start)
+              when DISABLED_STATUSES
+                r.enabled(false)
+                # It could be running, but we don't know.
+                r.running(false)
+              when RUNNING_STATUSES
+                r.enabled(true)
+                r.running(true)
+              else
+                r.enabled(true)
+                r.running(false)
+              end
+            end
+          end
+        end
+
+        private
+
+        def enable_service
+          monit_shell_out!('monitor')
+        end
+
+        def disable_service
+          if new_resource.monit_config_path && !::File.exist?(new_resource.monit_config_path)
+            Chef::Log.debug("[#{new_resource}] Config file #{new_resource.monit_config_path} does not exist, not trying to unmonitor")
+            return
+          end
+          monit_shell_out!('unmonitor') do |cmd|
+            # Command fails if it has an error and does not include the service
+            # error message.
+            cmd.error? && cmd.stdout !~ NO_SERVICE_ERROR && cmd.stderr !~ NO_SERVICE_ERROR
+          end
+        end
+
+        def start_service
+          monit_shell_out!('start')
+          monit_shell_out!('start')
+        end
+
+        def stop_service
+          if new_resource.monit_config_path && !::File.exist?(new_resource.monit_config_path)
+            Chef::Log.debug("[#{new_resource}] Config file #{new_resource.monit_config_path} does not exist, not trying to stop")
+            return
+          end
+          monit_shell_out!('stop') do |cmd|
+            # Command fails if it has an error and does not include the service
+            # error message. Then check that it is really stopped.
+            cmd.error? && cmd.stdout !~ NO_SERVICE_ERROR && cmd.stderr !~ NO_SERVICE_ERROR
+          end
+        end
+
+        def restart_service
+          monit_shell_out!('restart')
+        end
+
+        def find_monit_status
+          re = /^Process '#{new_resource.service_name}'\s+status\s+(\w.+)$/
+          status_cmd = monit_shell_out!('status') do |cmd|
+            # Command fails if it has an error, does't have Process line, or
+            # does have Initializing.
+            cmd.error? || cmd.stdout !~ re || cmd.stdout =~ /Initializing/
+          end
+          status_cmd.stdout =~ re && $1
+        end
+
+        def monit_shell_out!(monit_cmd, timeout: DEFAULT_TIMEOUT, wait: DEFAULT_WAIT, &block)
+          while true
+            cmd_args = [new_resource.parent.monit_binary, '-c', new_resource.parent.config_path, monit_cmd, new_resource.service_name]
+            Chef::Log.debug("[#{new_resource}] Running #{cmd_args.join(' ')}")
+            cmd = poise_shell_out(cmd_args, user: new_resource.parent.owner, group: new_resource.parent.group)
+            error = block ? block.call(cmd) : cmd.error?
+            # If there was an error (or error-like output), sleep and try again.
+            if error
+              # We fell off the end of the timeout, doneburger.
+              if timeout <= 0
+                Chef::Log.debug("[#{new_resource}] Timeout while running `monit #{monit_cmd}`")
+                # If there was a run error, raise that first.
+                cmd.error!
+                # Otherwise we just didn't have the requested output, which is fine.
+                break
+              end
+              # Wait and try again.
+              Chef::Log.debug("[#{new_resource}] Failure running `monit #{monit_cmd}`, retrying in #{wait}")
+              timeout -= Kernel.sleep(wait)
+            else
+              # All's quiet on the western front.
+              break
+            end
+          end
+          cmd
+        end
+
+      end
+    end
+  end
+end

data/lib/poise_monit/resources/monit_test.rb

@@ -0,0 +1,127 @@
+#
+# Copyright 2015, Noah Kantrowitz
+#
+# 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/resource'
+require 'chef/provider'
+require 'poise'
+
+require 'poise_service/resources/poise_service_test'
+
+
+module PoiseMonit
+  module Resources
+    # (see PoiseMonitTest::Resource)
+    module PoiseMonitTest
+      # A `monit_test` resource for integration testing monit providers.
+      # This is used in Test-Kitchen tests to ensure all providers behave
+      # similarly.
+      #
+      # @since 1.0.0
+      # @provides monit_test
+      # @action run
+      # @example
+      #   monit_test 'system' do
+      #     monit_provider :system
+      #     base_port 5000
+      #   end
+      class Resource < Chef::Resource
+        include Poise
+        provides(:monit_test)
+        actions(:run)
+
+        # @!attribute monit_provider
+        #   Monit provider to set for the test group.
+        #   @return [Symbol]
+        attribute(:monit_provider, kind_of: Symbol)
+        # @!attribute path
+        #   Path for writing files for this test group.
+        #   @return [String]
+        attribute(:path, kind_of: String, default: lazy { "/root/monit_test_#{name}" })
+        # @!attribute base_port
+        #   Port number to start from for the test group.
+        #   @return [Integer]
+        attribute(:base_port, kind_of: Integer)
+      end
+
+      # Provider for `monit_test`.
+      #
+      # @see Resource
+      # @provides monit_test
+      class Provider < Chef::Provider
+        include Poise
+        provides(:monit_test)
+
+        # `run` action for `poise_service_test`. Create all test services.
+        #
+        # @return [void]
+        def action_run
+          notifying_block do
+            # Make the test output root.
+            directory new_resource.path
+
+            # Install Monit.
+            r = monit new_resource.name do
+              provider new_resource.monit_provider if new_resource.monit_provider
+            end
+
+            # Write out some config files.
+            monit_config 'file_test' do
+              content <<-EOH
+CHECK FILE file_test PATH #{new_resource.path}/check
+  start = "/bin/touch #{new_resource.path}/check"
+EOH
+              parent r
+            end
+            monit_service 'file_test' do
+              action :enable
+              parent r
+            end
+            file "#{new_resource.path}/service" do
+              content <<-EOH
+#!/bin/bash
+nohup /bin/bash -c 'echo $$ >> #{new_resource.path}/pid; while sleep 1; do true; done' &
+EOH
+              mode '700'
+            end
+            monit_config 'process_test' do
+              content <<-EOH
+check process process_test with pidfile #{new_resource.path}/pid
+  start program = "#{new_resource.path}/service"
+EOH
+              parent r
+            end
+            monit_service "process_test" do
+              action [:enable, :start]
+              parent r
+            end
+
+            # Run some monit commands.
+            execute "#{r.monit_binary} -V -c '#{r.config_path}' > #{new_resource.path}/version"
+            execute "#{r.monit_binary} status -c '#{r.config_path}' > #{new_resource.path}/status"
+
+            # Run poise_service_test for the service provider.
+            poise_service_test "monit_#{new_resource.name}" do
+              base_port new_resource.base_port
+              service_provider :monit
+              service_options parent: r
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/poise_monit/service_providers.rb

@@ -0,0 +1,26 @@
+#
+# Copyright 2015, Noah Kantrowitz
+#
+# 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 'poise_monit/service_providers/monit'
+
+
+module PoiseMonit
+  # Providers for `poise_service`.
+  #
+  # @since 1.0.0
+  module ServiceProviders
+  end
+end

data/lib/poise_monit/service_providers/monit.rb

@@ -0,0 +1,124 @@
+#
+# Copyright 2015, Noah Kantrowitz
+#
+# 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 'poise_service/service_providers/sysvinit'
+
+
+module PoiseMonit
+  module ServiceProviders
+    # A `monit` provider for `poise_service`. This uses the sysvinit code to
+    # generate the underlying service script, but Monit to manage the service
+    # runtime.
+    #
+    # @since 1.0.0
+    # @provides monit
+    class Monit < PoiseService::ServiceProviders::Sysvinit
+      provides(:monit)
+
+      # Override the default reload action because monit_service doesn't
+      # support reload itself.
+      def action_reload
+        return if options['never_reload']
+        if running?
+          converge_by("reload service #{new_resource}") do
+            Process.kill(new_resource.reload_signal, pid)
+            Chef::Log.info("#{new_resource} reloaded")
+          end
+        end
+      end
+
+      private
+
+      def service_resource
+        @service_resource ||= PoiseMonit::Resources::MonitService::Resource.new(new_resource.service_name, run_context).tap do |r|
+          # Set standard resource parameters
+          r.enclosing_provider = self
+          r.source_line = new_resource.source_line
+          # Make sure we have a parent.
+          if options['parent']
+            r.parent options['parent']
+          else
+            begin
+              # Try to find a default parent, trigger an exception if not.
+              r.parent
+            rescue Poise::Error
+              # Use the default recipe to give us a parent the next time we ask.
+              include_recipe(node['poise-monit']['default_recipe'])
+            end
+          end
+          # Set some params on the service resource.
+          r.init_command(script_path)
+          # Mild encapulsation break, this is an internal detail of monit_config. :-/
+          r.monit_config_path(::File.join(r.parent.confd_path, "#{new_resource.service_name}.conf"))
+        end
+      end
+
+      def running?
+        begin
+          # Check if the PID is running.
+          pid && Process.kill(0, pid)
+        rescue Errno::ESRCH
+          false
+        end
+      end
+
+      # Patch Monit behavior in to service creation.
+      def create_service
+        super
+        create_monit_config
+      end
+
+      # Create the Monit configuration file.
+      def create_monit_config
+        # Scope closureeeeeee.
+        _options = options
+        _pid_file = pid_file
+        _parent = service_resource.parent
+        _script_path = script_path
+        monit_config new_resource.service_name do
+          cookbook 'poise-monit'
+          parent _parent
+          source 'monit_service.conf.erb'
+          variables service_resource: new_resource, options: _options, pid_file: _pid_file, script_path: _script_path
+          # Don't trigger a restart if the template doesn't already exist, this
+          # prevents restarting on the run that first creates the service.
+          restart_on_update = _options.fetch('restart_on_update', new_resource.restart_on_update)
+          if restart_on_update && ::File.exist?(path) # Path here is accessing MonitConfig::Resource#path.
+            mode = restart_on_update.to_s == 'immediately' ? :immediately : :delayed
+            notifies :restart, new_resource, mode
+          end
+        end
+      end
+
+      # Patch Monit behavior in to service teardown.
+      def destroy_service
+        delete_monit_config
+        super
+      end
+
+      # Delete the Monit configuration file.
+      def delete_monit_config
+        _parent = service_resource.parent
+        monit_config new_resource.service_name do
+          action :delete
+          parent _parent
+        end
+      end
+
+    end
+  end
+end
+