Changeset 2600

Timestamp:

12/01/05 23:55:11 (18 years ago)

Author:

jerome

Message:

dumpykota now accepts --data all to dump the whole database in XML format.

Location:

pykota/trunk

Files:

• bin/dumpykota (modified) (2 diffs)
• NEWS (modified) (1 diff)
• pykota/dumper.py (modified) (5 diffs)
• pykota/version.py (modified) (1 diff)

pykota/trunk/bin/dumpykota

@@ -57 +57 @@
                          - umembers : dumps user groups members.
                          - billingcodes : dumps billing codes.
+                         - all : dumps all PyKota datas. The output format
+                                 is always XML in this case.
                          
                        NB : the -d | --data command line option   
@@ -69 +71 @@
                          - ssv : separate datas with semicolons
                          - tsv : separate datas with tabs
-                         - xml : dump data as XML
+                         - xml : dump data as XML 
                          - cups : dump datas in CUPS' page_log format :
                                   ONLY AVAILABLE WITH --data history

pykota/trunk/NEWS

@@ -22 +22 @@
 PyKota NEWS :
        
+    - 1.24alpha5 :
+    
+        - dumpykota can now dump the complete database in XML 
+          format.
+          
     - 1.24alpha4 :
     

pykota/trunk/pykota/dumper.py

@@ -53 +53 @@
                        "umembers" : N_("Users Groups Membership"),
                        "billingcodes" : N_("Billing Codes"),
