| 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 |
|---|
Chromium Code Reviews
Issue 6124004:
Revert "Merge remote branch 'cros/upstream' into autotest-rebase" (Closed)
Base URL: ssh://git@gitrw.chromium.org:9222/autotest.git@master