chef 12.17.44 → 12.18.31

data/lib/chef/provider/package/dnf/dnf_helper.py

@@ -0,0 +1,91 @@
+#!/usr/bin/env python3
+# vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4
+
+import sys
+import dnf
+import hawkey
+import signal
+import os
+import json
+
+base = None
+
+def get_sack():
+    global base
+    if base is None:
+        base = dnf.Base()
+        base.read_all_repos()
+        base.fill_sack()
+    return base.sack
+
+# FIXME: leaks memory and does not work
+def flushcache():
+    try:
+        os.remove('/var/cache/dnf/@System.solv')
+    except OSError:
+        pass
+    get_sack().load_system_repo(build_cache=True)
+
+def query(command):
+    sack = get_sack()
+
+    subj = dnf.subject.Subject(command['provides'])
+    q = subj.get_best_query(sack, with_provides=True)
+
+    if command['action'] == "whatinstalled":
+        q = q.installed()
+
+    if command['action'] == "whatavailable":
+        q = q.available()
+
+    if 'epoch' in command:
+        q = q.filterm(epoch=int(command['epoch']))
+    if 'version' in command:
+        q = q.filterm(version__glob=command['version'])
+    if 'release' in command:
+        q = q.filterm(release__glob=command['release'])
+
+    if 'arch' in command:
+        q = q.filterm(arch__glob=command['arch'])
+
+    # only apply the default arch query filter if it returns something
+    archq = q.filter(arch=[ 'noarch', hawkey.detect_arch() ])
+    if len(archq.run()) > 0:
+        q = archq
+
+    pkgs = dnf.query.latest_limit_pkgs(q, 1)
+
+    if not pkgs:
+        sys.stdout.write('{} nil nil\n'.format(command['provides'].split().pop(0)))
+    else:
+        # make sure we picked the package with the highest version
+        pkgs.sort
+        pkg = pkgs.pop()
+        sys.stdout.write('{} {}:{}-{} {}\n'.format(pkg.name, pkg.epoch, pkg.version, pkg.release, pkg.arch))
+
+# the design of this helper is that it should try to be 'brittle' and fail hard and exit in order
+# to keep process tables clean.  additional error handling should probably be added to the retry loop
+# on the ruby side.
+def exit_handler(signal, frame):
+    sys.exit(0)
+
+signal.signal(signal.SIGINT, exit_handler)
+signal.signal(signal.SIGHUP, exit_handler)
+signal.signal(signal.SIGPIPE, exit_handler)
+signal.signal(signal.SIGCHLD, exit_handler)
+
+while 1:
+    # kill self if we get orphaned (tragic)
+    ppid = os.getppid()
+    if ppid == 1:
+        sys.exit(0)
+    line = sys.stdin.readline()
+    command = json.loads(line)
+    if command['action'] == "whatinstalled":
+        query(command)
+    elif command['action'] == "whatavailable":
+        query(command)
+    elif command['action'] == "flushcache":
+        flushcache()
+    else:
+        raise RuntimeError("bad command")

data/lib/chef/provider/package/dnf/python_helper.rb

