cloud-mu 3.6.10 → 3.6.12

data/cookbooks/firewall/libraries/provider_firewall_firewalld.rb

@@ -1,179 +0,0 @@
-#
-# Author:: Ronald Doorn (<rdoorn@schubergphilis.com>)
-# Cookbook:: firewall
-# Resource:: default
-#
-# 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::FirewallFirewalld < Chef::Provider::LWRPBase
-    include FirewallCookbook::Helpers::Firewalld
-
-    provides :firewall, os: 'linux', platform_family: %w(rhel fedora amazon) do |node|
-      (node['platform_version'].to_i >= 7 && !node['firewall']['redhat7_iptables']) || (amazon_linux? && !node['firewall']['redhat7_iptables'])
-    end
-
-    def whyrun_supported?
-      false
-    end
-
-    action :install do
-      return if disabled?(new_resource)
-
-      firewalld_package = package 'firewalld' do
-        action :nothing
-        options new_resource.package_options
-      end
-      firewalld_package.run_action(:install)
-      new_resource.updated_by_last_action(firewalld_package.updated_by_last_action?)
-
-      unless ::File.exist?(firewalld_rules_filename)
-        rules_file = lookup_or_create_rulesfile
-        rules_file.content '# created by chef to allow service to start'
-        rules_file.run_action(:create)
-        new_resource.updated_by_last_action(rules_file.updated_by_last_action?)
-      end
-
-      firewalld_service = lookup_or_create_service
-      [:enable, :start].each do |a|
-        firewalld_service.run_action(a)
-        new_resource.updated_by_last_action(firewalld_service.updated_by_last_action?)
-      end
-    end
-
-    action :restart do
-      return if disabled?(new_resource)
-
-      # ensure it's initialized
-      new_resource.rules({}) unless new_resource.rules
-      new_resource.rules['firewalld'] = {} unless new_resource.rules['firewalld']
-
-      # this populates the hash of rules from firewall_rule resources
-      firewall_rules = Chef.run_context.resource_collection.select { |item| item.is_a?(Chef::Resource::FirewallRule) }
-      firewall_rules.each do |firewall_rule|
-        next unless firewall_rule.action.include?(:create) && !firewall_rule.should_skip?(:create)
-
-        ip_versions(firewall_rule).each do |ip_version|
-          # build rules to apply with weight
-          k = "firewall-cmd --zone=#{firewall_rule.zone} --direct --add-rule #{build_firewall_rule(firewall_rule, ip_version)}"
-          v = firewall_rule.position
-
-          # unless we're adding them for the first time.... bail out.
-          next if new_resource.rules['firewalld'].key?(k) && new_resource.rules['firewalld'][k] == v
-          new_resource.rules['firewalld'][k] = v
-
-          # If persistent rules is enabled (default) make sure we add a permanent rule at the same time
-          perm_rules = node && node['firewall'] && node['firewall']['firewalld'] && node['firewall']['firewalld']['permanent']
-          if firewall_rule.permanent || perm_rules
-            k = "firewall-cmd --zone=#{firewall_rule.zone}  --permanent --direct --add-rule #{build_firewall_rule(firewall_rule, ip_version)}"
-            new_resource.rules['firewalld'][k] = v
-          end
-        end
-      end
-
-      # ensure a file resource exists with the current firewalld rules
-      rules_file = lookup_or_create_rulesfile
-      rules_file.content build_rule_file(new_resource.rules['firewalld'])
-      rules_file.run_action(:create)
-
-      # ensure the service is running without waiting.
-      firewalld_service = lookup_or_create_service
-      [:enable, :start].each do |a|
-        firewalld_service.run_action(a)
-        new_resource.updated_by_last_action(firewalld_service.updated_by_last_action?)
-      end
-
-      # mark updated if we changed the zone
-      unless firewalld_default_zone?(new_resource.enabled_zone)
-        firewalld_default_zone!(new_resource.enabled_zone)
-        new_resource.updated_by_last_action(true)
-      end
-
-      # if the file was changed, load new ruleset
-      return unless rules_file.updated_by_last_action?
-      firewalld_flush!
-      # TODO: support logging
-
-      new_resource.rules['firewalld'].sort_by { |_k, v| v }.map { |k, _v| k }.each do |cmd|
-        firewalld_rule!(cmd)
-      end
-
-      new_resource.updated_by_last_action(true)
-    end
-
-    action :disable do
-      return if disabled?(new_resource)
-
-      if firewalld_active?
-        firewalld_flush!
-        firewalld_default_zone!(new_resource.disabled_zone)
-        new_resource.updated_by_last_action(true)
-      end
-
-      # ensure the service is stopped without waiting.
-      firewalld_service = lookup_or_create_service
-      [:disable, :stop].each do |a|
-        firewalld_service.run_action(a)
-        new_resource.updated_by_last_action(firewalld_service.updated_by_last_action?)
-      end
-
-      rules_file = lookup_or_create_rulesfile
-      rules_file.content '# created by chef to allow service to start'
-      rules_file.run_action(:create)
-      new_resource.updated_by_last_action(rules_file.updated_by_last_action?)
-    end
-
-    action :flush do
-      return if disabled?(new_resource)
-      return unless firewalld_active?
-
-      firewalld_flush!
-      new_resource.updated_by_last_action(true)
-
-      rules_file = lookup_or_create_rulesfile
-      rules_file.content '# created by chef to allow service to start'
-      rules_file.run_action(:create)
-      new_resource.updated_by_last_action(rules_file.updated_by_last_action?)
-    end
-
-    action :save do
-      return if disabled?(new_resource)
-      return if firewalld_all_rules_permanent!
-
-      firewalld_save!
-      new_resource.updated_by_last_action(true)
-    end
-
-    def lookup_or_create_service
-      begin
-        firewalld_service = Chef.run_context.resource_collection.find(service: 'firewalld')
-      rescue
-        firewalld_service = service 'firewalld' do
-          action :nothing
-        end
-      end
-      firewalld_service
-    end
-
-    def lookup_or_create_rulesfile
-      begin
-        firewalld_file = Chef.run_context.resource_collection.find(file: firewalld_rules_filename)
-      rescue
-        firewalld_file = file firewalld_rules_filename do
-          action :nothing
-        end
-      end
-      firewalld_file
-    end
-  end
-end

