1 #

     2 # CDDL HEADER START

     3 #

     4 # The contents of this file are subject to the terms of the

     5 # Common Development and Distribution License (the "License").

     6 # You may not use this file except in compliance with the License.

     7 #

     8 # You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

     9 # or http://www.opensolaris.org/os/licensing.

    10 # See the License for the specific language governing permissions

    11 # and limitations under the License.

    12 #

    13 # When distributing Covered Code, include this CDDL HEADER in each

    14 # file and include the License file at usr/src/OPENSOLARIS.LICENSE.

    15 # If applicable, add the following below this CDDL HEADER, with the

    16 # fields enclosed by brackets "[]" replaced with your own identifying

    17 # information: Portions Copyright [yyyy] [name of copyright owner]

    18 #

    19 # CDDL HEADER END

    20 #

    21 

    22 #

    23 # Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.

    24 #

    25 

    26 

    27 Puppet::Type.type(:evs_vport).provide(:evs_vport) do

    28     desc "Provider for managing EVS VPort setup in the Solaris OS"

    29     confine :operatingsystem => [:solaris]

    30     defaultfor :osfamily => :solaris, :kernelrelease => ["5.11", "5.12"]

    31     commands :evsadm => "/usr/sbin/evsadm"

    32 

    33     mk_resource_methods

    34 

    35     def initialize(value={})

    36         super(value)

    37         @property_flush = {}

    38     end

    39 

    40     def self.get_vport_list

    41         begin

    42             vport_list = evsadm("show-vport", "-c", "-o", 

    43                 "name,tenant,status").split("\n")

    44         rescue Puppet::ExecutionFailure => e

    45             raise Puppet::Error, "unable to populate VPort instances: \n" \

    46                 "#{e.inspect}"

    47             return nil

    48         end

    49         vport_list

    50     end

    51    

    52     def self.get_vport_properties(vport, tenant, status, ensure_val)

    53         vport_props = {}

    54         vport_fullname = tenant + "/" + vport

    55         vport_props[:name] = vport_fullname

    56         vport_props[:status] = status

    57         vport_props[:ensure] = ensure_val

    58         

    59         evsadm("show-vportprop", "-f", "tenant=#{tenant}", "-c", "-o",

    60             "property,value", vport).split("\n").collect do |each_prop|

    61             property, value = each_prop.split(":", 2)

    62             value = "" if value.nil?

    63             case property

    64             # read/write properties (always updatable)

    65             when "cos"

    66                 vport_props[:cos] = value

    67             when "maxbw"

    68                 vport_props[:maxbw] = value

    69             when "priority"

    70                 vport_props[:priority] = value

    71             when "protection"

    72                 vport_props[:protection] = value

    73             # read-only properties (settable upon creation)

    74             when "ipaddr"

    75                 vport_props[:ipaddr] = value

    76             when "macaddr"

    77                 # macaddr ":" appears to be "\:". change it to ":"

    78                 vport_props[:macaddr] = value.gsub! "\\:", ":"

    79             when "uuid"

    80                 vport_props[:uuid] = value

    81             end

    82         end

    83 

    84         Puppet.debug "VPort properties: #{vport_props.inspect}"

    85         vport_props

    86     end

    87 

    88     def self.instances

    89         get_vport_list.collect do |each_vport|

    90             vport, tenant, status = each_vport.strip.split(":")

    91             vport_props = get_vport_properties(vport, tenant, status, :present)

    92             new(vport_props) # Create a provider instance

    93         end

    94     end        

    95         

    96     def self.prefetch(resources)

    97         instances.each do |inst|

    98             if resource = resources[inst.name]

    99                 resource.provider = inst

   100             end

   101         end

   102     end

   103 

   104     def exists?

   105         @property_hash[:ensure] == :present

   106     end

   107 

   108     def create

   109         tenant, vport = get_tenant_and_vport_name

   110         begin

   111             create_vport(tenant, vport, add_properties(@resource))

   112         rescue Puppet::ExecutionFailure => e

   113             raise Puppet::Error, "Cannot add VPort: \n #{e.inspect}"

   114         end

   115     end

   116 

   117     def destroy

   118         tenant, vport = get_tenant_and_vport_name

   119         begin

   120             delete_vport(tenant, vport)

   121         rescue Puppet::ExecutionFailure => e

   122             raise Puppet::Error, "Cannot remove VPort: \n #{e.inspect}"

   123         end

   124     end

   125 

   126     def reset

   127         tenant, vport = get_tenant_and_vport_name

   128         begin

   129             evsadm("reset-vport", "-T", tenant, vport)

   130         rescue Puppet::ExecutionFailure => e

   131             raise Puppet::Error, "Cannot reset VPort: \n #{e.inspect}"

   132         end

   133 

   134         @resource[:ensure] = :present

   135         Puppet::notice "The VPort has been successfully reset."

   136     end

   137     

   138     ### Define Setters ###

   139     ## read/write properties (always updatable) ##

   140     def cos=(value)

   141         @property_flush[:cos] = value

   142     end

   143 

   144     def maxbw=(value)

   145         @property_flush[:maxbw] = value

   146     end

   147     

   148     def priority=(value)

   149         @property_flush[:priority] = value

   150     end

   151     

   152     def protection=(value)

   153         @property_flush[:protection] = value

   154     end

   155 

   156     ## read-only properties (settable upon creation) ##

   157     def ipaddr=(value)

   158         raise Puppet::Error, "ipaddr property is settable only upon creation"

   159     end

   160 

   161     def macaddr=(value)

   162         raise Puppet::Error, "macaddr property is settable only upon creation"

   163     end

   164 

   165     def uuid=(value)

   166         raise Puppet::Error, "uuid property is settable only upon creation"

   167     end

   168 

   169     # Add VPort Instance

   170     def create_vport(tenant, vport, properties)

   171         begin

   172             evsadm("add-vport", "-T", tenant, properties, vport)

   173         rescue Puppet::ExecutionFailure => e

   174             # Pass up the exception to upper level

   175             raise

   176         end

   177     end

   178 

   179     # Remove Vport Instance

   180     def delete_vport(tenant, vport)

   181         begin

   182             evsadm("remove-vport", "-T", tenant, vport)

   183         rescue Puppet::ExecutionFailure => e

   184             # Pass up the exception to upper level

   185             raise

   186         end

   187     end

   188     

   189     # set read/write property 

   190     def set_vportprop(tenant, vport, property)

   191         begin

   192             evsadm("set-vportprop", "-T", tenant, property, vport)

   193         rescue Puppet::ExecutionFailure => e

   194             # Pass up the exception to upper level

   195             raise

   196         end

   197     end

   198 

   199     # Parse the "name" value from user and yield tenant and vport name

   200     def get_tenant_and_vport_name

   201         fullname = @resource[:name]

   202 

   203         return [] if fullname == nil

   204         parsed_val = fullname.strip.split("/")

   205         if (parsed_val.length != 3)

   206             raise Puppet::Error, "Invalid VPort name #{@resource[:name]} \n" \

   207                 "Name convention must be <tenant>/<evs>/<vport>"

   208         end

   209         tenant, evs, vport = parsed_val

   210         return tenant, evs + "/" + vport

   211     end

   212 

   213     # property setter for vport creation

   214     def add_properties(source)

   215         p = []

   216         if source[:ipaddr] != nil

   217             source[:ipaddr] = source[:ipaddr].split('/')[0]

   218         end

   219         prop_list = {

   220             "cos" => source[:cos], 

   221             "maxbw" => source[:maxbw], 

   222             "priority" => source[:priority],

   223             "protection" => source[:protection],

   224             "ipaddr" => source[:ipaddr],

   225             "macaddr" => source[:macaddr],

   226             "uuid" => source[:uuid]

   227         }

   228         prop_list.each do |key, value|

   229             next if (value == "") || (value == nil)

   230             p << "#{key}=#{value}"

   231         end

   232         return [] if p.empty?

   233         properties = Array["-p", p.join(",")]

   234     end

   235 

   236     # Update property change

   237     def flush

   238         tenant, vport = get_tenant_and_vport_name

   239        

   240         # Update property values when specified

   241         unless @property_flush.empty?

   242             # update multiple property values iteratively

   243             @property_flush.each do |key, value|

   244                 prop = ["-p", "#{key}=#{value}"]

   245                 begin

   246                     set_vportprop(tenant, vport, prop)

   247                 rescue Puppet::ExecutionFailure => e

   248                     raise Puppet::Error, "Cannot update the property " \

   249                         "#{key}=#{value}.\n#{e.inspect}"

   250                 end

   251             end

   252         end

   253 

   254         # Synchronize all the SHOULD values to IS values

   255         @property_hash = resource.to_hash

   256     end

   257 end