path: root/roverlay/defaultscript.py

# R overlay -- main()
# -*- coding: utf-8 -*-
# Copyright (C) 2013 André Erdmann <dywi@mailerd.de>
# Distributed under the terms of the GNU General Public License;
# either version 2 of the License, or (at your option) any later version.

from __future__ import print_function

import os
import sys
import logging

import roverlay.config.entrymap
import roverlay.config.entryutil
import roverlay.core
import roverlay.console.depres
import roverlay.hook
import roverlay.overlay.creator
import roverlay.overlay.pkgdir.distroot.static
import roverlay.packagerules.rules
import roverlay.recipe.distmap
import roverlay.remote.repolist
import roverlay.runtime
import roverlay.tools.shenv
import roverlay.util

from roverlay.core import DIE, die


# ===============
#  main routines
# ===============

def main_installed ( *args, **kw ):
   return main ( True, *args, **kw )
# --- end of main_installed (...) ---

def main ( installed, *args, **kw ):
   main_env = roverlay.runtime.RuntimeEnvironment ( installed, *args, **kw )
   main_env.setup()

   if run_early_commands ( main_env ):
      sys.exit ( os.EX_OK )

   elif (
      main_env.want_command ( 'depres_console' ) or
      main_env.want_command ( 'depres' )
   ):
      con = roverlay.console.depres.DepresConsole()
      con.setup ( config=main_env.config )
      try:
         con.run_forever()
      finally:
         con.close()

      sys.exit ( os.EX_OK )

   elif main_env.want_command ( 'distmap_rebuild' ):
      sys.exit ( run_distmap_rebuild ( main_env ) )

   elif main_env.want_command ( 'apply_rules' ):
      sys.exit ( run_apply_package_rules ( main_env ) )

   else:
      roverlay.hook.setup()
      main_env.setup_database()

      retcode = os.EX_OK

      if main_env.want_command ( 'sync' ):
         retcode = run_sync ( main_env )
      elif main_env.want_command ( 'create' ):
         retcode = run_overlay_create ( main_env )
      else:
         die ( "unknown command: {!r}".format ( main_env.command ) )

      main_env.write_database()
      main_env.dump_stats()
      sys.exit ( retcode )
# --- end of main (...) ---

def run_script_main_installed ( *args, **kw ):
   return run_script_main ( True, *args, **kw )
# --- end of run_script_main_installed (...) ---

def run_script_main ( installed ):
   if len ( sys.argv ) < 2 or not sys.argv[0]:
      die ( "no executable specified.", DIE.USAGE )

   exe = sys.argv[1]
   script_file = os.path.abspath ( exe )
   if os.path.isfile ( script_file ) or os.sep in exe:
      exe = script_file

   roverlay.core.default_helper_setup ( installed )
   roverlay.tools.shenv.run_script_exec (
      exe, "runscript", sys.argv[1:], use_path=True
   )
# --- end of run_script_main (...) ---

def run_shell_main_installed ( *args, **kw ):
   return run_shell_main ( True, *args, **kw )

def run_shell_main ( installed ):
   config = roverlay.core.default_helper_setup ( installed )
   shell  = config.get ( 'SHELL_ENV.shell', '/bin/sh' )
   roverlay.tools.shenv.run_script_exec (
      shell, "shell", [ shell, ] + sys.argv [1:], use_path=False
   )
# --- end of run_shell_main (...) ---


# ==============
#  sub routines
# ==============

def run_early_commands ( env ):
   want_exit = False

   if env.options ['list_config_entries']:
      want_exit = True
      print ( "== main config file ==\n" )
      print ( roverlay.config.entryutil.list_entries() )

   if env.options ['print_config']:
      want_exit = True
      env.config.visualize ( into=sys.stdout )

   if env.options ['print_package_rules']:
      want_exit = True
      package_rules = (
         roverlay.packagerules.rules.PackageRules.get_configured()
      )
      env.add_addition_control_rules ( package_rules )

      print ( env.HLINE )
      print ( str ( package_rules ) )
      print ( env.HLINE )

   return want_exit
# --- end of run_early_commands (...) ---