@@ -0,0 +1,120 @@
+#
+# Copyright:: Copyright 2016, 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 "chef/provider/package/dnf/version"
+require "timeout"
+
+class Chef
+  class Provider
+    class Package
+      class Dnf < Chef::Provider::Package
+        class PythonHelper
+          include Singleton
+          extend Chef::Mixin::Which
+
+          attr_accessor :stdin
+          attr_accessor :stdout
+          attr_accessor :stderr
+          attr_accessor :wait_thr
+
+          DNF_HELPER = ::File.expand_path(::File.join(::File.dirname(__FILE__), "dnf_helper.py")).freeze
+          DNF_COMMAND = "#{which("python3")} #{DNF_HELPER}"
+
+          def start
+            ENV["PYTHONUNBUFFERED"] = "1"
+            @stdin, @stdout, @stderr, @wait_thr = Open3.popen3(DNF_COMMAND)
+          end
+
+          def reap
+            unless wait_thr.nil?
+              Process.kill("KILL", wait_thr.pid) rescue nil
+              stdin.close unless stdin.nil?
+              stdout.close unless stdout.nil?
+              stderr.close unless stderr.nil?
+              wait_thr.value # this calls waitpit()
+            end
+          end
+
+          def check
+            start if stdin.nil?
+          end
+
+          # i couldn't figure out how to decompose an evr on the python side, it seems reasonably
+          # painless to do it in ruby (generally massaging nevras in the ruby side is HIGHLY
+          # discouraged -- this is an "every rule has an exception" exception -- any additional
+          # functionality should probably trigger moving this regexp logic into python)
+          def add_version(hash, version)
+            epoch = nil
+            if version =~ /(\S+):(\S+)/
+              epoch, version = $1, $2
+            end
+            if version =~ /(\S+)-(\S+)/
+              version, release = $1, $2
+            end
+            hash["epoch"] = epoch unless epoch.nil?
+            hash["release"] = release unless release.nil?
+            hash["version"] = version
+          end
+
+          def build_query(action, provides, version, arch)
+            hash = { "action" => action }
+            hash["provides"] = provides
+            add_version(hash, version) unless version.nil?
+            hash["arch" ] = arch unless arch.nil?
+            FFI_Yajl::Encoder.encode(hash)
+          end
+
+          def parse_response(output)
+            array = output.split.map { |x| x == "nil" ? nil : x }
+            array.each_slice(3).map { |x| Version.new(*x) }.first
+          end
+
+          # @returns Array<Version>
+          def query(action, provides, version = nil, arch = nil)
+            with_helper do
+              json = build_query(action, provides, version, arch)
+              Chef::Log.debug "sending '#{json}' to python helper"
+              stdin.syswrite json + "\n"
+              output = stdout.sysread(4096).chomp
+              Chef::Log.debug "got '#{output}' from python helper"
+              version = parse_response(output)
+              Chef::Log.debug "parsed #{version} from python helper"
+              version
+            end
+          end
+
+          def restart
+            reap
+            start
+          end
+
+          def with_helper
+            max_retries ||= 5
+            Timeout.timeout(600) do
+              check
+              yield
+            end
+          rescue EOFError, Errno::EPIPE, Timeout::Error, Errno::ESRCH => e
+            raise e unless ( max_retries -= 1 ) > 0
+            restart
+            retry
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chef/provider/package/dnf/version.rb

@@ -0,0 +1,56 @@
+#
+# Copyright:: Copyright 2016, 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 Package
+      class Dnf < Chef::Provider::Package
+
+        # helper class to assist in passing around name/version/arch triples
+        class Version
+          attr_accessor :name
+          attr_accessor :version
+          attr_accessor :arch
+
+          def initialize(name, version, arch)
+            @name    = name
+            @version = version
+            @arch    = arch
+          end
+
+          def to_s
+            "#{name}-#{version}.#{arch}"
+          end
+
+          def version_with_arch
+            "#{version}.#{arch}" unless version.nil?
+          end
+
+          def matches_name_and_arch?(other)
+            other.version == version && other.arch == arch
+          end
+
+          def ==(other)
+            name == other.name && version == other.version && arch == other.arch
+          end
+
+          alias_method :eql?, :==
+        end
+      end
+    end
+  end
+end

data/lib/chef/provider/package/easy_install.rb

@@ -122,7 +122,7 @@ class Chef
 
         def remove_package(name, version)
           Chef.deprecated(:easy_install, "The easy_install package provider is deprecated and will be removed in Chef 13.")
-          run_command(:command => "#{easy_install_binary_path }#{expand_options(@new_resource.options)} -m #{name}")
+          run_command(:command => "#{easy_install_binary_path}#{expand_options(@new_resource.options)} -m #{name}")
         end
 
         def purge_package(name, version)

data/lib/chef/provider/package/freebsd/base.rb

@@ -58,7 +58,7 @@ class Chef
           def makefile_variable_value(variable, dir = nil)
             options = dir ? { :cwd => dir } : {}
             make_v = shell_out_with_timeout!("make -V #{variable}", options.merge!(:env => nil, :returns => [0, 1]))
-            make_v.exitstatus.zero? ? make_v.stdout.strip.split($\).first : nil # $\ is the line separator, i.e. newline.
+            make_v.exitstatus == 0 ? make_v.stdout.strip.split($\).first : nil # $\ is the line separator, i.e. newline.
           end
         end
 

data/lib/chef/provider/package/freebsd/pkgng.rb

