chef 18.0.169-x64-mingw-ucrt

data/lib/chef/provider/systemd_unit.rb

@@ -0,0 +1,312 @@
+#
+# Author:: Nathan Williams (<nath.e.will@gmail.com>)
+# Copyright:: Copyright 2016-2018, Nathan Williams
+# 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 "../provider"
+require_relative "../mixin/which"
+require_relative "../resource/file"
+require_relative "../resource/file/verification/systemd_unit"
+require "iniparse"
+require "shellwords" unless defined?(Shellwords)
+require "chef-utils/dist" unless defined?(ChefUtils::Dist)
+
+class Chef
+  class Provider
+    class SystemdUnit < Chef::Provider
+      include Chef::Mixin::Which
+
+      provides :systemd_unit
+
+      def load_current_resource
+        @current_resource = Chef::Resource::SystemdUnit.new(new_resource.name)
+
+        current_resource.unit_name(new_resource.unit_name)
+        current_resource.content(::File.read(unit_path)) if ::File.exist?(unit_path)
+        current_resource.user(new_resource.user)
+        current_resource.enabled(enabled?)
+        current_resource.active(active?)
+        current_resource.masked(masked?)
+        current_resource.static(static?)
+        current_resource.indirect(indirect?)
+        current_resource.triggers_reload(new_resource.triggers_reload)
+
+        current_resource
+      end
+
+      def define_resource_requirements
+        super
+
+        requirements.assert(:create) do |a|
+          a.assertion { IniParse.parse(new_resource.to_ini) }
+          a.failure_message "Unit content is not valid INI text"
+        end
+      end
+
+      def systemd_unit_status
+        @systemd_unit_status ||= begin
+          # Collect all the status information for a unit and return it at once
+          # This may fail if we are managing a template unit (e.g. with '@'), in which case
+          # we just ignore the error because unit status is irrelevant in that case
+          s = shell_out(*systemctl_cmd, "show", "-p", "UnitFileState", "-p", "ActiveState", new_resource.unit_name, **systemctl_opts)
+          # e.g. /bin/systemctl --system show -p UnitFileState -p ActiveState syslog.socket
+          # Returns something like:
+          # ActiveState=inactive
+          # UnitFileState=static
+          status = {}
+          s.stdout.each_line do |line|
+            k, v = line.strip.split("=")
+            status[k] = v
+          end
+
+          status
+        end
+      end
+
+      action :create, description: "Create a systemd unit file, if it does not already exist." do
+        if current_resource.content != new_resource.to_ini
+          converge_by("creating unit: #{new_resource.unit_name}") do
+            manage_unit_file(:create)
+            daemon_reload if new_resource.triggers_reload
+          end
+        end
+      end
+
+      action :delete, description: "Delete a systemd unit file, if it exists." do
+        if ::File.exist?(unit_path)
+          converge_by("deleting unit: #{new_resource.unit_name}") do
+            manage_unit_file(:delete)
+            daemon_reload if new_resource.triggers_reload
+          end
+        end
+      end
+
+      action :preset, description: "Restore the preset '`enable`/`disable`' configuration for a systemd unit. *New in #{ChefUtils::Dist::Infra::PRODUCT} 14.0.*" do
+        converge_by("restoring enable/disable preset configuration for unit: #{new_resource.unit_name}") do
+          systemctl_execute!(:preset, new_resource.unit_name)
+        end
+      end
+
+      action :revert, description: "Revert to a vendor's version of a systemd unit file. *New in #{ChefUtils::Dist::Infra::PRODUCT} 14.0.*" do
+        converge_by("reverting to vendor version of unit: #{new_resource.unit_name}") do
+          systemctl_execute!(:revert, new_resource.unit_name)
+        end
+      end
+
+      action :enable, description: "Ensure the unit will be started after the next system boot." do
+        if current_resource.static
+          logger.debug("#{new_resource.unit_name} is a static unit, enabling is a NOP.")
+        end
+        if current_resource.indirect
+          logger.debug("#{new_resource.unit_name} is an indirect unit, enabling is a NOP.")
+        end
+
+        unless current_resource.enabled || current_resource.static || current_resource.indirect
+          converge_by("enabling unit: #{new_resource.unit_name}") do
+            systemctl_execute!(:enable, new_resource.unit_name)
+            logger.info("#{new_resource} enabled")
+          end
+        end
+      end
+
+      action :disable, description: "Ensure the unit will not be started after the next system boot." do
+        if current_resource.static
+          logger.debug("#{new_resource.unit_name} is a static unit, disabling is a NOP.")
+        end
+
+        if current_resource.indirect
+          logger.debug("#{new_resource.unit_name} is an indirect unit, enabling is a NOP.")
+        end
+
+        if current_resource.enabled && !current_resource.static && !current_resource.indirect
+          converge_by("disabling unit: #{new_resource.unit_name}") do
+            systemctl_execute!(:disable, new_resource.unit_name)
+            logger.info("#{new_resource} disabled")
+          end
+        end
+      end
+
+      action :reenable, description: "Reenable a unit file. *New in #{ChefUtils::Dist::Infra::PRODUCT} 14.0.*" do
+        converge_by("reenabling unit: #{new_resource.unit_name}") do
+          systemctl_execute!(:reenable, new_resource.unit_name)
+          logger.info("#{new_resource} reenabled")
+        end
+      end
+
+      action :mask, description: "Ensure the unit will not start, even to satisfy dependencies." do
+        unless current_resource.masked
+          converge_by("masking unit: #{new_resource.unit_name}") do
+            systemctl_execute!(:mask, new_resource.unit_name)
+            logger.info("#{new_resource} masked")
+          end
+        end
+      end
+
+      action :unmask, description: "Stop the unit from being masked and cause it to start as specified." do
+        if current_resource.masked
+          converge_by("unmasking unit: #{new_resource.unit_name}") do
+            systemctl_execute!(:unmask, new_resource.unit_name)
+            logger.info("#{new_resource} unmasked")
+          end
+        end
+      end
+
+      action :start, description: "Start a systemd unit." do
+        unless current_resource.active
+          converge_by("starting unit: #{new_resource.unit_name}") do
+            systemctl_execute!(:start, new_resource.unit_name, default_env: false)
+            logger.info("#{new_resource} started")
+          end
+        end
+      end
+
+      action :stop, description: "Stop a running systemd unit." do
+        if current_resource.active
+          converge_by("stopping unit: #{new_resource.unit_name}") do
+            systemctl_execute!(:stop, new_resource.unit_name, default_env: false)
+            logger.info("#{new_resource} stopped")
+          end
+        end
+      end
+
+      action :restart, description: "Restart a systemd unit." do
+        converge_by("restarting unit: #{new_resource.unit_name}") do
+          systemctl_execute!(:restart, new_resource.unit_name, default_env: false)
+          logger.info("#{new_resource} restarted")
+        end
+      end
+
+      action :reload, description: "Reload the configuration file for a systemd unit." do
+        if current_resource.active
+          converge_by("reloading unit: #{new_resource.unit_name}") do
+            systemctl_execute!(:reload, new_resource.unit_name, default_env: false)
+            logger.info("#{new_resource} reloaded")
+          end
+        else
+          logger.debug("#{new_resource.unit_name} is not active, skipping reload.")
+        end
+      end
+
+      action :try_restart, description: "Try to restart a systemd unit if the unit is running." do
+        converge_by("try-restarting unit: #{new_resource.unit_name}") do
+          systemctl_execute!("try-restart", new_resource.unit_name, default_env: false)
+          logger.info("#{new_resource} try-restarted")
+        end
+      end
+
+      action :reload_or_restart, description: "For systemd units that are services, this action reloads the configuration of the service without restarting, if possible; otherwise, it will restart the service so the new configuration is applied." do
+        converge_by("reload-or-restarting unit: #{new_resource.unit_name}") do
+          systemctl_execute!("reload-or-restart", new_resource.unit_name, default_env: false)
+          logger.info("#{new_resource} reload-or-restarted")
+        end
+      end
+
+      action :reload_or_try_restart, description: "For systemd units that are services, this action reloads the configuration of the service without restarting, if possible; otherwise, it will try to restart the service so the new configuration is applied." do
+        converge_by("reload-or-try-restarting unit: #{new_resource.unit_name}") do
+          systemctl_execute!("reload-or-try-restart", new_resource.unit_name, default_env: false)
+          logger.info("#{new_resource} reload-or-try-restarted")
+        end
+      end
+
+      def active?
+        # Note: "activating" is not active (as with type=notify or a oneshot)
+        systemd_unit_status["ActiveState"] == "active"
+      end
+
+      def enabled?
+        # See https://github.com/systemd/systemd/blob/master/src/systemctl/systemctl-is-enabled.c
+        # Note: enabled-runtime is excluded because this is volatile, and the state of enabled-runtime
+        # specifically means that the service is not enabled
+        %w{enabled static generated alias indirect}.include?(systemd_unit_status["UnitFileState"])
+      end
+
+      def masked?
+        # Note: masked-runtime is excluded, because runtime is volatile, and
+        # because masked-runtime is not masked.
+        systemd_unit_status["UnitFileState"] == "masked"
+      end
+
+      def static?
+        systemd_unit_status["UnitFileState"] == "static"
+      end
+
+      def indirect?
+        systemd_unit_status["UnitFileState"] == "indirect"
+      end
+
+      private
+
+      def unit_path
+        if new_resource.user
+          "/etc/systemd/user/#{new_resource.unit_name}"
+        else
+          "/etc/systemd/system/#{new_resource.unit_name}"
+        end
+      end
+
+      def manage_unit_file(the_action = :nothing)
+        file unit_path do
+          owner "root"
+          group "root"
+          mode "0644"
+          sensitive new_resource.sensitive
+          content new_resource.to_ini
+          verify :systemd_unit if new_resource.verify
+          action the_action
+        end
+      end
+
+      def daemon_reload
+        shell_out!(systemctl_cmd, "daemon-reload", **systemctl_opts, default_env: false)
+      end
+
+      def systemctl_execute!(action, unit, **options)
+        shell_out!(systemctl_cmd, action, unit, **systemctl_opts.merge(options))
+      end
+
+      def systemctl_execute(action, unit, **options)
+        shell_out(systemctl_cmd, action, unit, **systemctl_opts.merge(options))
+      end
+
+      def systemctl_cmd
+        @systemctl_cmd ||= [ systemctl_path, systemctl_args ]
+      end
+
+      def systemctl_path
+        @systemctl_path ||= which("systemctl")
+      end
+
+      def systemctl_args
+        @systemctl_args ||= new_resource.user ? "--user" : "--system"
+      end
+
+      def systemctl_opts
+        @systemctl_opts ||=
+          if new_resource.user
+            uid = Etc.getpwnam(new_resource.user).uid
+            {
+              user: new_resource.user,
+              environment: {
+                "DBUS_SESSION_BUS_ADDRESS" => "unix:path=/run/user/#{uid}/bus",
+              },
+            }
+          else
+            {}
+          end
+      end
+    end
+  end
+end