def run_distmap_rebuild ( env ):
   if env.action_done ( 'distmap_rebuild' ):
      return os.EX_OK

   roverlay.core.force_console_logging ( logging.INFO )

   roverlay.recipe.distmap.setup()
   distroot = None
   try:
      distroot = roverlay.overlay.pkgdir.distroot.static.get_configured()
      distroot.check_integrity()
   finally:
      if distroot is not None:
         distroot.finalize()

   return os.EX_OK
# --- end of run_distmap_rebuild (...) ---

def run_sync ( env ):
   if env.action_done ( 'sync' ):
      return

   STRICT_SYNC = env.option ( 'strict' ) or env.option ( 'strict_sync' )

   try:
      # set up the repo list
      repo_list = env.get_repo_list()

      ## extra_opts->distdir
      if 'distdirs' in env.options:
         repo_list.add_distdirs ( env.option ( 'distdirs' ) )
      else:
         # default repo list
         repo_list.load()

      ## this runs _nosync() or _sync(), depending on extra_opts->nosync
      sync_success = repo_list.sync ( fail_greedy=STRICT_SYNC )
      env.set_action_done ( "sync" )

   except KeyboardInterrupt:
      die ( "Interrupted", DIE.INTERRUPT )
   except:
      if env.hide_exceptions:
         die (
            ( "no" if env.option ( "nosync" ) else "" ) + "sync() failed!",
            DIE.SYNC
         )
      else:
         raise
   else:
      if not sync_success and STRICT_SYNC:
         die ( "errors occured while syncing.", DIE.SYNC )
# --- end of run_sync() ---

def run_overlay_create ( env ):
   if env.action_done ( "create" ):
      return
   run_sync ( env )

   repo_list       = None
   overlay_creator = None

   try:
      repo_list       = env.get_repo_list()
      overlay_creator = env.get_overlay_creator()
      env.add_addition_control_to_overlay_creator()

      ebuild_import_nosync = env.option ( 'sync_imported' )
      if ebuild_import_nosync is None:
         ebuild_import_nosync = env.config.get_or_fail ( 'nosync' )
      else:
         ebuild_import_nosync = not ebuild_import_nosync


      overlay_creator.overlay.import_ebuilds (
         overwrite = not env.option ( 'incremental' ),
         nosync    = ebuild_import_nosync,
      )

      repo_list.add_packages ( overlay_creator.add_package )
      if env.options ['revbump']:
         overlay_creator.enqueue_postponed()
      else:
         overlay_creator.discard_postponed()

      overlay_creator.release_package_rules()

      if env.options ['fixup_category_move']:
         overlay_creator.remove_moved_ebuilds ( reverse=False )
      elif env.options ['fixup_category_move_reverse']:
         overlay_creator.remove_moved_ebuilds ( reverse=True )

      # overlay creation should succeed after 2 runs, limit passno here
      #
      overlay_creator.run ( close_when_done=True, max_passno=2 )

      if env.options ['write_overlay']:
         overlay_creator.write_overlay()

      if env.options ['show_overlay']:
         overlay_creator.show_overlay()

      if env.options ['print_stats']:
         sys.stdout.write ( '\n' )
         sys.stdout.write ( env.stats.get_creation_str() )
         sys.stdout.write ( '\n\n' )
         sys.stdout.flush()


      # FIXME/TODO:
      #  this hook should be called _after_ verifying the overlay
      #  (verification is not implemented yet)
      #
      roverlay.hook.run ( 'overlay_success' )

      env.want_db_commit = True
      env.set_action_done ( "create" )

   except KeyboardInterrupt:
      die ( "Interrupted", DIE.INTERRUPT )
   except:
      if env.hide_exceptions:
         die ( "Overlay creation failed.", DIE.OV_CREATE )
      else:
         raise
   finally:
      if overlay_creator is not None and not overlay_creator.closed:
         # This is important 'cause it unblocks remaining ebuild creation
         # jobs/threads, specifically waiting EbuildJobChannels in depres.
         # It also writes the deps_unresolved file
         overlay_creator.close()
# --- end of run_overlay_create() ---