@@ -64,7 +64,7 @@ class Chef
             end
 
             pkg_query = shell_out_with_timeout!("pkg rquery#{expand_options(options)} '%v' #{@new_resource.package_name}", :env => nil)
-            pkg_query.exitstatus.zero? ? pkg_query.stdout.strip.split(/\n/).last : nil
+            pkg_query.exitstatus == 0 ? pkg_query.stdout.strip.split(/\n/).last : nil
           end
 
           def repo_regex

data/lib/chef/provider/package/powershell.rb

@@ -60,7 +60,7 @@ class Chef
         # Removes the package for the version passed and if no version is passed, then all installed versions of the package are removed
         def remove_package(names, versions)
           names.each_with_index do |name, index|
-            if versions && versions[index] != nil
+            if versions && !versions[index].nil?
               powershell_out( "Uninstall-Package '#{name}' -Force -ForceBootstrap -RequiredVersion #{versions[index]}", { :timeout => @new_resource.timeout })
             else
               version = "0"
@@ -78,7 +78,7 @@ class Chef
         def build_candidate_versions
           versions = []
           new_resource.package_name.each_with_index do |name, index|
-            if new_resource.version && new_resource.version[index] != nil
+            if new_resource.version && !new_resource.version[index].nil?
               version = powershell_out("(Find-Package '#{name}' -RequiredVersion #{new_resource.version[index]} -ForceBootstrap -Force | select version | Format-Table -HideTableHeaders | Out-String).Trim()", { :timeout => @new_resource.timeout }).stdout.strip()
             else
               version = powershell_out("(Find-Package '#{name}' -ForceBootstrap -Force | select version | Format-Table -HideTableHeaders | Out-String).Trim()", { :timeout => @new_resource.timeout }).stdout.strip()
@@ -95,7 +95,7 @@ class Chef
         def build_current_versions
           version_list = []
           new_resource.package_name.each_with_index do |name, index|
-            if new_resource.version && new_resource.version[index] != nil
+            if new_resource.version && !new_resource.version[index].nil?
               version = powershell_out("(Get-Package -Name '#{name}' -RequiredVersion #{new_resource.version[index]} -ForceBootstrap -Force | select version | Format-Table -HideTableHeaders | Out-String).Trim()", { :timeout => @new_resource.timeout }).stdout.strip()
             else
               version = powershell_out("(Get-Package -Name '#{name}' -ForceBootstrap -Force | select version | Format-Table -HideTableHeaders | Out-String).Trim()", { :timeout => @new_resource.timeout }).stdout.strip()

data/lib/chef/provider/package/windows.rb

@@ -262,7 +262,7 @@ class Chef
           if source_location.nil?
             inferred_registry_type == :msi
           else
-            ::File.extname(source_location).casecmp(".msi").zero?
+            ::File.extname(source_location).casecmp(".msi") == 0
           end
         end
       end

data/lib/chef/provider/package/zypper.rb

@@ -144,7 +144,7 @@ class Chef
           end
         end
 
-        def gpg_checks()
+        def gpg_checks
           case Chef::Config[:zypper_check_gpg]
           when true
             ""

data/lib/chef/provider/route.rb

@@ -21,209 +21,211 @@ require "chef/mixin/command"
 require "chef/provider"
 require "ipaddr"
 
