class Berta::Service

Berta service for communication with OpenNebula

Constants

FILTERS

Attributes

client[R]
endpoint[R]

Public Class Methods

new(secret, endpoint) click to toggle source

Initializes service object and connects to opennebula backend. If both arguments are nil default ONE_AUTH will be used.

@param secret [String] Opennebula secret @param endpoint [String] Endpoint of OpenNebula

# File lib/berta/service.rb, line 18
def initialize(secret, endpoint)
  @endpoint = endpoint
  @client = OpenNebula::Client.new(secret, endpoint)
  create_filter
end

Public Instance Methods

clusters() click to toggle source

Fetch clusters from OpenNebula

@return [OpenNebula::ClusterPool] Clusters on OpenNebula @raise [Berta::Errors::OpenNebula::AuthenticationError] @raise [Berta::Errors::OpenNebula::UserNotAuthorizedError] @raise [Berta::Errors::OpenNebula::ResourceNotFoundError] @raise [Berta::Errors::OpenNebula::ResourceStateError] @raise [Berta::Errors::OpenNebula::ResourceRetrievalError]

# File lib/berta/service.rb, line 95
def clusters
  return @cached_clusters if @cached_clusters
  cluster_pool = OpenNebula::ClusterPool.new(client)
  Berta::Utils::OpenNebula::Helper.handle_error { cluster_pool.info }
  logger.debug "Fetched clusters: #{cluster_pool.map(&:id)}"
  @cached_clusters = cluster_pool
  cluster_pool
end
create_filter() click to toggle source
# File lib/berta/service.rb, line 24
def create_filter
  filter = FILTERS[Berta::Settings.filter.type]
  raise Berta::Errors::WrongFilterTypeError, "Wrong filter type: #{Berta::Settings.filter.type}" unless filter
  @filter = filter.new(Berta::Settings.filter.ids,
                       Berta::Settings.filter.users,
                       Berta::Settings.filter.groups,
                       filtered_clusters)
end
group_vms(group) click to toggle source
# File lib/berta/service.rb, line 83
def group_vms(group)
  running_vms.select { |vm| vm.handle['GID'] == group.id }
end
groups() click to toggle source
# File lib/berta/service.rb, line 67
def groups
  group_pool = OpenNebula::GroupPool.new(client)
  Berta::Utils::OpenNebula::Helper.handle_error { group_pool.info }
  logger.debug "Fetched groups: #{group_pool.map(&:id)}"
  group_pool.map { |group| Berta::EntityHandler.new(group) }
end
running_vms() click to toggle source

Fetch running vms from OpenNebula and filter out vms that take no resources.

@return [Array<Berta::VirtualMachineHandler>] Virtual machines

running on OpenNebula

@raise [Berta::Errors::OpenNebula::AuthenticationError] @raise [Berta::Errors::OpenNebula::UserNotAuthorizedError] @raise [Berta::Errors::OpenNebula::ResourceNotFoundError] @raise [Berta::Errors::OpenNebula::ResourceStateError] @raise [Berta::Errors::OpenNebula::ResourceRetrievalError]

# File lib/berta/service.rb, line 43
def running_vms
  return @cached_vms if @cached_vms
  vm_pool = OpenNebula::VirtualMachinePool.new(client)
  Berta::Utils::OpenNebula::Helper.handle_error { vm_pool.info_all }
  logger.debug "Fetched vms: #{vm_pool.map(&:id)}"
  @cached_vms = @filter.run(vm_pool.map { |vm| Berta::VirtualMachineHandler.new(vm) })
  @cached_vms
end
user_vms(user) click to toggle source

Return vms that belong to given user

@note calls running_vms @param user [Berta::UserHandler] User to find vms for @return [Array<Berta::VirtualMachineHandler>] VMs that belong to given user

# File lib/berta/service.rb, line 79
def user_vms(user)
  running_vms.select { |vm| vm.handle['UID'] == user.id }
end
users() click to toggle source

Fetch users from OpenNebula

@return [Array<OpenNebula::UserHandler>] Users on OpenNebula @raise [Berta::Errors::OpenNebula::AuthenticationError] @raise [Berta::Errors::OpenNebula::UserNotAuthorizedError] @raise [Berta::Errors::OpenNebula::ResourceNotFoundError] @raise [Berta::Errors::OpenNebula::ResourceStateError] @raise [Berta::Errors::OpenNebula::ResourceRetrievalError]

# File lib/berta/service.rb, line 60
def users
  user_pool = OpenNebula::UserPool.new(client)
  Berta::Utils::OpenNebula::Helper.handle_error { user_pool.info }
  logger.debug "Fetched users: #{user_pool.map(&:id)}"
  user_pool.map { |user| Berta::EntityHandler.new(user) }
end

Private Instance Methods

filtered_clusters() click to toggle source
# File lib/berta/service.rb, line 106
def filtered_clusters
  return unless Berta::Settings.filter.clusters
  clusters.select { |cluster| Berta::Settings.filter.clusters.find { |cname| cname == cluster['NAME'] } }
end