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))