AIOP Core
The AIOP Core is the heart of the AIOP solution. It consists of several modules that handle the different phases of building a package. Let's explore the basic concepts and workings of AIOP Core.
Basic Concepts
AIOP Core is built upon several basic concepts. These concepts form the foundation of the AIOP solution.
Package
A package is a collection of artifacts that make up an application. A package can be a web application, a mobile application, a desktop application, an embedded application or set of applications, a service, a library, etc.
Originally, the goal of AIOP was to design packages for embedded applications. However, the solution was designed to be used in any other types of projects. If you have specific needs, do not hesitate to contact us.
Composition
A package is composed of several artifacts. These artifacts can be files or directories.
Artifacts can be textual files
Reports
Configuration
Certificates
Source code
Data
Documentation
Log files
...anything readable by a human
Artifacts can be binary files
Sounds
Images
Videos
Libraries
Executables
Archives (zip)
Databases
Encrypted documents
...anything compiled, encrypted, or unreadable by a human
Sources of Artifacts
Artifacts can come from several sources:
Organization of Artifacts
You are free to organize the artifacts as you wish. AIOP does not impose a structure on you. However, it is recommended to adopt a standard structure for all your packages.
The advantage of AIOP lies in its ability to establish a standard artifact structure for all your packages defined by you and your team. This approach facilitates maintenance and debugging of packages, as everyone involved will know this structure and will be accustomed to navigating inside it.
Validation and Error Handling
AIOP Core is designed to display as much information as possible about errors encountered before and during the construction of a package. Errors are reported to the user in the form of reports in the console.
AIOP reports errors as early as possible so that the user can correct them quickly.
It is important to note that AIOP does not correct errors for you (this would happen sooner or later). It informs you of the errors and gives you indications on how to correct them. It is up to you to correct them.
Configurations
The behavior of AIOP Core can be modified by configurations. There are several types of configurations: user configuration, project configuration, system configuration. Learn more.
Declarations
AIOP operates on the declarative principle of resources. Declarations are files that describe the artifacts of a package as well as their compatibilities with systems. Learn more.
Integrations
AIOP Core includes various third-party tools and services to perform different tasks. Among them are universal artifact repository managers such as Nexus (opens in a new tab) or Artifactory (opens in a new tab). Additionally, it integrates a PDF building tool.
A multitude of other features and services will arrive in future versions (see the roadmap). Learn more.
Caching
AIOP Core utilizes a caching mechanism to store remote resources. This feature aims to reduce the time required to build packages, especially in cases where the connection with remote servers is interrupted or when internet connection is limited.
Operation
Now let's see how AIOP works.
Used Languages
The programming language used is Python. Declarations and configurations are written in YAML (opens in a new tab).
Declaration Selections
Selection is an operation that consists of choosing the declarations to use for building a package. Selection is based on the targeted system and the chosen configuration. The targeted system is defined by the user in the system configuration file. Learn more.
Logs and Reports
AIOP Core produces logs for each construction step, displaying various information such as errors, warnings, artifact details, and more, directly in the console.
Additionally, AIOP Core generates textual reports stored in the build directory. These reports include:
- A detailed build report, listing all operations performed by AIOP.
- A summary of the built package, providing essential information about it.
- A specific report describing changes made to the package during the
post-buildstep.
Construction Phases
AIOP Core consists of several package construction phases. Each phase is responsible for several specific tasks. Phases are executed in a specific order. Here are the construction phases:
Lint
The lint phase ensures the validation of declarations and configurations by checking the syntax of the corresponding files as well as the consistency between them.
As a static analysis, it does not require specifying the target system. However, an option is available to define the target system and perform additional checks, notably on potential conflicts at the resource level. Learn more.
Note that it is possible to add custom lint tasks to validate rules specific to your project.
The free plan does not allow
adding custom lint tasks.
Pre-build
The pre-build phase is responsible for preparing the build environment. It ensures the retrieval of remote artifacts, the creation of build directories, etc. Learn more.
Build
The build phase is responsible for building the package. It ensures the assembly of resources into the package. Learn more.
Post-build
The post-build phase is used to perform tasks that do not make sense to be included in the build phase. For example, you might want to generate a wallpaper for a client that displays metadata about the target system in text format. Any manipulation of the temporary packages after build must be done in this phase. Learn more.
As a reminder, a report is generated at the end of the post-build phase by comparing the package before and after this phase. This report is stored in the build directory.
Additionally, it is possible to add custom post-build tasks to perform actions specific to your project.
The free plan does not allow adding custom post-build tasks.
Seal
The seal phase is a step where several tasks are performed to finalize and prepare the package for distribution in the next phase. Learn more.
Deploy
The deploy phase is responsible for distributing the package. It ensures the sending of the package to universal artifact repository managers and/or the deployment of the targeted systems directly. Learn more.