puppet 4.1.0 → 5.0.0

data/lib/puppet/util/logging.rb

@@ -1,9 +1,12 @@
 # A module to make logging a bit easier.
 require 'puppet/util/log'
 require 'puppet/error'
+require 'puppet/util/multi_match.rb'
+
 require 'facter'
 
-module Puppet::Util::Logging
+module Puppet::Util
+module Logging
 
   def send_log(level, message)
     Puppet::Util::Log.create({:level => level, :source => log_source, :message => message}.merge(log_metadata))
@@ -52,7 +55,7 @@ module Puppet::Util::Logging
       backtrace = []
       build_exception_trace(backtrace, exception, trace)
       Puppet::Util::Log.create({
-          :level => :err,
+          :level => options[:level] || :err,
           :source => log_source,
           :message => exception.basic_message,
           :issue_code => exception.issue_code,
@@ -77,7 +80,7 @@ module Puppet::Util::Logging
     if exception.respond_to?(:original)
       original =  exception.original
       unless original.nil?
-        arr << 'Wrapped exception:'
+        arr << _('Wrapped exception:')
         arr << original.message
         build_exception_trace(arr, original, trace)
       end
@@ -100,7 +103,7 @@ module Puppet::Util::Logging
       arr << Puppet::Util.pretty_backtrace(exception.backtrace)
     end
     if exception.respond_to?(:original) and exception.original
-      arr << "Wrapped exception:"
+      arr << _("Wrapped exception:")
       arr << format_exception(exception.original, :default, trace)
     end
     arr.flatten.join("\n")
@@ -148,6 +151,43 @@ module Puppet::Util::Logging
     key ||= "#{file}:#{line}"
     issue_deprecation_warning(message, key, file, line, false)
   end
+  MM = MultiMatch
+  FILE_AND_LINE = MM::TUPLE
+  FILE_NO_LINE  = MM.new(MM::NOT_NIL, nil).freeze
+  NO_FILE_LINE  = MM.new(nil, MM::NOT_NIL).freeze
+
+  # Logs a (non deprecation) warning once for a given key.
+  #
+  # @param kind [String] The kind of warning. The
+  #   kind must be one of the defined kinds for the Puppet[:disable_warnings] setting.
+  # @param message [String] The message to log (logs via warning)
+  # @param key [String] Key used to make this warning unique
+  # @param file [String,nil] the File related to the warning
+  # @param line [Integer,nil] the Line number related to the warning
+  #   warning as unique
+  #
+  # Either :file and :line and/or :key must be passed.
+  def warn_once(kind, key, message, file = nil, line = nil)
+    return if Puppet[:disable_warnings].include?(kind)
+    $unique_warnings ||= {}
+    if $unique_warnings.length < 100 then
+      if (! $unique_warnings.has_key?(key)) then
+        $unique_warnings[key] = message
+        call_trace =
+        case MM.new(file, line)
+        when FILE_AND_LINE
+          _("\n   (at %{file}:%{line})") % { file: file, line: line }
+        when FILE_NO_LINE
+          _("\n   (in %{file})") % { file: file }
+        when NO_FILE_LINE
+          _("\n   (in unknown file, line %{line})") % { line: line }
+        else
+          _("\n   (file & line not available)")
+        end
+        warning("#{message}#{call_trace}")
+      end
+    end
+  end
 
   def get_deprecation_offender()
     # we have to put this in its own method to simplify testing; we need to be able to mock the offender results in
@@ -163,6 +203,7 @@ module Puppet::Util::Logging
   end
 
   def clear_deprecation_warnings
+    $unique_warnings.clear if $unique_warnings
     $deprecation_warnings.clear if $deprecation_warnings
   end
 
@@ -183,7 +224,8 @@ module Puppet::Util::Logging
     # find the same offender, and we'd end up logging it again.
     $logged_deprecation_warnings ||= {}
 
-    File.open(deprecations_file, "a") do |f|
+    # Deprecation messages are UTF-8 as they are produced by Ruby
+    Puppet::FileSystem.open(deprecations_file, nil, "a:UTF-8") do |f|
       if ($deprecation_warnings) then
         $deprecation_warnings.each do |offender, message|
           if (! $logged_deprecation_warnings.has_key?(offender)) then
@@ -237,10 +279,13 @@ module Puppet::Util::Logging
       key ||= (offender = get_deprecation_offender)
       if (! $deprecation_warnings.has_key?(key)) then
         $deprecation_warnings[key] = message
+        # split out to allow translation
+        unknown = _('unknown')
         call_trace = use_caller ?
           (offender || get_deprecation_offender).join('; ') :
-          "#{file || 'unknown'}:#{line || 'unknown'}"
-        warning("#{message}\n   (at #{call_trace})")
+          "#{file || unknown}:#{line || unknown}"
+        #TRANSLATORS error message with origin location
+        warning(_("%{message}\n   (at %{call_trace})") % { message: message, call_trace: call_trace })
       end
     end
   end
@@ -266,3 +311,4 @@ module Puppet::Util::Logging
     to_s
   end
 end
+end

data/lib/puppet/util/metric.rb

@@ -4,17 +4,24 @@ require 'puppet/network/format_support'
 
 # A class for handling metrics.  This is currently ridiculously hackish.
 class Puppet::Util::Metric
+  include Puppet::Util::PsychSupport
   include Puppet::Network::FormatSupport
 
   attr_accessor :type, :name, :value, :label
   attr_writer :values
 
   def self.from_data_hash(data)
-    metric = new(data['name'], data['label'])
-    metric.values = data['values']
+    metric = allocate
+    metric.initialize_from_hash(data)
     metric
   end
 
+  def initialize_from_hash(data)
+    @name = data['name']
+    @label = data['label'] || self.class.labelize(@name)
+    @values = data['values']
+  end
+
   def to_data_hash
     {
       'name' => @name,
@@ -23,10 +30,6 @@ class Puppet::Util::Metric
     }
   end
 
-  def to_pson(*args)
-    to_data_hash.to_pson(*args)
-  end
-
   # Return a specific value
   def [](name)
     if value = @values.find { |v| v[0] == name }

data/lib/puppet/util/monkey_patches.rb

@@ -18,16 +18,6 @@ module RDoc
   end
 end
 
-class Symbol
-  def <=> (other)
-    self.to_s <=> other.to_s
-  end unless method_defined? '<=>'
-
-  def intern
-    self
-  end unless method_defined? 'intern'
-end
-
 class Object
   # ActiveSupport 2.3.x mixes in a dangerous method
   # that can cause rspec to fork bomb
@@ -37,54 +27,6 @@ class Object
   end
 end
 
-require 'fcntl'
-class IO
-  def self.binwrite(name, string, offset = nil)
-    # Determine if we should truncate or not.  Since the truncate method on a
-    # file handle isn't implemented on all platforms, safer to do this in what
-    # looks like the libc / POSIX flag - which is usually pretty robust.
-    # --daniel 2012-03-11
-    mode = Fcntl::O_CREAT | Fcntl::O_WRONLY | (offset.nil? ? Fcntl::O_TRUNC : 0)
-
-    # We have to duplicate the mode because Ruby on Windows is a bit precious,
-    # and doesn't actually carry over the mode.  It won't work to just use
-    # open, either, because that doesn't like our system modes and the default
-    # open bits don't do what we need, which is awesome. --daniel 2012-03-30
-    IO.open(IO::sysopen(name, mode), mode) do |f|
-      # ...seek to our desired offset, then write the bytes.  Don't try to
-      # seek past the start of the file, eh, because who knows what platform
-      # would legitimately blow up if we did that.
-      #
-      # Double-check the positioning, too, since destroying data isn't my idea
-      # of a good time. --daniel 2012-03-11
-      target = [0, offset.to_i].max
-      unless (landed = f.sysseek(target, IO::SEEK_SET)) == target
-        raise "unable to seek to target offset #{target} in #{name}: got to #{landed}"
-      end
-
-      f.syswrite(string)
-    end
-  end unless singleton_methods.include?(:binwrite)
-end
-
-class Range
-  def intersection(other)
-    raise ArgumentError, 'value must be a Range' unless other.kind_of?(Range)
-    return unless other === self.first || self === other.first
-
-    start = [self.first, other.first].max
-    if self.exclude_end? && self.last <= other.last
-      start ... self.last
-    elsif other.exclude_end? && self.last >= other.last
-      start ... other.last
-    else
-      start .. [ self.last, other.last ].min
-    end
-  end unless method_defined? :intersection
-
-  alias_method :&, :intersection unless method_defined? :&
-end
-
 # (#19151) Reject all SSLv2 ciphers and handshakes
 require 'openssl'
 class OpenSSL::SSL::SSLContext
@@ -93,7 +35,9 @@ class OpenSSL::SSL::SSLContext
   else
     DEFAULT_PARAMS[:options] = OpenSSL::SSL::OP_NO_SSLv2 | OpenSSL::SSL::OP_NO_SSLv3
   end
-  DEFAULT_PARAMS[:ciphers] << ':!SSLv2'
+  if DEFAULT_PARAMS[:ciphers]
+    DEFAULT_PARAMS[:ciphers] << ':!SSLv2'
+  end
 
   alias __original_initialize initialize
   private :__original_initialize
@@ -114,15 +58,20 @@ if Puppet::Util::Platform.windows?
   require 'openssl'
 
   class OpenSSL::X509::Store
+    @puppet_certs_loaded = false
     alias __original_set_default_paths set_default_paths
     def set_default_paths
       # This can be removed once openssl integrates with windows
-      # cert store, see http://rt.openssl.org/Ticket/Display.html?id=2158
-      Puppet::Util::Windows::RootCerts.instance.to_a.uniq.each do |x509|
-        begin
-          add_cert(x509)
-        rescue OpenSSL::X509::StoreError => e
-          warn "Failed to add #{x509.subject.to_s}"
+      # cert store, see https://rt.openssl.org/Ticket/Display.html?id=2158
+      unless @puppet_certs_loaded
+        @puppet_certs_loaded = true
+
+        Puppet::Util::Windows::RootCerts.instance.to_a.uniq { |cert| cert.to_der }.each do |x509|
+          begin
+            add_cert(x509)
+          rescue OpenSSL::X509::StoreError => e
+            warn "Failed to add #{x509.subject.to_s}"
+          end
         end
       end
 
@@ -130,3 +79,30 @@ if Puppet::Util::Platform.windows?
     end
   end
 end
+
+# The Enumerable#uniq method was added in Ruby 2.4.0 (https://bugs.ruby-lang.org/issues/11090)
+# This is a backport to earlier Ruby versions.
+#
+unless Enumerable.instance_methods.include?(:uniq)
+  module Enumerable
+    def uniq
+      result = []
+      uniq_map = {}
+      if block_given?
+        each do |value|
+          key = yield value
+          next if uniq_map.has_key?(key)
+          uniq_map[key] = true
+          result << value
+        end
+      else
+        each do |value|
+          next if uniq_map.has_key?(value)
+          uniq_map[value] = true
+          result << value
+        end
+      end
+      result
+    end
+  end
+end

data/lib/puppet/util/multi_match.rb

@@ -0,0 +1,51 @@
+# MultiMatch allows multiple values to be tested at once in a case expression.
+# This class is needed since Array does not implement the === operator to mean
+# "each v === other.each v". 
+#
+# This class is useful in situations when the Puppet Type System cannot be used
+# (e.g. in Logging, since it needs to be able to log very early in the initialization
+# cycle of puppet)
+#
+# Typically used with the constants
+# NOT_NIL
+# TUPLE
+# TRIPLE
+# 
+# which test against single NOT_NIL value, Array with two NOT_NIL, and Array with three NOT_NIL
+#
+module Puppet::Util
+class MultiMatch
+  attr_reader :values
+
+  def initialize(*values)
+    @values = values
+  end
+
+  def ===(other)
+    lv = @values  # local var is faster than instance var
+    case other
+    when MultiMatch
+      return false unless other.values.size == values.size
+      other.values.each_with_index {|v, i| return false unless lv[i] === v || v === lv[i]}
+    when Array
+      return false unless other.size == values.size
+      other.each_with_index {|v, i| return false unless lv[i] === v || v === lv[i]}
+    else
+      false
+    end
+    true
+  end
+
+  # Matches any value that is not nil using the === operator.
+  #
+  class MatchNotNil
+    def ===(v)
+      !v.nil?
+    end
+  end
+
+  NOT_NIL = MatchNotNil.new().freeze
+  TUPLE = MultiMatch.new(NOT_NIL, NOT_NIL).freeze
+  TRIPLE = MultiMatch.new(NOT_NIL, NOT_NIL, NOT_NIL).freeze
+end
+end

data/lib/puppet/util/network_device/cisco/device.rb

@@ -47,7 +47,13 @@ class Puppet::Util::NetworkDevice::Cisco::Device < Puppet::Util::NetworkDevice::
   end
 
   def execute(cmd)
-    transport.command(cmd)
+    transport.command(cmd) do |out|
+      if out =~ /^%/mo or out =~ /^Command rejected:/mo
+        # strip off the command just sent
+        error = out.sub(cmd,'')
+        Puppet.err _("Error while executing '%{cmd}', device returned: %{error}") % { cmd: cmd, error: error }
+      end
+    end
   end
 
   def login
@@ -61,7 +67,7 @@ class Puppet::Util::NetworkDevice::Cisco::Device < Puppet::Util::NetworkDevice::
   end
 
   def enable
-    raise "Can't issue \"enable\" to enter privileged, no enable password set" unless enable_password
+    raise _("Can't issue \"enable\" to enter privileged, no enable password set") unless enable_password
     transport.command("enable", :prompt => /^Password:/)
     transport.command(enable_password)
   end
@@ -190,7 +196,7 @@ class Puppet::Util::NetworkDevice::Cisco::Device < Puppet::Util::NetworkDevice::
         end
         vlans[vlan[:name]] = vlan
       when /^\s+([a-zA-Z0-9,\/. ]+)\s*$/
-        raise "invalid sh vlan summary output" unless vlan
+        raise _("invalid sh vlan summary output") unless vlan
         if $1.strip.length > 0
           vlan[:interfaces] += $1.strip.split(/\s*,\s*/).map{ |ifn| canonalize_ifname(ifn) }
         end
@@ -202,13 +208,19 @@ class Puppet::Util::NetworkDevice::Cisco::Device < Puppet::Util::NetworkDevice::
 
   def update_vlan(id, is = {}, should = {})
     if should[:ensure] == :absent
-      Puppet.info "Removing #{id} from device vlan"
+      Puppet.info _("Removing %{id} from device vlan") % { id: id }
       execute("conf t")
       execute("no vlan #{id}")
       execute("exit")
       return
     end
 
+    # Cisco VLANs are supposed to be alphanumeric only
+    if should[:description] =~ /[^\w]/
+      Puppet.err _("Invalid VLAN name '%{name}' for Cisco device.\nVLAN name must be alphanumeric, no spaces or special characters.") % { name: should[:description] }
+      return
+    end
+    
     # We're creating or updating an entry
     execute("conf t")
     execute("vlan #{id}")
@@ -234,20 +246,26 @@ class Puppet::Util::NetworkDevice::Cisco::Device < Puppet::Util::NetworkDevice::
           trunking[:mode] = :trunk
         when "static access"
           trunking[:mode] = :access
+        when "dynamic auto"
+          trunking[:mode] = 'dynamic auto'
+        when "dynamic desirable"
+          trunking[:mode] = 'dynamic desirable'
         else
-          raise "Unknown switchport mode: #{$1} for #{interface}"
+          raise _("Unknown switchport mode: %{mode} for %{interface}") % { mode: $1, interface: interface }
         end
       when /^Administrative Trunking Encapsulation:\s+(.*)$/
         case $1
         when "dot1q","isl"
-          trunking[:encapsulation] = $1.to_sym if trunking[:mode] == :trunk
+          trunking[:encapsulation] = $1.to_sym if trunking[:mode] != :access
+        when "negotiate"
+          trunking[:encapsulation] = :negotiate
         else
-          raise "Unknown switchport encapsulation: #{$1} for #{interface}"
+          raise _("Unknown switchport encapsulation: %{value} for %{interface}") % { value: $1, interface: interface }
         end
-      when /^Access Mode VLAN:\s+(.*) \(\(Inactive\)\)$/
-        # nothing
-      when /^Access Mode VLAN:\s+(.*) \(.*\)$/
-        trunking[:native_vlan] = $1 if trunking[:mode] == :access
+      when /^Access Mode VLAN:\s+(.*) \((.*)\)$/
+        trunking[:access_vlan] = $1 if $2 != '(Inactive)'
+      when /^Trunking Native Mode VLAN:\s+(.*) \(.*\)$/
+        trunking[:native_vlan] = $1
       when /^Trunking VLANs Enabled:\s+(.*)$/
         next if trunking[:mode] == :access
         vlans = $1

data/lib/puppet/util/network_device/cisco/interface.rb

@@ -19,17 +19,18 @@ class Puppet::Util::NetworkDevice::Cisco::Interface
     :description   => [1, "description %s"],
     :speed         => [2, "speed %s"],
     :duplex        => [3, "duplex %s"],
-    :native_vlan   => [4, "switchport access vlan %s"],
-    :encapsulation => [5, "switchport trunk encapsulation %s"],
-    :mode          => [6, "switchport mode %s"],
-    :allowed_trunk_vlans => [7, "switchport trunk allowed vlan %s"],
-    :etherchannel  => [8, ["channel-group %s", "port group %s"]],
-    :ipaddress     => [9,
+    :encapsulation => [4, "switchport trunk encapsulation %s"],
+    :mode          => [5, "switchport mode %s"],
+    :access_vlan   => [6, "switchport access vlan %s"],
+    :native_vlan   => [7, "switchport trunk native vlan %s"],
+    :allowed_trunk_vlans => [8, "switchport trunk allowed vlan %s"],
+    :etherchannel  => [9, ["channel-group %s", "port group %s"]],
+    :ipaddress     => [10,
       lambda do |prefix,ip,option|
         ip.ipv6? ? "ipv6 address #{ip.to_s}/#{prefix} #{option}" :
                    "ip address #{ip.to_s} #{netmask(Socket::AF_INET,prefix)}"
       end],
-      :ensure        => [10, lambda { |value| value == :present ? "no shutdown" : "shutdown" } ]
+    :ensure        => [11, lambda { |value| value == :present ? "no shutdown" : "shutdown" } ]
   }
 
   def update(is={}, should={})
@@ -37,8 +38,15 @@ class Puppet::Util::NetworkDevice::Cisco::Interface
     command("conf t")
     command("interface #{name}")
 
-    # apply changes in a defined orders for cisco IOS devices
+    # apply changes in a defined order for cisco IOS devices
     [is.keys, should.keys].flatten.uniq.sort {|a,b| COMMANDS[a][0] <=> COMMANDS[b][0] }.each do |property|
+      # Work around for old documentation which shows :native_vlan used for access vlan
+      if property == :access_vlan and should[:mode] != :trunk and should[:access_vlan].nil?
+        should[:access_vlan] = should[:native_vlan]
+      end
+
+      Puppet.debug("comparing #{property}: #{is[property]} == #{should[property]}")
+
       # They're equal, so do nothing.
       next if is[property] == should[property]
 
@@ -76,7 +84,11 @@ class Puppet::Util::NetworkDevice::Cisco::Interface
 
   def command(command)
     transport.command(command) do |out|
-      Puppet.err "Error while executing #{command}, device returned #{out}" if out =~ /^%/mo
+      if out =~ /^%/mo or out =~ /^Command rejected:/mo
+        # strip off the command just sent
+        error = out.sub(command,'')
+        Puppet.err _("Error while executing '%{command}', device returned: %{error}") % { command: command, error: error }
+      end
     end
   end
 end

data/lib/puppet/util/network_device/config.rb

@@ -52,26 +52,26 @@ class Puppet::Util::NetworkDevice::Config
           when /^\[([\w.-]+)\]\s*$/ # [device.fqdn]
             name = $1
             name.chomp!
-            raise Puppet::Error, "Duplicate device found at line #{count}, already found at #{device.line}" if devices.include?(name)
+            raise Puppet::Error, _("Duplicate device found at line %{count}, already found at %{line}") % { count: count, line: device.line } if devices.include?(name)
             device = OpenStruct.new
             device.name = name
             device.line = count
             device.options = { :debug => false }
             Puppet.debug "found device: #{device.name} at #{device.line}"
             devices[name] = device
-          when /^\s*(type|url|debug)(\s+(.+))*$/
+          when /^\s*(type|url|debug)(\s+(.+)\s*)*$/
             parse_directive(device, $1, $3, count)
           else
-            raise Puppet::Error, "Invalid line #{count}: #{line}"
+            raise Puppet::Error, _("Invalid line %{count}: %{line}") % { count: count, line: line }
           end
           count += 1
         }
       }
     rescue Errno::EACCES => detail
