3rdparty/modules/keystone/lib/puppet/provider/keystone_tenant/openstack.rb

   1 require 'puppet/provider/keystone'
   2
   3 Puppet::Type.type(:keystone_tenant).provide(
   4   :openstack,
   5   :parent => Puppet::Provider::Keystone
   6 ) do
   7
   8   desc "Provider to manage keystone tenants/projects."
   9
  10   @credentials = Puppet::Provider::Openstack::CredentialsV3.new
  11
  12   def initialize(value={})
  13     super(value)
  14     @property_flush = {}
  15   end
  16
  17   def create
  18     # see if resource[:domain], or project_name::project_domain
  19     project_name, project_domain = self.class.name_and_domain(resource[:name], resource[:domain])
  20     properties = [project_name]
  21     if resource[:enabled] == :true
  22       properties << '--enable'
  23     elsif resource[:enabled] == :false
  24       properties << '--disable'
  25     end
  26     if resource[:description]
  27       properties << '--description'
  28       properties << resource[:description]
  29     end
  30     if project_domain
  31       properties << '--domain'
  32       properties << project_domain
  33     end
  34     @property_hash = self.class.request('project', 'create', properties)
  35     @property_hash[:ensure] = :present
  36   end
  37
  38   def exists?
  39     @property_hash[:ensure] == :present
  40   end
  41
  42   def destroy
  43     self.class.request('project', 'delete', id)
  44     @property_hash.clear
  45   end
  46
  47   def enabled=(value)
  48     @property_flush[:enabled] = value
  49   end
  50
  51   def enabled
  52     bool_to_sym(@property_hash[:enabled])
  53   end
  54
  55   def description=(value)
  56     @property_flush[:description] = value
  57   end
  58
  59   def description
  60     @property_hash[:description]
  61   end
  62
  63   def domain
  64     @property_hash[:domain]
  65   end
  66
  67   def id
  68     @property_hash[:id]
  69   end
  70
  71   def self.instances
  72     instance_hash = {}
  73     list = request('project', 'list', '--long')
  74     list.each do |project|
  75       domname = domain_name_from_id(project[:domain_id])
  76       if instance_hash.include?(project[:name]) # not unique
  77         curdomid = instance_hash[project[:name]][:domain_id]
  78         if curdomid != default_domain_id
  79           # Move the project from the short name slot to the long name slot
  80           # because it is not in the default domain.
  81           curdomname = domain_name_from_id(curdomid)
  82           instance_hash["#{project[:name]}::#{curdomname}"] = instance_hash[project[:name]]
  83           # Use the short name slot for the new project
  84           instance_hash[project[:name]] = project
  85         else
  86           # Use the long name for the new project
  87           instance_hash["#{project[:name]}::#{domname}"] = project
  88         end
  89       else
  90         # Unique (for now) - store in short name slot
  91         instance_hash[project[:name]] = project
  92       end
  93     end
  94     instance_hash.keys.collect do |project_name|
  95       project = instance_hash[project_name]
  96       domname = domain_name_from_id(project[:domain_id])
  97       new(
  98         :name        => project_name,
  99         :ensure      => :present,
 100         :enabled     => project[:enabled].downcase.chomp == 'true' ? true : false,
 101         :description => project[:description],
 102         :domain      => domname,
 103         :domain_id   => project[:domain_id],
 104         :id          => project[:id]
 105       )
 106     end
 107   end
 108
 109   def self.prefetch(resources)
 110     project_hash = {}
 111     projects = instances
 112     resources.each do |resname, resource|
 113       # resname may be specified as just "name" or "name::domain"
 114       name, resdomain = name_and_domain(resname, resource[:domain])
 115       provider = projects.find do |project|
 116         # have a match if the full instance name matches the full resource name, OR
 117         # the base resource name matches the base instance name, and the
 118         # resource domain matches the instance domain
 119         project_name, project_domain = name_and_domain(project.name, project.domain)
 120         (project.name == resname) ||
 121           ((project_name == name) && (project_domain == resdomain))
 122       end
 123       resource.provider = provider if provider
 124     end
 125   end
 126
 127   def flush
 128     options = []
 129     if @property_flush && !@property_flush.empty?
 130       case @property_flush[:enabled]
 131       when :true
 132         options << '--enable'
 133       when :false
 134         options << '--disable'
 135       end
 136       (options << "--description=#{resource[:description]}") if @property_flush[:description]
 137       self.class.request('project', 'set', [id] + options) unless options.empty?
 138       @property_flush.clear
 139     end
 140   end
 141
 142 end