--- /dev/null
+diff -ruN a/lib/puppet/provider/network_config/interfaces.rb b/lib/puppet/provider/network_config/interfaces.rb
+--- a/lib/puppet/provider/network_config/interfaces.rb 2020-04-14 15:30:26.488316830 +0800
++++ b/lib/puppet/provider/network_config/interfaces.rb 2020-04-14 15:30:11.388316418 +0800
+@@ -14,7 +14,7 @@
+ desc "Debian interfaces style provider"
+
+ confine :osfamily => :debian
+- defaultfor :osfamily => :debian
++ defaultfor :operatingsystem => [:debian, :ubuntu]
+
+ has_feature :provider_options
+ has_feature :hotpluggable
+diff -ruN a/lib/puppet/provider/network_config/poky-stx.rb b/lib/puppet/provider/network_config/poky-stx.rb
+--- a/lib/puppet/provider/network_config/poky-stx.rb 1970-01-01 08:00:00.000000000 +0800
++++ b/lib/puppet/provider/network_config/poky-stx.rb 2020-04-15 15:40:31.266687901 +0800
+@@ -0,0 +1,310 @@
++require 'puppetx/filemapper'
++
++Puppet::Type.type(:network_config).provide(:pokystx) do
++ # Wind River Linux network_config interfaces provider.
++ #
++ # This provider uses the filemapper mixin to map the interfaces file to a
++ # collection of network_config providers, and back.
++ #
++ include PuppetX::FileMapper
++
++ desc "Poky starlingX interfaces style provider"
++
++ defaultfor :operatingsystem => :'poky-stx'
++
++ has_feature :provider_options
++ has_feature :hotpluggable
++
++ def select_file
++ '/var/run/interfaces.puppet'
++ end
++
++ def self.target_files
++ ['/var/run/interfaces.puppet']
++ end
++
++ class MalformedInterfacesError < Puppet::Error
++ def initialize(msg = nil)
++ msg = 'Malformed poky-stx interfaces file; cannot instantiate network_config resources' if msg.nil?
++ super
++ end
++ end
++
++ def self.raise_malformed
++ @failed = true
++ raise MalformedInterfacesError
++ end
++
++ class Instance
++
++ attr_reader :name
++
++ # Booleans
++ attr_accessor :onboot, :hotplug
++
++
++ # These fields are going to get rearranged to resolve issue 16
++ # https://github.com/adrienthebo/puppet-network/issues/16
++ attr_accessor :ipaddress, :netmask, :family, :method, :mtu
++
++ # Options hash
++ attr_reader :options
++
++ def initialize(name)
++ @name = name
++
++ @options = Hash.new {|hash, key| hash[key] = []}
++ end
++
++ def to_hash
++ h = {
++ :name => @name,
++ :onboot => @onboot,
++ :hotplug => @hotplug,
++ :ipaddress => @ipaddress,
++ :netmask => @netmask,
++ :family => @family,
++ :method => @method,
++ :mtu => @mtu,
++ :options => squeeze_options
++ }
++
++ h.inject({}) do |hash, (key, val)|
++ hash[key] = val unless val.nil?
++ hash
++ end
++ end
++
++ def squeeze_options
++ @options.inject({}) do |hash, (key, value)|
++ if value.size <= 1
++ hash[key] = value.pop
++ else
++ hash[key] = value
++ end
++
++ hash
++ end
++ end
++
++ class << self
++
++ def reset!
++ @interfaces = {}
++ end
++
++ # @return [Array<Instance>] All class instances
++ def all_instances
++ @interfaces ||= {}
++ @interfaces
++ end
++
++ def [](name)
++ if all_instances[name]
++ obj = all_instances[name]
++ else
++ obj = self.new(name)
++ all_instances[name] = obj
++ end
++
++ obj
++ end
++ end
++ end
++
++ def self.parse_file(filename, contents)
++ # Debian has a very irregular format for the interfaces file. The
++ # parse_file method is somewhat derived from the ifup executable
++ # supplied in the debian ifupdown package. The source can be found at
++ # http://packages.debian.org/squeeze/ifupdown
++
++
++ # The debian interfaces implementation requires global state while parsing
++ # the file; namely, the stanza being parsed as well as the interface being
++ # parsed.
++ status = :none
++ current_interface = nil
++
++ lines = contents.split("\n")
++ # TODO Join lines that end with a backslash
++
++ # Iterate over all lines and determine what attributes they create
++ lines.each do |line|
++
++ # Strip off any trailing comments
++ line.sub!(/#.*$/, '')
++
++ case line
++ when /^\s*#|^\s*$/
++ # Ignore comments and blank lines
++ next
++
++ when /^auto|^allow-auto/
++ # Parse out any auto sections
++ interfaces = line.split(' ')
++ interfaces.delete_at(0)
++
++ interfaces.each do |name|
++ Instance[name].onboot = true
++ end
++
++ # Reset the current parse state
++ current_interface = nil
++
++ when /^allow-hotplug/
++ # parse out allow-hotplug lines
++
++ interfaces = line.split(' ')
++ interfaces.delete_at(0)
++
++ interfaces.each do |name|
++ Instance[name].hotplug = true
++ end
++
++ # Don't reset Reset the current parse state
++ when /^iface/
++
++ # Format of the iface line:
++ #
++ # iface <iface> <family> <method>
++ # zero or more options for <iface>
++
++ if match = line.match(/^iface\s+(\S+)\s+(\S+)\s+(\S+)/)
++ name = match[1]
++ family = match[2]
++ method = match[3]
++
++ # If an iface block for this interface has been seen, the file is
++ # malformed.
++ raise_malformed if Instance[name] and Instance[name].family
++
++ status = :iface
++ current_interface = name
++
++ # This is done automatically
++ #Instance[name].name = name
++ Instance[name].family = family
++ Instance[name].method = method
++
++ else
++ # If we match on a string with a leading iface, but it isn't in the
++ # expected format, malformed blar blar
++ raise_malformed
++ end
++
++ when /^mapping/
++
++ # XXX dox
++ raise Puppet::DevError, "Debian interfaces mapping parsing not implemented."
++ status = :mapping
++
++ else
++ # We're currently examining a line that is within a mapping or iface
++ # stanza, so we need to validate the line and add the options it
++ # specifies to the known state of the interface.
++
++ case status
++ when :iface
++ if match = line.match(/(\S+)\s+(\S.*)/)
++ # If we're parsing an iface stanza, then we should receive a set of
++ # lines that contain two or more space delimited strings. Append
++ # them as options to the iface in an array.
++
++ key = match[1]
++ val = match[2]
++
++ name = current_interface
++
++ case key
++ when 'address'; Instance[name].ipaddress = val
++ when 'netmask'; Instance[name].netmask = val
++ when 'mtu'; Instance[name].mtu = val
++ else Instance[name].options[key] << val
++ end
++ else
++ raise_malformed
++ end
++ when :mapping
++ raise Puppet::DevError, "Debian interfaces mapping parsing not implemented."
++ when :none
++ raise_malformed
++ end
++ end
++ end
++
++ Instance.all_instances.map {|name, instance| instance.to_hash }
++ end
++
++ # Generate an array of sections
++ def self.format_file(filename, providers)
++ contents = []
++ contents << header
++
++ # Add onboot interfaces
++ if (auto_interfaces = providers.select {|provider| provider.onboot == true })
++ stanza = []
++ stanza << "auto " + auto_interfaces.map(&:name).sort.join(" ")
++ contents << stanza.join("\n")
++ end
++
++ # Build iface stanzas
++ providers.sort_by(&:name).each do |provider|
++ # TODO add validation method
++ raise Puppet::Error, "#{provider.name} does not have a method." if provider.method.nil?
++ raise Puppet::Error, "#{provider.name} does not have a family." if provider.family.nil?
++
++ stanza = []
++ if provider.method == :static and (not provider.ipaddress or provider.ipaddress == :absent)
++ stanza << %{iface #{provider.name} #{provider.family} manual}
++ else
++ stanza << %{iface #{provider.name} #{provider.family} #{provider.method}}
++ end
++
++ [
++ [:ipaddress, 'address'],
++ [:netmask, 'netmask'],
++ [:gateway, 'gateway'],
++ [:mtu, 'mtu'],
++ ].each do |(property, section)|
++ stanza << " #{section} #{provider.send property}" if provider.send(property) and provider.send(property) != :absent
++ end
++
++ if provider.options and provider.options != :absent
++ provider.options.each_pair do |key_f, val|
++ key = key_f.gsub('_', '-')
++ if ['pre-up', 'up', 'post-up', 'down', 'pre-down', 'post-down'].include? key
++ if val.is_a? String
++ stanza << " #{key} #{val}"
++ elsif val.is_a? Array
++ val.each { |entry| stanza << " #{key} #{entry}" }
++ else
++ raise Puppet::Error, "#{self} options key #{key} expects a String or Array, got #{val.class}"
++ end
++ end
++ if key == 'SCOPE'
++ if val.is_a? String
++ stanza << " #{val}"
++ else
++ raise Puppet::Error, "#{self} options key #{key} expects a String, got #{val.class}"
++ end
++ end
++ end
++ end
++
++ contents << stanza.join("\n")
++ end
++
++ contents.map {|line| line + "\n\n"}.join
++ end
++
++ def self.header
++ str = <<-HEADER
++# HEADER: This file is is being managed by puppet. Changes to
++# HEADER: interfaces that are not being managed by puppet will persist;
++# HEADER: however changes to interfaces that are being managed by puppet will
++# HEADER: be overwritten. In addition, file order is NOT guaranteed.
++# HEADER: Last generated at: #{Time.now}
++HEADER
++ str
++ end
++end
Code Review / pti / rtp.git / blobdiff