-      Puppet.err "Configuration error: Cannot read #{@file}; cannot serve"
+      Puppet.err _("Configuration error: Cannot read %{file}; cannot serve") % { file: @file }
       #raise Puppet::Error, "Cannot read #{@config}"
     rescue Errno::ENOENT => detail
-      Puppet.err "Configuration error: '#{@file}' does not exit; cannot serve"
+      Puppet.err _("Configuration error: '%{file}' does not exit; cannot serve") % { file: @file }
     end
 
     @devices = devices
@@ -85,13 +85,13 @@ class Puppet::Util::NetworkDevice::Config
       begin
         URI.parse(value)
       rescue URI::InvalidURIError
-        raise Puppet::Error, "#{value} is an invalid url"
+        raise Puppet::Error, _("%{value} is an invalid url") % { value: value }
       end
       device.url = value
     when "debug"
       device.options[:debug] = true
     else
-      raise Puppet::Error, "Invalid argument '#{var}' at line #{count}"
+      raise Puppet::Error, _("Invalid argument '%{var}' at line %{count}") % { var: var, count: count }
     end
   end
 

data/lib/puppet/util/network_device/transport/ssh.rb

@@ -13,7 +13,7 @@ class Puppet::Util::NetworkDevice::Transport::Ssh < Puppet::Util::NetworkDevice:
     super()
     @verbose = verbose
     unless Puppet.features.ssh?