data/cookbooks/firewall/libraries/provider_firewall_iptables.rb

@@ -1,171 +0,0 @@
-#
-# Author:: Seth Chisamore (<schisamo@opscode.com>)
-# Cookbook:: firewall
-# Resource:: default
-#
-# Copyright:: 2011-2019, Chef Software, Inc.
-#
-# 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::FirewallIptables < Chef::Provider::LWRPBase
-    include FirewallCookbook::Helpers
-    include FirewallCookbook::Helpers::Iptables
-
-    provides :firewall, os: 'linux', platform_family: %w(rhel fedora amazon) do |node|
-      (node['platform_version'].to_i < 7 && !amazon_linux?) || node['platform_version'].to_i >= 8 || node['firewall']['redhat7_iptables']
-    end
-
-    def whyrun_supported?
-      false
-    end
-
-    action :install do
-      return if disabled?(new_resource)
-
-      # Ensure the package is installed
-      iptables_packages(new_resource).each do |p|
-        iptables_pkg = package p do
-          action :nothing
-        end
-        iptables_pkg.run_action(:install)
-        new_resource.updated_by_last_action(true) if iptables_pkg.updated_by_last_action?
-      end
-
-      iptables_commands(new_resource).each do |svc|
-        # must create empty file for service to start
-        unless ::File.exist?("/etc/sysconfig/#{svc}")
-          # must create empty file for service to start
-          iptables_file = lookup_or_create_rulesfile(svc)
-          iptables_file.content '# created by chef to allow service to start'
-          iptables_file.run_action(:create)
-          new_resource.updated_by_last_action(true) if iptables_file.updated_by_last_action?
-        end
-
-        iptables_service = lookup_or_create_service(svc)
-        [:enable, :start].each do |a|
-          iptables_service.run_action(a)
-          new_resource.updated_by_last_action(true) if iptables_service.updated_by_last_action?
-        end
-      end
-    end
-
-    action :restart do
-      return if disabled?(new_resource)
-
-      # prints all the firewall rules
-      log_iptables(new_resource)
-
-      # ensure it's initialized
-      new_resource.rules({}) unless new_resource.rules
-      ensure_default_rules_exist(node, new_resource)
-
-      # this populates the hash of rules from firewall_rule resources
-      firewall_rules = Chef.run_context.resource_collection.select { |item| item.is_a?(Chef::Resource::FirewallRule) }
-      firewall_rules.each do |firewall_rule|
-        next unless firewall_rule.action.include?(:create) && !firewall_rule.should_skip?(:create)
-
-        types = if ipv6_rule?(firewall_rule) # an ip4 specific rule
-                  %w(ip6tables)
-                elsif ipv4_rule?(firewall_rule) # an ip6 specific rule
-                  %w(iptables)
-                else # or not specific
-                  %w(iptables ip6tables)
-                end
-
-        types.each do |iptables_type|
-          # build rules to apply with weight
-          k = build_firewall_rule(node, firewall_rule, iptables_type == 'ip6tables')
-          v = firewall_rule.position
-
-          # unless we're adding them for the first time.... bail out.
-          next if new_resource.rules[iptables_type].key?(k) && new_resource.rules[iptables_type][k] == v
-          new_resource.rules[iptables_type][k] = v
-        end
-      end
-
-      iptables_commands(new_resource).each do |iptables_type|
-        # this takes the commands in each hash entry and builds a rule file
-        iptables_file = lookup_or_create_rulesfile(iptables_type)
-        iptables_file.content build_rule_file(new_resource.rules[iptables_type])
-        iptables_file.run_action(:create)
-
-        # if the file was unchanged, skip loop iteration, otherwise restart iptables
-        next unless iptables_file.updated_by_last_action?
-
-        iptables_service = lookup_or_create_service(iptables_type)
-        iptables_service.run_action(:restart)
-        new_resource.updated_by_last_action(true)
-      end
-    end
-
-    action :disable do
-      return if disabled?(new_resource)
-
-      iptables_flush!(new_resource)
-      iptables_default_allow!(new_resource)
-      new_resource.updated_by_last_action(true)
-
-      iptables_commands(new_resource).each do |svc|
-        iptables_service = lookup_or_create_service(svc)
-        [:disable, :stop].each do |a|
-          iptables_service.run_action(a)
-          new_resource.updated_by_last_action(true) if iptables_service.updated_by_last_action?
-        end
-
-        # must create empty file for service to start
-        iptables_file = lookup_or_create_rulesfile(svc)
-        iptables_file.content '# created by chef to allow service to start'
-        iptables_file.run_action(:create)
-        new_resource.updated_by_last_action(true) if iptables_file.updated_by_last_action?
-      end
-    end
-
-    action :flush do
-      return if disabled?(new_resource)
-
-      iptables_flush!(new_resource)
-      new_resource.updated_by_last_action(true)
-
-      iptables_commands(new_resource).each do |svc|
-        # must create empty file for service to start
-        iptables_file = lookup_or_create_rulesfile(svc)
-        iptables_file.content '# created by chef to allow service to start'
-        iptables_file.run_action(:create)
-        new_resource.updated_by_last_action(true) if iptables_file.updated_by_last_action?
-      end
-    end
-
-    def lookup_or_create_service(name)
-      begin
-        iptables_service = Chef.run_context.resource_collection.find(service: svc)
-      rescue
-        iptables_service = service name do
-          action :nothing
-        end
-      end
-      iptables_service
-    end
-
-    def lookup_or_create_rulesfile(name)
-      begin
-        iptables_file = Chef.run_context.resource_collection.find(file: name)
-      rescue
-        iptables_file = file "/etc/sysconfig/#{name}" do
-          action :nothing
-        end
-      end
-      iptables_file
-    end
-  end
-end