data/lib/chef/provider/template/content.rb

@@ -0,0 +1,90 @@
+# rubocop: disable Performance/InefficientHashSearch
+#
+# Author:: Lamont Granquist (<lamont@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_relative "../../mixin/template"
+require_relative "../../file_content_management/content_base"
+
+class Chef
+  class Provider
+    class Template
+
+      class Content < Chef::FileContentManagement::ContentBase
+
+        include Chef::Mixin::Template
+
+        def template_location
+          @template_file_cache_location ||= template_finder.find(new_resource.source, local: new_resource.local, cookbook: new_resource.cookbook)
+        end
+
+        private
+
+        def file_for_provider
+          # Deal with any DelayedEvaluator values in the template variables.
+          visitor = lambda do |obj|
+            case obj
+            when Hash
+              # If this is an Attribute object, we need to change class otherwise
+              # we get the immutable behavior. This could probably be fixed by
+              # using Hash#transform_values once we only support Ruby 2.4.
+              obj_class = obj.is_a?(Chef::Node::ImmutableMash) ? Mash : obj.class
+              # Avoid mutating hashes in the resource in case we're changing anything.
+              obj.each_with_object(obj_class.new) do |(key, value), memo|
+                memo[key] = visitor.call(value)
+              end
+            when Array
+              # Avoid mutating arrays in the resource in case we're changing anything.
+              obj.map { |value| visitor.call(value) }
+            when DelayedEvaluator
+              new_resource.instance_eval(&obj)
+            else
+              obj
+            end
+          end
+          variables = visitor.call(new_resource.variables)
+
+          context = TemplateContext.new(variables)
+          context[:node] = run_context.node
+          context[:template_finder] = template_finder
+
+          # helper variables
+          context[:cookbook_name] = new_resource.cookbook_name unless context.keys.include?(:cookbook_name)
+          context[:recipe_name] = new_resource.recipe_name unless context.keys.include?(:recipe_name)
+          context[:recipe_line_string] = new_resource.source_line unless context.keys.include?(:recipe_line_string)
+          context[:recipe_path] = new_resource.source_line_file unless context.keys.include?(:recipe_path)
+          context[:recipe_line] = new_resource.source_line_number unless context.keys.include?(:recipe_line)
+          context[:template_name] = new_resource.source unless context.keys.include?(:template_name)
+          context[:template_path] = template_location unless context.keys.include?(:template_path)
+
+          context._extend_modules(new_resource.helper_modules)
+          output = context.render_template(template_location)
+
+          tempfile = Chef::FileContentManagement::Tempfile.new(new_resource).tempfile
+          tempfile.binmode
+          tempfile.write(output)
+          tempfile.close
+          tempfile
+        end
+
+        def template_finder
+          @template_finder ||= TemplateFinder.new(run_context, new_resource.cookbook_name, run_context.node)
+        end
+      end
+    end
+  end
+end

