puppet 0.24.4 → 0.24.5

data/lib/puppet/provider/interface/redhat.rb

@@ -1,250 +0,0 @@
-require 'puppet/provider/parsedfile'
-require 'erb'
-
-Puppet::Type.type(:interface).provide(:redhat) do
-    desc "Manage network interfaces on Red Hat operating systems.  This provider
-        parses and generates configuration files in ``/etc/sysconfig/network-scripts``."
-
-    INTERFACE_DIR = "/etc/sysconfig/network-scripts"
-    confine :exists => INTERFACE_DIR
-    defaultfor :operatingsystem => [:fedora, :centos, :redhat]
-
-    # Create the setter/gettor methods to match the model.
-    mk_resource_methods
-
-    @templates = {}
-
-    # Register a template.
-    def self.register_template(name, string)
-        @templates[name] = ERB.new(string)
-    end
-
-    # Retrieve a template by name.
-    def self.template(name)
-        @templates[name]
-    end
-
-    register_template :alias, <<-ALIAS
-DEVICE=<%= self.device %>
-ONBOOT=<%= self.on_boot %>
-BOOTPROTO=none
-IPADDR=<%= self.name %>
-NETMASK=<%= self.netmask %>
-BROADCAST=
-ALIAS
-
-
-    register_template :normal, <<-LOOPBACKDUMMY
-DEVICE=<%= self.device %>
-ONBOOT=<%= self.on_boot %>
-BOOTPROTO=static
-IPADDR=<%= self.name %>
-NETMASK=<%= self.netmask %>
-BROADCAST=
-LOOPBACKDUMMY
-
-    # maximum number of dummy interfaces
-    @max_dummies = 10
-
-    # maximum number of aliases per interface
-    @max_aliases_per_iface = 10
-
-    @@dummies = []
-    @@aliases = Hash.new { |hash, key| hash[key] = [] }
-
-    # calculate which dummy interfaces are currently already in
-    # use prior to needing to call self.next_dummy later on.
-    def self.instances
-        # parse all of the config files at once
-        Dir.glob("%s/ifcfg-*" % INTERFACE_DIR).collect do |file|
-            record = parse(file)
-
-            # store the existing dummy interfaces
-            @@dummies << record[:ifnum] if (record[:interface_type] == :dummy and ! @@dummies.include?(record[:ifnum]))
-
-            @@aliases[record[:interface]] << record[:ifnum] if record[:interface_type] == :alias
-
-            new(record)
-        end
-    end
-
-    # return the next avaliable dummy interface number, in the case where
-    # ifnum is not manually specified
-    def self.next_dummy
-        @max_dummies.times do |i|
-            unless @@dummies.include?(i.to_s)
-                @@dummies << i.to_s
-                return i.to_s
-            end
-        end
-    end
-
-    # return the next available alias on a given interface, in the case
-    # where ifnum if not manually specified
-    def self.next_alias(interface)
-        @max_aliases_per_iface.times do |i|
-            unless @@aliases[interface].include?(i.to_s)
-                @@aliases[interface] << i.to_s
-                return i.to_s
-            end
-        end
-    end
-
-    # base the ifnum, for dummy / loopback interface in linux
-    # on the last octect of the IP address
-
-    # Parse the existing file.
-    def self.parse(file)
-        instance = new()
-        return instance unless FileTest.exist?(file)
-
-        File.readlines(file).each do |line|
-            if line =~ /^(\w+)=(.+)$/
-                instance.send($1.downcase + "=", $2)
-            end
-        end
-
-        return instance
-    end
-
-    # Prefetch our interface list, yo.
-    def self.prefetch(resources)
-        instances.each do |prov|
-            if resource = resources[prov.name]
-                resource.provider = prov
-            end
-        end
-    end
-
-    def create
-        self.class.resource_type.validproperties.each do |property|
-            if value = @resource.should(property)
-                @property_hash[property] = value
-            end
-        end
-        @property_hash[:name] = @resource.name
-
-        return (@resource.class.name.to_s + "_created").intern
-    end
-
-    def destroy
-        File.unlink(file_path)
-    end
-
-    def exists?
-        FileTest.exist?(file_path)
-    end
-
-    # generate the content for the interface file, so this is dependent
-    # on whether we are adding an alias to a real interface, or a loopback
-    # address (also dummy) on linux. For linux it's quite involved, and we
-    # will use an ERB template
-    def generate
-        itype = self.interface_type == :alias ? :alias : :normal
-        self.class.template(itype).result(binding)
-    end
-
-    # Where should the file be written out?
-    # This defaults to INTERFACE_DIR/ifcfg-<namevar>, but can have a
-    # more symbolic name by setting interface_desc in the type. 
-    def file_path
-        if resource and val = resource[:interface_desc]
-            desc = val
-        else
-            desc = self.name
-        end
-
-        self.fail("Could not get name for interface") unless desc
-
-        if self.interface_type == :alias
-            return File.join(INTERFACE_DIR, "ifcfg-" + self.interface + ":" + desc)
-        else
-            return File.join(INTERFACE_DIR, "ifcfg-" + desc)
-        end
-    end
-
-    # Use the device value to figure out all kinds of nifty things.
-    def device=(value)
-        case value
-        when /:/:
-            @property_hash[:interface], @property_hash[:ifnum] = value.split(":")
-            @property_hash[:interface_type] = :alias
-        when /^dummy/:
-            @property_hash[:interface_type] = :loopback
-            @property_hash[:interface] = "dummy"
-
-            # take the number of the dummy interface, as this is used
-            # when working out whether to call next_dummy when dynamically
-            # creating these
-            @property_hash[:ifnum] = value.sub("dummy",'')
-
-            @@dummies << @property_hash[:ifnum].to_s unless @@dummies.include?(@property_hash[:ifnum].to_s)
-        else
-            @property_hash[:interface_type] = :normal
-            @property_hash[:interface] = value
-        end
-    end
-
-    # create the device name, so this based on the IP, and interface + type
-    def device
-        case @resource.should(:interface_type)
-        when :loopback
-            @property_hash[:ifnum] ||= self.class.next_dummy
-            return "dummy" + @property_hash[:ifnum]
-        when :alias
-            @property_hash[:ifnum] ||= self.class.next_alias(@resource[:interface])
-            return @resource[:interface] + ":" + @property_hash[:ifnum]
-        end
-    end
-
-    # Set the name to our ip address.
-    def ipaddr=(value)
-        @property_hash[:name] = value
-    end
-
-    # whether the device is to be brought up on boot or not. converts
-    # the true / false of the type, into yes / no values respectively
-    # writing out the ifcfg-* files
-    def on_boot
-        case @property_hash[:onboot].to_s
-        when "true"
-            return "yes"
-        when "false"
-            return "no"
-        else
-            return "neither"
-        end
-    end
-
-    # Mark whether the interface should be started on boot.
-    def on_boot=(value)
-        # translate whether we come up on boot to true/false
-        case value.downcase
-        when "yes":
-            @property_hash[:onboot] = :true
-        else
-            @property_hash[:onboot] = :false
-        end
-    end
-
-    # Write the new file out.
-    def flush
-        # Don't flush to disk if we're removing the config.
-        return if self.ensure == :absent
-
-        @property_hash.each do |name, val|
-            if val == :absent
-                raise ArgumentError, "Propety %s must be provided" % val
-            end
-        end
-
-        File.open(file_path, "w") do |f|
-            f.puts generate()
-        end
-    end
-
-    def prefetch
-        @property_hash = self.class.parse(file_path)
-    end
-end
-

