---
# System prepended metadata

title: Simplifier le workflow
tags: [lyra, howtos, dsplus]

---

---
tags: dsplus,lyra,howtos
title : Simplifier le workflow
description: Exemples, trucs et astuces pour dsplus
---

# Faciliter les reports

Dans le cas de figure où tous les développeurs ont leur propre environnement de développement DataStage mais travaillent sur la même branche du projet Git il n'est pas simple de reporter les modifications après un `git pull` sans repackager le projet en `FULL` et le déployer.

On propose ici quelques idées pour faciliter et fluidifier ce workflow.

## Branche locale
L'idée est que dans un sens:
* chaque développeur commit dans une branche locale personnelle
* merge ses changements dans la branche commune
* push la branche commune à jour

Dans l'autre sens:
* le développeur pull la branche commune
* package un `DELTA` entre la branche commune et sa branche personnelle
* déploie ce package dans son environnement
* merge la branche commune avec sa branche personnelle

```bash
# On switch sur la branche commune
git checkout develop
# On la met à jour
git pull
# Package le diff entre la branche locale et la commune
dsplus package --mode DELTA --version localBranch develop --pack delta.isx
# On deploie ce package
dsplus deploy --packa delta.isx
# On met à jour la branche locale
git checkout localBranch
git merge develop
# On met à jour l'index
dsplus init --update -m

dsplus get --job MyJob -xo
git add MyJob
git commit "add MyJob"
git checkout develop
git merge localBranch
```

Cela aurait l'avantage de ne pas avoir à garder la trace ou à retrouver ses propres commits pour consituer le package différentiel. 
Par contre cela modifie le workflow actuel.

## Dernier commit

L'idée est de
* vérifier le dernier commit avant de faire un pull
* Faire le pull
* Packager le `DELTA` avec ce dernier commit (par défaut dsplus fera le différentiel entre ce commit et `HEAD`)
* Déployer ce package

```bash
# Version courante locale
currentRev=$(git rev-parse HEAD)
echo "Current Revision: ${currentRev}"
# Pull la branche remote
git pull || exit 1
# Package le delta avec la version courante locale
dsplus package --mode DELTA --pack delta.isx --version "${currentRev}"
# Deploiement du delta
dsplus deploy --pack delta.isx
# Update de l'index
dsplus init --update -m
```


# Pour aller plus vite

Pour se simplifier la vie il est possible de simplifier ces opérations grâce à une fonctionnalité de ``Git``. Soit via des `hooks` ou via des scripts d'extensions.
Par exemple, en plaçant le script ``git-ds`` ci-dessous dans un répertoire du ``$PATH `` (par exemple au même endroit que ``dsplus``), on créé une intégration entre ``Git`` et ``dsplus``.

```bash!
#!/bin/bash

#Fonction de comparaison de code
diffds(){
    asset=$1
    path=$(dsplus get -mv --job $asset --query "category" --format json)
    [ ! -f ./$path/$asset/$asset.ast.json ] && echo "no code" && exit 1
    dsplus get --ast -v --job $asset --format json | git diff --no-index --  ./$path/$asset/$asset.ast.json -
}

pullds(){
    # Version courante locale
    currentRev=$(git rev-parse HEAD)
    echo "Current Revision: ${currentRev}"
    # Pull la branche remote
    git pull || exit 1
    # Package le delta avec la version courante locale
    dsplus package --mode DELTA --pack __delta.isx --version "${currentRev}"
    # Deploiement du delta
    DSP_DELETES=true DSP_ROLLBACK=true dsplus deploy --pack  __delta.isx
    # Update de l'index
    dsplus init --update -m
    # Nettoyage 
    rm __delta.isx
}


#Commandes git
[ "$1" == "add" ] && dsplus get -mxgiokc --doc --ast --job $2 && git add ".$(dsplus get -mv --job $asset --query "category" --format json)/$2"
[ "$1" == "status" ] && dsplus status --format table
[ "$1" == "checkout" ] && git checkout $2 $3 && dsplus deploy --isx $3/*.isx && dsplus get --ast -o -g
[ "$1" == "diff" ] && diffds $2
[ "$1" == "pull" ] && pullds
```

Ainsi par exemple la commande:
```bash
git ds add MyJob
```
revient à faire
```bash
dsplus get --job ...
git add ./..../MyJob
```

De même toute l'opération de pull, packaging, déploiement etc... décrit précédemment est faisable en une commande:
```bash
git ds pull
```

## Recommandations
Pour simplifier les opérations le plus possible on recommande que les développeurs configurent leur repository Git via la commande:
```bash
git config --local dsplus.option valeur
```
```bash=
dsplus.project=dstage1
dsplus.git=true
```
Ainsi il n'est plus nécessaire de spécifier le nom du projet (le repository y est connecté) ni l'option `--g(it)`.
Cela est à adapter en fonction de l'usage fait.


## Index

Dans les exemples précédents l'étape de mise à jour de l'index permet de rapidement mettre en phase l'index du repository git local avec le projet au quel il est connecté. Ainsi on n'est pas pollué par les reports lorsque l'on vérifie l'état du projet avec la commande `dsplus status`.
:::warning
Si on effectue les reports alors que l'on a du travail qui n'a pas encore été ajouté au repository (et donc à l'index), les objets modifiés ne seront plus listés comme modifiés ou nouveaux.
Pour remedier à cela on peut modifier le script pour mettre à jour l'index uniquement avec les objets qui viennent d'être reportés:

```bash
# Deploiement du delta
DSP_DELETES=true DSP_ROLLBACK=true dsplus deploy --pack  __delta.isx
# Update de l'index
dsplus init --update -m
```
>```bash
> currentDate=$(date '+%Y/%m/%d %H:%M:%S') [color=#907bf7]
># Deploiement du delta
>DSP_DELETES=true DSP_ROLLBACK=true dsplus deploy --pack  __delta.isx
># Update de l'index
>dsplus init --update -m --filter  "modificationTimestamp>='${currentDate}'"
>```
    
:::

