dak/examine_package.py

   1 #!/usr/bin/env python
   2
   3 # Script to automate some parts of checking NEW packages
   4 # Copyright (C) 2000, 2001, 2002, 2003  James Troup <james@nocrew.org>
   5 # $Id: fernanda.py,v 1.10 2003-11-10 23:01:17 troup Exp $
   6
   7 # This program is free software; you can redistribute it and/or modify
   8 # it under the terms of the GNU General Public License as published by
   9 # the Free Software Foundation; either version 2 of the License, or
  10 # (at your option) any later version.
  11
  12 # This program is distributed in the hope that it will be useful,
  13 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 # GNU General Public License for more details.
  16
  17 # You should have received a copy of the GNU General Public License
  18 # along with this program; if not, write to the Free Software
  19 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20
  21 ################################################################################
  22
  23 # <Omnic> elmo wrote docs?!!?!?!?!?!?!
  24 # <aj> as if he wasn't scary enough before!!
  25 # * aj imagines a little red furry toy sitting hunched over a computer
  26 #   tapping furiously and giggling to himself
  27 # <aj> eventually he stops, and his heads slowly spins around and you
  28 #      see this really evil grin and then he sees you, and picks up a
  29 #      knife from beside the keyboard and throws it at you, and as you
  30 #      breathe your last breath, he starts giggling again
  31 # <aj> but i should be telling this to my psychiatrist, not you guys,
  32 #      right? :)
  33
  34 ################################################################################
  35
  36 import errno, os, re, sys
  37 import utils
  38 import apt_pkg, apt_inst
  39 import pg, db_access
  40
  41 ################################################################################
  42
  43 re_package = re.compile(r"^(.+?)_.*");
  44 re_doc_directory = re.compile(r".*/doc/([^/]*).*");
  45
  46 re_contrib = re.compile('^contrib/')
  47 re_nonfree = re.compile('^non\-free/')
  48
  49 re_arch = re.compile("Architecture: .*")
  50 re_builddep = re.compile("Build-Depends: .*")
  51 re_builddepind = re.compile("Build-Depends-Indep: .*")
  52
  53 re_localhost = re.compile("localhost\.localdomain")
  54 re_version = re.compile('^(.*)\((.*)\)')
  55
  56 re_newlinespace = re.compile('\n')
  57 re_spacestrip = re.compile('(\s)')
  58
  59 ################################################################################
  60
  61 # Colour definitions
  62
  63 # Main
  64 main_colour = "\033[36m";
  65 # Contrib
  66 contrib_colour = "\033[33m";
  67 # Non-Free
  68 nonfree_colour = "\033[31m";
  69 # Arch
  70 arch_colour = "\033[32m";
  71 # End
  72 end_colour = "\033[0m";
  73 # Bold
  74 bold_colour = "\033[1m";
  75 # Bad maintainer
  76 maintainer_colour = arch_colour;
  77
  78 ################################################################################
  79
  80 Cnf = None;
  81 projectB = None;
  82
  83 Cnf = utils.get_conf()
  84 projectB = pg.connect(Cnf["DB::Name"], Cnf["DB::Host"], int(Cnf["DB::Port"]))
  85 db_access.init(Cnf, projectB);
  86
  87 ################################################################################
  88
  89 def usage (exit_code=0):
  90     print """Usage: fernanda [PACKAGE]...
  91 Check NEW package(s).
  92
  93   -h, --help                 show this help and exit
  94
  95 PACKAGE can be a .changes, .dsc, .deb or .udeb filename."""
  96
  97     sys.exit(exit_code)
  98
  99 ################################################################################
 100
 101 def get_depends_parts(depend) :
 102     v_match = re_version.match(depend)
 103     if v_match:
 104         d_parts = { 'name' : v_match.group(1), 'version' : v_match.group(2) }
 105     else :
 106         d_parts = { 'name' : depend , 'version' : '' }
 107     return d_parts
 108
 109 def get_or_list(depend) :
 110     or_list = depend.split("|");
 111     return or_list
 112
 113 def get_comma_list(depend) :
 114     dep_list = depend.split(",");
 115     return dep_list
 116
 117 def split_depends (d_str) :
 118     # creates a list of lists of dictionaries of depends (package,version relation)
 119
 120     d_str = re_spacestrip.sub('',d_str);
 121     depends_tree = [];
 122     # first split depends string up amongs comma delimiter
 123     dep_list = get_comma_list(d_str);
 124     d = 0;
 125     while d < len(dep_list):
 126         # put depends into their own list
 127         depends_tree.append([dep_list[d]]);
 128         d += 1;
 129     d = 0;
 130     while d < len(depends_tree):
 131         k = 0;
 132         # split up Or'd depends into a multi-item list
 133         depends_tree[d] = get_or_list(depends_tree[d][0]);
 134         while k < len(depends_tree[d]):
 135             # split depends into {package, version relation}
 136             depends_tree[d][k] = get_depends_parts(depends_tree[d][k]);
 137             k += 1;
 138         d += 1;
 139     return depends_tree;
 140
 141 def read_control (filename):
 142     recommends = [];
 143     depends = [];
 144     section = '';
 145     maintainer = '';
 146     arch = '';
 147
 148     deb_file = utils.open_file(filename);
 149     try:
 150         extracts = apt_inst.debExtractControl(deb_file);
 151         control = apt_pkg.ParseSection(extracts);
 152     except:
 153         print "can't parse control info";
 154         control = '';
 155
 156     deb_file.close();
 157
 158     control_keys = control.keys();
 159
 160     if control.has_key("Depends"):
 161         depends_str = control.Find("Depends");
 162         # create list of dependancy lists
 163         depends = split_depends(depends_str);
 164
 165     if control.has_key("Recommends"):
 166         recommends_str = control.Find("Recommends");
 167         recommends = split_depends(recommends_str);
 168
 169     if control.has_key("Section"):
 170         section_str = control.Find("Section");
 171
 172         c_match = re_contrib.search(section_str)
 173         nf_match = re_nonfree.search(section_str)
 174         if c_match :
 175             # contrib colour
 176             section = contrib_colour + section_str + end_colour
 177         elif nf_match :
 178             # non-free colour
 179             section = nonfree_colour + section_str + end_colour
 180         else :
 181             # main
 182             section = main_colour +  section_str + end_colour
 183     if control.has_key("Architecture"):
 184         arch_str = control.Find("Architecture")
 185         arch = arch_colour + arch_str + end_colour
 186
 187     if control.has_key("Maintainer"):
 188         maintainer = control.Find("Maintainer")
 189         localhost = re_localhost.search(maintainer)
 190         if localhost:
 191             #highlight bad email
 192             maintainer = maintainer_colour + maintainer + end_colour;
 193
 194     return (control, control_keys, section, depends, recommends, arch, maintainer)
 195
 196 def read_dsc (dsc_filename):
 197     dsc = {};
 198
 199     dsc_file = utils.open_file(dsc_filename);
 200     try:
 201         dsc = utils.parse_changes(dsc_filename);
 202     except:
 203         print "can't parse control info"
 204     dsc_file.close();
 205
 206     filecontents = strip_pgp_signature(dsc_filename);
 207
 208     if dsc.has_key("build-depends"):
 209         builddep = split_depends(dsc["build-depends"]);
 210         builddepstr = create_depends_string(builddep);
 211         filecontents = re_builddep.sub("Build-Depends: "+builddepstr, filecontents);
 212
 213     if dsc.has_key("build-depends-indep"):
 214         builddepindstr = create_depends_string(split_depends(dsc["build-depends-indep"]));
 215         filecontents = re_builddepind.sub("Build-Depends-Indep: "+builddepindstr, filecontents);
 216
 217     if dsc.has_key("architecture") :
 218         if (dsc["architecture"] != "any"):
 219             newarch = arch_colour + dsc["architecture"] + end_colour;
 220             filecontents = re_arch.sub("Architecture: " + newarch, filecontents);
 221
 222     return filecontents;
 223
 224 def create_depends_string (depends_tree):
 225     # just look up unstable for now. possibly pull from .changes later
 226     suite = "unstable";
 227     result = "";
 228     comma_count = 1;
 229     for l in depends_tree:
 230         if (comma_count >= 2):
 231             result += ", ";
 232         or_count = 1
 233         for d in l:
 234             if (or_count >= 2 ):
 235                 result += " | "
 236             # doesn't do version lookup yet.
 237
 238             q = projectB.query("SELECT DISTINCT(b.package), b.version, c.name, su.suite_name FROM  binaries b, files fi, location l, component c, bin_associations ba, suite su WHERE b.package='%s' AND b.file = fi.id AND fi.location = l.id AND l.component = c.id AND ba.bin=b.id AND ba.suite = su.id AND su.suite_name='%s' ORDER BY b.version desc" % (d['name'], suite));
 239             ql = q.getresult();
 240             if ql:
 241                 i = ql[0];
 242
 243                 if i[2] == "contrib":
 244                     result += contrib_colour + d['name'];
 245                 elif i[2] == "non-free":
 246                     result += nonfree_colour + d['name'];
 247                 else :
 248                     result += main_colour + d['name'];
 249
 250                 if d['version'] != '' :
 251                     result += " (%s)" % (d['version']);
 252                 result += end_colour;
 253             else:
 254                 result += bold_colour + d['name'];
 255                 if d['version'] != '' :
 256                     result += " (%s)" % (d['version']);
 257                 result += end_colour;
 258             or_count += 1;
 259         comma_count += 1;
 260     return result;
 261
 262 def output_deb_info(filename):
 263     (control, control_keys, section, depends, recommends, arch, maintainer) = read_control(filename);
 264
 265     if control == '':
 266         print "no control info"
 267     else:
 268         for key in control_keys :
 269             output = " " + key + ": "
 270             if key == 'Depends':
 271                 output += create_depends_string(depends);
 272             elif key == 'Recommends':
 273                 output += create_depends_string(recommends);
 274             elif key == 'Section':
 275                 output += section;
 276             elif key == 'Architecture':
 277                 output += arch;
 278             elif key == 'Maintainer':
 279                 output += maintainer;
 280             elif key == 'Description':
 281                 desc = control.Find(key);
 282                 desc = re_newlinespace.sub('\n ', desc);
 283                 output += desc;
 284             else:
 285                 output += control.Find(key);
 286             print output;
 287
 288 def do_command (command, filename):
 289     o = os.popen("%s %s" % (command, filename));
 290     print o.read();
 291
 292 def print_copyright (deb_filename):
 293     package = re_package.sub(r'\1', deb_filename);
 294     o = os.popen("ar p %s data.tar.gz | tar tzvf - | egrep 'usr(/share)?/doc/[^/]*/copyright' | awk '{ print $6 }' | head -n 1" % (deb_filename));
 295     copyright = o.read()[:-1];
 296
 297     if copyright == "":
 298         print "WARNING: No copyright found, please check package manually."
 299         return;
 300
 301     doc_directory = re_doc_directory.sub(r'\1', copyright);
 302     if package != doc_directory:
 303         print "WARNING: wrong doc directory (expected %s, got %s)." % (package, doc_directory);
 304         return;
 305
 306     o = os.popen("ar p %s data.tar.gz | tar xzOf - %s" % (deb_filename, copyright));
 307     print o.read();
 308
 309 def check_dsc (dsc_filename):
 310     print "---- .dsc file for %s ----" % (dsc_filename);
 311     (dsc) = read_dsc(dsc_filename)
 312     print dsc
 313
 314 def check_deb (deb_filename):
 315     filename = os.path.basename(deb_filename);
 316
 317     if filename.endswith(".udeb"):
 318         is_a_udeb = 1;
 319     else:
 320         is_a_udeb = 0;
 321
 322     print "---- control file for %s ----" % (filename);
 323     #do_command ("dpkg -I", deb_filename);
 324     output_deb_info(deb_filename)
 325
 326     if is_a_udeb:
 327         print "---- skipping lintian check for µdeb ----";
 328         print ;
 329     else:
 330         print "---- lintian check for %s ----" % (filename);
 331         do_command ("lintian", deb_filename);
 332         print "---- linda check for %s ----" % (filename);
 333         do_command ("linda", deb_filename);
 334
 335     print "---- contents of %s ----" % (filename);
 336     do_command ("dpkg -c", deb_filename);
 337
 338     if is_a_udeb:
 339         print "---- skipping copyright for µdeb ----";
 340     else:
 341         print "---- copyright of %s ----" % (filename);
 342         print_copyright(deb_filename);
 343
 344     print "---- file listing of %s ----" % (filename);
 345     do_command ("ls -l", deb_filename);
 346
 347 # Read a file, strip the signature and return the modified contents as
 348 # a string.
 349 def strip_pgp_signature (filename):
 350     file = utils.open_file (filename);
 351     contents = "";
 352     inside_signature = 0;
 353     skip_next = 0;
 354     for line in file.readlines():
 355         if line[:-1] == "":
 356             continue;
 357         if inside_signature:
 358             continue;
 359         if skip_next:
 360             skip_next = 0;
 361             continue;
 362         if line.startswith("-----BEGIN PGP SIGNED MESSAGE"):
 363             skip_next = 1;
 364             continue;
 365         if line.startswith("-----BEGIN PGP SIGNATURE"):
 366             inside_signature = 1;
 367             continue;
 368         if line.startswith("-----END PGP SIGNATURE"):
 369             inside_signature = 0;
 370             continue;
 371         contents += line;
 372     file.close();
 373     return contents;
 374
 375 # Display the .changes [without the signature]
 376 def display_changes (changes_filename):
 377     print "---- .changes file for %s ----" % (changes_filename);
 378     print strip_pgp_signature(changes_filename);
 379
 380 def check_changes (changes_filename):
 381     display_changes(changes_filename);
 382
 383     changes = utils.parse_changes (changes_filename);
 384     files = utils.build_file_list(changes);
 385     for file in files.keys():
 386         if file.endswith(".deb") or file.endswith(".udeb"):
 387             check_deb(file);
 388         if file.endswith(".dsc"):
 389             check_dsc(file);
 390         # else: => byhand
 391
 392 def main ():
 393     global Cnf, projectB, db_files, waste, excluded;
 394
 395 #    Cnf = utils.get_conf()
 396
 397     Arguments = [('h',"help","Fernanda::Options::Help")];
 398     for i in [ "help" ]:
 399         if not Cnf.has_key("Frenanda::Options::%s" % (i)):
 400             Cnf["Fernanda::Options::%s" % (i)] = "";
 401
 402     args = apt_pkg.ParseCommandLine(Cnf,Arguments,sys.argv);
 403     Options = Cnf.SubTree("Fernanda::Options")
 404
 405     if Options["Help"]:
 406         usage();
 407
 408     stdout_fd = sys.stdout;
 409
 410     for file in args:
 411         try:
 412             # Pipe output for each argument through less
 413             less_fd = os.popen("less -R -", 'w', 0);
 414             # -R added to display raw control chars for colour
 415             sys.stdout = less_fd;
 416
 417             try:
 418                 if file.endswith(".changes"):
 419                     check_changes(file);
 420                 elif file.endswith(".deb") or file.endswith(".udeb"):
 421                     check_deb(file);
 422                 elif file.endswith(".dsc"):
 423                     check_dsc(file);
 424                 else:
 425                     utils.fubar("Unrecognised file type: '%s'." % (file));
 426             finally:
 427                 # Reset stdout here so future less invocations aren't FUBAR
 428                 less_fd.close();
 429                 sys.stdout = stdout_fd;
 430         except IOError, e:
 431             if errno.errorcode[e.errno] == 'EPIPE':
 432                 utils.warn("[fernanda] Caught EPIPE; skipping.");
 433                 pass;
 434             else:
 435                 raise;
 436         except KeyboardInterrupt:
 437             utils.warn("[fernanda] Caught C-c; skipping.");
 438             pass;
 439
 440 #######################################################################################
 441
 442 if __name__ == '__main__':
 443     main()
 444