-      raise 'Connecting with ssh to a network device requires the \'net/ssh\' ruby library'
+      raise _('Connecting with ssh to a network device requires the \'net/ssh\' ruby library')
     end
   end
 
@@ -33,21 +33,21 @@ class Puppet::Util::NetworkDevice::Transport::Ssh < Puppet::Util::NetworkDevice:
       Puppet.debug("connecting to #{host} as #{user}")
       @ssh = Net::SSH.start(host, user, :port => port, :password => password, :timeout => timeout)
     rescue TimeoutError
-      raise TimeoutError, "timed out while opening an ssh connection to the host", $!.backtrace
+      raise TimeoutError, _("timed out while opening an ssh connection to the host"), $!.backtrace
     rescue Net::SSH::AuthenticationFailed
-      raise Puppet::Error, "SSH authentication failure connecting to #{host} as #{user}", $!.backtrace
+      raise Puppet::Error, _("SSH authentication failure connecting to %{host} as %{user}") % { host: host, user: user }, $!.backtrace
     rescue Net::SSH::Exception
-      raise Puppet::Error, "SSH connection failure to #{host}", $!.backtrace
+      raise Puppet::Error, _("SSH connection failure to %{host}") % { host: host }, $!.backtrace
     end
 
     @buf = ""
     @eof = false
     @channel = nil
     @ssh.open_channel do |channel|