data/lib/chef/provider/template.rb

@@ -0,0 +1,60 @@
+#--
+# Author:: Adam Jacob (<adam@chef.io>)
+# Author:: Daniel DeLeo (<dan@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_relative "template_finder"
+require_relative "file"
+
+class Chef
+  class Provider
+    class Template < Chef::Provider::File
+      provides :template
+
+      def initialize(new_resource, run_context)
+        @content_class = Chef::Provider::Template::Content
+        super
+      end
+
+      def load_current_resource
+        @current_resource = Chef::Resource::Template.new(new_resource.name)
+        super
+      end
+
+      def define_resource_requirements
+        super
+
+        requirements.assert(:create, :create_if_missing) do |a|
+          a.assertion { ::File.exist?(content.template_location) }
+          a.failure_message "Template source #{content.template_location} could not be found."
+          a.whyrun "Template source #{content.template_location} does not exist. Assuming it would have been created."
+          a.block_action!
+        end
+      end
+
+      private
+
+      def managing_content?
+        return true if new_resource.checksum
+        return true if !new_resource.source.nil? && @action != :create_if_missing
+
+        false
+      end
+
+    end
+  end
+end

data/lib/chef/provider/template_finder.rb

@@ -0,0 +1,54 @@
+#--
+# Author:: Andrea Campi (<andrea.campi@zephirworks.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.
+#
+
+class Chef
+  class Provider
+
+    class TemplateFinder
+
+      def initialize(run_context, cookbook_name, node)
+        @run_context = run_context
+        @cookbook_name = cookbook_name
+        @node = node
+      end
+
+      def find(template_name, options = {})
+        template_name = template_source_name(template_name, options)
+
+        if options[:local]
+          return template_name
+        end
+
+        cookbook_name = find_cookbook_name(options)
+        cookbook = @run_context.cookbook_collection[cookbook_name]
+
+        cookbook.preferred_filename_on_disk_location(@node, :templates, template_name)
+      end
+
+      protected
+
+      def template_source_name(name, options)
+        options[:source] || name
+      end
+
+      def find_cookbook_name(options)
+        options[:cookbook] || @cookbook_name
+      end
+    end
+  end
+end