-class Chef::Provider::Route < Chef::Provider
-  include Chef::Mixin::Command
-
-  provides :route
-
-  attr_accessor :is_running
-
-  MASK = { "0.0.0.0"          => "0",
-           "128.0.0.0"        => "1",
-           "192.0.0.0"        => "2",
-           "224.0.0.0"        => "3",
-           "240.0.0.0"        => "4",
-           "248.0.0.0"        => "5",
-           "252.0.0.0"        => "6",
-           "254.0.0.0"        => "7",
-           "255.0.0.0"        => "8",
-           "255.128.0.0"      => "9",
-           "255.192.0.0"      => "10",
-           "255.224.0.0"      => "11",
-           "255.240.0.0"      => "12",
-           "255.248.0.0"      => "13",
-           "255.252.0.0"      => "14",
-           "255.254.0.0"      => "15",
-           "255.255.0.0"      => "16",
-           "255.255.128.0"    => "17",
-           "255.255.192.0"    => "18",
-           "255.255.224.0"    => "19",
-           "255.255.240.0"    => "20",
-           "255.255.248.0"    => "21",
-           "255.255.252.0"    => "22",
-           "255.255.254.0"    => "23",
-           "255.255.255.0"    => "24",
-           "255.255.255.128"  => "25",
-           "255.255.255.192"  => "26",
-           "255.255.255.224"  => "27",
-           "255.255.255.240"  => "28",
-           "255.255.255.248"  => "29",
-           "255.255.255.252"  => "30",
-           "255.255.255.254"  => "31",
-           "255.255.255.255"  => "32" }
-
-  def hex2ip(hex_data)
-    # Cleanup hex data
-    hex_ip = hex_data.to_s.downcase.gsub(/[^0-9a-f]/, "")
-
-    # Check hex data format (IP is a 32bit integer, so should be 8 chars long)
-    return nil if hex_ip.length != hex_data.length || hex_ip.length != 8
-
-    # Extract octets from hex data
-    octets = hex_ip.scan(/../).reverse.collect { |octet| [octet].pack("H2").unpack("C").first }
-
-    # Validate IP
-    ip = octets.join(".")
-    begin
-      IPAddr.new(ip, Socket::AF_INET).to_s
-    rescue ArgumentError
-      Chef::Log.debug("Invalid IP address data: hex=#{hex_ip}, ip=#{ip}")
-      return nil
-    end
-  end
-
-  def whyrun_supported?
-    true
-  end
+class Chef
+  class Provider
+    class Route < Chef::Provider
+      include Chef::Mixin::Command
+
+      provides :route
+
+      attr_accessor :is_running
+
+      MASK = { "0.0.0.0"          => "0",
+               "128.0.0.0"        => "1",
+               "192.0.0.0"        => "2",
+               "224.0.0.0"        => "3",
+               "240.0.0.0"        => "4",
+               "248.0.0.0"        => "5",
+               "252.0.0.0"        => "6",
+               "254.0.0.0"        => "7",
+               "255.0.0.0"        => "8",
+               "255.128.0.0"      => "9",
+               "255.192.0.0"      => "10",
+               "255.224.0.0"      => "11",
+               "255.240.0.0"      => "12",
+               "255.248.0.0"      => "13",
+               "255.252.0.0"      => "14",
+               "255.254.0.0"      => "15",
+               "255.255.0.0"      => "16",
+               "255.255.128.0"    => "17",
+               "255.255.192.0"    => "18",
+               "255.255.224.0"    => "19",
+               "255.255.240.0"    => "20",
+               "255.255.248.0"    => "21",
+               "255.255.252.0"    => "22",
+               "255.255.254.0"    => "23",
+               "255.255.255.0"    => "24",
+               "255.255.255.128"  => "25",
+               "255.255.255.192"  => "26",
+               "255.255.255.224"  => "27",
+               "255.255.255.240"  => "28",
+               "255.255.255.248"  => "29",
+               "255.255.255.252"  => "30",
+               "255.255.255.254"  => "31",
+               "255.255.255.255"  => "32" }.freeze
+
+      def hex2ip(hex_data)
+        # Cleanup hex data
+        hex_ip = hex_data.to_s.downcase.gsub(/[^0-9a-f]/, "")
+
+        # Check hex data format (IP is a 32bit integer, so should be 8 chars long)
+        return nil if hex_ip.length != hex_data.length || hex_ip.length != 8
+
+        # Extract octets from hex data
+        octets = hex_ip.scan(/../).reverse.collect { |octet| [octet].pack("H2").unpack("C").first }
+
+        # Validate IP
+        ip = octets.join(".")
+        begin
+          IPAddr.new(ip, Socket::AF_INET).to_s
+        rescue ArgumentError
+          Chef::Log.debug("Invalid IP address data: hex=#{hex_ip}, ip=#{ip}")
+          return nil
+        end
+      end
 
-  def load_current_resource
-    self.is_running = false
+      def whyrun_supported?
+        true
+      end
 
