DEB build scripts: several enhancements as follow:

- major rework of update_repositories.sh script, which now supports
multiple branches and provide better feedback to user.
- added support for pre-built extra dependency packages. A user can now
use Slavek Banko's binary packages instead of building the extra
dependency locally. This removes a quite tedious process during the
setup of the building environment.
- bug fixes and more user friendly folder names.
- improved README to cover the complete process until TDE installation.

Special thanks to Gregory Guy <zadig83@laposte.net> for testing and
feedback done so far.

Signed-off-by: Michele Calgaro <michele.calgaro@yahoo.it>

1 files changed, 0 insertions, 207 deletions

diff --git a/debian/_buildscripts/local/scripts/README.txt b/debian/_buildscripts/local/scripts/README.txt
deleted file mode 100644
index 8d8a248c7..000000000
--- a/debian/_buildscripts/local/scripts/README.txt
+++ /dev/null
@@ -1,207 +0,0 @@
------
-Index
------
-A) Environment preparation
-B) Notes about scripts
-C) How to use the scripts
-
-
---------------------------
-A) Environment preparation
---------------------------
-0) Initial notes
-   - this guide has been prepared based on a clean debian testing netinstall system without any other DE.
-     It should work for other debian/ubuntu distros as well, but eventually you may run into small differences
-     here and there.
-   - you can change folder names below, as long as you update the "_config.sh" file accordingly.
-
-1) Install following packages: bc, cdbs, git, links2, pbuilder, rsync and required dependencies.
-   NOTE: sudo should already be installed. If not, install sudo as well.
-
-2) Create a base folder for TDE, hereafter referred to as TDE_DIR (for example $HOME/tde_src)
-
-3) Create the following folders [ see NOTE at point 0) about folder names ]
-   - in TDE_DIR: 0_logs : contains log files for repo update and global builds (more on this later)
-                 1_git  : contains the git repo clones and build hook scripts
-                 2_build: folder used for build preparation and for local builds
-                 3_repo : local repo for package installation (to be configured in /etc/apt/sources.list)
-                 buildscripts: contains a local copy of the build scripts, which can be modified as required
-   - in TDE_DIR/1_git: 
-                 edeps  : contains extra dependency modules necessary to build TDE
-                 hooks  : contains build hook scripts to execute ad-hoc code before and after the building process.
-                          Mainly used to apply patches automatically during the building process
-                          
-4) Clone TDE git repositories and extra dependency modules:
-   - TDE main repo
-     cd "TDE_DIR/1_git"
-     git clone https://mirror.git.trinitydesktop.org/gitea/TDE/tde
-     cd tde
-     git submodule init -- scripts
-     git submodule update -- scripts
-     ./scripts/switch_all_submodules_to_head_and_clean anonymous
-   - TDE packaging repo 
-     cd "TDE_DIR/1_git"
-     git clone https://mirror.git.trinitydesktop.org/gitea/TDE/tde-packaging
-   - extra dependency packages
-     using a browser, download the source code for extra dependency modules from Slavek's PPA
-     (usually more recently updated):
-       https://quickbuild.pearsoncomputing.net/~slavek-banko/+archive/deps-r14/+packages
-     or from the official PPA:
-       https://quickbuild.pearsoncomputing.net/~trinity/+archive/trinity-nightly-build-dependencies/+packages
-     NOTES:
-     * Once the page open in your browser, select your distro in the combobox near the "Filter" button and click
-       the button to update. You should get a list of 10-15 modules, depending on the distro.
-     * Click on one module at a time, it will expand (or open another page) and show a list of .deb and other files.
-     * Save those files (exclude .deb files. Only .orig.tar.xz, .dsc, .debian.tar.xz are required) and store
-       them to TDE_DIR/1_git/edeps/<MODULE NAME> folder (one folder per module).
-
-5) Add your user to the sudo group (not required if you are root)
-     su -c "adduser <username> sudo"
-   Optionally, consider extending your sudo timeout interval to avoid having to type your password too often (this
-   could be quite painful especially during long builds, which would not be able to complete if unattended).
-   Logout and login again to make sure the setting is applied.
-
-6) Copy the files from "TDE_DIR/1_git/tde-packaging/debian/_buildscripts/local/buildscripts/additional files" folder
-   to the respectivily named folders.
-
-7) Create pbuilder base package with the command:
-     sudo pbuilder --create
-   If you wish to build for a different distro or architecture, use the command:
-     sudo DIST=<target distro> ARCH=<target architecture> pbuilder --create
-   
-8) Setup the build scripts locally:
-  - copy build scripts from "TDE_DIR/1_git/tde-packaging/debian/_buildscripts/local/buildscripts" to "TDE_DIR/buildscripts"
-    and make sure all shell scripts are executable
-  - cd "TDE_DIR/buildscripts"
-  - cp ./internals/_config_template.sh _config.sh
-  - edit "_config.sh" to set your preferences and check that the various folder names match the structure on your disk.
-    Make sure to set the variable TDE_DIR to the correct path and the variables DISTRO, DISTRO_NAME and ARCHITECTURE to
-    match the distro and architecture you want to build for.
-
-
- 
-----------------------
-B) Notes about scripts
-----------------------
-1) * Notes *
-Modules are built using the build_module.sh script. After the build is completed, the installation .deb files are located in TDE_DIR/2_build/debs/<MODULE NAME>/ and the source code and build reports in TDE_DIR/2_build/debs/<MODULE NAME>/src/
-
-The source code can be either the git repo or a local copy in TDE_DIR/2_build/build/<MODULE NAME>.
-A module can be built in a clean chroot environment using pbuilder (default option) or locally using dpkg-buildpackage (useful for quick debugging/developing).
-When using pbuilder, a hook can be used to invoke a shell when the build fails.
-
-Build logs are automatically stored to files, but can also be displayed during the build process.
-The default location of a module build log is TDE_DIR/2_build/debs/<MODULE NAME>/src/__build__.log
-
-When building sets of modules or the whole TDE, a global build summary is automatically stored to TDE_DIR/0_logs/build_result.log to quickly check what built and what failed. It is recommended to delete that file before starting a new TDE build (if not, build results will be appended at the end of the file).
-
-
-2) * Scripts description *
-- scripts in 'internals' folder
-  Scripts used intenally by other scripts. No need for invoking these directly.
-
-- update_git_repository.sh:
-  Scripts used to update the local clone of the git repositories.
-  Usage:
-    update_git_repository.sh
-
-- build_module.sh
-  Build a single module.
-  Usage:
-    build_module.sh [options] module_name
-  Options:
-    -g  (Git)         : build from git repo sources. If missing, build from the local copy in build folder.
-    -l  (Local)       : build the module locally. If missing, build in a clean chroot environment
-    -sl (Show Log)    : output the building logs to terminal while the build is ongoing
-    -lr (Log Result)  : log (append) build result (OK, FAILED) to TDE_DIR/0_logs/build_result.log file
-    -sh (Shell Hook)  : use a shell hook for failing builds, only valid if building using pbuilder (clean chroot environment)
-    -po (Prepare Only): only prepare the source folder but do not build the module. Useful to prepare the source code before
-                        doing local changes/development. The module can then be built from the modified local folder
-    -d  (Debug)       : enable debug symbols if possible (debian/rules file must contain "RelWithDebInfo" for this to work)
-    -ip (Internal Pbuilder): build using internal pbuilder mode (experimental)
-  
-- <dd>_<set_name>.sh
-  A number of scripts used to build sets of modules. Each script builds an individual set.
-  Modules are built from the git sources and the build result is automatically appended to 
-  TDE_DIR/0_logs/build_result.log.
-  Usage:
-    <dd>_<set_name>.sh [options] set_name
-  Options:
-    -s N: if specified, skip first N modules from the set of modules
-
-	The sets are logically grouped as "base system", "applications" and "others"
-  00_extradeps.sh                             : extra dependencies modules
-  01_base_01.sh        - 03_base_03.sh        : TDE base system
-  04_application_01.sh - 08_application_05.sh : application modules
-  09_others_01.sh      - 10_others_02.sh      : other modules that either fail to build/install or that are somehow less used
-  91_build_base.sh                            : whole TDE base system
-  92_build_applications.sh                    : all TDE applications in 04_application_01.sh - 08_application_05.sh
-  93_build_others.sh                          : all modules in 09_others_01.sh - 10_others_02.sh
-
-- 99_build_TDE.sh
-  Script used to build the whole TDE at once. Calls the dd_setname.sh set scripts in order.
-  Usage:
-    build_TDE.sh [options]
-  Options:
-    -s N: if specified, skip first N sets from the list of sets
-    
-- create_repo.sh
-  Creates a local repository from the .deb files currently stored in TDE_DIR/2_build/debs. 
-  Usage:
-    create_repo.sh [options]
-  Options:
-    -b (Backup) : create a backup of the existing repository in TDE_DIR/CFG_REPO_DIR.backup
-
-  
-3) * Building hooks *
-Hooks are available to execute ad-hoc code before and after the build process. For example this is very useful to automatically apply patches.
-There are two type of hooks: 
-- pre_build : applied before switching the module to quilt format and build
-- post_build: applied after the build (dpkg-buildpackage or pbuilder) has terminated 
-To use a hook, create an executable script (pre_build.sh and/or post_build.sh) in the TDE_DIR/1_git/hooks/<MODULE NAME> folder. The scripts are executed in the build_module.sh environment, so have access to all the variables defined in that file. See the files in the "hook examples" folder for real usage samples.
-
-
-
--------------------------
-C) How to use the scripts
--------------------------
-1) Follow the steps in section "A) Environment preparation" (only required the first time).
-2) cd "TDE_DIR/buildscripts"
-3) Update to latest git repository using
-   ./update_repositories.sh
-   Wait until "Update completed" is printed out. Check log in TDE_DIR/0_logs/ if you wish.
-4) Run "sudo pbuilder update" at the beginning of the day to update the base package to the latest version. This will speed up
-   the process when building several modules in sequence.
-5) Build modules as per your needs. You don't need to use "sudo" directly since the scripts will do that automatically if
-   required. Just type your sudo password when prompted to do so.
-6) Create a local repository from the packages you have just built, to be used as installation repository. 
-   Add the following lines to /etc/apt/sources.list and follow the usual way to install TDE.
-		 # --- LOCAL TDE REPOSITORY ---
-		 deb [arch=<YOUR ARCH> trusted=yes] file:TDE_DIR/3_repo <YOUR DISTRO> main
-	 For example:
-		 deb [arch=amd64 trusted=yes] file:/home/tde_src/3_repo buster main 
-  
-  
-Examples of real usage:
-
-1) build a single module
-   - ./build_module.sh -g -sl "dependencies/libr"       -> build libr package. This is a good test to check
-                                                           whether everything is working fine
-   - ./build_module.sh -g "tdelibs"       -> build "tdelibs" from git sources in a clean chroot environment
-   - ./build_module.sh -g -l -sl "applications/amarok"  -> build "amarok" locally from git sources and 
-                                                           display building logs during building
-   - ./build_module.sh -sh -lr "tdebase"  -> build "tdebase" from the local sources (in TDE_DIR/2_build/build/tdebase)
-                                             in a clean chroot environment and launch a shell in case of building failure.
-                                             Append the build result (OK, FAILED) to TDE_DIR/scripts/logs/build_result.log
-   - ./build_module.sh -g -po "tdelibs"   -> prepare "tdelibs" for building from git sources. Source code will be available
-                                             in TDE_DIR/2_build/build/tdelibs. After you have made changes to the source and
-                                             want to build the modified package, run './build_module.sh "tdelibs"'
-                                          
-2) build a single set
-  (optional) delete the TDE_DIR/0_logs/build_result.log file
-  ./01_base_01.sh      : build this set. 
-  ./03_base_03.sh -s 3 : build this set but skip the first 3 modules of the set.
-
-3) build all TDE
-  ./99_build_TDE.sh       : build all TDE
-  ./99_build_TDE.sh -s 4  : build all TDE, but skip the first 4 sets