def add_command_quick_with_id(self, idcmd, target, lang, gid=None):
"""
@param idcmd: id of the quick action
@type idcmd: str
@param target: targets, list of computers UUIDs
@type target: list
@param lang: language to use for the command title (two characters)
@type lang: str
@param gid: if not None, apply command to a group of machine
@type gid: str
"""
ctx = self.currentContext
result, qas = qa_list_files()
if result and idcmd in qas:
try:
desc = qas[idcmd]["title" + lang]
except KeyError:
desc = qas[idcmd]["title"]
if gid:
# Get all targets corresponding to the computer given group ID
target = ComputerGroupManager().get_group_results(
ctx, gid, 0, -1, '', True)
# Use maybeDeferred because addCommandQuick will return an error
# code in case of failure
d = defer.maybeDeferred(MscDatabase().addCommandQuick, ctx,
qas[idcmd]["command"], target, desc, gid)
d.addCallback(xmlrpcCleanup)
ret = d
else:
ret = -1
return ret
def __treatQueryLevelOR(self, ctx, query, grpby, join_query, queries, join_tables, invert = False):
"""
Build OR queries
"""
filter_on = []
for lq in queries:
if len(lq) == 4:
if lq[1] == 'dyngroup':
join_tab = self.computersTable()
computers = ComputerGroupManager().result_group_by_name(ctx, lq[3])
filt = self.computersMapping(computers, invert)
else:
join_tab = self.mappingTable(ctx, lq)
filt = self.mapping(ctx, lq, invert)
join_q = join_query
if type(join_tab) == list:
for table in join_tab:
if table != join_query:
join_q = join_q.outerjoin(table)
else:
join_q = join_q.join(join_tab)
q = query.add_column(grpby).select_from(join_q).filter(filt)
if self.filters.has_key(ctx.userid):
q = q.filter(self.filters[ctx.userid])
q = q.group_by(grpby).all()
res = map(lambda x: x[1], q)
self.logger.debug(">>>> or : %s %s"%(str(lq), str(len(res))))
filter_on.append(grpby.in_(res))
else:
query_filter, join_tables = self.__treatQueryLevel(ctx, query, grpby, join_query, lq, join_tables)
filter_on.append(query_filter)
query_filter = or_(*filter_on)
return (query_filter, join_tables)
def get(self):
try:
self.gid = self.filt["group"]
except KeyError:
self.sendResult()
if self.gid:
self.machines = []
if ComputerGroupManager().isdyn_group(self.ctx, self.gid):
if ComputerGroupManager().isrequest_group(self.ctx, self.gid):
self.machines = ComputerGroupManager().requestresult_group(self.ctx, self.gid, 0, -1, '')
else:
self.machines = ComputerGroupManager().result_group(self.ctx, self.gid, 0, -1, '')
else:
self.machines = ComputerGroupManager().result_group(self.ctx, self.gid, 0, -1, '')
d = MirrorApi().getApiPackages(self.machines)
d.addCallbacks(self.getMirrors, self.onError)
d.addErrback(lambda err: self.onError(err))
def add_bundle_api(self, porders, target, params, mode, gid = None, proxy = []):
ctx = self.currentContext
if gid:
target = ComputerGroupManager().get_group_results(ctx, gid, 0, -1, '', True)
g = mmc.plugins.msc.package_api.SendBundleCommand(ctx, porders, target, params, mode, gid, proxy)
g.deferred = defer.Deferred()
g.send()
g.deferred.addCallbacks(xmlrpcCleanup, lambda err: err)
return g.deferred
def create_update_command(ctx, target, update_list, gid=None):
"""
Create the Windows Update command.
@param target: list of target UUIDs
@type target: list
@param update_list: list of KB numbers to install
@type update_list: list
@param gid: group id - if not None, apply command to a group of machine
@type gid: str
@return: command id
@rtype: Deferred
"""
if update_list:
cmd = "%s -i %s" % (MscConfig().wu_command, " ".join(update_list))
else:
cmd = ''
cmd = cmd + ("\n%s -l --json" % MscConfig().wu_command)
desc = "Install Windows Updates"
if gid:
target = ComputerGroupManager().get_group_results(
ctx, gid, 0, -1, '', True)
do_wol = "disable"
if MscConfig().web_def_awake == 1:
do_wol = "enable"
# set end_date to now() + 24H Refs #2313
fmt = "%Y-%m-%d %H:%M:%S"
end_date = (datetime.datetime.now() +
datetime.timedelta(days=1)).strftime(fmt)
d = defer.maybeDeferred(MscDatabase().addCommand,
ctx,
None,
cmd,
"", [],
target,
'push',
gid,
end_date=end_date,
title=desc,
do_wol=do_wol,
do_windows_update="enable",
cmd_type=4)
d.addCallback(xmlrpcCleanup)
return d
def __treatQueryLevelAND(self,
ctx,
query,
grpby,
join_query,
queries,
join_tables,
invert=False):
"""
Build AND queries
"""
filter_on = []
result_set = None
optimize = True
for lq in queries:
if len(lq) == 4:
if lq[1] == 'dyngroup':
join_tab = self.computersTable()
computers = ComputerGroupManager().result_group_by_name(
ctx, lq[3])
filt = self.computersMapping(computers, invert)
else:
join_tab = self.mappingTable(ctx, lq)
filt = self.mapping(ctx, lq, invert)
join_q = join_query
if type(join_tab) == list:
for table in join_tab:
if table != join_query:
join_q = join_q.join(table)
else:
join_q = join_q.join(join_tab)
q = query.add_column(grpby).select_from(join_q).filter(filt)
if self.filters.has_key(ctx.userid):
q = q.filter(self.filters[ctx.userid])
q = q.group_by(grpby).all()
res = map(lambda x: x[1], q)
self.logger.debug(">>> and : %s %s" % (str(lq), str(len(res))))
if result_set != None:
result_set.intersection_update(Set(res))
else:
result_set = Set(res)
filter_on.append(grpby.in_(res))
else:
optimize = False
query_filter, join_tables = self.__treatQueryLevel(
ctx, query, grpby, join_query, lq, join_tables)
filter_on.append(query_filter)
if optimize:
query_filter = grpby.in_(result_set)
else:
query_filter = and_(*filter_on)
return (query_filter, join_tables)
def add_command_api(self, pid, target, params, p_api, mode, gid = None, proxy = []):
"""
@param target: must be list of UUID
@type target: list
"""
ctx = self.currentContext
#get_group_results(self, ctx, gid, min, max, filter):
if gid:
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)
g.deferred = defer.Deferred()
g.send()
g.deferred.addCallbacks(xmlrpcCleanup, lambda err: err)
return g.deferred
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 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_updates_for_group(params):
"""
Get updates from uuids list if params['uuids'] is a correct list of uuid
and from group if params['gid'] is a correct group id
"""
if 'gid' in params:
params['uuids'] = []
# Creating root context
ctx = SecurityContext()
ctx.userid = 'root'
# get uuid for all computer of this group
ComputerList = ComputerGroupManager().get_group_results(
ctx, params['gid'], 0, -1, {})
for uuid in ComputerList:
params['uuids'].append(int(uuid.lower().replace('uuid', '')))
# get updates for this group
updates = updateDatabase().get_updates_for_group(params)
return updates
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 result_group(self, gid, min, max, filter):
ctx = self.currentContext
return xmlrpcCleanup(ComputerGroupManager().result_group(
ctx, gid, min, max, filter))
def isrequest_group(self, gid):
ctx = self.currentContext
return xmlrpcCleanup(ComputerGroupManager().isrequest_group(ctx, gid))
