OLD | NEW |
(Empty) | |
| 1 #!/usr/bin/python |
| 2 """ |
| 3 Software package management library. |
| 4 |
| 5 This is an abstraction layer on top of the existing distributions high level |
| 6 package managers. It supports package operations useful for testing purposes, |
| 7 and multiple high level package managers (here called backends). If you want |
| 8 to make this lib to support your particular package manager/distro, please |
| 9 implement the given backend class. |
| 10 |
| 11 @author: Higor Vieira Alves (halves@br.ibm.com) |
| 12 @author: Lucas Meneghel Rodrigues (lmr@redhat.com) |
| 13 @author: Ramon de Carvalho Valle (rcvalle@br.ibm.com) |
| 14 |
| 15 @copyright: IBM 2008-2009 |
| 16 @copyright: Red Hat 2009-2010 |
| 17 """ |
| 18 import os, re, logging, ConfigParser, optparse, random, string |
| 19 try: |
| 20 import yum |
| 21 except: |
| 22 pass |
| 23 import common |
| 24 from autotest_lib.client.bin import os_dep, utils |
| 25 from autotest_lib.client.common_lib import error |
| 26 from autotest_lib.client.common_lib import logging_config, logging_manager |
| 27 |
| 28 |
| 29 def generate_random_string(length): |
| 30 """ |
| 31 Return a random string using alphanumeric characters. |
| 32 |
| 33 @length: Length of the string that will be generated. |
| 34 """ |
| 35 r = random.SystemRandom() |
| 36 str = "" |
| 37 chars = string.letters + string.digits |
| 38 while length > 0: |
| 39 str += r.choice(chars) |
| 40 length -= 1 |
| 41 return str |
| 42 |
| 43 |
| 44 class SoftwareManagerLoggingConfig(logging_config.LoggingConfig): |
| 45 """ |
| 46 Used with the sole purpose of providing convenient logging setup |
| 47 for the KVM test auxiliary programs. |
| 48 """ |
| 49 def configure_logging(self, results_dir=None, verbose=False): |
| 50 super(SoftwareManagerLoggingConfig, self).configure_logging( |
| 51 use_console=True, |
| 52 verbose=verbose) |
| 53 |
| 54 |
| 55 class SystemInspector(object): |
| 56 """ |
| 57 System inspector class. |
| 58 |
| 59 This may grow up to include more complete reports of operating system and |
| 60 machine properties. |
| 61 """ |
| 62 def __init__(self): |
| 63 """ |
| 64 Probe system, and save information for future reference. |
| 65 """ |
| 66 self.distro = utils.get_os_vendor() |
| 67 self.high_level_pms = ['apt-get', 'yum', 'zypper'] |
| 68 |
| 69 |
| 70 def get_package_management(self): |
| 71 """ |
| 72 Determine the supported package management systems present on the |
| 73 system. If more than one package management system installed, try |
| 74 to find the best supported system. |
| 75 """ |
| 76 list_supported = [] |
| 77 for high_level_pm in self.high_level_pms: |
| 78 try: |
| 79 os_dep.command(high_level_pm) |
| 80 list_supported.append(high_level_pm) |
| 81 except: |
| 82 pass |
| 83 |
| 84 pm_supported = None |
| 85 if len(list_supported) == 0: |
| 86 pm_supported = None |
| 87 if len(list_supported) == 1: |
| 88 pm_supported = list_supported[0] |
| 89 elif len(list_supported) > 1: |
| 90 if 'apt-get' in list_supported and self.distro in ['Debian', 'Ubuntu
']: |
| 91 pm_supported = 'apt-get' |
| 92 elif 'yum' in list_supported and self.distro == 'Fedora': |
| 93 pm_supported = 'yum' |
| 94 else: |
| 95 pm_supported = list_supported[0] |
| 96 |
| 97 logging.debug('Package Manager backend: %s' % pm_supported) |
| 98 return pm_supported |
| 99 |
| 100 |
| 101 class SoftwareManager(object): |
| 102 """ |
| 103 Package management abstraction layer. |
| 104 |
| 105 It supports a set of common package operations for testing purposes, and it |
| 106 uses the concept of a backend, a helper class that implements the set of |
| 107 operations of a given package management tool. |
| 108 """ |
| 109 def __init__(self): |
| 110 """ |
| 111 Class constructor. |
| 112 |
| 113 Determines the best supported package management system for the given |
| 114 operating system running and initializes the appropriate backend. |
| 115 """ |
| 116 inspector = SystemInspector() |
| 117 backend_type = inspector.get_package_management() |
| 118 if backend_type == 'yum': |
| 119 self.backend = YumBackend() |
| 120 elif backend_type == 'zypper': |
| 121 self.backend = ZypperBackend() |
| 122 elif backend_type == 'apt-get': |
| 123 self.backend = AptBackend() |
| 124 else: |
| 125 raise NotImplementedError('Unimplemented package management ' |
| 126 'system: %s.' % backend_type) |
| 127 |
| 128 |
| 129 def check_installed(self, name, version=None, arch=None): |
| 130 """ |
| 131 Check whether a package is installed on this system. |
| 132 |
| 133 @param name: Package name. |
| 134 @param version: Package version. |
| 135 @param arch: Package architecture. |
| 136 """ |
| 137 return self.backend.check_installed(name, version, arch) |
| 138 |
| 139 |
| 140 def list_all(self): |
| 141 """ |
| 142 List all installed packages. |
| 143 """ |
| 144 return self.backend.list_all() |
| 145 |
| 146 |
| 147 def list_files(self, name): |
| 148 """ |
| 149 Get a list of all files installed by package [name]. |
| 150 |
| 151 @param name: Package name. |
| 152 """ |
| 153 return self.backend.list_files(name) |
| 154 |
| 155 |
| 156 def install(self, name): |
| 157 """ |
| 158 Install package [name]. |
| 159 |
| 160 @param name: Package name. |
| 161 """ |
| 162 return self.backend.install(name) |
| 163 |
| 164 |
| 165 def remove(self, name): |
| 166 """ |
| 167 Remove package [name]. |
| 168 |
| 169 @param name: Package name. |
| 170 """ |
| 171 return self.backend.remove(name) |
| 172 |
| 173 |
| 174 def add_repo(self, url): |
| 175 """ |
| 176 Add package repo described by [url]. |
| 177 |
| 178 @param name: URL of the package repo. |
| 179 """ |
| 180 return self.backend.add_repo(url) |
| 181 |
| 182 |
| 183 def remove_repo(self, url): |
| 184 """ |
| 185 Remove package repo described by [url]. |
| 186 |
| 187 @param url: URL of the package repo. |
| 188 """ |
| 189 return self.backend.remove_repo(url) |
| 190 |
| 191 |
| 192 def upgrade(self): |
| 193 """ |
| 194 Upgrade all packages available. |
| 195 """ |
| 196 return self.backend.upgrade() |
| 197 |
| 198 |
| 199 def provides(self, file): |
| 200 """ |
| 201 Returns a list of packages that provides a given capability to the |
| 202 system (be it a binary, a library). |
| 203 |
| 204 @param file: Path to the file. |
| 205 """ |
| 206 return self.backend.provides(file) |
| 207 |
| 208 |
| 209 def install_what_provides(self, file): |
| 210 """ |
| 211 Installs package that provides [file]. |
| 212 |
| 213 @param file: Path to file. |
| 214 """ |
| 215 provides = self.provides(file) |
| 216 if provides is not None: |
| 217 self.install(provides) |
| 218 else: |
| 219 logging.warning('No package seems to provide %s', file) |
| 220 |
| 221 |
| 222 class RpmBackend(object): |
| 223 """ |
| 224 This class implements operations executed with the rpm package manager. |
| 225 |
| 226 rpm is a lower level package manager, used by higher level managers such |
| 227 as yum and zypper. |
| 228 """ |
| 229 def __init__(self): |
| 230 self.lowlevel_base_cmd = os_dep.command('rpm') |
| 231 |
| 232 |
| 233 def _check_installed_version(self, name, version): |
| 234 """ |
| 235 Helper for the check_installed public method. |
| 236 |
| 237 @param name: Package name. |
| 238 @param version: Package version. |
| 239 """ |
| 240 cmd = (self.lowlevel_base_cmd + ' -q --qf %{VERSION} ' + name + |
| 241 ' 2> /dev/null') |
| 242 inst_version = utils.system_output(cmd) |
| 243 |
| 244 if inst_version >= version: |
| 245 return True |
| 246 else: |
| 247 return False |
| 248 |
| 249 |
| 250 def check_installed(self, name, version=None, arch=None): |
| 251 """ |
| 252 Check if package [name] is installed. |
| 253 |
| 254 @param name: Package name. |
| 255 @param version: Package version. |
| 256 @param arch: Package architecture. |
| 257 """ |
| 258 if arch: |
| 259 cmd = (self.lowlevel_base_cmd + ' -q --qf %{ARCH} ' + name + |
| 260 ' 2> /dev/null') |
| 261 inst_archs = utils.system_output(cmd) |
| 262 inst_archs = inst_archs.split('\n') |
| 263 |
| 264 for inst_arch in inst_archs: |
| 265 if inst_arch == arch: |
| 266 return self._check_installed_version(name, version) |
| 267 return False |
| 268 |
| 269 elif version: |
| 270 return self._check_installed_version(name, version) |
| 271 else: |
| 272 cmd = 'rpm -q ' + name + ' 2> /dev/null' |
| 273 return (os.system(cmd) == 0) |
| 274 |
| 275 |
| 276 def list_all(self): |
| 277 """ |
| 278 List all installed packages. |
| 279 """ |
| 280 installed_packages = utils.system_output('rpm -qa').splitlines() |
| 281 return installed_packages |
| 282 |
| 283 |
| 284 def list_files(self, name): |
| 285 """ |
| 286 List files installed on the system by package [name]. |
| 287 |
| 288 @param name: Package name. |
| 289 """ |
| 290 path = os.path.abspath(name) |
| 291 if os.path.isfile(path): |
| 292 option = '-qlp' |
| 293 name = path |
| 294 else: |
| 295 option = '-ql' |
| 296 |
| 297 l_cmd = 'rpm' + ' ' + option + ' ' + name + ' 2> /dev/null' |
| 298 |
| 299 try: |
| 300 result = utils.system_output(l_cmd) |
| 301 list_files = result.split('\n') |
| 302 return list_files |
| 303 except error.CmdError: |
| 304 return [] |
| 305 |
| 306 |
| 307 class DpkgBackend(object): |
| 308 """ |
| 309 This class implements operations executed with the dpkg package manager. |
| 310 |
| 311 dpkg is a lower level package manager, used by higher level managers such |
| 312 as apt and aptitude. |
| 313 """ |
| 314 def __init__(self): |
| 315 self.lowlevel_base_cmd = os_dep.command('dpkg') |
| 316 |
| 317 |
| 318 def check_installed(self, name): |
| 319 if os.path.isfile(name): |
| 320 n_cmd = (self.lowlevel_base_cmd + ' -f ' + name + |
| 321 ' Package 2>/dev/null') |
| 322 name = utils.system_output(n_cmd) |
| 323 i_cmd = self.lowlevel_base_cmd + ' -s ' + name + ' 2>/dev/null' |
| 324 # Checking if package is installed |
| 325 package_status = utils.system_output(i_cmd, ignore_status=True) |
| 326 not_inst_pattern = re.compile('not-installed', re.IGNORECASE) |
| 327 dpkg_not_installed = re.search(not_inst_pattern, package_status) |
| 328 if dpkg_not_installed: |
| 329 return False |
| 330 return True |
| 331 |
| 332 |
| 333 def list_all(self): |
| 334 """ |
| 335 List all packages available in the system. |
| 336 """ |
| 337 installed_packages = [] |
| 338 raw_list = utils.system_output('dpkg -l').splitlines()[5:] |
| 339 for line in raw_list: |
| 340 parts = line.split() |
| 341 if parts[0] == "ii": # only grab "installed" packages |
| 342 installed_packages.append("%s-%s" % (parts[1], parts[2])) |
| 343 |
| 344 |
| 345 def list_files(self, package): |
| 346 """ |
| 347 List files installed by package [package]. |
| 348 |
| 349 @param package: Package name. |
| 350 @return: List of paths installed by package. |
| 351 """ |
| 352 if os.path.isfile(package): |
| 353 l_cmd = self.lowlevel_base_cmd + ' -c ' + package |
| 354 else: |
| 355 l_cmd = self.lowlevel_base_cmd + ' -l ' + package |
| 356 return utils.system_output(l_cmd).split('\n') |
| 357 |
| 358 |
| 359 class YumBackend(RpmBackend): |
| 360 """ |
| 361 Implements the yum backend for software manager. |
| 362 |
| 363 Set of operations for the yum package manager, commonly found on Yellow Dog |
| 364 Linux and Red Hat based distributions, such as Fedora and Red Hat |
| 365 Enterprise Linux. |
| 366 """ |
| 367 def __init__(self): |
| 368 """ |
| 369 Initializes the base command and the yum package repository. |
| 370 """ |
| 371 super(YumBackend, self).__init__() |
| 372 executable = os_dep.command('yum') |
| 373 base_arguments = '-y' |
| 374 self.base_command = executable + ' ' + base_arguments |
| 375 self.repo_file_path = '/etc/yum.repos.d/autotest.repo' |
| 376 self.cfgparser = ConfigParser.ConfigParser() |
| 377 self.cfgparser.read(self.repo_file_path) |
| 378 y_cmd = executable + ' --version | head -1' |
| 379 self.yum_version = utils.system_output(y_cmd, ignore_status=True) |
| 380 logging.debug('Yum backend initialized') |
| 381 logging.debug('Yum version: %s' % self.yum_version) |
| 382 self.yum_base = yum.YumBase() |
| 383 |
| 384 |
| 385 def _cleanup(self): |
| 386 """ |
| 387 Clean up the yum cache so new package information can be downloaded. |
| 388 """ |
| 389 utils.system("yum clean all") |
| 390 |
| 391 |
| 392 def install(self, name): |
| 393 """ |
| 394 Installs package [name]. Handles local installs. |
| 395 """ |
| 396 if os.path.isfile(name): |
| 397 name = os.path.abspath(name) |
| 398 command = 'localinstall' |
| 399 else: |
| 400 command = 'install' |
| 401 |
| 402 i_cmd = self.base_command + ' ' + command + ' ' + name |
| 403 |
| 404 try: |
| 405 utils.system(i_cmd) |
| 406 return True |
| 407 except: |
| 408 return False |
| 409 |
| 410 |
| 411 def remove(self, name): |
| 412 """ |
| 413 Removes package [name]. |
| 414 |
| 415 @param name: Package name (eg. 'ipython'). |
| 416 """ |
| 417 r_cmd = self.base_command + ' ' + 'erase' + ' ' + name |
| 418 try: |
| 419 utils.system(r_cmd) |
| 420 return True |
| 421 except: |
| 422 return False |
| 423 |
| 424 |
| 425 def add_repo(self, url): |
| 426 """ |
| 427 Adds package repository located on [url]. |
| 428 |
| 429 @param url: Universal Resource Locator of the repository. |
| 430 """ |
| 431 # Check if we URL is already set |
| 432 for section in self.cfgparser.sections(): |
| 433 for option, value in self.cfgparser.items(section): |
| 434 if option == 'url' and value == url: |
| 435 return True |
| 436 |
| 437 # Didn't find it, let's set it up |
| 438 while True: |
| 439 section_name = 'software_manager' + '_' + generate_random_string(4) |
| 440 if not self.cfgparser.has_section(section_name): |
| 441 break |
| 442 self.cfgparser.add_section(section_name) |
| 443 self.cfgparser.set(section_name, 'name', |
| 444 'Repository added by the autotest software manager.') |
| 445 self.cfgparser.set(section_name, 'url', url) |
| 446 self.cfgparser.set(section_name, 'enabled', 1) |
| 447 self.cfgparser.set(section_name, 'gpgcheck', 0) |
| 448 self.cfgparser.write(self.repo_file_path) |
| 449 |
| 450 |
| 451 def remove_repo(self, url): |
| 452 """ |
| 453 Removes package repository located on [url]. |
| 454 |
| 455 @param url: Universal Resource Locator of the repository. |
| 456 """ |
| 457 for section in self.cfgparser.sections(): |
| 458 for option, value in self.cfgparser.items(section): |
| 459 if option == 'url' and value == url: |
| 460 self.cfgparser.remove_section(section) |
| 461 self.cfgparser.write(self.repo_file_path) |
| 462 |
| 463 |
| 464 def upgrade(self): |
| 465 """ |
| 466 Upgrade all available packages. |
| 467 """ |
| 468 r_cmd = self.base_command + ' ' + 'update' |
| 469 try: |
| 470 utils.system(r_cmd) |
| 471 return True |
| 472 except: |
| 473 return False |
| 474 |
| 475 |
| 476 def provides(self, name): |
| 477 """ |
| 478 Returns a list of packages that provides a given capability. |
| 479 |
| 480 @param name: Capability name (eg, 'foo'). |
| 481 """ |
| 482 d_provides = self.yum_base.searchPackageProvides(args=[name]) |
| 483 provides_list = [key for key in d_provides] |
| 484 if provides_list: |
| 485 logging.info("Package %s provides %s", provides_list[0], name) |
| 486 return str(provides_list[0]) |
| 487 else: |
| 488 return None |
| 489 |
| 490 |
| 491 class ZypperBackend(RpmBackend): |
| 492 """ |
| 493 Implements the zypper backend for software manager. |
| 494 |
| 495 Set of operations for the zypper package manager, found on SUSE Linux. |
| 496 """ |
| 497 def __init__(self): |
| 498 """ |
| 499 Initializes the base command and the yum package repository. |
| 500 """ |
| 501 super(ZypperBackend, self).__init__() |
| 502 self.base_command = os_dep.command('zypper') + ' -n' |
| 503 z_cmd = self.base_command + ' --version' |
| 504 self.zypper_version = utils.system_output(z_cmd, ignore_status=True) |
| 505 logging.debug('Zypper backend initialized') |
| 506 logging.debug('Zypper version: %s' % self.zypper_version) |
| 507 |
| 508 |
| 509 def install(self, name): |
| 510 """ |
| 511 Installs package [name]. Handles local installs. |
| 512 |
| 513 @param name: Package Name. |
| 514 """ |
| 515 path = os.path.abspath(name) |
| 516 i_cmd = self.base_command + ' install -l ' + name |
| 517 try: |
| 518 utils.system(i_cmd) |
| 519 return True |
| 520 except: |
| 521 return False |
| 522 |
| 523 |
| 524 def add_repo(self, url): |
| 525 """ |
| 526 Adds repository [url]. |
| 527 |
| 528 @param url: URL for the package repository. |
| 529 """ |
| 530 ar_cmd = self.base_command + ' addrepo ' + url |
| 531 try: |
| 532 utils.system(ar_cmd) |
| 533 return True |
| 534 except: |
| 535 return False |
| 536 |
| 537 |
| 538 def remove_repo(self, url): |
| 539 """ |
| 540 Removes repository [url]. |
| 541 |
| 542 @param url: URL for the package repository. |
| 543 """ |
| 544 rr_cmd = self.base_command + ' removerepo ' + url |
| 545 try: |
| 546 utils.system(rr_cmd) |
| 547 return True |
| 548 except: |
| 549 return False |
| 550 |
| 551 |
| 552 def remove(self, name): |
| 553 """ |
| 554 Removes package [name]. |
| 555 """ |
| 556 r_cmd = self.base_command + ' ' + 'erase' + ' ' + name |
| 557 |
| 558 try: |
| 559 utils.system(r_cmd) |
| 560 return True |
| 561 except: |
| 562 return False |
| 563 |
| 564 |
| 565 def upgrade(self): |
| 566 """ |
| 567 Upgrades all packages of the system. |
| 568 """ |
| 569 u_cmd = self.base_command + ' update -l' |
| 570 |
| 571 try: |
| 572 utils.system(u_cmd) |
| 573 return True |
| 574 except: |
| 575 return False |
| 576 |
| 577 |
| 578 def provides(self, name): |
| 579 """ |
| 580 Searches for what provides a given file. |
| 581 |
| 582 @param name: File path. |
| 583 """ |
| 584 p_cmd = self.base_command + ' what-provides ' + name |
| 585 list_provides = [] |
| 586 try: |
| 587 p_output = utils.system_output(p_cmd).split('\n')[4:] |
| 588 for line in p_output: |
| 589 line = [a.strip() for a in line.split('|')] |
| 590 try: |
| 591 state, pname, type, version, arch, repository = line |
| 592 if pname not in list_provides: |
| 593 list_provides.append(pname) |
| 594 except IndexError: |
| 595 pass |
| 596 if len(list_provides) > 1: |
| 597 logging.warning('More than one package found, ' |
| 598 'opting by the first queue result') |
| 599 if list_provides: |
| 600 logging.info("Package %s provides %s", list_provides[0], name) |
| 601 return list_provides[0] |
| 602 return None |
| 603 except: |
| 604 return None |
| 605 |
| 606 |
| 607 class AptBackend(DpkgBackend): |
| 608 """ |
| 609 Implements the apt backend for software manager. |
| 610 |
| 611 Set of operations for the apt package manager, commonly found on Debian and |
| 612 Debian based distributions, such as Ubuntu Linux. |
| 613 """ |
| 614 def __init__(self): |
| 615 """ |
| 616 Initializes the base command and the debian package repository. |
| 617 """ |
| 618 super(AptBackend, self).__init__() |
| 619 executable = os_dep.command('apt-get') |
| 620 self.base_command = executable + ' -y' |
| 621 self.repo_file_path = '/etc/apt/sources.list.d/autotest' |
| 622 self.apt_version = utils.system_output('apt-get -v | head -1', |
| 623 ignore_status=True) |
| 624 logging.debug('Apt backend initialized') |
| 625 logging.debug('apt version: %s' % self.apt_version) |
| 626 |
| 627 |
| 628 def install(self, name): |
| 629 """ |
| 630 Installs package [name]. |
| 631 |
| 632 @param name: Package name. |
| 633 """ |
| 634 command = 'install' |
| 635 i_cmd = self.base_command + ' ' + command + ' ' + name |
| 636 |
| 637 try: |
| 638 utils.system(i_cmd) |
| 639 return True |
| 640 except: |
| 641 return False |
| 642 |
| 643 |
| 644 def remove(self, name): |
| 645 """ |
| 646 Remove package [name]. |
| 647 |
| 648 @param name: Package name. |
| 649 """ |
| 650 command = 'remove' |
| 651 flag = '--purge' |
| 652 r_cmd = self.base_command + ' ' + command + ' ' + flag + ' ' + name |
| 653 |
| 654 try: |
| 655 utils.system(r_cmd) |
| 656 return True |
| 657 except: |
| 658 return False |
| 659 |
| 660 |
| 661 def add_repo(self, repo): |
| 662 """ |
| 663 Add an apt repository. |
| 664 |
| 665 @param repo: Repository string. Example: |
| 666 'deb http://archive.ubuntu.com/ubuntu/ maverick universe' |
| 667 """ |
| 668 repo_file = open(self.repo_file_path, 'a') |
| 669 repo_file_contents = repo_file.read() |
| 670 if repo not in repo_file_contents: |
| 671 repo_file.write(repo) |
| 672 |
| 673 |
| 674 def remove_repo(self, repo): |
| 675 """ |
| 676 Remove an apt repository. |
| 677 |
| 678 @param repo: Repository string. Example: |
| 679 'deb http://archive.ubuntu.com/ubuntu/ maverick universe' |
| 680 """ |
| 681 repo_file = open(self.repo_file_path, 'r') |
| 682 new_file_contents = [] |
| 683 for line in repo_file.readlines: |
| 684 if not line == repo: |
| 685 new_file_contents.append(line) |
| 686 repo_file.close() |
| 687 new_file_contents = "\n".join(new_file_contents) |
| 688 repo_file.open(self.repo_file_path, 'w') |
| 689 repo_file.write(new_file_contents) |
| 690 repo_file.close() |
| 691 |
| 692 |
| 693 def upgrade(self): |
| 694 """ |
| 695 Upgrade all packages of the system with eventual new versions. |
| 696 """ |
| 697 ud_command = 'update' |
| 698 ud_cmd = self.base_command + ' ' + ud_command |
| 699 try: |
| 700 utils.system(ud_cmd) |
| 701 except: |
| 702 logging.error("Apt package update failed") |
| 703 up_command = 'upgrade' |
| 704 up_cmd = self.base_command + ' ' + up_command |
| 705 try: |
| 706 utils.system(up_cmd) |
| 707 return True |
| 708 except: |
| 709 return False |
| 710 |
| 711 |
| 712 def provides(self, file): |
| 713 """ |
| 714 Return a list of packages that provide [file]. |
| 715 |
| 716 @param file: File path. |
| 717 """ |
| 718 if not self.check_installed('apt-file'): |
| 719 self.install('apt-file') |
| 720 command = os_dep.command('apt-file') |
| 721 cache_update_cmd = command + ' update' |
| 722 try: |
| 723 utils.system(cache_update_cmd, ignore_status=True) |
| 724 except: |
| 725 logging.error("Apt file cache update failed") |
| 726 fu_cmd = command + ' search ' + file |
| 727 try: |
| 728 provides = utils.system_output(fu_cmd).split('\n') |
| 729 list_provides = [] |
| 730 for line in provides: |
| 731 if line: |
| 732 try: |
| 733 line = line.split(':') |
| 734 package = line[0].strip() |
| 735 path = line[1].strip() |
| 736 if path == file and package not in list_provides: |
| 737 list_provides.append(package) |
| 738 except IndexError: |
| 739 pass |
| 740 if len(list_provides) > 1: |
| 741 logging.warning('More than one package found, ' |
| 742 'opting by the first queue result') |
| 743 if list_provides: |
| 744 logging.info("Package %s provides %s", list_provides[0], file) |
| 745 return list_provides[0] |
| 746 return None |
| 747 except: |
| 748 return None |
| 749 |
| 750 |
| 751 if __name__ == '__main__': |
| 752 parser = optparse.OptionParser( |
| 753 "usage: %prog [install|remove|list-all|list-files|add-repo|remove-repo|" |
| 754 "upgrade|what-provides|install-what-provides] arguments") |
| 755 parser.add_option('--verbose', dest="debug", action='store_true', |
| 756 help='include debug messages in console output') |
| 757 |
| 758 options, args = parser.parse_args() |
| 759 debug = options.debug |
| 760 logging_manager.configure_logging(SoftwareManagerLoggingConfig(), |
| 761 verbose=debug) |
| 762 software_manager = SoftwareManager() |
| 763 if args: |
| 764 action = args[0] |
| 765 args = " ".join(args[1:]) |
| 766 else: |
| 767 action = 'show-help' |
| 768 |
| 769 if action == 'install': |
| 770 software_manager.install(args) |
| 771 elif action == 'remove': |
| 772 software_manager.remove(args) |
| 773 if action == 'list-all': |
| 774 software_manager.list_all() |
| 775 elif action == 'list-files': |
| 776 software_manager.list_files(args) |
| 777 elif action == 'add-repo': |
| 778 software_manager.add_repo(args) |
| 779 elif action == 'remove-repo': |
| 780 software_manager.remove_repo(args) |
| 781 elif action == 'upgrade': |
| 782 software_manager.upgrade() |
| 783 elif action == 'what-provides': |
| 784 software_manager.provides(args) |
| 785 elif action == 'install-what-provides': |
| 786 software_manager.install_what_provides(args) |
| 787 elif action == 'show-help': |
| 788 parser.print_help() |
OLD | NEW |