-    # cidr or quad dot mask
-    if @new_resource.netmask
-      new_ip = IPAddr.new("#{@new_resource.target}/#{@new_resource.netmask}")
-    else
-      new_ip = IPAddr.new(@new_resource.target)
-    end
+      def load_current_resource
+        self.is_running = false
+
+        # cidr or quad dot mask
+        new_ip = if new_resource.netmask
+                   IPAddr.new("#{new_resource.target}/#{new_resource.netmask}")
+                 else
+                   IPAddr.new(new_resource.target)
+                 end
+
+        # For linux, we use /proc/net/route file to read proc table info
+        return if node[:os] != "linux"
+
+        route_file = ::File.open("/proc/net/route", "r")
+
+        # Read all routes
+        while (line = route_file.gets)
+          # Get all the fields for a route
+          _, destination, gateway, _, _, _, _, mask = line.split
+
+          # Convert hex-encoded values to quad-dotted notation (e.g. 0064A8C0 => 192.168.100.0)
+          destination = hex2ip(destination)
+          gateway = hex2ip(gateway)
+          mask = hex2ip(mask)
+
+          # Skip formatting lines (header, etc)
+          next unless destination && gateway && mask
+          Chef::Log.debug("#{new_resource} system has route: dest=#{destination} mask=#{mask} gw=#{gateway}")
+
+          # check if what were trying to configure is already there
+          # use an ipaddr object with ip/mask this way we can have
+          # a new resource be in cidr format (i don't feel like
+          # expanding bitmask by hand.
+          #
+          running_ip = IPAddr.new("#{destination}/#{mask}")
+          Chef::Log.debug("#{new_resource} new ip: #{new_ip.inspect} running ip: #{running_ip.inspect}")
+          self.is_running = true if running_ip == new_ip && gateway == new_resource.gateway
+        end
 
-    # For linux, we use /proc/net/route file to read proc table info
-    if node[:os] == "linux"
-      route_file = ::File.open("/proc/net/route", "r")
-
-      # Read all routes
-      while (line = route_file.gets)
-        # Get all the fields for a route
-        iface, destination, gateway, flags, refcnt, use, metric, mask, mtu, window, irtt = line.split
-
-        # Convert hex-encoded values to quad-dotted notation (e.g. 0064A8C0 => 192.168.100.0)
-        destination = hex2ip(destination)
-        gateway = hex2ip(gateway)
-        mask = hex2ip(mask)
-
-        # Skip formatting lines (header, etc)
-        next unless destination && gateway && mask
-        Chef::Log.debug("#{@new_resource} system has route: dest=#{destination} mask=#{mask} gw=#{gateway}")
-
-        # check if what were trying to configure is already there
-        # use an ipaddr object with ip/mask this way we can have
-        # a new resource be in cidr format (i don't feel like
-        # expanding bitmask by hand.
-        #
-        running_ip = IPAddr.new("#{destination}/#{mask}")
-        Chef::Log.debug("#{@new_resource} new ip: #{new_ip.inspect} running ip: #{running_ip.inspect}")
-        self.is_running = true if running_ip == new_ip && gateway == @new_resource.gateway
+        route_file.close
       end
 
-      route_file.close
-    end
-  end
+      def action_add
+        # check to see if load_current_resource found the route
+        if is_running
+          Chef::Log.debug("#{new_resource} route already active - nothing to do")
+        else
+          command = generate_command(:add)
+          converge_by("run #{command.join(' ')} to add route") do
+            shell_out_compact!(command)
+            Chef::Log.info("#{new_resource} added")
+          end
+        end
 
-  def action_add
-    # check to see if load_current_resource found the route
-    if is_running
-      Chef::Log.debug("#{@new_resource} route already active - nothing to do")
-    else
-      command = generate_command(:add)
-      converge_by ("run #{ command } to add route") do
-        run_command( :command => command )
-        Chef::Log.info("#{@new_resource} added")
+        # for now we always write the file (ugly but its what it is)
+        generate_config
       end
-    end
 
-    #for now we always write the file (ugly but its what it is)
-    generate_config
-  end
+      def action_delete
+        if is_running
+          command = generate_command(:delete)
+          converge_by("run #{command.join(' ')} to delete route ") do
+            shell_out_compact!(command)
+            Chef::Log.info("#{new_resource} removed")
+          end
+        else
+          Chef::Log.debug("#{new_resource} route does not exist - nothing to do")
+        end
 
-  def action_delete
-    if is_running
-      command = generate_command(:delete)
-      converge_by ("run #{ command } to delete route ") do
-        run_command( :command => command )
-        Chef::Log.info("#{@new_resource} removed")
+        # for now we always write the file (ugly but its what it is)
+        generate_config
       end