data/lib/chef/provider/user/aix.rb

@@ -0,0 +1,139 @@
+#
+# 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 "../user"
+
+class Chef
+  class Provider
+    class User
+      class Aix < Chef::Provider::User
+        provides :user, os: "aix"
+        provides :aix_user
+
+        # The ruby-shadow gem is not supported on aix.
+        def supports_ruby_shadow?
+          false
+        end
+
+        def create_user
+          shell_out!("useradd", universal_options, useradd_options, new_resource.username)
+          add_password
+        end
+
+        def manage_user
+          add_password
+          manage_home
+          return if universal_options.empty? && usermod_options.empty?
+
+          shell_out!("usermod", universal_options, usermod_options, new_resource.username)
+        end
+
+        def remove_user
+          shell_out!("userdel", userdel_options, new_resource.username)
+        end
+
+        # Aix does not support -r like other unix, system account is created by adding to 'system' group
+        def useradd_options
+          opts = []
+          opts << "-g" << "system" if new_resource.system
+          if updating_home?
+            if new_resource.manage_home
+              logger.trace("#{new_resource} managing the users home directory")
+              opts << "-m"
+            else
+              logger.trace("#{new_resource} setting home to #{new_resource.home}")
+            end
+          end
+          opts
+        end
+
+        def userdel_options
+          opts = []
+          opts << "-r" if new_resource.manage_home
+          opts << "-f" if new_resource.force
+          opts
+        end
+
+        def usermod_options
+          []
+        end
+
+        def check_lock
+          lock_info = shell_out!("lsuser", "-a", "account_locked", new_resource.username)
+          if whyrun_mode? && passwd_s.stdout.empty? && lock_info.stderr.include?("does not exist")
+            # if we're in whyrun mode and the user is not yet created we assume it would be
+            return false
+          end
+          raise Chef::Exceptions::User, "Cannot determine if #{new_resource} is locked!" if lock_info.stdout.empty?
+
+          status = /\S+\s+account_locked=(\S+)/.match(lock_info.stdout)
+          @locked =
+            if status && status[1] == "true"
+              true
+            else
+              false
+            end
+
+          @locked
+        end
+
+        def lock_user
+          shell_out!("chuser", "account_locked=true", new_resource.username)
+        end
+
+        def unlock_user
+          shell_out!("chuser", "account_locked=false", new_resource.username)
+        end
+
+        def universal_options
+          opts = []
+          opts << "-c" << new_resource.comment if should_set?(:comment)
+          opts << "-g" << new_resource.gid if should_set?(:gid)
+          opts << "-s" << new_resource.shell if should_set?(:shell)
+          opts << "-u" << new_resource.uid if should_set?(:uid)
+          opts << "-d" << new_resource.home if updating_home?
+          opts << "-o" if new_resource.non_unique
+          opts
+        end
+
+        private
+
+        def add_password
+          return unless current_resource.password != new_resource.password && new_resource.password
+
+          logger.trace("#{new_resource.username} setting password to #{new_resource.password}")
+          command = "echo '#{new_resource.username}:#{new_resource.password}' | chpasswd -c -e"
+          shell_out!(command)
+        end
+
+        # Aix specific handling to update users home directory.
+        def manage_home
+          return unless updating_home? && new_resource.manage_home
+
+          # -m option does not work on aix, so move dir.
+          if ::File.directory?(current_resource.home)
+            logger.trace("Changing users home directory from #{current_resource.home} to #{new_resource.home}")
+            FileUtils.mv current_resource.home, new_resource.home
+          else
+            logger.trace("Creating users home directory #{new_resource.home}")
+            FileUtils.mkdir_p new_resource.home
+          end
+        end
+
+      end
+    end
+  end
+end