+                       "all": N_("All"),
                      }
     validformats = { "csv" : N_("Comma Separated Values"),
@@ -74 +75 @@
             raise PyKotaCommandLineError, "%s : %s" % (pwd.getpwuid(os.geteuid())[0], _("You're not allowed to use this command."))
             
-        extractonly = {}
-        for filterexp in arguments :
-            if filterexp.strip() :
-                try :
-                    (filterkey, filtervalue) = [part.strip() for part in filterexp.split("=")]
-                    if filterkey not in self.validfilterkeys :
-                        raise ValueError                
-                except ValueError :    
-                    raise PyKotaCommandLineError, _("Invalid filter value [%s], see help.") % filterexp
-                else :    
-                    extractonly.update({ filterkey : filtervalue })
-            
         datatype = options["data"]
         if datatype not in self.validdatatypes.keys() :
             raise PyKotaCommandLineError, _("Invalid modifier [%s] for --data command line option, see help.") % datatype
                     
+        extractonly = {}
+        if datatype == "all" :            
+            if (options["format"] != "xml") or options["sum"] or arguments :
+                self.printInfo(_("Dumping all PyKota's datas forces format to XML, and disables --sum and filters."), "warn")
+            options["format"] = "xml"
+            options["sum"] = None
+        else :    
+            for filterexp in arguments :
+                if filterexp.strip() :
+                    try :
+                        (filterkey, filtervalue) = [part.strip() for part in filterexp.split("=")]
+                        if filterkey not in self.validfilterkeys :
+                            raise ValueError                
+                    except ValueError :    
+                        raise PyKotaCommandLineError, _("Invalid filter value [%s], see help.") % filterexp
+                    else :    
+                        extractonly.update({ filterkey : filtervalue })
+            
         format = options["format"]
         if (format not in self.validformats.keys()) \
@@ -102 +109 @@
             raise PyKotaCommandLineError, _("Invalid data type [%s] for --sum command line option, see help.") % datatype
             
-        entries = getattr(self.storage, "extract%s" % datatype.title())(extractonly)
-        if entries :
-            mustclose = 0    
-            if options["output"].strip() == "-" :    
-                self.outfile = sys.stdout
-            else :    
-                self.outfile = open(options["output"], "w")
-                mustclose = 1
+            
+        retcode = 0
+        nbentries = 0    
+        mustclose = 0    
+        if options["output"].strip() == "-" :    
+            self.outfile = sys.stdout
+        else :    
+            self.outfile = open(options["output"], "w")
+            mustclose = 1
+            
+        if datatype == "all" :    
+            # NB : order does matter to allow easier or faster restore
+            allentries = []
+            datatypes = [ "printers", "pmembers", "users", "groups", \
+                          "billingcodes", "umembers", "upquotas", \
+                          "gpquotas", "payments", "history" ]
+            for datatype in datatypes :
+                entries = getattr(self.storage, "extract%s" % datatype.title())(extractonly)
+                nbentries += len(entries)
+                allentries.append(entries)
+            retcode = self.dumpXml(allentries, datatypes)
+                         
+        else :    
+            entries = getattr(self.storage, "extract%s" % datatype.title())(extractonly)
+            if entries :
+                nbentries = len(entries)
+                retcode = getattr(self, "dump%s" % format.title())([self.summarizeDatas(entries, datatype, extractonly, options["sum"])], [datatype])
                 
-            retcode = getattr(self, "dump%s" % format.title())(self.summarizeDatas(entries, datatype, extractonly, options["sum"]), datatype)
-            
-            if mustclose :
-                self.outfile.close()
-                
-            return retcode    
-        return 0
+        if mustclose :
+            self.outfile.close()
+            if not nbentries : 
+                os.remove(options["output"])
+            
+        return retcode
         
     def summarizeDatas(self, entries, datatype, extractonly, sum=0) :    
@@ -181 +206 @@
             return newentries
             
-    def dumpWithSeparator(self, separator, entries) :    
+    def dumpWithSeparator(self, separator, allentries) :    
         """Dumps datas with a separator."""
-        for entry in entries :
-            line = []
-            for value in entry :
-                if type(value).__name__ in ("str", "NoneType") :
-                    line.append('"%s"' % str(value).replace(separator, "\\%s" % separator).replace('"', '\\"'))
-                else :    
-                    line.append(str(value))
-            try :
-                self.outfile.write("%s\n" % separator.join(line))
-            except IOError, msg :    
-                sys.stderr.write("%s : %s\n" % (_("PyKota data dumper failed : I/O error"), msg))
-                return -1
+        for entries in allentries :
+            for entry in entries :
+                line = []
+                for value in entry :
+                    if type(value).__name__ in ("str", "NoneType") :
+                        line.append('"%s"' % str(value).replace(separator, "\\%s" % separator).replace('"', '\\"'))
+                    else :    
+                        line.append(str(value))
+                try :
+                    self.outfile.write("%s\n" % separator.join(line))
+                except IOError, msg :    
+                    sys.stderr.write("%s : %s\n" % (_("PyKota data dumper failed : I/O error"), msg))
+                    return -1
         return 0        
         
-    def dumpCsv(self, entries, dummy) :    
+    def dumpCsv(self, allentries, dummy) :    
         """Dumps datas with a comma as the separator."""
-        return self.dumpWithSeparator(",", entries)
+        return self.dumpWithSeparator(",", allentries)
                            
-    def dumpSsv(self, entries, dummy) :    
+    def dumpSsv(self, allentries, dummy) :    
         """Dumps datas with a comma as the separator."""
-        return self.dumpWithSeparator(";", entries)
+        return self.dumpWithSeparator(";", allentries)
                            
-    def dumpTsv(self, entries, dummy) :    
+    def dumpTsv(self, allentries, dummy) :    
         """Dumps datas with a comma as the separator."""
-        return self.dumpWithSeparator("\t", entries)
-        
-    def dumpCups(self, entries, dummy) :    
+        return self.dumpWithSeparator("\t", allentries)
+        
+    def dumpCups(self, allentries, dummy) :    
         """Dumps history datas as CUPS' page_log format."""
+        entries = allentries[0]
         fieldnames = entries[0]
         fields = {}
@@ -231 +258 @@
             for pagenum in range(1, jobsize+1) :
                 self.outfile.write("%s %s %s [%s] %s %s %s %s\n" % (printername, username, jobid, jobdate, pagenum, copies, billingcode, hostname))
-        
-    def dumpXml(self, entries, datatype) :    
+        return 0        
+        
+    def dumpXml(self, allentries, datatypes) :
         """Dumps datas as XML."""
         x = jaxml.XML_document(encoding="UTF-8")
         x.pykota(version=version.__version__, author=version.__author__)
-        x.dump(storage=self.config.getStorageBackend()["storagebackend"], type=datatype)
-        headers = entries[0]
-        for entry in entries[1:] :
+        for (entries, datatype) in zip(allentries, datatypes) :
             x._push()
-            x.entry()
-            for (header, value) in zip(headers, entry) :
-                strvalue = str(value)
-                typval = type(value).__name__
-                if header in ("filename", "title", "options", "billingcode") \
-                          and (typval == "str") :
-                    try :
-                        strvalue = unicode(strvalue, self.getCharset()).encode("UTF-8")
-                    except UnicodeError :    
-                        pass
-                    strvalue = saxutils.escape(strvalue, { "'" : "'", \
-                                                           '"' : """ })
-                x.attribute(strvalue, type=typval, name=header)
+            x.dump(storage=self.config.getStorageBackend()["storagebackend"], type=datatype)
+            headers = entries[0]
+            for entry in entries[1:] :
+                x._push()
+                x.entry()
+                for (header, value) in zip(headers, entry) :
+                    strvalue = str(value)
+                    typval = type(value).__name__
+                    if header in ("filename", "title", "options", "billingcode") \
+                              and (typval == "str") :
+                        try :
+                            strvalue = unicode(strvalue, self.getCharset()).encode("UTF-8")
+                        except UnicodeError :    
+                            pass
+                        strvalue = saxutils.escape(strvalue, { "'" : "'", \
+                                                               '"' : """ })
+                    x.attribute(strvalue, type=typval, name=header)
+                x._pop()    
             x._pop()    
         x._output(self.outfile)
+        return 0        

pykota/trunk/pykota/version.py

@@ -22 +22 @@
 #
 
-__version__ = "1.24alpha4_unofficial"
+__version__ = "1.24alpha5_unofficial"
 
 __doc__ = "PyKota : a complete Printing Quota Solution for CUPS."