data/cookbooks/firewall/libraries/provider_firewall_iptables_ubuntu.rb

@@ -1,200 +0,0 @@
-#
-# Author:: Seth Chisamore (<schisamo@opscode.com>)
-# Cookbook:: firewall
-# Resource:: default
-#
-# Copyright:: 2011-2019, Chef Software, Inc.
-#
-# 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::FirewallIptablesUbuntu < Chef::Provider::LWRPBase
-    include FirewallCookbook::Helpers
-    include FirewallCookbook::Helpers::Iptables
-
-    provides :firewall, os: 'linux', platform_family: %w(debian) do |node|
-      node['firewall'] && node['firewall']['ubuntu_iptables'] &&
-        node['platform_version'].to_f > (node['platform'] == 'ubuntu' ? 14.04 : 7)
-    end
-
-    def whyrun_supported?
-      false
-    end
-
-    action :install do
-      return if disabled?(new_resource)
-
-      # Ensure the package is installed
-      pkg = package 'iptables-persistent' do
-        action :nothing
-      end
-      pkg.run_action(:install)
-      new_resource.updated_by_last_action(true) if pkg.updated_by_last_action?
-
-      rule_files = %w(rules.v4)
-      rule_files << 'rules.v6' if ipv6_enabled?(new_resource)
-      rule_files.each do |svc|
-        next if ::File.exist?("/etc/iptables/#{svc}")
-
-        # must create empty file for service to start
-        f = lookup_or_create_rulesfile(svc)
-        f.content '# created by chef to allow service to start'
-        f.run_action(:create)
-
-        new_resource.updated_by_last_action(true) if f.updated_by_last_action?
-      end
-
-      iptables_service = lookup_or_create_service('netfilter-persistent')
-      [:enable, :start].each do |act|
-        # iptables-persistent isn't a real service
-        iptables_service.status_command 'true'
-
-        iptables_service.run_action(act)
-        new_resource.updated_by_last_action(true) if iptables_service.updated_by_last_action?
-      end
-    end
-
-    action :restart do
-      return if disabled?(new_resource)
-
-      # prints all the firewall rules
-      log_iptables(new_resource)
-
-      # ensure it's initialized
-      new_resource.rules({}) unless new_resource.rules
-      ensure_default_rules_exist(node, new_resource)
-
-      # this populates the hash of rules from firewall_rule resources
-      firewall_rules = Chef.run_context.resource_collection.select { |item| item.is_a?(Chef::Resource::FirewallRule) }
-      firewall_rules.each do |firewall_rule|
-        next unless firewall_rule.action.include?(:create) && !firewall_rule.should_skip?(:create)
-
-        types = if ipv6_rule?(firewall_rule) # an ip4 specific rule
-                  %w(ip6tables)
-                elsif ipv4_rule?(firewall_rule) # an ip6 specific rule
-                  %w(iptables)
-                else # or not specific
-                  %w(iptables ip6tables)
-                end
-
-        types.each do |iptables_type|
-          # build rules to apply with weight
-          k = build_firewall_rule(node, firewall_rule, iptables_type == 'ip6tables')
-          v = firewall_rule.position
-
-          # unless we're adding them for the first time.... bail out.
-          next if new_resource.rules[iptables_type].key?(k) && new_resource.rules[iptables_type][k] == v
-          new_resource.rules[iptables_type][k] = v
-        end
-      end
-
-      restart_service = false
-
-      rule_files = %w(iptables)
-      rule_files << 'ip6tables' if ipv6_enabled?(new_resource)
-
-      rule_files.each do |iptables_type|
-        iptables_filename = if iptables_type == 'ip6tables'
-                              '/etc/iptables/rules.v6'
-                            else
-                              '/etc/iptables/rules.v4'
-                            end
-
-        # ensure a file resource exists with the current iptables rules
-        begin
-          iptables_file = Chef.run_context.resource_collection.find(file: iptables_filename)
-        rescue
-          iptables_file = file iptables_filename do
-            action :nothing
-          end
-        end
-        iptables_file.content build_rule_file(new_resource.rules[iptables_type])
-        iptables_file.run_action(:create)
-
-        # if the file was changed, restart iptables
-        restart_service = true if iptables_file.updated_by_last_action?
-      end
-
-      if restart_service
-        service_affected = service 'netfilter-persistent' do
-          action :nothing
-        end
-        service_affected.run_action(:restart)
-        new_resource.updated_by_last_action(true)
-      end
-    end
-
-    action :disable do
-      return if disabled?(new_resource)
-
-      iptables_flush!(new_resource)
-      iptables_default_allow!(new_resource)
-      new_resource.updated_by_last_action(true)
-
-      iptables_service = lookup_or_create_service('netfilter-persistent')
-      [:disable, :stop].each do |act|
-        iptables_service.run_action(act)
-        new_resource.updated_by_last_action(true) if iptables_service.updated_by_last_action?
-      end
-
-      %w(rules.v4 rules.v6).each do |svc|
-        # must create empty file for service to start
-        f = lookup_or_create_rulesfile(svc)
-        f.content '# created by chef to allow service to start'
-        f.run_action(:create)
-
-        new_resource.updated_by_last_action(true) if f.updated_by_last_action?
-      end
-    end
-
-    action :flush do
-      return if disabled?(new_resource)
-
-      iptables_flush!(new_resource)
-      new_resource.updated_by_last_action(true)
-
-      rule_files = %w(rules.v4)
-      rule_files << 'rules.v6' if ipv6_enabled?(new_resource)
-      rule_files.each do |svc|
-        # must create empty file for service to start
-        f = lookup_or_create_rulesfile(svc)
-        f.content '# created by chef to allow service to start'
-        f.run_action(:create)
-
-        new_resource.updated_by_last_action(true) if f.updated_by_last_action?
-      end
-    end
-
-    def lookup_or_create_service(name)
-      begin
-        iptables_service = Chef.run_context.resource_collection.find(service: svc)
-      rescue
-        iptables_service = service name do
-          action :nothing
-        end
-      end
-      iptables_service
-    end
-
-    def lookup_or_create_rulesfile(name)
-      begin
-        iptables_file = Chef.run_context.resource_collection.find(file: name)
-      rescue
-        iptables_file = file "/etc/iptables/#{name}" do
-          action :nothing
-        end
-      end
-      iptables_file
-    end
-  end
-end