data/lib/puppet/provider/interface/sunos.rb

@@ -1,133 +0,0 @@
-require 'puppet/provider/parsedfile'
-require 'erb'
-
-Puppet::Type.type(:interface).provide(:sunos) do
-    confine :kernel => "SunOS"
-
-    # Add accessor/getter methods for each property/parameter; these methods
-    # modify @property_hash.
-    mk_resource_methods
-
-    # Get a list of interface instances.
-    def self.instances
-		Dir.glob("/etc/hostname.*").collect do |file|
-            device = File.basename(file).split(".").pop
-
-            instance = new(:interface => device)
-            instance.parse
-            instance
-        end
-    end
-
-	def self.match(hash)
-		# see if we can match the has against an existing object
-		if model.find { |obj| obj.value(:name) == hash[:name] }
-			return obj
-        else
-            return false
-		end	
-	end
-
-    # Prefetch our interface list, yo.
-    def self.prefetch(resources)
-        instances.each do |prov|
-            if resource = resources[prov.name]
-                resource.provider = prov
-            end
-        end
-    end
-
-    def initialize(*args)
-        @property_hash = {}
-        super
-    end
-
-    def create
-        self.class.resource_type.validproperties.each do |property|
-            if value = resource.should(property)
-                @property_hash[property] = value
-            end
-        end
-        @property_hash[:name] = resource.name
-
-        return (@resource.class.name.to_s + "_created").intern
-    end
-
-    def destroy
-        File.unlink(file_path)
-        @property_hash[:ensure] = :absent
-    end
-
-    def exists?
-        FileTest.exist?(file_path)
-    end
-
-    # Where should the file be written out?  Can be overridden by setting
-    # :target in the model.
-    def file_path
-        self.fail("Could not determine interface") unless interface = @property_hash[:interface] || (resource and resource[:interface])
-       	return File.join("/etc", "hostname." + interface)
-    end
-
-    def flush
-        return if self.ensure == :absent
-        File.open(file_path, "w") { |f| f.print generate() + "\n" }
-    end
-
-    # Turn our record into a line.
-    def generate
-        ret = []
-        if self.interface_type == :alias
-            ret << "addif"
-        end
-        ret << self.name
-
-        if self.ifopts != :absent
-            if @property_hash[:ifopts].is_a?(Array)
-                ret << @property_hash[:ifopts].join(" ")
-            else
-                ret << @property_hash[:ifopts]
-            end
-        end
-
-        if self.onboot and ! [:absent, :false].include?(self.onboot)
-            ret << "up"
-        end
-
-        return ret.join(" ")
-    end
-
-    # Parse our interface file.
-    def parse
-        (@property_hash = {:ensure => :absent} and return) unless FileTest.exist?(file_path)
-
-        values = File.read(file_path).chomp.split(/\s+/)
-
-        @property_hash[:ensure] = :present
-        #@property_hash = {:ensure => :present}
-
-        # Are we the primary interface?
-        if values[0] == "addif"
-            @property_hash[:interface_type] = :alias
-            values.shift
-        else
-            @property_hash[:interface_type] = :normal
-        end
-
-        # Should the interface be up by default?
-        if values[-1] == "up"
-            @property_hash[:onboot] = :true
-            values.pop
-        else
-            @property_hash[:onboot] = :false
-        end
-
-        # Set the interface name.
-        @property_hash[:name] = values.shift
-
-        # Handle any interface options
-        unless values.empty?
-            @property_hash[:ifopts] = values.join(" ")
-        end
-    end
-end

