def setbool_group(self, id, bool, type=0, parent_id=None):
if type == 2 and parent_id is not None: # convergence group, get parent group's user context
_group_user = DyngroupDatabase()._get_group_user(parent_id)
ctx = self.getContext(user=_group_user)
else:
ctx = self.currentContext
return xmlrpcCleanup(DyngroupDatabase().setbool_group(ctx, id, bool))
def delete_group(self, id):
ctx = self.currentContext
if self.isprofile(id):
grp = DyngroupDatabase().get_group(ctx, id, True)
profile_UUID = grp.getUUID()
ComputerProfileManager().delProfile(profile_UUID)
return xmlrpcCleanup(DyngroupDatabase().delete_group(ctx, id))
def create_group(self, name, visibility, type=0, parent_id=None):
if type == 2 and parent_id is not None: # convergence group, get parent group's user context
_group_user = DyngroupDatabase()._get_group_user(parent_id)
ctx = self.getContext(user=_group_user)
else:
ctx = self.currentContext
return xmlrpcCleanup(DyngroupDatabase().create_group(
ctx, name, visibility, type, parent_id))
def get_group(self, id, ro=False, root_context=False):
grp = DyngroupDatabase().get_group(self.getContext(), id)
if grp.type == 2:
_group_user = DyngroupDatabase()._get_group_user(grp.parent_id)
ctx = self.getContext(user=_group_user)
else:
ctx = root_context and self.getContext() or self.currentContext
grp = DyngroupDatabase().get_group(ctx, id, ro)
if grp:
return xmlrpcCleanup(grp.toH())
return xmlrpcCleanup(False)
def get_profile_entity(self, gid):
if gid == '':
return False
if not self.isprofile(gid):
return False
ret = DyngroupDatabase().getProfileEntity(gid)
return xmlrpcCleanup(ret)
def get_profile_imaging_server(self, gid):
if gid == '':
return False
if not self.isprofile(gid):
return False
ret = DyngroupDatabase().getProfileImagingServer(gid)
return xmlrpcCleanup(ret)
def addmembers_to_group(self, id, uuids):
ctx = self.currentContext
# remove all the computers that cant be added to a profile from the list
didnt_work = []
are_some_to_remove = False
if self.isprofile(id):
computers = []
uuid2key = {}
for c in uuids:
computers.append(uuids[c]['uuid'])
uuid2key[uuids[c]['uuid']] = c
didnt_work = ComputerProfileManager().areForbiddebComputers(
computers)
if len(didnt_work) > 0:
logging.getLogger().debug(
"Can't add the following computers in that profile %s : %s"
% (str(id), str(didnt_work)))
for i in didnt_work:
if uuid2key[i] in uuids:
are_some_to_remove = True
uuids.pop(uuid2key[i])
if len(uuids) != 0:
if self.isprofile(id):
ComputerProfileManager().addComputersToProfile(ctx, uuids, id)
else:
ret = DyngroupDatabase().addmembers_to_group(ctx, id, uuids)
return [ret]
return xmlrpcCleanup([not are_some_to_remove, didnt_work])
def reload_group(self, id):
ctx = self.currentContext
ret = DyngroupDatabase().reload_group(ctx, id, queryManager)
# WIP : call ComputerProfileManager to add machines
# if self.isprofile(id):
# ComputerProfileManager().addComputersToProfile(ctx, [1, 2], id) # fake!
return xmlrpcCleanup(ret)
def result_group(self, id, start, end, filter):
ctx = self.currentContext
return xmlrpcCleanup(
map(
lambda g: g.toH(),
DyngroupDatabase().result_group(ctx, id, start, end, filter,
False)))
def delmembers_to_group(self, id, uuids):
ctx = self.currentContext
ret = DyngroupDatabase().delmembers_to_group(ctx, id, uuids)
# WIP : call ComputerProfileManager to add machines
if len(uuids) != 0 and self.isprofile(id):
ComputerProfileManager().delComputersFromProfile(uuids, id)
return xmlrpcCleanup(ret)
def query(ctx, criterion, value):
logging.getLogger().info(ctx)
logging.getLogger().info(criterion)
logging.getLogger().info(value)
machines = []
if criterion == 'groupname':
machines = map(lambda x: x.name, DyngroupDatabase().getMachines(ctx, {'gname':value}))
return [machines, True]
def add_convergence_datas(self, parent_group_id, deploy_group_id,
done_group_id, pid, p_api, command_id, active,
params):
ret = DyngroupDatabase().add_convergence_datas(parent_group_id,
deploy_group_id,
done_group_id, pid,
p_api, command_id,
active, params)
return xmlrpcCleanup(ret)
def add_command_api(self, pid, target, params, p_api, mode, gid = None, proxy = [], cmd_type = 0):
"""
@param target: must be list of UUID
@type target: list
"""
ctx = self.currentContext
if gid:
grp = DyngroupDatabase().get_group(self.getContext(), gid)
# If convergence group, get context of group's owner
if grp.type == 2:
_group_user = DyngroupDatabase()._get_group_user(grp.parent_id)
ctx = self.getContext(user=_group_user)
target = ComputerGroupManager().get_group_results(ctx, gid, 0, -1, '', True)
g = mmc.plugins.msc.package_api.SendPackageCommand(ctx, p_api, pid, target, params, mode, gid, proxies = proxy, cmd_type = cmd_type)
g.deferred = defer.Deferred()
g.send()
g.deferred.addCallbacks(xmlrpcCleanup, lambda err: err)
return g.deferred
def get_active_convergence_for_host(self, host_uuid):
all_convergences = DyngroupDatabase().get_active_convergences()
host_convergences = []
for cv in all_convergences:
# Do next with root context
ctx = self.getContext()
if ComputerManager().getRestrictedComputersList(
ctx, 0, -1, {
'uuid': host_uuid,
'gid': cv['gid']
}, False, False, True):
host_convergences.append(cv)
return host_convergences
def activate():
logger = logging.getLogger()
global config
config = DGConfig()
config.init("dyngroup")
if config.disable:
logger.warning("Plugin dyngroup: disabled by configuration.")
return False
DyngroupDatabase().activate(config)
if not DyngroupDatabase().db_check():
return False
ComputerGroupManager().register("dyngroup", DyngroupGroup)
ComputerProfileManager().register("dyngroup", DyngroupProfile)
ComputerManager().register("dyngroup", DyngroupComputers)
if config.check_db_enable:
scheduleCheckStatus(config.check_db_interval)
return True
def get_all_commands_for_consult(self,
min=0,
max=10,
filt='',
expired=True):
ctx = self.currentContext
size, ret1 = MscDatabase().getAllCommandsConsult(
ctx, min, max, filt, expired)
ret = []
logger = logging.getLogger()
cache = {}
for c in ret1:
if c['gid']:
if cache.has_key("G%s" % (c['gid'])):
#if "G%s"%(c['gid']) in cache:
c['target'] = cache["G%s" % (c['gid'])]
else:
group = DyngroupDatabase().get_group(ctx, c['gid'], True)
if type(
group
) == bool: # we dont have the permission to view the group
c['target'] = 'UNVISIBLEGROUP' # TODO!
elif group == None:
c['target'] = 'this group has been deleted'
elif hasattr(group, 'ro') and group.ro:
logger.debug("user %s access to group %s in RO mode" %
(ctx.userid, group.name))
c['target'] = group.name
else:
c['target'] = group.name
cache["G%s" % (c['gid'])] = c['target']
else:
if cache.has_key("M%s" % (c['uuid'])):
#if "M%s"%(c['uuid']) in cache:
c['target'] = cache["M%s" % (c['uuid'])]
else:
if not ComputerLocationManager(
).doesUserHaveAccessToMachine(ctx, c['uuid']):
c['target'] = "UNVISIBLEMACHINE"
elif not ComputerManager().getComputer(
ctx, {'uuid': c['uuid']}):
c['target'] = "UNVISIBLEMACHINE"
cache["M%s" % (c['uuid'])] = c['target']
# treat c['title'] to remove the date when possible
# "Bundle (1) - 2009/12/14 10:22:24" => "Bundle (1)"
date_re = re.compile(" - \d\d\d\d/\d\d/\d\d \d\d:\d\d:\d\d")
c['title'] = date_re.sub('', c['title'])
ret.append(c)
return xmlrpcCleanup((size, ret))
def update_machine_cache(self):
ctx = self.currentContext
dyndatabase = DyngroupDatabase()
cache = dyndatabase.getAllMachinesUuid()
machines = ComputerManager().getRestrictedComputersList(
ctx, 0, -1, {'uuids': cache.keys()}, False, False, True)
need_update = {}
for m in machines:
if m['hostname'] != cache[m['uuid']]:
need_update[m['uuid']] = m['hostname']
dyndatabase.updateNewNames(need_update)
return len(need_update)
def checkPool():
ret = True
try:
pool = DyngroupDatabase().db.pool
if pool._max_overflow > -1 and pool._overflow >= pool._max_overflow:
logging.getLogger().error(
'dyngroup plugin: CHECK: NOK: timeout then overflow (%d vs. %d) detected in SQL pool : check your network connectivity !'
% (pool._overflow, pool._max_overflow))
pool.dispose()
pool = pool.recreate()
ret = False
except Exception, e:
logging.getLogger().warn(
'dyngroup plugin: CHECK: NOK: got the following error : %s' % (e))
ret = False
def _get_machine_groups(self, uuid):
"""
Get groups of one machine with is uuid as number"
"""
# Creating root context
ctx = SecurityContext()
ctx.userid = 'root'
group_list = []
groups = DyngroupDatabase().getallgroups(ctx, {})
groups = map(lambda g: g.toH(), groups)
for group in groups:
if 'id' in group:
result = ComputerGroupManager().get_group_results(
ctx, group['id'], 0, -1, {})
if "UUID" + str(uuid) in result:
group_list.append(group['id'])
return group_list
def _get_convergence_soon_ended_commands(all=False):
"""
@param all: If True, get all convergence active commands
@type all: Bool
@return: list of soon ended convergence commands
@rtype: list
"""
ret = []
active_convergence_cmd_ids = DyngroupDatabase()._get_convergence_active_commands_ids()
if all:
# Return all active_convergence_cmd_ids
return active_convergence_cmd_ids
elif active_convergence_cmd_ids:
# Get active_convergence_cmd_ids who are soon expired
ret = MscDatabase()._get_convergence_soon_ended_commands(cmd_ids=active_convergence_cmd_ids)
return xmlrpcCleanup(ret)
def expire_all_package_commands(self, pid):
"""
Expires all commands of a given package
Used usually when a package is dropped
@param pid: uuid of dropped package
@type pid: uuid
"""
# get all cmd_ids with their start_date of given package id
cmds = MscDatabase().get_package_cmds(pid)
if cmds:
logging.getLogger().info('%d command will be expired' % len(cmds))
# for all cmd_ids, get start_date and expire them
for cmd_id, start_date in cmds.items():
logging.getLogger().info('Expires command %d' % cmd_id)
end_date = time.strftime("%Y-%m-%d %H:%M:%S")
self.extend_command(cmd_id, start_date, end_date)
# Delete convergence groups if any
DyngroupDatabase().delete_package_convergence(pid)
return True
def getAllGroupName(ctx, value = ''):
return map(lambda x:x.name, DyngroupDatabase().getallgroups(ctx, {'filter':value}))
def getProfileByNameImagingServer(self, name, is_uuid):
return DyngroupDatabase().getProfileByNameImagingServer(name, is_uuid)
def getProfileByUUID(self, uuid):
return DyngroupDatabase().getProfileByUUID(uuid)
def _get_convergence_deploy_group_id_and_user(cmd_id):
return DyngroupDatabase()._get_convergence_deploy_group_id_and_user(cmd_id)
def _get_convergence_phases(cmd_id, deploy_group_id):
return DyngroupDatabase()._get_convergence_phases(cmd_id, deploy_group_id)
def getProfileImagingServerUUID(self, uuid):
return DyngroupDatabase().getProfileImagingServer(uuid)
def addComputersToProfile(self, ctx, computers_UUID, profile_UUID):
return DyngroupDatabase().addmembers_to_group(ctx, profile_UUID,
computers_UUID)
def getProfileContent(self, uuid):
return DyngroupDatabase().getProfileContent(uuid)
def getComputersProfile(self, uuid):
return DyngroupDatabase().getComputersProfile(uuid)
