Data

Tools

Indexes

Applications

Experiments

Awesome

An open API service indexing awesome lists of open source software.

https://github.com/destrangis/mkarchive

Linux self extracting archiver for ad-hoc installers.
https://github.com/destrangis/mkarchive

archiver-application installer-tools linux-app self-executable self-extracting

Last synced: 7 months ago
JSON representation

Linux self extracting archiver for ad-hoc installers.

Awesome Lists containing this project

README 

          
mkarchive

=========



Mkarchive is a self-executable archive generator for Linux. It generates

an archive in the form of an ELF executable file that, when executed,

will extract its contents to a temporary directory, and then run a

program called ``setup``, which *must* have been included with the

archive files.



It comes with ``smartsetup``, a utility that will generate a ``setup``

program for you, based on the ``dialog`` utility.



You may want to consider makeself_ as an alternative to this software.



.. _makeself: https://makeself.io/



Installing

----------



Mkarchive can be installed straight from PYPI using ``pip``::



    python3 -m pip install mkarchive



Requirements

------------



On the development machine, ``mkarchive`` requires the ``gcc`` compiler

to be in the path, and also ``libtar`` and ``zlib``.



On the target machine, it requires ``bash`` and ``libc6`` must be the

same version as  in the development machine. Also, depending on how you

created the archive, it might need ``libtar`` and ``zlib`` to be installed.

On a Debian-like distro you may need to do::



    $ apt install libtar-dev zlib1g-dev



``mkarchive`` will try to link both libraries statically to relieve the

target machine of this requirement but, obviously, the archive will be

a little heavier as a result.



If you are using ``dialog`` or ``whiptail`` then it needs to be

installed on the target machine, or you may need to include it inside

your archive and provide a ``setup`` program that can find them.



Usage

-----



To simply create a self-extracting archive just use::



    $ mkarchive *



This will archive all the files and directories on the current working

directory and create the self-executable archive called ``selfextract``

also on the working directory.



If you want the archive to have a different name or to be created

elsewhere, you can use the ``--output``, or ``-o`` option::



    $ mkarchive -o ~/extractor.bin *



Note that the archives, as mentioned above, after unarchiving, will run

a user-supplied program called ``setup`` that must have been included on

the top level directory.



A minimal ``setup`` program could be::



    #!/bin/bash

    echo "Hello, I'm $0 called with $1 and the working directory is $(pwd)"



We can then create a minimal self-executable with it::



    $ mkarchive setup

    Creating tar '/tmp/tmpsqwogss0/_tmp.tar.gz'

    Creating selfextract1

    /tmp/tmpsqwogss0/selfextract1 created with size 104560

    Recompiling /tmp/tmpsqwogss0/selfextract0.c

    Size of /tmp/tmpsqwogss0/selfextract1 matches 104560

    Concatenating /tmp/tmpsqwogss0/selfextract1 and /tmp/tmpsqwogss0/_tmp.tar.gz into selfextract

    Adding /tmp/tmpsqwogss0/selfextract1

    Adding /tmp/tmpsqwogss0/_tmp.tar.gz



And then we can run the resulting ``selfextract`` archive::



    $ ./selfextract

    Hello, I'm /tmp/selfex__AvVAsz/setup called with /tmp/selfex__AvVAsz and the working directory is /home/javier



Your program will probably need to be a tad more sophisticated than this

one and will use the directory supplied as its first argument to do its

job.



If a ``setup`` program is not provided, mkarchive will

supply one for you that just copies the unarchived files and directories

to the user's current working directory.



Also, in the examples above, ``mkarchive`` has found ``libtar.a`` and

``libz.a`` on their default locations. You may want to specify a path to

these libraries using the ``--libtar`` and ``--zlib`` command line

options if you have your own compiled versions of these libraries, or

your distribution installs them at a different location than Ubuntu,

e.g::



    $ mkarchive --libtar /path/to/libtar.a --zlib /path/to/libz.a -o ~/extractor.bin setup file1 file2



You may link them dynamically by specifying ``-ltar`` and ``-lz``

respectively::



   $ mkarchive --lbitar=-ltar --zlib=-lz setup file1 file2



Generating the ``setup`` program

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~



``mkarchive`` can generate the ``setup`` program for you using the

included ``smartsetup`` utility. In order to do that you need to create

a YAML file containing a specification of the installer program. All it

does is to make it a bit easier to write an installer program using

``dialog`` screens.



Basically, the installer specification has two sections: the ``install``

section that contains the screens of the installer, and an ``uninstall``

section. Each of these two sections contain a list of objects that

correspond to parameters of the ``dialog`` utility, or a bash code

snippet, e.g::



    install:

      - type: inputbox

        title: Enter input file

        text: What file do you want to copy?

        store: filetocopy

        default: file1



      - type: inputbox

        title: Destination directory

        text: Enter the destination directory

        store: destdir



      - type: code

        text: cp -v $filetocopy $destdir



All types in the ``type`` field, except ``code`` correspond to dialog

types of the ``dialog`` utility, e.g ``inputbox``, ``yesno``, ``checklist``

etc. ``title`` is the ``--title`` option and ``text`` is the text. Other

options can be specified as a list in the ``options`` field.



When ``dialog`` would write a value to the error stream ``stderr`` you

can specify in the ``store`` field the  name of a variable to store it.

When the result is the program return code, you can check it using

``$exitval``.



The installer *must always* define the variable ``$destdir``, as it is

where the uninstaller program (if there is an ``uninstall`` section)

will be created.



The dialogs may be shown conditionally by putting a condition in the

``condition`` file. This should be the arguments of the ``test`` shell

command e.g::



    - title: Installation Successful

      type: msgbox

      condition: $success -eq 1

      text: The installation of $program $version has been successful.



Having ``mkarchive`` create the setup program

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~



``mkarchive`` accepts the ``--install-spec`` command line option to

specify the YAML file specification.



You can also use one or more ``--var`` options to pre-define variables

available to the installer program.



You can use ``--dialog-tool`` to specify the path (on the destination

machine with an absolute path, or inside the archive with a relative

path) of the ``dialog`` or ``whiptail`` command.



Finally, you can specify a name for the uninstaller program using the

``--uninstaller-name`` option::



    $ mkarchive --output ~/mysoft_installer.bin      \

            --install-spec=setup.yml                 \

            --uninstaller-name=mysoft_uninstall.bin  \

            --var=program=mysoft                     \

            --var=version=1.2                        \

            file1 file2 dir1



The ``smartsetup`` utility

~~~~~~~~~~~~~~~~~~~~~~~~~~



The ``setup`` program can be generated independently of the

self-extracting archive using the ``smartsetup`` command with options

similar to the ones mentioned above::



    $ smartsetup --help

    usage: smartsetup [-h] [--name script-name] [--uname script-name]

                      [--dialog-tool dialog-tool] [--var varname[=value]]

                      spec



    Generate installer/uninstaller scripts from a YAML specification



    positional arguments:

      spec                  Input specification in YAML



    optional arguments:

      -h, --help            show this help message and exit

      --name script-name, -n script-name

                            Generate script with this name. Default 'setup'

      --uname script-name, -u script-name

                            Name of the uninstaller script. Default 'uninstall'

      --dialog-tool dialog-tool, -d dialog-tool

                            Name of the dialog tool. Default 'dialog'

      --var varname[=value], -v varname[=value]

                            Define variable and its value for use in the script



License

-------

This software is released under the MIT License