data/lib/puppet/type/interface.rb

@@ -1,60 +0,0 @@
-Puppet::Type.newtype(:interface) do
-	require 'erb'
-
-	@doc = "Create configuration for IP address aliases and loopback addresses."
-
-	newparam(:name, :namevar => true) do
-		desc "The ipaddress to add to alias or loopback/dummy interface"
-	end
-
-    ensurable
-
-	newparam(:interface) do
-		desc "The interface the IP should be added to"
-	end
-
-	newproperty(:interface_type) do
-		desc "The interface type, loopback (also dummy) or alias"
-
-        newvalue(:loopback)
-        newvalue(:alias)
-        newvalue(:normal)
-
-        # Make dummy and loopback equivalent
-        aliasvalue(:dummy, :loopback)
-
-        defaultto :normal
-	end
-
-	newparam(:interface_desc) do
-		desc "On Linux, the description / symbolic name you wish to refer to the 
-              interface by. When absent, Redhat Linux defaults to uses the namevar
-              which will be either the IP address, or hostname."
-	end
-
-	newproperty(:onboot) do
-		desc "Whether the interface should be configured to come up on boot"
-		newvalue(:true)
-		newvalue(:false)
-	end
-
-	newproperty(:ifnum) do
-		desc "If not automatically configuring the dummy interface or
-              and alias. This is use to force a given number to be used"
-	end
-
-	newproperty(:netmask) do
-		desc "The netmask for the interface."
-	end
-
-	newproperty(:ifopts) do
-		desc "Interface options."
-	end
-
-    newparam(:target) do
-        include Puppet::Util::Warnings
-        desc "The path to the file this resource creates."
-
-        munge { |value| warnonce "Interface targets are deprecated and no longer have any function" }
-    end
-end

data/lib/puppet/util/variables.rb

@@ -1,38 +0,0 @@
-module Puppet::Util::Variables
-    def inithooks
-        @instance_init_hooks.dup
-    end
-
-    def initvars
-        return unless defined? @class_init_hooks
-        self.inithooks.each do |var, value|
-            if value.is_a?(Class)
-                instance_variable_set("@" + var.to_s, value.new)
-            else
-                instance_variable_set("@" + var.to_s, value)
-            end
-        end
-    end
-
-    def instancevar(hash)
-        @instance_init_hooks ||= {}
-
-        unless method_defined?(:initvars)
-            define_method(:initvars) do
-                self.class.inithooks.each do |var, value|
-                    if value.is_a?(Class)
-                        instance_variable_set("@" + var.to_s, value.new)
-                    else
-                        instance_variable_set("@" + var.to_s, value)
-                    end
-                end
-            end
-        end
-        hash.each do |var, value|
-            raise("Already initializing %s" % var) if @instance_init_hooks[var]
-
-            @instance_init_hooks[var] = value
-        end
-    end
-end
-