---
# System prepended metadata

title: dpslus version tracking
tags: [lyra, howtos, dsplus]

---

---
tags: dsplus,lyra,howtos
title : dpslus version tracking
description: Exemples, trucs et astuces pour dsplus
---



# Tracer les versions déployées

Comment tracer et connaître les versions déployées.

[toc]

## Principes

Par version, on entend la version packagée d'un projet git/datastage. Cette version est censée pointer vers une révision git et peut être un commit ou un tag. Elle peut également être une branche à un instant T.

## Dans un fichier plat

### Via l'outil de déploiement

Le plus facile est d'utiliser les capacités de l'outil de déploiement afin de tracer dans un fichier les différents déploiements. La version étant inscrite dans le manifeste du package, il est facile de l'exploiter :
```bash=
dsplus deploy --pack MyPackage.isx --project dstageProd
[ $? -eq 0 ] && dsplus manifest --pack MyPackage.isx --query infos.version --format json >> Versions.txt
```
:::info
Dans le cas d'un package DELTA, la version est une donnée de type Array de 2 éléments où le premier est la version d'origine et le 2ième la version actuelle. Dans ce cas, on pourra utiliser la syntaxe suivante pour sélectionner uniquement la version actuelle :
`infos.version[1]`
Ou alors aplatir :
`'$join(infos.version,":")'`
On peut aussi souhaiter y ajouter la date :
`'$join([$now(),infos.version],":")'`
:::


### Via les plugins dsplus

Via le système d'extensions de dsplus on peut automatiquement déclencher des programmes externes. Dans ce cas de figure si on souhaite à la fin d'un déploiement tracer la version déployée dans un fichier on pourra spécifier le plugin suivant dans le fichier de configuration de dsplus en ajoutant la section `plugins` :
```yaml
plugins:
trackversions:
type: bin
program: echo
event: end:deploy
args: ["${infos.version}",">>","Versions.txt"]
context:
deploy:
trackversion: true
```

:::info
Dans cet exemple le plugin est activé si l'option `trackversion` est `true`.
Celle-ci peut donc être activée soit systématiquement dans le fichier de configuration soit via la variable d'environnement DSP_TRACKVERSION (qui peut-être positionnée dans un fichier .env ou dans l'environnement).
:::

On pourrait également utiliser la syntaxe suivante pour par exemple ajouter la date et nommé le fichier en fonction du projet cible :
```yaml
args: ["$(date)",":","${infos.version}",">>","${project}_version.txt"]
```

:::info
Comme dans l'exemple précédent, dans le cas d'un DELTA il faudra une syntaxe différente pour applatir l'information:
```yaml
args: ["$(date)",":","${infos.version.1}",">>","${project}_version.txt"]
```
:::

On peut utiliser également les plugins pour ajouter une fonctionnalité à dsplus afin d'afficher la version :
```yaml
getversion:
type: bin
program: tail
event: start:getversion
args: ["-1","${project}_version.txt"]
```

Ainsi avec la commande `dsplus getversion --project dstageProd` on obtient al dernière version déployée.


## Dans le projet cible

### Via les variables d'environnement

Dsplus permet de spécifier une configuration projet et notamment des variables d'environnements qui sont appliquées au moment d'un déploiement.

Pour cela, il faut commencer par créer le fichier de configuration.
Celui-ci doit se trouver à la racine du repository git et se nommer `project.yml`.

Dans cet exemple, on veut simplement renseigner ene variables d'environnement qui contient la version déployée:

```yaml
env:
version:
value: "[[version]]"
type: STRING
prompt: version Tracking
```

Ainsi à chaque déploiement la variable d'environnement `version` est valorisée avec la version déployée.

On peut également vouloir historiser cette information :

```yaml
versionHistory:
value: "${versionHistory} - [[version]]"
type: STRING
prompt: version History
```

Ainsi, à chaque déploiement, on ajoute la version déployée à la liste des versions précédentes dans la variable d'environnement `versionHistory`.

:::info
On notera les syntaxe de *templating*:
`[[option]]]`: pour remplacer des informations du manifeste.
`${variable}`: pour remplacer par une variable d'environnement du projet.
:::

### Via le mécanisme interne de dsplus

En activant l'option `trackversions` à `true` (ou la variable d'environnement `DSP_TRACKVERSIONS`), dsplus écrira des informations directement dans le projet à la fin du déploiement.

Ces informations sont extractibles via la commande `dsplus current --project dstageProd`.
Par exemple :
```json
{
name: 'MyGitProject',
repository: '',
git: '587558db2d95f141bd971b191261050c4f69f088 refs/remotes/origin/HEAD',
mode: 'FULL',
remote: 'https://remoteGit/...',
created: '2021-02-05T10:02:23.920Z',
deployed: '2021-02-05T10:02:57.649Z',
version: 'HEAD'
}
```

`dsplus current --project dstageProd --query '$.version'` donnera la dernière version.

:::info
Les versions sont historisées et l'argument `--verbose` (ou `-v`) permet d'afficher le détail.
:::

Cette fonctionnalité supporte le multi-repository (si un projet datastage est versionné dans plusieurs repository git).

:::warning
Le mécanisme en place ici est d'ajouter des parameterSets dans le projet DataStage (dans une arborescence dédiée). Cela induit de fait une différence d'ordre technique avec le projet de développement.
Par ailleurs si ceux ci sont manuellement modifiés ils seraient considérés corrompus par dsplus.
:::


:::info
On peut combiner cette fonctionnalité avec le fichier de configuration `project.yml` en ajoutant des variables (`vars`):
:::
```yaml
vars:
name: "myApp"
repository: "myRepo"
mode: "FULL"
pack: "[[name]].[[version]].[[mode]].isx"
```

Avec cette configuration la commande `dsplus package --version v1.0.0` produit automatiquement le package `myApp.v1.0.0.FULL.isx`.
Une fois celui-ci déployé la commande `dsplus current --project dstageProd` renverrai le message:
```json
{
name: 'myApp',
repository: 'myRepo',
git: '587558db2d95f141bd971b191261050c4f69f088 refs/tags/v.1.0.0',
mode: 'FULL',
remote: 'https://remoteGit/...',
created: '2021-02-05T10:28:12.626Z',
deployed: '2021-02-05T10:29:14.159Z',
version: 'v1.0.0'
}
```

