Submitted By: Mario Fetka (geos_one) (mario dot fetka at gmail dot com) Date: 2010-05-01 Initial Package Version: 2.3.1 Origin: http://mds.mandriva.org/svn/mmc-agent/branches/printing Upstream Status: unknown Description: add the printing plugin from the 2.3.1 branch diff -Naur mds-2.4.0.orig/agent/conf/plugins/printing.ini mds-2.4.0/agent/conf/plugins/printing.ini --- mds-2.4.0.orig/agent/conf/plugins/printing.ini 1970-01-01 00:00:00.000000000 +0000 +++ mds-2.4.0/agent/conf/plugins/printing.ini 2010-05-01 11:57:24.515871440 +0000 @@ -0,0 +1,5 @@ +[main] +# Is this plugin disabled ? +disable = 0 +# Where are located the printers +basePrintersDN = ou=Printers, dc=linbox, dc=com diff -Naur mds-2.4.0.orig/agent/conf/plugins/printstats.ini mds-2.4.0/agent/conf/plugins/printstats.ini --- mds-2.4.0.orig/agent/conf/plugins/printstats.ini 1970-01-01 00:00:00.000000000 +0000 +++ mds-2.4.0/agent/conf/plugins/printstats.ini 2010-05-01 11:57:24.516870811 +0000 @@ -0,0 +1,26 @@ +[main] +disable = 0 +dbhost = localhost +dbport = 5432 +dbname = lpstats +dbuser = lpstats +dbpasswd = lpstats + +[sql] +history = SELECT sum(pages * copies), (SELECT EXTRACT(day FROM date)) AS day, (SELECT EXTRACT(month from date)) AS month, (SELECT EXTRACT(year from date)) AS year FROM linboxprintstats WHERE (now()::date - date::date <= %(days)d and printserver like '%(printserver)s') GROUP by day, month, year; + +historybymonth = SELECT sum(pages * copies), (SELECT EXTRACT(month from date)) AS month, (SELECT EXTRACT(year from date)) AS year FROM linboxprintstats WHERE (now()::date - date::date <= %(days)d and printserver like '%(printserver)s') GROUP by month, year; + +printers = select lps.printer as impr, coalesce(sum(lps.copies * lps.pages), 0) as total , (select coalesce(sum(lps2.copies * lps2.pages), 0) from linboxprintstats lps2 where (lps.printer = lps2.printer and lps2.color = 2 and lps2.date >= '%(begin)s' and lps2.date<='%(end)s' and lps2.printserver like '%(printserver)s')) as color, (select coalesce(sum(lps3.copies * lps3.pages), 0) from linboxprintstats lps3 where (lps3.printer = lps.printer and lps3.color <= 1 and lps3.date >= '%(begin)s' and lps3.date <= '%(end)s' and lps3.printserver like '%(printserver)s')) as bw from linboxprintstats lps where (lps.date >= '%(begin)s' and lps.date <= '%(end)s' and lps.printserver like '%(printserver)s') group by lps.printer order by %(orderby)s %(sort)s limit %(limit)s; + +users = select lps.username, coalesce(sum(lps.copies * lps.pages), 0) as total , (select coalesce(sum(lps2.copies * lps2.pages), 0) from linboxprintstats lps2 where (lps2.username = lps.username and lps2.color = 2 and lps2.date >= '%(begin)s' and lps2.date <= '%(end)s' and lps2.printserver like '%(printserver)s')) as color, (select coalesce(sum(lps3.copies * lps3.pages), 0) from linboxprintstats lps3 where (lps3.username = lps.username and lps3.color<=1 and lps3.date >= '%(begin)s' and lps3.date <= '%(end)s' and lps3.printserver like '%(printserver)s')) as bw from linboxprintstats lps where (lps.date >= '%(begin)s' and lps.date <= '%(end)s' and lps.printserver like '%(printserver)s') group by lps.username order by %(orderby)s %(sort)s limit %(limit)s; + +printer = select (select sum(lps2.copies) from linboxprintstats lps2 where (lps2.pages >= '%(lim1)d' and lps2.pages <= '%(lim2)d' and lps2.printer='%(printer)s' and lps2.date >= '%(begin)s' and date <= '%(end)s' and lps2.printserver like '%(printserver)s')), (select sum(lps3.copies) from linboxprintstats lps3 where (lps3.pages > '%(lim2)d' and lps3.pages <= '%(lim3)d' and lps3.printer='%(printer)s' and lps3.date >= '%(begin)s' and lps3.date <= '%(end)s') and lps3.printserver like '%(printserver)s'), (select sum(lps4.copies) from linboxprintstats lps4 where (lps4.pages > '%(lim3)s' and lps4.pages <= '%(lim4)s' and lps4.printer = '%(printer)s' and lps4.date >= '%(begin)s' and lps4.date <= '%(end)s' and lps4.printserver like '%(printserver)s')), (select sum(lps5.copies) from linboxprintstats lps5 where (lps5.pages > '%(lim4)s' and lps5.pages <= '%(lim5)s' and lps5.printer = '%(printer)s' and lps5.date >= '%(begin)s' and lps5.date <= '%(end)s' and lps5.printserver like '%(printserver)s')), (select sum(lps6.copies) from linboxprintstats lps6 where (lps6.pages > '%(lim5)s' and lps6.printer = '%(printer)s' and lps6.date >= '%(begin)s' and date <= '%(end)s' and lps6.printserver like '%(printserver)s')) from linboxprintstats limit 1; + +user4printer = select lps.username, coalesce(sum(lps.copies * lps.pages), 0) as total , (select coalesce(sum(lps2.copies * lps2.pages), 0) from linboxprintstats lps2 where (lps2.printer = '%(printer)s' and lps2.username = lps.username and lps2.color = 2 and lps2.date >= '%(begin)s' and lps2.date <= '%(end)s' and lps2.printserver like '%(printserver)s')) as color, (select coalesce(sum(lps3.copies * lps3.pages), 0) from linboxprintstats lps3 where (lps3.printer = '%(printer)s' and lps3.username = lps.username and lps3.color <= 1 and lps3.date >= '%(begin)s' and lps3.date <= '%(end)s' and lps3.printserver like '%(printserver)s')) as bw from linboxprintstats lps where (lps.printer = '%(printer)s' and lps.date >= '%(begin)s' and lps.date <= '%(end)s' and lps.printserver like '%(printserver)s') group by username order by %(orderby)s %(sort)s limit %(limit)s; + +printservers = select distinct(printserver) from linboxprintstats; + +printerlist = select distinct(printer) from linboxprintstats; + +colors = SELECT color,sum(copies*pages) from linboxprintstats WHERE (date >= '%(begin)s' and date <= '%(end)s' and printserver like '%(printserver)s') GROUP by color; diff -Naur mds-2.4.0.orig/agent/mmc/plugins/printing/__init__.py mds-2.4.0/agent/mmc/plugins/printing/__init__.py --- mds-2.4.0.orig/agent/mmc/plugins/printing/__init__.py 1970-01-01 00:00:00.000000000 +0000 +++ mds-2.4.0/agent/mmc/plugins/printing/__init__.py 2010-05-01 11:57:29.705870043 +0000 @@ -0,0 +1,480 @@ +# -*- coding: utf-8; -*- +# +# (c) 2004-2007 Linbox / Free&ALter Soft, http://linbox.com +# (c) 2007-2008 Mandriva, http://www.mandriva.com +# +# $Id: __init__.py 642 2008-05-19 16:16:55Z cdelfosse $ +# +# This file is part of Mandriva Management Console (MMC). +# +# MMC is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# MMC is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with MMC; if not, write to the Free Software +# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + +import ConfigParser +import logging + +import ldap +from ldap.modlist import addModlist + +from mmc.plugins.base import ldapUserGroupControl, GpoManager +from mmc.support import mmctools + +VERSION = "2.3.1" +APIVERSION = "1:0:0" +REVISION = int("$Rev: 642 $".split(':')[1].strip(' $')) + +def getVersion(): return VERSION +def getApiVersion(): return APIVERSION +def getRevision(): return REVISION + +def activate(): + """ + This function defines if this module can be activated + @return: return True if this module can be activated + @rtype: boolean + """ + configParser = mmctools.getConfigParser("printing") + logger = logging.getLogger() + ret = False + if configParser.get("main", "disable") == "1": + logger.info("printing plugin disabled by configuration.") + else: + # Create Printers Ou + p = ldapPrinters() + head, path = p.basePrintersDN.split(",", 1) + ouName = head.split("=")[1] + try: + p.addOu(ouName, path) + logger.info("Created OU " + p.basePrintersDN) + except ldap.ALREADY_EXISTS: + pass + gpomanager = GpoManager("Printers") + try: + gpomanager.add("GPOPrintServiceAccessAllowed", { "ACLPrintServiceAccess" : "True" }) + except ldap.ALREADY_EXISTS: + pass + try: + gpomanager.add("GPOPrintServiceAllRights", { "ACLPrintServiceAllRights" : "True" }) + except ldap.ALREADY_EXISTS: + pass + ret = True + return ret + +# Printers management + +def get(pattern = "*"): + return ldapPrinters().get(pattern) + +def add(name, location = "", info = ""): + d = {} + d["printer-name"] = name + d["printer-location"] = location + d["printer-info"] = info + return ldapPrinters().add(d) + +def delete(name): + return ldapPrinters().delete(name) + +def exists(printer): + return ldapPrinters().exists(printer) + +# User rights management + +def addUserServiceAccessAllowed(uid): + ldapPrinters().addUserServiceAccessAllowed(uid) + +def delUserServiceAccessAllowed(uid): + ldapPrinters().delUserServiceAccessAllowed(uid) + +def isUserServiceAccessAllowed(uid): + return ldapPrinters().isUserServiceAccessAllowed(uid) + +def addUserServiceAllRights(uid): + ldapPrinters().addUserServiceAllRights(uid) + +def delUserServiceAllRights(uid): + ldapPrinters().delUserServiceAllRights(uid) + +def isUserServiceAllRights(uid): + return ldapPrinters().isUserServiceAllRights(uid) + +def addUserPrinterAccessAllowed(uid, printer): + ldapPrinters().addUserPrinterAccessAllowed(uid, printer) + +def delUserPrinterAccessAllowed(uid, printer): + ldapPrinters().delUserPrinterAccessAllowed(uid, printer) + +def getUserPrintersAccessAllowed(uid): + return ldapPrinters().getUserPrintersAccessAllowed(uid) + +# Group rights management + +def addGroupServiceAccessAllowed(group): + ldapPrinters().addGroupServiceAccessAllowed(group) + +def delGroupServiceAccessAllowed(group): + ldapPrinters().delGroupServiceAccessAllowed(group) + +def isGroupServiceAccessAllowed(group): + return ldapPrinters().isGroupServiceAccessAllowed(group) + +def addGroupServiceAllRights(group): + ldapPrinters().addGroupServiceAllRights(group) + +def delGroupServiceAllRights(group): + ldapPrinters().delGroupServiceAllRights(group) + +def isGroupServiceAllRights(group): + return ldapPrinters().isGroupServiceAllRights(group) + +def addGroupPrinterAccessAllowed(group, printer): + ldapPrinters().addGroupPrinterAccessAllowed(group, printer) + +def delGroupPrinterAccessAllowed(group, printer): + ldapPrinters().delGroupPrinterAccessAllowed(group, printer) + +def getGroupPrintersAccessAllowed(group): + return ldapPrinters().getGroupPrintersAccessAllowed(group) + +# + +def getUsersAccessAllowedForPrinter(printer): + return ldapPrinters().getUsersAccessAllowedForPrinter(printer) + +def getGroupsAccessAllowedForPrinter(printer): + return ldapPrinters().getGroupsAccessAllowedForPrinter(printer) + +# + +def getUsersPrintServiceGPO(gpo): + return ldapPrinters().getUsersPrintServiceGPO(gpo) + +def getGroupsPrintServiceGPO(gpo): + return ldapPrinters().getGroupsPrintServiceGPO(gpo) + + +class ldapPrinters(ldapUserGroupControl): + + # Printers management methods + def __init__(self, conffile = None, conffilebase = None, gpoCreate = True): + """ + @param gpoCreate: If True, base GPO for printer rights management will be created. + @type gpoCreate: bool + """ + ldapUserGroupControl.__init__(self, conffilebase) + cp = ConfigParser.ConfigParser() + if not conffile: + cp = mmctools.getConfigParser("printing") + else: + cp = ConfigParser.ConfigParser() + cp.read(conffile) + self.basePrintersDN = cp.get("main", "basePrintersDN").replace(" ", "") + self.gpomanager = GpoManager("Printers", conffilebase, gpoCreate) + + def get(self, pattern="*"): + """ + Return the printers list found in the LDAP. + """ + entries = self.search("printer-name="+pattern, self.basePrintersDN) + result = [] + for entry in entries: + dn, attrs = entry[0] + result.append(attrs["printer-name"][0]) + result.sort() + return result + + def add(self, printerDesc): + """ + Add a printer into the LDAP. + + The GPOs corresponding to the printer are created too. + """ + printerDesc["objectClass"] = ("printerService") + modlist = addModlist(printerDesc) + entry = "printer-name=" + printerDesc["printer-name"] + "," + self.basePrintersDN + self.l.add_s(entry, modlist) + self.gpomanager.add("GPOPrinterAccessAllowed_" + printerDesc["printer-name"], { "PrinterServiceAccess" : "True" }) + + def delete(self, name): + """ + Delete a printer from the LDAP. + + The GPOs corresponding to the printer are deleted too. + """ + entry = "printer-name=" + name + ", " + self.basePrintersDN + self.delRecursiveEntry(entry) + self.gpomanager.delete("GPOPrinterAccessAllowed_" + name) + + def exists(self, printer): + """ + Return True if a printer with this name exists. + """ + entry = self.search("printer-name=" + printer, self.basePrintersDN) + return (len(entry) == 1) + + # Users rights management + + def addUserServiceAccessAllowed(self, uid): + """ + Give an user the right to access the print service + + @param uid: user to give access + """ + self.gpomanager.addUserToGPO(uid, "GPOPrintServiceAccessAllowed") + + def delUserServiceAccessAllowed(self, uid): + """ + Remove an user the right to access the print service + + @param uid: user to give access + """ + self.gpomanager.delUserFromGPO(uid, "GPOPrintServiceAccessAllowed") + + def isUserServiceAccessAllowed(self, uid): + """ + Return true if the user has print service access + + @param uid: user to get access + @rtype: Boolean + """ + dn = "uid=" + uid + "," + self.baseUsersDN + members = self.gpomanager.getUsersFromGPO("GPOPrintServiceAccessAllowed") + return dn in members + + def addUserServiceAllRights(self, uid): + """ + Give an user the right to access the print service without restriction + + @param uid: user to give access + """ + self.gpomanager.addUserToGPO(uid, "GPOPrintServiceAllRights") + + def delUserServiceAllRights(self, uid): + """ + Remove an user the right to access the print service without restriction + + @param uid: user to give access + """ + self.gpomanager.delUserFromGPO(uid, "GPOPrintServiceAllRights") + + def isUserServiceAllRights(self, uid): + """ + Return true if the user has print service access without restriction + + @param uid: user to get access + @rtype: Boolean + """ + dn = "uid=" + uid + "," + self.baseUsersDN + members = self.gpomanager.getUsersFromGPO("GPOPrintServiceAllRights") + return dn in members + + def addUserPrinterAccessAllowed(self, uid, printer): + """ + Give an user the right to use a printer + + @param uid: user to give access + @param printer: printer name + """ + self.gpomanager.addUserToGPO(uid, "GPOPrinterAccessAllowed_" + printer) + + def delUserPrinterAccessAllowed(self, uid, printer): + """ + Remove an user the right to access the print service + + @param uid: user to give access + @param printer: printer name + """ + self.gpomanager.delUserFromGPO(uid, "GPOPrinterAccessAllowed_" + printer) + + def getUserPrintersAccessAllowed(self, uid): + """ + Return the list of printers the user has right access + + @param uid: user name + """ + dn = "uid=" + uid + "," + self.baseUsersDN + return self.gpomanager.getResourceGpo(dn, "GPOPrinterAccessAllowed") + + # Groups rights management + + def addGroupServiceAccessAllowed(self, group): + """ + Give a group the right to access the print service + + @param group: group to give access to + """ + self.gpomanager.addGroupToGPO(group, "GPOPrintServiceAccessAllowed") + + def delGroupServiceAccessAllowed(self, group): + """ + Remove a group the right to access the print service + + @param group: group to give access to + """ + self.gpomanager.delGroupFromGPO(group, "GPOPrintServiceAccessAllowed") + + def isGroupServiceAccessAllowed(self, group): + """ + Return true if the group has print service access + + @param group: group to get access + @rtype: Boolean + """ + dn = "cn=" + group + "," + self.baseGroupsDN + members = self.gpomanager.getGroupsFromGPO("GPOPrintServiceAccessAllowed") + return dn in members + + def addGroupServiceAllRights(self, group): + """ + Give a group the right to access to the print service without restriction + + @param group: group to give access to + """ + self.gpomanager.addGroupToGPO(group, "GPOPrintServiceAllRights") + + def delGroupServiceAllRights(self, group): + """ + Remove a group the right to access to the print service without restriction + + @param group: group to give access to + """ + self.gpomanager.delGroupFromGPO(group, "GPOPrintServiceAllRights") + + def isGroupServiceAllRights(self, group): + """ + Return true if the group has print service access without restriction + + @param group: group to get access + @rtype: Boolean + """ + dn = "cn=" + group + "," + self.baseGroupsDN + members = self.gpomanager.getGroupsFromGPO("GPOPrintServiceAllRights") + return dn in members + + def addGroupPrinterAccessAllowed(self, group, printer): + """ + Give a group the right to use a printer + + @param group: group to give access + @param printer: printer name + """ + self.gpomanager.addGroupToGPO(group, "GPOPrinterAccessAllowed_" + printer) + + def delGroupPrinterAccessAllowed(self, group, printer): + """ + Remove a group the right to access the print service + + @param group: group to give access + @param printer: printer name + """ + self.gpomanager.delGroupFromGPO(group, "GPOPrinterAccessAllowed_" + printer) + + def getGroupPrintersAccessAllowed(self, group): + """ + Return the list of printers the group has right access + + @param group: group name + """ + dn = "cn=" + group + "," + self.baseGroupsDN + return self.gpomanager.getResourceGpo(dn, "GPOPrinterAccessAllowed") + + # Methods to know who can print on a specific printer + + def getUsersAccessAllowedForPrinter(self, printer): + """ + Return the list of users who can use this printer + + @param printer: the printer name + """ + ret = [] + for dn in self.gpomanager.getUsersFromGPO("GPOPrinterAccessAllowed_" + printer): + # Process dn to only return the uid value + ret.append(dn.split(",")[0].split("=")[1]) + return ret + + def getGroupsAccessAllowedForPrinter(self, printer): + """ + Return the list of groups who can use this printer + + @param printer: the printer name + """ + ret = [] + for dn in self.gpomanager.getGroupsFromGPO("GPOPrinterAccessAllowed_" + printer): + # Process dn to only return the cn value + ret.append(dn.split(",")[0].split("=")[1]) + return ret + + # To get print service GPO members + + def getUsersPrintServiceGPO(self, gpo): + """ + Return the list of users member of the GPO. + + @param gpo: Name of the GPO + """ + ret = [] + for dn in self.gpomanager.getUsersFromGPO(gpo): + # Process dn to only return the uid value + ret.append(dn.split(",")[0].split("=")[1]) + return ret + + def getGroupsPrintServiceGPO(self, gpo): + """ + Return the list of groups member of this GPO + + @param gpo: Name of the GPO + """ + ret = [] + for dn in self.gpomanager.getGroupsFromGPO(gpo): + # Process dn to only return the cn value + ret.append(dn.split(",")[0].split("=")[1]) + return ret + + def userCanPrintOn(self, uid, printer): + """ + This method is used by the MMC CUPS backend to check if an user can print on a printer. + For the moment, only access right is checked according to group membership. + + @return: True if the user uid can print on the printer + @rtype: boolean + """ + result = False + + groups = self.getUserGroups(uid) + # Get groups which has print service access + groupAccess = [] + for group in groups: + if self.isGroupServiceAccessAllowed(group): + groupAccess.append(group) + + # Get remaining group which has all rights on print service + groupAllrights = [] + for group in groupAccess: + if self.isGroupServiceAllRights(group): + groupAllrights.append(group) + + if len(groupAllrights): + # User is in a group which has all rights on print service. + # So this user can print + result = True + else: + # Does one of these groups has the right to use this printer ? + for group in groupAccess: + printers = self.getGroupPrintersAccessAllowed(group) + if printer in printers: + # We have a winner + result = True + break + + return result diff -Naur mds-2.4.0.orig/agent/mmc/plugins/printstats/__init__.py mds-2.4.0/agent/mmc/plugins/printstats/__init__.py --- mds-2.4.0.orig/agent/mmc/plugins/printstats/__init__.py 1970-01-01 00:00:00.000000000 +0000 +++ mds-2.4.0/agent/mmc/plugins/printstats/__init__.py 2010-05-01 11:57:29.707870252 +0000 @@ -0,0 +1,219 @@ +# -*- coding: utf-8; -*- +# +# (c) 2004-2007 Linbox / Free&ALter Soft, http://linbox.com +# (c) 2007 Mandriva, http://www.mandriva.com/ +# +# $Id: __init__.py 454 2008-01-18 14:09:42Z cedric $ +# +# This file is part of Mandriva Management Console (MMC). +# +# MMC is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# MMC is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with MMC; if not, write to the Free Software +# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + +import psycopg +import ConfigParser +import logging +from mmc.support import mmctools + +VERSION = "2.3.1" +APIVERSION = "1:0:0" +REVISION = int("$Rev: 557 $".split(':')[1].strip(' $')) + +def getVersion(): return VERSION +def getApiVersion(): return APIVERSION +def getRevision(): return REVISION + +def activate(): + """ + This function defines if this module can be activated + @return: return True if this module can be activated + @rtype: boolean + """ + configParser = mmctools.getConfigParser("printstats") + logger = logging.getLogger() + ret = False + if configParser.get("main", "disable") == "1": + logger.info("printstats plugin disabled by configuration.") + else: ret = True + return ret + +def getHistory(printserver, days): + return Printstats().getHistory(printserver, days) + +def getHistoryByMonths(printserver, days): + return Printstats().getHistoryByMonths(printserver, days) + +def getPrintersStats(printserver, begin, end, orderby, sort, limit): + return Printstats().getPrintersStats(printserver, begin, end, orderby, sort, limit) + +def getPrinterStats(printserver, printer, begin, end, lim1, lim2, lim3, lim4, lim5): + return Printstats().getPrinterStats(printserver, printer, begin, end, lim1, lim2, lim3, lim4, lim5) + +def getUsersStatsForPrinter(printserver, printer, begin, end, orderby, sort, limit): + return Printstats().getUsersStatsForPrinter(printserver, printer, begin, end, orderby, sort, limit) + +def getUsersStats(printserver, begin, end, orderby, sort, limit): + return Printstats().getUsersStats(printserver, begin, end, orderby, sort, limit) + +def getPrintServers(): + return Printstats().getPrintServers() + +def getPrinterList(): + return Printstats().getPrinterList() + +def getColors(printserver, begin, end): + return Printstats().getColors(printserver, begin, end) + +class Printstats: + + def __init__(self, conffile = "/etc/mmc/plugins/printstats.ini"): + cp = ConfigParser.RawConfigParser() + cp.read(conffile) + self.dbhost = cp.get("main", "dbhost") + self.dbport = cp.get("main", "dbport") + self.dbname = cp.get("main", "dbname") + self.dbuser = cp.get("main", "dbuser") + self.dbpasswd = cp.get("main", "dbpasswd") + self.sql = {} + for option in cp.options("sql"): + self.sql[option] = cp.get("sql", option) + + def _getCursor(self): + l = logging.getLogger() + l.debug("Connecting to dbname=%s user=%s password=%s host=%s port=%s" % (self.dbname, self.dbuser, self.dbpasswd, self.dbhost, self.dbport)) + self.db = psycopg.connect("dbname=%s user=%s password=%s host=%s port=%s" % (self.dbname, self.dbuser, self.dbpasswd, self.dbhost, self.dbport)) + return self.db.cursor() + + def _prepareData(self, data): + ret = [] + for item in data: + if not None in item: ret.append(item) + else: + new = () + for i in item: + if i == None: new = new + (0,) + else: new = new + (i,) + ret.append(new) + return ret + + def _printServerQuery(self, printserver, where = False): + if printserver == "ALL": ret = "%" + else: ret = printserver + return ret + + def getHistory(self, printserver, days): + c = self._getCursor() + d = {} + d["days"] = days + d["printserver"] = self._printServerQuery(printserver) + c.execute(self.sql["history"] % d) + ret = c.fetchall() + self.db.close() + return ret + + def getHistoryByMonths(self, printserver, days): + c = self._getCursor() + d = {} + d["days"] = days + d["printserver"] = self._printServerQuery(printserver) + c.execute(self.sql["historybymonth"] % d) + ret = c.fetchall() + self.db.close() + return ret + + def getPrintersStats(self, printserver, begin, end, orderby, sort, limit): + c = self._getCursor() + d = {} + d["begin"] = begin + d["end"] = end + d["printserver"] = self._printServerQuery(printserver) + d["orderby"] = orderby + d["sort"] = sort + d["limit"] = limit + c.execute(self.sql["printers"] % d) + result = c.fetchall() + self.db.close() + return self._prepareData(result) + + def getUsersStats(self, printserver, begin, end, orderby, sort, limit): + c = self._getCursor() + d = {} + d["begin"] = begin + d["end"] = end + d["printserver"] = self._printServerQuery(printserver) + d["orderby"] = orderby + d["sort"] = sort + d["limit"] = limit + c.execute(self.sql["users"] % d) + ret = c.fetchall() + self.db.close() + return self._prepareData(ret) + + def getPrinterStats(self, printserver, printer, begin, end, lim1, lim2, lim3, lim4, lim5): + c = self._getCursor() + d = {} + d["printserver"] = self._printServerQuery(printserver, True) + d["printer"] = printer + d["begin"] = begin + d["end"] = end + d["lim1"] = lim1 + d["lim2"] = lim2 + d["lim3"] = lim3 + d["lim4"] = lim4 + d["lim5"] = lim5 + c.execute(self.sql["printer"] % d) + ret = c.fetchall() + self.db.close() + return self._prepareData(ret) + + def getUsersStatsForPrinter(self, printserver, printer, begin, end, orderby, sort, limit): + d = {} + d["printserver"] = self._printServerQuery(printserver) + d["printer"] = printer + d["begin"] = begin + d["end"] = end + d["orderby"] = orderby + d["sort"] = sort + d["limit"] = limit + c = self._getCursor() + c.execute(self.sql["user4printer"] % d) + ret = c.fetchall() + self.db.close() + return self._prepareData(ret) + + def getPrintServers(self): + c = self._getCursor() + c.execute(self.sql["printservers"]) + ret = c.fetchall() + self.db.close() + return self._prepareData(ret) + + def getPrinterList(self): + c = self._getCursor() + c.execute(self.sql["printerlist"]) + ret = c.fetchall() + self.db.close() + return self._prepareData(ret) + + def getColors(self, printserver, begin, end): + d = {} + d["printserver"] = self._printServerQuery(printserver) + d["begin"] = begin + d["end"] = end + c = self._getCursor() + c.execute(self.sql["colors"] % d) + ret = c.fetchall() + self.db.close() + return self._prepareData(ret) + diff -Naur mds-2.4.0.orig/agent/setup.py mds-2.4.0/agent/setup.py --- mds-2.4.0.orig/agent/setup.py 2010-05-01 11:54:47.347622644 +0000 +++ mds-2.4.0/agent/setup.py 2010-05-01 11:58:36.108623972 +0000 @@ -39,5 +39,6 @@ packages = ["mmc.plugins.samba", "mmc.plugins.mail", "mmc.plugins.network", "mmc.plugins.proxy", "mmc.plugins.sshlpk", "mmc.plugins.bulkimport", - "mmc.plugins.userquota"], + "mmc.plugins.userquota", "mmc.plugins.printstats", + "mmc.plugins.printing"], )