pakfire/cli.py

   1 #!/usr/bin/python
   2 ###############################################################################
   3 #                                                                             #
   4 # Pakfire - The IPFire package management system                              #
   5 # Copyright (C) 2011 Pakfire development team                                 #
   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 3 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, see <http://www.gnu.org/licenses/>.       #
  19 #                                                                             #
  20 ###############################################################################
  21
  22 import argparse
  23 import sys
  24
  25 import logger
  26 import packages
  27 import repository
  28 import server
  29 import util
  30
  31 import pakfire.api as pakfire
  32 from constants import *
  33 from i18n import _
  34
  35 # Initialize a very simple logging that is removed when a Pakfire instance
  36 # is started.
  37 logger.setup_logging()
  38
  39 class Cli(object):
  40         def __init__(self):
  41                 self.parser = argparse.ArgumentParser(
  42                         description = _("Pakfire command line interface."),
  43                 )
  44
  45                 self.parse_common_arguments()
  46
  47                 self.parser.add_argument("--root", metavar="PATH",
  48                         default="/",
  49                         help=_("The path where pakfire should operate in."))
  50
  51                 # Add sub-commands.
  52                 self.sub_commands = self.parser.add_subparsers()
  53
  54                 self.parse_command_install()
  55                 self.parse_command_localinstall()
  56                 self.parse_command_remove()
  57                 self.parse_command_info()
  58                 self.parse_command_search()
  59                 self.parse_command_check_update()
  60                 self.parse_command_update()
  61                 self.parse_command_provides()
  62                 self.parse_command_grouplist()
  63                 self.parse_command_groupinstall()
  64                 self.parse_command_repolist()
  65                 self.parse_command_clean()
  66                 self.parse_command_check()
  67                 self.parse_command_resolvdep()
  68
  69                 # Finally parse all arguments from the command line and save them.
  70                 self.args = self.parser.parse_args()
  71
  72                 self.action2func = {
  73                         "install"      : self.handle_install,
  74                         "localinstall" : self.handle_localinstall,
  75                         "remove"       : self.handle_remove,
  76                         "check_update" : self.handle_check_update,
  77                         "update"       : self.handle_update,
  78                         "info"         : self.handle_info,
  79                         "search"       : self.handle_search,
  80                         "provides"     : self.handle_provides,
  81                         "grouplist"    : self.handle_grouplist,
  82                         "groupinstall" : self.handle_groupinstall,
  83                         "repolist"     : self.handle_repolist,
  84                         "clean_all"    : self.handle_clean_all,
  85                         "check"        : self.handle_check,
  86                         "resolvdep"    : self.handle_resolvdep,
  87                 }
  88
  89         @property
  90         def pakfire_args(self):
  91                 ret = { "mode" : "normal" }
  92
  93                 if hasattr(self.args, "root"):
  94                         ret["path"] = self.args.root
  95
  96                 if hasattr(self.args, "disable_repo"):
  97                         ret["disable_repos"] = self.args.disable_repo
  98
  99                 if hasattr(self.args, "enable_repo"):
 100                         ret["enable_repos"] = self.args.enable_repo
 101
 102                 if hasattr(self.args, "offline"):
 103                         ret["offline"] = self.args.offline
 104
 105                 return ret
 106
 107         def parse_common_arguments(self):
 108                 self.parser.add_argument("--version", action="version",
 109                         version="%(prog)s " + PAKFIRE_VERSION)
 110
 111                 self.parser.add_argument("-v", "--verbose", action="store_true",
 112                         help=_("Enable verbose output."))
 113
 114                 self.parser.add_argument("-c", "--config", nargs="?",
 115                         help=_("Path to a configuration file to load."))
 116
 117                 self.parser.add_argument("--disable-repo", nargs="*", metavar="REPO",
 118                         help=_("Disable a repository temporarily."))
 119
 120                 self.parser.add_argument("--enabled-repo", nargs="*", metavar="REPO",
 121                         help=_("Enable a repository temporarily."))
 122
 123                 self.parser.add_argument("--offline", action="store_true",
 124                         help=_("Run pakfire in offline mode."))
 125
 126         def parse_command_install(self):
 127                 # Implement the "install" command.
 128                 sub_install = self.sub_commands.add_parser("install",
 129                         help=_("Install one or more packages to the system."))
 130                 sub_install.add_argument("package", nargs="+",
 131                         help=_("Give name of at least one package to install."))
 132                 sub_install.add_argument("action", action="store_const", const="install")
 133
 134         def parse_command_localinstall(self):
 135                 # Implement the "localinstall" command.
 136                 sub_install = self.sub_commands.add_parser("localinstall",
 137                         help=_("Install one or more packages from the filesystem."))
 138                 sub_install.add_argument("package", nargs="+",
 139                         help=_("Give filename of at least one package."))
 140                 sub_install.add_argument("action", action="store_const", const="localinstall")
 141
 142         def parse_command_remove(self):
 143                 # Implement the "remove" command.
 144                 sub_remove = self.sub_commands.add_parser("remove",
 145                         help=_("Remove one or more packages from the system."))
 146                 sub_remove.add_argument("package", nargs="+",
 147                         help=_("Give name of at least one package to remove."))
 148                 sub_remove.add_argument("action", action="store_const", const="remove")
 149
 150         def parse_command_update(self):
 151                 # Implement the "update" command.
 152                 sub_update = self.sub_commands.add_parser("update",
 153                         help=_("Update the whole system or one specific package."))
 154                 sub_update.add_argument("package", nargs="*",
 155                         help=_("Give a name of a package to update or leave emtpy for all."))
 156                 sub_update.add_argument("action", action="store_const", const="update")
 157
 158         def parse_command_check_update(self):
 159                 # Implement the "check-update" command.
 160                 sub_check_update = self.sub_commands.add_parser("check-update",
 161                         help=_("Check, if there are any updates available."))
 162                 sub_check_update.add_argument("package", nargs="*",
 163                         help=_("Give a name of a package to update or leave emtpy for all."))
 164                 sub_check_update.add_argument("action", action="store_const", const="check_update")
 165
 166         def parse_command_info(self):
 167                 # Implement the "info" command.
 168                 sub_info = self.sub_commands.add_parser("info",
 169                         help=_("Print some information about the given package(s)."))
 170                 sub_info.add_argument("package", nargs="+",
 171                         help=_("Give at least the name of one package."))
 172                 sub_info.add_argument("action", action="store_const", const="info")
 173
 174         def parse_command_search(self):
 175                 # Implement the "search" command.
 176                 sub_search = self.sub_commands.add_parser("search",
 177                         help=_("Search for a given pattern."))
 178                 sub_search.add_argument("pattern",
 179                         help=_("A pattern to search for."))
 180                 sub_search.add_argument("action", action="store_const", const="search")
 181
 182         def parse_command_provides(self):
 183                 # Implement the "provides" command
 184                 sub_provides = self.sub_commands.add_parser("provides",
 185                         help=_("Get a list of packages that provide a given file or feature."))
 186                 sub_provides.add_argument("pattern", nargs="+",
 187                         help=_("File or feature to search for."))
 188                 sub_provides.add_argument("action", action="store_const", const="provides")
 189
 190         def parse_command_grouplist(self):
 191                 # Implement the "grouplist" command
 192                 sub_grouplist = self.sub_commands.add_parser("grouplist",
 193                         help=_("Get list of packages that belong to the given group."))
 194                 sub_grouplist.add_argument("group", nargs=1,
 195                         help=_("Group name to search for."))
 196                 sub_grouplist.add_argument("action", action="store_const", const="grouplist")
 197
 198         def parse_command_groupinstall(self):
 199                 # Implement the "grouplist" command
 200                 sub_groupinstall = self.sub_commands.add_parser("groupinstall",
 201                         help=_("Install all packages that belong to the given group."))
 202                 sub_groupinstall.add_argument("group", nargs=1,
 203                         help=_("Group name."))
 204                 sub_groupinstall.add_argument("action", action="store_const", const="groupinstall")
 205
 206         def parse_command_repolist(self):
 207                 # Implement the "repolist" command
 208                 sub_repolist = self.sub_commands.add_parser("repolist",
 209                         help=_("List all currently enabled repositories."))
 210                 sub_repolist.add_argument("action", action="store_const", const="repolist")
 211
 212         def parse_command_clean(self):
 213                 sub_clean = self.sub_commands.add_parser("clean", help=_("Cleanup commands."))
 214
 215                 sub_clean_commands = sub_clean.add_subparsers()
 216
 217                 self.parse_command_clean_all(sub_clean_commands)
 218
 219         def parse_command_clean_all(self, sub_commands):
 220                 sub_create = sub_commands.add_parser("all",
 221                         help=_("Cleanup all temporary files."))
 222                 sub_create.add_argument("action", action="store_const", const="clean_all")
 223
 224         def parse_command_check(self):
 225                 # Implement the "check" command
 226                 sub_check = self.sub_commands.add_parser("check",
 227                         help=_("Check the system for any errors."))
 228                 sub_check.add_argument("action", action="store_const", const="check")
 229
 230         def parse_command_resolvdep(self):
 231                 # Implement the "resolvdep" command.
 232                 sub_resolvdep = self.sub_commands.add_parser("resolvdep",
 233                         help=_("Check the dependencies for a particular package."))
 234                 sub_resolvdep.add_argument("package", nargs="+",
 235                         help=_("Give name of at least one package to check."))
 236                 sub_resolvdep.add_argument("action", action="store_const", const="resolvdep")
 237
 238         def run(self):
 239                 action = self.args.action
 240
 241                 if not self.action2func.has_key(action):
 242                         raise
 243
 244                 try:
 245                         func = self.action2func[action]
 246                 except KeyError:
 247                         raise # XXX catch and return better error message
 248
 249                 return func()
 250
 251         def handle_info(self, long=False):
 252                 pkgs = pakfire.info(self.args.package, **self.pakfire_args)
 253
 254                 for pkg in pkgs:
 255                         print pkg.dump(long=long)
 256
 257         def handle_search(self):
 258                 pkgs = pakfire.search(self.args.pattern, **self.pakfire_args)
 259
 260                 for pkg in pkgs:
 261                         print pkg.dump(short=True)
 262
 263         def handle_update(self):
 264                 pakfire.update(self.args.package, **self.pakfire_args)
 265
 266         def handle_check_update(self):
 267                 pakfire.update(self.args.package, check=True, **self.pakfire_args)
 268
 269         def handle_install(self):
 270                 pakfire.install(self.args.package, **self.pakfire_args)
 271
 272         def handle_localinstall(self):
 273                 pakfire.localinstall(self.args.package, **self.pakfire_args)
 274
 275         def handle_remove(self):
 276                 pakfire.remove(self.args.package, **self.pakfire_args)
 277
 278         def handle_provides(self):
 279                 pkgs = pakfire.provides(self.args.pattern, **self.pakfire_args)
 280
 281                 for pkg in pkgs:
 282                         print pkg.dump()
 283
 284         def handle_grouplist(self):
 285                 pkgs = pakfire.grouplist(self.args.group[0], **self.pakfire_args)
 286
 287                 for pkg in pkgs:
 288                         print " * %s" % pkg
 289
 290         def handle_groupinstall(self):
 291                 pakfire.groupinstall(self.args.group[0], **self.pakfire_args)
 292
 293         def handle_repolist(self):
 294                 repos = pakfire.repo_list(**self.pakfire_args)
 295
 296                 FORMAT = " %-20s %8s %12s %12s "
 297
 298                 title = FORMAT % (_("Repository"), _("Enabled"), _("Priority"), _("Packages"))
 299                 print title
 300                 print "=" * len(title) # spacing line
 301
 302                 for repo in repos:
 303                         # Skip the installed repository.
 304                         if repo.name == "installed":
 305                                 continue
 306
 307                         print FORMAT % (repo.name, repo.enabled, repo.priority, len(repo))
 308
 309         def handle_clean_all(self):
 310                 print _("Cleaning up everything...")
 311
 312                 pakfire.clean_all(**self.pakfire_args)
 313
 314         def handle_check(self):
 315                 pakfire.check(**self.pakfire_args)
 316
 317         def handle_resolvdep(self):
 318                 pakfire.resolvdep(self.args.package, **self.pakfire_args)
 319
 320
 321 class CliBuilder(Cli):
 322         def __init__(self):
 323                 self.parser = argparse.ArgumentParser(
 324                         description = _("Pakfire builder command line interface."),
 325                 )
 326
 327                 self.parse_common_arguments()
 328
 329                 # Add sub-commands.
 330                 self.sub_commands = self.parser.add_subparsers()
 331
 332                 self.parse_command_build()
 333                 self.parse_command_dist()
 334                 self.parse_command_info()
 335                 self.parse_command_search()
 336                 self.parse_command_shell()
 337                 self.parse_command_update()
 338                 self.parse_command_provides()
 339                 self.parse_command_grouplist()
 340                 self.parse_command_repolist()
 341                 self.parse_command_clean()
 342                 self.parse_command_resolvdep()
 343
 344                 # Finally parse all arguments from the command line and save them.
 345                 self.args = self.parser.parse_args()
 346
 347                 self.action2func = {
 348                         "build"       : self.handle_build,
 349                         "dist"        : self.handle_dist,
 350                         "update"      : self.handle_update,
 351                         "info"        : self.handle_info,
 352                         "search"      : self.handle_search,
 353                         "shell"       : self.handle_shell,
 354                         "provides"    : self.handle_provides,
 355                         "grouplist"   : self.handle_grouplist,
 356                         "repolist"    : self.handle_repolist,
 357                         "clean_all"   : self.handle_clean_all,
 358                         "resolvdep"   : self.handle_resolvdep,
 359                 }
 360
 361         @property
 362         def pakfire_args(self):
 363                 ret = { "mode" : "builder" }
 364
 365                 if hasattr(self.args, "disable_repo"):
 366                         ret["disable_repos"] = self.args.disable_repo
 367
 368                 if hasattr(self.args, "enable_repo"):
 369                         ret["enable_repos"] = self.args.enable_repo
 370
 371                 if hasattr(self.args, "offline"):
 372                         ret["offline"] = self.args.offline
 373
 374                 return ret
 375
 376         def parse_command_update(self):
 377                 # Implement the "update" command.
 378                 sub_update = self.sub_commands.add_parser("update",
 379                         help=_("Update the package indexes."))
 380                 sub_update.add_argument("action", action="store_const", const="update")
 381
 382         def parse_command_build(self):
 383                 # Implement the "build" command.
 384                 sub_build = self.sub_commands.add_parser("build",
 385                         help=_("Build one or more packages."))
 386                 sub_build.add_argument("package", nargs=1,
 387                         help=_("Give name of at least one package to build."))
 388                 sub_build.add_argument("action", action="store_const", const="build")
 389
 390                 sub_build.add_argument("-a", "--arch",
 391                         help=_("Build the package for the given architecture."))
 392                 sub_build.add_argument("--resultdir", nargs="?",
 393                         help=_("Path were the output files should be copied to."))
 394                 sub_build.add_argument("-m", "--mode", nargs="?", default="development",
 395                         help=_("Mode to run in. Is either 'release' or 'development' (default)."))
 396
 397         def parse_command_shell(self):
 398                 # Implement the "shell" command.
 399                 sub_shell = self.sub_commands.add_parser("shell",
 400                         help=_("Go into a shell."))
 401                 sub_shell.add_argument("package", nargs="?",
 402                         help=_("Give name of a package."))
 403                 sub_shell.add_argument("action", action="store_const", const="shell")
 404
 405                 sub_shell.add_argument("-a", "--arch",
 406                         help=_("Emulated architecture in the shell."))
 407                 sub_shell.add_argument("-m", "--mode", nargs="?", default="development",
 408                         help=_("Mode to run in. Is either 'release' or 'development' (default)."))
 409
 410         def parse_command_dist(self):
 411                 # Implement the "dist" command.
 412                 sub_dist = self.sub_commands.add_parser("dist",
 413                         help=_("Generate a source package."))
 414                 sub_dist.add_argument("package", nargs="+",
 415                         help=_("Give name(s) of a package(s)."))
 416                 sub_dist.add_argument("action", action="store_const", const="dist")
 417
 418                 sub_dist.add_argument("--resultdir", nargs="?",
 419                         help=_("Path were the output files should be copied to."))
 420
 421         def handle_info(self):
 422                 Cli.handle_info(self, long=True)
 423
 424         def handle_build(self):
 425                 # Get the package descriptor from the command line options
 426                 pkg = self.args.package[0]
 427
 428                 # Check, if we got a regular file
 429                 if os.path.exists(pkg):
 430                         pkg = os.path.abspath(pkg)
 431
 432                 else:
 433                         raise FileNotFoundError, pkg
 434
 435                 # Create distribution configuration from command line.
 436                 distro_config = {
 437                         "arch" : self.args.arch,
 438                 }
 439
 440                 pakfire.build(pkg, builder_mode=self.args.mode,
 441                         distro_config=distro_config, resultdirs=[self.args.resultdir,],
 442                         shell=True, **self.pakfire_args)
 443
 444         def handle_shell(self):
 445                 pkg = None
 446
 447                 # Get the package descriptor from the command line options
 448                 if self.args.package:
 449                         pkg = self.args.package
 450
 451                         # Check, if we got a regular file
 452                         if os.path.exists(pkg):
 453                                 pkg = os.path.abspath(pkg)
 454
 455                         else:
 456                                 raise FileNotFoundError, pkg
 457
 458                 # Create distribution configuration from command line.
 459                 distro_config = {
 460                         "arch" : self.args.arch,
 461                 }
 462
 463                 pakfire.shell(pkg, builder_mode=self.args.mode,
 464                         distro_config=distro_config, **self.pakfire_args)
 465
 466         def handle_dist(self):
 467                 # Get the packages from the command line options
 468                 pkgs = []
 469
 470                 for pkg in self.args.package:
 471                         # Check, if we got a regular file
 472                         if os.path.exists(pkg):
 473                                 pkg = os.path.abspath(pkg)
 474                                 pkgs.append(pkg)
 475
 476                         else:
 477                                 raise FileNotFoundError, pkg
 478
 479                 pakfire.dist(pkgs, resultdirs=[self.args.resultdir,],
 480                         **self.pakfire_args)
 481
 482         def handle_provides(self):
 483                 pkgs = pakfire.provides(self.args.pattern, **self.pakfire_args)
 484
 485                 for pkg in pkgs:
 486                         print pkg.dump(long=True)
 487
 488
 489 class CliServer(Cli):
 490         def __init__(self):
 491                 self.parser = argparse.ArgumentParser(
 492                         description = _("Pakfire server command line interface."),
 493                 )
 494
 495                 self.parse_common_arguments()
 496
 497                 # Add sub-commands.
 498                 self.sub_commands = self.parser.add_subparsers()
 499
 500                 self.parse_command_build()
 501                 self.parse_command_keepalive()
 502                 self.parse_command_repoupdate()
 503                 self.parse_command_repo()
 504
 505                 # Finally parse all arguments from the command line and save them.
 506                 self.args = self.parser.parse_args()
 507
 508                 self.server = server.Server()
 509
 510                 self.action2func = {
 511                         "build"      : self.handle_build,
 512                         "keepalive"  : self.handle_keepalive,
 513                         "repoupdate" : self.handle_repoupdate,
 514                         "repo_create": self.handle_repo_create,
 515                 }
 516
 517         @property
 518         def pakfire_args(self):
 519                 ret = { "mode" : "server" }
 520
 521                 if hasattr(self.args, "offline"):
 522                         ret["offline"] = self.args.offline
 523
 524                 return ret
 525
 526         def parse_command_build(self):
 527                 # Implement the "build" command.
 528                 sub_keepalive = self.sub_commands.add_parser("build",
 529                         help=_("Request a build job from the server."))
 530                 sub_keepalive.add_argument("action", action="store_const", const="build")
 531
 532         def parse_command_keepalive(self):
 533                 # Implement the "keepalive" command.
 534                 sub_keepalive = self.sub_commands.add_parser("keepalive",
 535                         help=_("Send a keepalive to the server."))
 536                 sub_keepalive.add_argument("action", action="store_const",
 537                         const="keepalive")
 538
 539         def parse_command_repoupdate(self):
 540                 # Implement the "repoupdate" command.
 541                 sub_repoupdate = self.sub_commands.add_parser("repoupdate",
 542                         help=_("Update all repositories."))
 543                 sub_repoupdate.add_argument("action", action="store_const",
 544                         const="repoupdate")
 545
 546         def parse_command_repo(self):
 547                 sub_repo = self.sub_commands.add_parser("repo",
 548                         help=_("Repository management commands."))
 549
 550                 sub_repo_commands = sub_repo.add_subparsers()
 551
 552                 self.parse_command_repo_create(sub_repo_commands)
 553
 554         def parse_command_repo_create(self, sub_commands):
 555                 sub_create = sub_commands.add_parser("create",
 556                         help=_("Create a new repository index."))
 557                 sub_create.add_argument("path", nargs=1, help=_("Path to the packages."))
 558                 sub_create.add_argument("inputs", nargs="+", help=_("Path to input packages."))
 559                 sub_create.add_argument("action", action="store_const", const="repo_create")
 560
 561         def handle_keepalive(self):
 562                 self.server.update_info()
 563
 564         def handle_build(self):
 565                 self.server.build_job()
 566
 567         def handle_repoupdate(self):
 568                 self.server.update_repositories()
 569
 570         def handle_repo_create(self):
 571                 path = self.args.path[0]
 572
 573                 pakfire.repo_create(path, self.args.inputs, **self.pakfire_args)
 574
 575
 576 class CliBuilderIntern(Cli):
 577         def __init__(self):
 578                 self.parser = argparse.ArgumentParser(
 579                         description = _("Pakfire builder command line interface."),
 580                 )
 581
 582                 self.parse_common_arguments()
 583
 584                 # Add sub-commands.
 585                 self.sub_commands = self.parser.add_subparsers()
 586
 587                 self.parse_command_build()
 588
 589                 # Finally parse all arguments from the command line and save them.
 590                 self.args = self.parser.parse_args()
 591
 592                 self.action2func = {
 593                         "build"       : self.handle_build,
 594                 }
 595
 596         def parse_command_build(self):
 597                 # Implement the "build" command.
 598                 sub_build = self.sub_commands.add_parser("build",
 599                         help=_("Build one or more packages."))
 600                 sub_build.add_argument("package", nargs=1,
 601                         help=_("Give name of at least one package to build."))
 602                 sub_build.add_argument("action", action="store_const", const="build")
 603
 604                 sub_build.add_argument("-a", "--arch",
 605                         help=_("Build the package for the given architecture."))
 606                 sub_build.add_argument("--resultdir", nargs="?",
 607                         help=_("Path were the output files should be copied to."))
 608                 sub_build.add_argument("-m", "--mode", nargs="?", default="development",
 609                         help=_("Mode to run in. Is either 'release' or 'development' (default)."))
 610                 sub_build.add_argument("--nodeps", action="store_true",
 611                         help=_("Do not verify build dependencies."))
 612
 613         def handle_build(self):
 614                 # Get the package descriptor from the command line options
 615                 pkg = self.args.package[0]
 616
 617                 # Check, if we got a regular file
 618                 if os.path.exists(pkg):
 619                         pkg = os.path.abspath(pkg)
 620                 else:
 621                         raise FileNotFoundError, pkg
 622
 623                 # Create distribution configuration from command line.
 624                 distro_config = {
 625                         "arch" : self.args.arch,
 626                 }
 627
 628                 pakfire._build(pkg, builder_mode=self.args.mode,
 629                         distro_config=distro_config, resultdir=self.args.resultdir,
 630                         nodeps=self.args.nodeps, **self.pakfire_args)