-    else
-      Chef::Log.debug("#{@new_resource} route does not exist - nothing to do")
-    end
-
-    #for now we always write the file (ugly but its what it is)
-    generate_config
-  end
 
-  def generate_config
-    conf = Hash.new
-    case node[:platform]
-    when "centos", "redhat", "fedora"
-      # walk the collection
-      run_context.resource_collection.each do |resource|
-        if resource.is_a? Chef::Resource::Route
-          # default to eth0
-          if resource.device
-            dev = resource.device
-          else
-            dev = "eth0"
+      def generate_config
+        conf = {}
+        case node[:platform]
+        when "centos", "redhat", "fedora"
+          # walk the collection
+          run_context.resource_collection.each do |resource|
+            next unless resource.is_a? Chef::Resource::Route
+            # default to eth0
+            dev = if resource.device
+                    resource.device
+                  else
+                    "eth0"
+                  end
+
+            conf[dev] = "" if conf[dev].nil?
+            case @action
+            when :add
+              conf[dev] << config_file_contents(:add, target: resource.target, netmask: resource.netmask, gateway: resource.gateway) if resource.action == [:add]
+            when :delete
+              # need to do this for the case when the last route on an int
+              # is removed
+              conf[dev] << config_file_contents(:delete)
+            end
           end
-
-          conf[dev] = String.new if conf[dev].nil?
-          case @action
-          when :add
-            conf[dev] << config_file_contents(:add, :target => resource.target, :netmask => resource.netmask, :gateway => resource.gateway) if resource.action == [:add]
-          when :delete
-            # need to do this for the case when the last route on an int
-            # is removed
-            conf[dev] << config_file_contents(:delete)
+          conf.each do |k, v|
+            network_file_name = "/etc/sysconfig/network-scripts/route-#{k}"
+            converge_by("write route route.#{k}\n#{conf[k]} to #{network_file_name}") do
+              network_file = ::File.new(network_file_name, "w")
+              network_file.puts(conf[k])
+              Chef::Log.debug("#{new_resource} writing route.#{k}\n#{conf[k]}")
+              network_file.close
+            end
           end
         end
       end
-      conf.each do |k, v|
-        network_file_name = "/etc/sysconfig/network-scripts/route-#{k}"
-        converge_by ("write route route.#{k}\n#{conf[k]} to #{ network_file_name }") do
-          network_file = ::File.new(network_file_name, "w")
-          network_file.puts(conf[k])
-          Chef::Log.debug("#{@new_resource} writing route.#{k}\n#{conf[k]}")
-          network_file.close
+
+      def generate_command(action)
+        target = new_resource.target
+        target = "#{target}/#{MASK[new_resource.netmask.to_s]}" if new_resource.netmask
+
+        case action
+        when :add
+          command = [ "ip", "route", "replace", target ]
+          command += [ "via", new_resource.gateway ] if new_resource.gateway
+          command += [ "dev", new_resource.device ] if new_resource.device
+        when :delete
+          command = [ "ip", "route", "delete", target ]
+          command += [ "via", new_resource.gateway ] if new_resource.gateway
         end
-      end
-    end
-  end
 
-  def generate_command(action)
-    common_route_items = ""
-    common_route_items << "/#{MASK[@new_resource.netmask.to_s]}" if @new_resource.netmask
-    common_route_items << " via #{@new_resource.gateway} " if @new_resource.gateway
-
-    case action
-    when :add
-      command = "ip route replace #{@new_resource.target}"
-      command << common_route_items
-      command << " dev #{@new_resource.device} " if @new_resource.device
-    when :delete
-      command = "ip route delete #{@new_resource.target}"
-      command << common_route_items
-    end
+        command
+      end
 
-    return command
-  end
+      def config_file_contents(action, options = {})
+        content = ""
+        case action
+        when :add
+          content << (options[:target]).to_s
+          content << "/#{options[:netmask]}" if options[:netmask]
+          content << " via #{options[:gateway]}" if options[:gateway]
+          content << "\n"
+        end
 
-  def config_file_contents(action, options = {})
-    content = ""
-    case action
-    when :add
-      content << "#{options[:target]}"
-      content << "/#{options[:netmask]}" if options[:netmask]
-      content << " via #{options[:gateway]}" if options[:gateway]
-      content << "\n"
+        content
+      end
     end
-
-    return content
   end
 end