Page History

## Introduction

-   Docker is a tool which allows to start containers i.e. lightweight lightweight,
    isolated environments (OS, libraries, configurations)

    -   You can install Docker for Mac, Windows or Linux:
        [documentation](https://docs.docker.com/get-docker/)

-   To work with a container you need an image to start from

-   Images can be found in public or private repositories:

    -   Base operating systems
        e.g.  [Ubuntu](https://hub.docker.com/_/ubuntu) or
        [CentOS](https://hub.docker.com/_/centos)
    -   Ready-to-start interpreters
        e.g.  [Python](https://hub.docker.com/_/python) or
        [PHP](https://hub.docker.com/_/php)
    -   Database management systems
        e.g.  [MySQL](https://hub.docker.com/_/mysql) or
        [PostgreSQL](https://hub.docker.com/_/postgres)

-   A container executes one or more processes in its isolated
    environment

-   The process might be a daemon e.g. Apache Apache HTTP Server or it can be
    an interactive terminal

-   Dockerization advantages:

    -   Quick prototyping and testing

        -   For example, you can easily spawn multiple versions of
            PostgreSQL and test your SQL queries against them

    -   Better dissemination

        -   The product owner can share a Docker image and anyone
            interested can use it straight away

    -   Enhanced security

        -   A container is isolated and runs a limited number of
            processes
        -   Even if it gets hacked, the rest of the system remains
            unharmed

    -   Easier maintenance

        -   The images are usually built in an automatic way via CI/CD
            pipelines or regularly scheduled jobs
        -   No matter how complex the environment is, once the image
            recipe is created all interested users can instantiate
            containers at will

## IMAS Docker

-   The IMAS environment is available under a few flavors

-   The most important is `imas/ual`, which contains Data Dictionary and
    Access Layer

-   The images are available in a private Docker registry
    <https://gitlab.eufus.psnc.pl:5050>pl>, which requires logging in first:

    ``` sh
    docker login gitlab.eufus.psnc.pl:5050     
	```

### Interactive session

-   To pull the image:

    ``` sh
    docker pull gitlab.eufus.psnc.pl:5050/containerization/imas/imas-installer/rockylinux8.6/ual:latest      
	```

-   To tag the image with shorter name:

    ``` sh
    docker tag gitlab.eufus.psnc.pl:5050/containerization/imas/imas-installer/rockylinux8.6/ual:latest imas/ual
    ```

-   To begin an interactive session:

    ``` sh
    docker run -it imas/ual
    ```

    -   `-it` stands for `--interactive` and `--tty`, which allows to
        establish the session

### Running codes in the container

-   A collection of simple IMAS codes to start with can be found here:
    <https://gitlab.eufus.psnc.pl/imas/imas-hello-world>
-   The examples cover C++, Fortran, Java and Python
-   All codes create the `summary` IDS in `shot=1` and `run=1`, each
    with a different value in the `comment` field
-   There is a helper Python script `python/read.py` which allows to
    verify correctness of those codes

#### C++

Source code of `cpp/hello.cpp`:

``` cpp
#include <UALClasses.h>
#include <pwd.h>
#include <unistd.h>

int main() {
    uid_t uid = geteuid();
    struct passwd *pw = getpwuid(uid);

    IdsNs::IDS ids(1, 1, 0, 0);
    ids.createEnv(pw->pw_name, "test", "3");

    ids._summary.ids_properties.comment = "Hello World from C++";
    ids._summary.ids_properties.homogeneous_time = 1;
    ids._summary.time.resize(1);
    ids._summary.time(0) = 0.1;
    ids._summary.put();

    ids.close();
    return 0;
}
```