def run_apply_package_rules ( env ):
   if env.action_done ( 'apply_rules' ):
      return
   run_sync ( env )

   dump_file = env.option ( "dump_file" )
   FH        = None

   prules = roverlay.packagerules.rules.PackageRules.get_configured()
   env.add_addition_control_rules ( prules )

   # track package rules
   prules.add_trace_actions()

   NUM_MODIFIED = 0


   BEGIN_RECEIVE_PACKAGE = ( 8 * '-' ) + " {header} " + ( 8 * '-' ) + '\n'
   #END_RECEIVE_PACKAGE   = ( 31 * '-' ) + '\n\n'

   get_header = lambda p : BEGIN_RECEIVE_PACKAGE.format (
      header = ( p ['name'] + ' ' + p ['ebuild_verstr'] )
   )
   get_footer = lambda header : ( len ( header ) - 1 ) * '-' + '\n\n'

   def tristate_counter ( f ):
      """Wrapper that returns a 2-tuple (result_list, function f').
      f' which increases result_list first, second or third
      element depending on the return value of function f (True,False,None)

      arguments:
      * f -- function to wrap
      """
      result_list = [ 0, 0, 0 ]

      def wrapped ( *args, **kwargs ):
         result = f ( *args, **kwargs )
         if result is None:
            result_list [2] += 1
         elif result:
            result_list [0] += 1
         else:
            result_list [1] += 1
         return result
      # --- end of wrapped (...) ---

      return result_list, wrapped
   # --- end of tristate_counter (...) ---

   def receive_package ( P ):
      if prules.apply_actions ( P ):
         if hasattr ( P, 'modified_by_package_rules' ):
            # ^ that check is sufficient here
            #if P.modified_by_package_rules

            receive_header = get_header ( P )

            FH.write ( receive_header )

            evars = P.get_evars()
            if evars:
               FH.write ( "evars applied:\n" )
               for evar in evars:
                  FH.write ( "* {}\n".format ( evar ) )

            if P.depconf:
               FH.write ( "dependencies manipulated:\n" )
               for root_key, subdict in P.depconf.items():
                  if subdict:
                     klen = max ( len(s) for s in subdict.keys() )

                     FH.write ( "* {k}\n".format ( k=root_key ) )
                     for key, deplist in sorted (
                        subdict.items(), key=( lambda kv: kv[0] ),
                     ):
                        for dep in deplist:
                           FH.write (
                              "  {key:<{l}} += \"{dep}\"\n".format (
                                 key=key, dep=dep, l=klen
                              )
                           )


            if P.modified_by_package_rules is not True:
               # ^ check needs to be changed when adding more trace actions
               FH.write ( "trace marks:\n" )
               for s in P.modified_by_package_rules:
                  if s is not True:
                     FH.write ( "* {}\n".format ( s ) )

            FH.write ( "misc data:\n" )
            for key in ( 'name', 'category', 'src_uri_dest', ):
               FH.write (
                  "{k:<12} = {v}\n".format (
                     k=key, v=P.get ( key, "(undef)" )
                  )
               )

            FH.write (
               "{k:<12} = {v}\n".format (
                  k = "add-policy",
                  v = (
                     getattr ( P, 'overlay_addition_override', None )
                        or "(undef)"
                  ),
               )
            )

            FH.write ( get_footer ( receive_header ) )

            return True
         else:
            # not modified
            return False
      else:
         receive_header = get_header ( P )
         FH.write ( receive_header )
         FH.write ( "filtered out!\n" )
         FH.write ( get_footer ( receive_header ) )
         return None

   # --- end of receive_package (...) ---

   modify_counter, receive_package_counting = (
      tristate_counter ( receive_package )
   )

   FH_SHARED = True
   try:
      if dump_file == "-":
         FH = sys.stdout
      else:
         FH_SHARED = False
         FH = open ( dump_file, 'wt' )

      env.get_repo_list().add_packages ( receive_package_counting )

      if modify_counter [0] > 0:
         FH.write ( "\n" )

      #FH.write (
      sys.stdout.write (
         'done after {t:.2f} seconds\n'
         '{p} packages processed in total, out of which\n'
         '{m} have been modified and '
         '{n} have been filtered out\n'.format (
            t = env.stats.repo.queue_time.get_total(),
            p = sum ( modify_counter ),
            m = modify_counter [0],
            n = modify_counter [2],
         )
      )

   finally:
      if FH and not FH_SHARED:
         FH.close()

# --- end of run_apply_package_rules (...) ---