-      channel.request_pty { |ch,success| raise "failed to open pty" unless success }
+      channel.request_pty { |ch,success| raise _("failed to open pty") unless success }
 
       channel.send_channel_request("shell") do |ch, success|
-        raise "failed to open ssh shell channel" unless success
+        raise _("failed to open ssh shell channel") unless success
 
         ch.on_data { |_,data| @buf << data }
         ch.on_extended_data { |_,type,data|  @buf << data if type == 1 }
@@ -68,9 +68,13 @@ class Puppet::Util::NetworkDevice::Transport::Ssh < Puppet::Util::NetworkDevice:
   end
 
   def close
-    @channel.close if @channel
-    @channel = nil
-    @ssh.close if @ssh
+    begin
+      @channel.close if @channel
+      @channel = nil
+      @ssh.close if @ssh
+    rescue IOError
+      Puppet.debug "device terminated ssh session impolitely"
+    end
   end
 
   def expect(prompt)

data/lib/puppet/util/network_device/transport/telnet.rb

@@ -1,44 +1,47 @@
 require 'puppet/util/network_device'
 require 'puppet/util/network_device/transport'
 require 'puppet/util/network_device/transport/base'
-require 'net/telnet'
-
-class Puppet::Util::NetworkDevice::Transport::Telnet < Puppet::Util::NetworkDevice::Transport::Base
-    def initialize(verbose = false)
-      super()
-      @verbose = verbose
-    end
-
-    def handles_login?
-      false
-    end
-
-    def connect
-      @telnet = Net::Telnet::new("Host" => host, "Port" => port || 23,
-                                 "Timeout" => 10,
-                                 "Prompt" => default_prompt)
-    end
-
-    def close
-      @telnet.close if @telnet
-      @telnet = nil
-    end
-
-    def expect(prompt)
-      @telnet.waitfor(prompt) do |out|
-        yield out if block_given?
+
+if Puppet.features.telnet?
+  require 'net/telnet'
+
+  class Puppet::Util::NetworkDevice::Transport::Telnet < Puppet::Util::NetworkDevice::Transport::Base
+      def initialize(verbose = false)
+        super()
+        @verbose = verbose
+      end
+
+      def handles_login?
+        false
+      end
+
+      def connect
+        @telnet = Net::Telnet::new("Host" => host, "Port" => port || 23,
+                                   "Timeout" => 10,
+                                   "Prompt" => default_prompt)
       end
-    end
 
-    def command(cmd, options = {})
-      send(cmd)
-      expect(options[:prompt] || default_prompt) do |output|
-        yield output if block_given?
+      def close
+        @telnet.close if @telnet
+        @telnet = nil
       end
-    end
 
-    def send(line)
-      Puppet.debug("telnet: send #{line}") if @verbose
-      @telnet.puts(line)
-    end
+      def expect(prompt)
+        @telnet.waitfor(prompt) do |out|
+          yield out if block_given?
+        end
+      end
+
+      def command(cmd, options = {})
+        send(cmd)
+        expect(options[:prompt] || default_prompt) do |output|
+          yield output if block_given?
+        end
+      end
+
+      def send(line)
+        Puppet.debug("telnet: send #{line}") if @verbose
+        @telnet.puts(line)
+      end
+  end
 end