Statuts dans le vtexport

Code couleur des statuts dans VTOM.

    R = ENCOURS       #05FAFA
    X = ENDIFFICULTE  #FFC800
    W = AVENIR        #FAFF14
    F = TERMINE       #14FF14
    E = ENERREUR      #FA0000
    D = DEPLANIFIE    #C3C3C3
    U = NONPLANIFIE   #FAFAFA

{
  "R" : {"rvb":"5,250,250","nom":"ENCOURS"},
  "X" : {"rvb":"255,200,0","nom":"ENDIFFICULTE"},
  "W" : {"rvb":"250,255,20","nom":"AVENIR"},
  "F" : {"rvb":"20,255,20","nom":"TERMINE"},
  "E" : {"rvb":"250,0,0","nom":"ENERREUR"},
  "D" : {"rvb":"195,195,195","nom":"DEPLANIFIE"},
  "U" : {"rvb":"250,250,250","nom":"NONPLANIFIE"}
}

Et la column vtstatus dans la table vt_stats_job : (index de 0 à 6)

let Status = ["", "AVENIR ", "ENCOURS", "TERMINE", "ENERREUR", "DEPLANIFIE", "NONPLANIFIE"]
# mode d'exécution
let VTOMModeExec = ["", "Exéc", "Simu", "Test", "Stop", "Job"]

(voir plus) Statuts dans le vtexport

12-12-2016

Curl sftp avec mot de passe

Je ne sais pas s’il existe une raison justifiant le fait de faire du sftp non sécurisé (mot de passe en clair, sans certificat SSL) mais des fois, il ne faut pas trop chercher à comprendre.

Donc sachez que si on vous dit, “plus de FTP, il faut faire du SFTP” et qu’on vous dit, “ah non, impossible de mettre en place des clés privées, publiques”, vous pouvez scripter du sftp avec curl avec le user / mot de passe !

Lister, afficher, récupérer

# la racine de connexion du user
curl -k -u user:mdp sftp://host

# un répertoire en particulier (ne pas oublier le dernier /)
curl -k -u user:mdp sftp://host/MyDir/

# affiche le contenu du fichier à l'écran
curl -k -u user:mdp sftp://host/monFichier

# récupérer un fichier 
curl -k -u user:mdp sftp://host/monFichier -o /monRep/monFichier

les options intéressantes

-v                  | mode verbose, pratique pour debug
-u user:mdp         | pour l'authentification
sftp://@IP:port     | protocole peut être sftp, ftp, http par exemple
-Q "CMD dir/file"   | exécution de la commande sur le fichier (on part de la racine de connexion user)
-k ou --insecure    | (SSL) This option explicitly allows curl to perform "insecure" SSL connections and transfers
                    | problème résolu de "curl: (51) SSL peer certificate or SSH remote key was not OK"
-o dir/file         | redirige la sortie dans le fichier dir/file

Quelques commandes FTP

# delete
curl -u user:mdp ftp://host -Q 'DELE MyDir/FileTodelete'
# rename
curl -u user:mdp ftp://host -Q 'RNFR MyDir/FileToRename' -Q 'RNTO MyDir/FileRenamed'

Quelques commandes SFTP

# delete
curl -k -u user:mdp sftp://host -Q 'rm MyDir/FileTodelete'

# rename
curl -k -u user:mdp sftp://host -Q 'rename MyDir/FileToRename MyDir/FileRenamed'

# on peut cumuler la commande + le listage (attention, par défaut, la commande est effectuée avant)
# supprimer le rep' /var/tmp/MyDir et lister le contenu de /var/tmp/
curl -k -u user:mdp sftp://host/var/tmp/ -Q 'rmdir /var/tmp/MyDir'

man curl
 -Q, --quote <command>
  (FTP/SFTP)  Send  an arbitrary command to the remote FTP or SFTP server. Quote commands are sent BEFORE the transfer takes place (just
  after the initial PWD command in an FTP transfer, to be exact). To make commands take place after a successful transfer,  prefix  them
  with  a  dash '-'.  To make commands be sent after curl has changed the working directory, just before the transfer command(s), prefix
  the command with a '+' (this is only supported for FTP). You may specify any number of commands. If the server returns failure for one
  of  the  commands,  the  entire  operation will be aborted. You must send syntactically correct FTP commands as RFC 959 defines to FTP
  servers, or one of the commands listed below to SFTP servers.  This option can be used multiple times. When speaking to an FTP server,
  prefix the command with an asterisk (*) to make curl continue even if the command fails as by default curl will stop at first failure.

  SFTP  is  a binary protocol. Unlike for FTP, curl interprets SFTP quote commands itself before sending them to the server.  File names
  may be quoted shell-style to embed spaces or special characters.  Following is the list of all supported SFTP quote commands:

  chgrp group file
         The chgrp command sets the group ID of the file named by the file operand to the group ID specified by the group  operand.  The
         group operand is a decimal integer group ID.
  chmod mode file
         The chmod command modifies the file mode bits of the specified file. The mode operand is an octal integer mode number.
  chown user file
         The  chown  command sets the owner of the file named by the file operand to the user ID specified by the user operand. The user
         operand is a decimal integer user ID.
  ln source_file target_file
         The ln and symlink commands create a symbolic link at the target_file location pointing to the source_file location.

  mkdir directory_name
         The mkdir command creates the directory named by the directory_name operand.
  pwd    The pwd command returns the absolute pathname of the current working directory.
  rename source target
         The rename command renames the file or directory named by the source operand to the destination path named by the target  oper‐
         and.
  rm file
         The rm command removes the file specified by the file operand.
  rmdir directory
         The rmdir command removes the directory entry specified by the directory operand, provided it is empty.
  symlink source_file target_file
         See ln.

Bug rencontré sur AIX

OpenSSL version mismatch. Built against 1000105f, you have 100000bf

Merci JM F. pour celle-là ;)

export LIBPATH=:/usr/lib:$LIBPATH

curl: (51) SSL peer certificate or SSH remote key was not OK

-k ou --insecure

sinon curl c’est aussi …

Sympa pour les API avec un retour JSON par exemple : voir mon article sur le WebAccess

et pour plein d’autres fonctionnalités sympa (comme récupérer les entêtes d’une requête HTML) client URL

Javascript fonction unique (distinct) sur un tableau d'objet

Mon besoin en Javascript

J’ai un tableau d’objets, et je veux récupérer un tableau de valeurs uniques d’objets ayant le même attribut.

Fonction

let _distinctUniqueValuesInArray = (arr, prop) => arr.map(obj => obj[prop]).filter((v, i, a) => a.indexOf(v) == i)

Exemple

var monArray = [
{"VTENVNAME":"ENV1","VTDOMAINE":"MONDOMAINE25","NB_JOBS_NON_STATS":"15"},
{"VTENVNAME":"ENV2","VTDOMAINE":"MONDOMAINE15","NB_JOBS_NON_STATS":"58"},
{"VTENVNAME":"ENV2","VTDOMAINE":"MONDOMAINE35","NB_JOBS_NON_STATS":"18"},
{"VTENVNAME":"ENV2","VTDOMAINE":"MONDOMAINE25","NB_JOBS_NON_STATS":"50"},
{"VTENVNAME":"ENV5","VTDOMAINE":"MONDOMAINE36","NB_JOBS_NON_STATS":"2"},
{"VTENVNAME":"ENV5","VTDOMAINE":"MONDOMAINE26","NB_JOBS_NON_STATS":"10"},
{"VTENVNAME":"ENV7","VTDOMAINE":"MONDOMAINE26","NB_JOBS_NON_STATS":"81"},
{"VTENVNAME":"ENV7","VTDOMAINE":"MONDOMAINE36","NB_JOBS_NON_STATS":"47"},
{"VTENVNAME":"ENV7","VTDOMAINE":"MONDOMAINE16","NB_JOBS_NON_STATS":"71"},
{"VTENVNAME":"ENV8","VTDOMAINE":"MONDOMAINE25","NB_JOBS_NON_STATS":"45"},
{"VTENVNAME":"ENV8","VTDOMAINE":"MONDOMAINE15","NB_JOBS_NON_STATS":"31"},
{"VTENVNAME":"ENV8","VTDOMAINE":"MONDOMAINE35","NB_JOBS_NON_STATS":"62"},
{"VTENVNAME":"ENV13","VTDOMAINE":"MONDOMAINE36","NB_JOBS_NON_STATS":"2"},
{"VTENVNAME":"ENV13","VTDOMAINE":"MONDOMAINE16","NB_JOBS_NON_STATS":"2"},
{"VTENVNAME":"ENV13","VTDOMAINE":"MONDOMAINE26","NB_JOBS_NON_STATS":"2"},
{"VTENVNAME":"ENV14","VTDOMAINE":"MONDOMAINE16","NB_JOBS_NON_STATS":"56"},
{"VTENVNAME":"ENV14","VTDOMAINE":"MONDOMAINE36","NB_JOBS_NON_STATS":"29"},
{"VTENVNAME":"ENV14","VTDOMAINE":"MONDOMAINE26","NB_JOBS_NON_STATS":"77"},
{"VTENVNAME":"ENV15","VTDOMAINE":"MONDOMAINE26","NB_JOBS_NON_STATS":"164"},
{"VTENVNAME":"ENV15","VTDOMAINE":"MONDOMAINE36","NB_JOBS_NON_STATS":"90"},
{"VTENVNAME":"ENV15","VTDOMAINE":"MONDOMAINE16","NB_JOBS_NON_STATS":"139"},
{"VTENVNAME":"ENV16","VTDOMAINE":"MONDOMAINE16","NB_JOBS_NON_STATS":"113"},
{"VTENVNAME":"ENV16","VTDOMAINE":"MONDOMAINE36","NB_JOBS_NON_STATS":"123"},
{"VTENVNAME":"ENV16","VTDOMAINE":"MONDOMAINE26","NB_JOBS_NON_STATS":"410"}
]
_distinctUniqueValuesInArray(monArray,"VTDOMAINE")

["MONDOMAINE25", "MONDOMAINE15", "MONDOMAINE35", "MONDOMAINE36", "MONDOMAINE26", "MONDOMAINE16"]

_distinctUniqueValuesInArray(monArray,"VTENVNAME")

["ENV1", "ENV2", "ENV5", "ENV7", "ENV8", "ENV13", "ENV14", "ENV15", "ENV16"]

Pour aller plus loin

Array.prototype.map()

Mon talbeau d’entrée étant constitué d’objets, et ne voulant qu’un tableau de valeurs pour une clé donnée, je créé un nouveau tableau avec map qui satisfait mes besoins.

(arr, prop) => arr.map(obj => obj[prop])

Array.prototype.filter() Array.prototype.indexOf()

Comme map() retourne un tableau, je peux l’enchainer avec filter()

Je ne retourne que les élements qui vérifient ma condition.

v (valeur), i (index), a (le tableau complet, ici monnouveautableau qui correspond à arr.map(obj => obj[prop]))

monnouveautableau.filter((v, i, a) => a.indexOf(v) == i)

En français : on boucle sur tous les élements de monnouveautableau et on retourne chaque élément dans un nouveau tableau si son index (i) correspond à l’index du premier élément (indexOf) de monnouveautableau qui a la valeur v.

Je ne sais pas si c’est français, mais j’me comprends !

sort sur un tableau de tableaux sur plusieurs index

https://stackoverflow.com/a/2784879

Array.prototype.deepSortAlpha= function(){
    var itm, L=arguments.length, order=arguments;

    var alphaSort= function(a, b){
        a= a.toLowerCase();
        b= b.toLowerCase();
        if(a== b) return 0;
        return a> b? 1:-1;
    }
    if(!L) return this.sort(alphaSort);

    this.sort(function(a, b){
        var tem= 0,  indx=0;
        while(tem==0 && indx<L){
            itm=order[indx];
            tem= alphaSort(a[itm], b[itm]); 
            indx+=1;        
        }
        return tem;
    });
    return this;
}

monArr = [
  ["EVOLAN", "libéléEVOLAN2", "applEVOLAN", "jobEVOLAN", "domEVOLAN", "caisse1", "endEVOLAN", "YES"],
  ["ALIS", "libéléALIS2", "applALIS", "jobALIS", "domALIS", "caisse2", "endALIS", "YES"],
  ["ALIS", "libéléALIS", "applALIS", "jobALIS", "domALIS", "caisse2", "endALIS", "YES"],
  ["ALIS", "libéléALIS", "applALIS", "jobALIS", "domALIS", "caisse3", "endALIS", "NO"],
  ["EVOLAN", "libéléEVOLAN", "applEVOLAN", "jobEVOLAN", "domEVOLAN", "caisse1", "endEVOLAN", "YES"],
  ["IAM", "libéléIAM1", "applIAM", "jobIAM", "domIAM", "caisse1", "endIAM", "YES"],
  ["IAM", "libéléIAM", "applIAM", "jobIAM", "domIAM", "caisse1", "endIAM", "YES"],
  ["OUI", "libéléOUI", "applOUI", "jobOUI", "domOUI", "caisse1", "endOUI", "YES"],
  ["ALIS", "libéléALIS2", "applALIS", "jobALIS", "domALIS", "caisse2", "endALIS", "NO"],
  ["EVOLAN", "libéléEVOLAN3", "applEVOLAN", "jobEVOLAN", "domEVOLAN", "caisse1", "endEVOLAN", "YES"],
  ["ALIS", "libéléALIS", "applALIS", "jobALIS", "domALIS", "caisse1", "endALIS", "YES"],
  ["IAM", "libéléIAM3", "applIAM", "jobIAM", "domIAM", "caisse1", "endIAM", "NO"],
  ["IAM", "libéléIAM2", "applIAM", "jobIAM", "domIAM", "caisse1", "endIAM", "NO"],
  ["IAM", "libéléIAM", "applIAM", "jobIAM", "domIAM", "caisse2", "endIAM", "NO"]
]
monArr.deepSortAlpha(0,1,7)
(14) [Array(8), Array(8), Array(8), Array(8), Array(8), Array(8), Array(8), Array(8), Array(8), Array(8), Array(8), Array(8), Array(8), Array(8)]
0:(8) ["ALIS", "libéléALIS", "applALIS", "jobALIS", "domALIS", "caisse3", "endALIS", "NO"]
1:(8) ["ALIS", "libéléALIS", "applALIS", "jobALIS", "domALIS", "caisse2", "endALIS", "YES"]
2:(8) ["ALIS", "libéléALIS", "applALIS", "jobALIS", "domALIS", "caisse1", "endALIS", "YES"]
3:(8) ["ALIS", "libéléALIS2", "applALIS", "jobALIS", "domALIS", "caisse2", "endALIS", "NO"]
4:(8) ["ALIS", "libéléALIS2", "applALIS", "jobALIS", "domALIS", "caisse2", "endALIS", "YES"]
5:(8) ["EVOLAN", "libéléEVOLAN", "applEVOLAN", "jobEVOLAN", "domEVOLAN", "caisse1", "endEVOLAN", "YES"]
6:(8) ["EVOLAN", "libéléEVOLAN2", "applEVOLAN", "jobEVOLAN", "domEVOLAN", "caisse1", "endEVOLAN", "YES"]
7:(8) ["EVOLAN", "libéléEVOLAN3", "applEVOLAN", "jobEVOLAN", "domEVOLAN", "caisse1", "endEVOLAN", "YES"]
8:(8) ["IAM", "libéléIAM", "applIAM", "jobIAM", "domIAM", "caisse2", "endIAM", "NO"]
9:(8) ["IAM", "libéléIAM", "applIAM", "jobIAM", "domIAM", "caisse1", "endIAM", "YES"]
10:(8) ["IAM", "libéléIAM1", "applIAM", "jobIAM", "domIAM", "caisse1", "endIAM", "YES"]
11:(8) ["IAM", "libéléIAM2", "applIAM", "jobIAM", "domIAM", "caisse1", "endIAM", "NO"]
12:(8) ["IAM", "libéléIAM3", "applIAM", "jobIAM", "domIAM", "caisse1", "endIAM", "NO"]
13:(8) ["OUI", "libéléOUI", "applOUI", "jobOUI", "domOUI", "caisse1", "endOUI", "YES"]

vthttpd -dump et requêtes SQL - tlist ameliore - vtexport.xml to csv

<Article mis à jour> J’ai rajouté pas mal de petites astuces sur cet article qui date de l’année dernière (filtre XSL - merci Joey pour l’inspiration !, parsing java, utilisation de Panda Python)

Une autre astuce avec le Webaccess VTOM vthttpd : on peut dump tout le contenu de la base VTOM en un fichier exploitable par SQLITE !

L’utilisation principale est de lister tous les jobs, à la manière d’un tlistmais avec beaucoup plus d’informations (dont les paramètres et le script)

Voici un petit exemple :

vthttpd -dump /var/tmp/vthttpd.dat
sqlite3 /var/tmp/vthttpd.dat
>
.tables  -- liste toutes les tables
pragma table_info(JOBS) ; -- liste les champs de la table JOBS
.schema JOBS ; -- idem mais avec le type de la colonne (varchar(35) par ex.)

On peut exécuter un script .sql :

sqlite3 /var/tmp/vthttpd.dat < /var/tmp/monfichier.sql

Et on grep sur ce qu’on souhaite

select j.JOB_SID, e.NAME, a.NAME, j.NAME, j.COMMENT, j.FAMILY, j.SCRIPT, h.NAME, u.NAME, q.NAME, d.NAME, GROUP_CONCAT(p.VALUE,'|')
from jobs j
left join applications a on j.APP_SID = a.APP_SID
left join environments e on a.ENV_SID = e.ENV_SID
left join hosts h on j.HOST_SID = h.HOST_SID or (ifnull(j.HOST_SID,'') = '' and ( a.HOST_SID = h.HOST_SID or (ifnull(a.HOST_SID,'') = '' and e.HOST_SID = h.HOST_SID) ) )
left join users u on j.USER_SID = u.USER_SID or (ifnull(j.USER_SID,'') = '' and ( a.USER_SID = u.USER_SID or (ifnull(a.USER_SID,'') = '' and e.USER_SID = u.USER_SID) ) )
left join queues q on j.QUEUE_SID = q.QUEUE_SID or (ifnull(j.QUEUE_SID,'') = '' and ( a.QUEUE_SID = q.QUEUE_SID or (ifnull(a.QUEUE_SID,'') = '' and e.QUEUE_SID = q.QUEUE_SID) ) )
left join dates d on j.DATE_SID = d.DATE_SID or (ifnull(j.DATE_SID,'') = '' and ( a.DATE_SID = d.DATE_SID or (ifnull(a.DATE_SID,'') = '' and e.DATE_SID = d.DATE_SID) ) )
left join job_parameters p on j.JOB_SID = p.JOB_SID
group by j.JOB_SID
;

ex.

root@acf59c2005cf:/mnt/workspace/temp# sqlite3 vthttpd.dat < all_jobs.sql
JOBac1100030a411a8d570cf93000000004|exploitation|appli_test|job2|||jobok.bat|client_local|vtom|queue_ksh|date_exp|
JOBac1100033f6aedb3570cf93000000002|exploitation|appli_test|job1|||jobok.bat|client_local|vtom|queue_ksh|date_exp|param1|param2|param3
JOBac1100036f024b9d570cf93000000006|exploitation|appli_test|job3|||jobok.bat|client_local|vtom|queue_ksh|date_exp|

(exemple en Java, P.I je ne suis pas expert en Java - je suis tombé sur des machines qui n’avaient pas sqlite3 … Ca ne suit surement pas les bonnes pratiques JAva mais ça fonctionne)

package top100_vthttpd_jobs_to_csv;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;

public class Top100Main {

	public static void main(String[] args) {
		Connection c = null;
		Statement stmt = null;
		String sepCSV = "," ;
		
		try {
			Class.forName("org.sqlite.JDBC");
			c = DriverManager.getConnection("jdbc:sqlite:D:\\workspace\\java\\top100_vthttpd_jobs_to_csv\\vthttpd.dat");
			c.setAutoCommit(false);
			stmt = c.createStatement();
			
			String allJobs = "select j.JOB_SID, e.NAME, a.NAME, j.NAME, j.COMMENT, j.FAMILY, j.SCRIPT, h.NAME, u.NAME, q.NAME, d.NAME, GROUP_CONCAT(p.VALUE,'|')"
					+ " from jobs j"
					+ " left join applications a on j.APP_SID = a.APP_SID"
					+ " left join environments e on a.ENV_SID = e.ENV_SID"
					+ " left join hosts h on j.HOST_SID = h.HOST_SID or (ifnull(j.HOST_SID,'') = '' and ( a.HOST_SID = h.HOST_SID or (ifnull(a.HOST_SID,'') = '' and e.HOST_SID = h.HOST_SID) ) )"
					+ " left join users u on j.USER_SID = u.USER_SID or (ifnull(j.USER_SID,'') = '' and ( a.USER_SID = u.USER_SID or (ifnull(a.USER_SID,'') = '' and e.USER_SID = u.USER_SID) ) )"
					+ " left join queues q on j.QUEUE_SID = q.QUEUE_SID or (ifnull(j.QUEUE_SID,'') = '' and ( a.QUEUE_SID = q.QUEUE_SID or (ifnull(a.QUEUE_SID,'') = '' and e.QUEUE_SID = q.QUEUE_SID) ) )"
					+ " left join dates d on j.DATE_SID = d.DATE_SID or (ifnull(j.DATE_SID,'') = '' and ( a.DATE_SID = d.DATE_SID or (ifnull(a.DATE_SID,'') = '' and e.DATE_SID = d.DATE_SID) ) )"
					+ " left join job_parameters p on j.JOB_SID = p.JOB_SID"
					+ " group by j.JOB_SID"
				//	+ " limit 10"
					+ " ;"
			;

			ResultSet rs = stmt.executeQuery( allJobs );
			
			
			while ( rs.next() ) {
			   String jSID = rs.getString(1);
			   String eName = rs.getString(2);
			   String aName = rs.getString(3);
			   String jName = rs.getString(4);
			   String jComment = rs.getString(5);
			   String jFamily = rs.getString(6);
			   String jScript = rs.getString(7);
			   String hName = rs.getString(8);
			   String uName = rs.getString(9);
			   String qName = rs.getString(10);
			   String dName = rs.getString(11);
			   String pValue = rs.getString(12);
			   System.out.print( 
					   //jSID + sepCSV + 
					   eName + sepCSV + aName + sepCSV + jName + sepCSV + jComment + sepCSV +
					   jFamily + sepCSV + jScript + sepCSV +hName + sepCSV + uName + sepCSV +
					   qName + sepCSV + dName + sepCSV + pValue
					);
			   System.out.println();
			}
		
			rs.close();
			stmt.close();
			c.close();
			
		}catch ( Exception e ) {
		  System.err.println( e.getClass().getName() + ": " + e.getMessage() );
		  System.exit(0);
		}

	}
}

Filtrer directement un fichier XML avec un fichier XSL et sortie en texte (pour du csv)

J’avais déjà utilisé ce langage de transformation XSL mais il m’était complétement sorti de la tête. Merci à JOEY de m’avoir inspriré ! :)

Fichier XSL de transformation (à adapter selon vos besoin)

<xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:output method="text" encoding="utf-8" />
  
  <!-- j'utilise cette sortie pour constituer mon fichier CSV utilisé en tant que data pour load dans Oracle une table avec SQLLDR et un fichier de controle .ctl -->
  <!--
  sqlldr do not set OPTIONALLY ENCLOSED BY '"' because this char appears in comments and params 

        LOAD DATA APPEND
        INTO TABLE nom_dela_table_oracle
        FIELDS TERMINATED BY "£"
        
        (
          "VTENVNAME"                     CHAR,
          "VTAPPLNAME"                    CHAR,
          "VTJOBNAME"                     CHAR,
          "APPMODE"                     CHAR,
          "JOBMODE"                     CHAR, 
          etc...
        )
  -->
  
  <xsl:param name="delimCSV" select="'£'" /><!-- j'utilise ce char car il n'est pas utilisé dans mon référentiel VTOM -->
  <xsl:param name="delimParam" select="'§'" />
  <xsl:param name="break" select="'&#xA;'" />
  <!--
  <xsl:value-of select="$delimCSV" />
   -->

  <xsl:template match="/">
	  <xsl:apply-templates select="Domain/Environments/Environment/Applications/Application/Jobs/Job" />
  </xsl:template>

  <!-- All Job node for root node -->
  <xsl:template match="Domain/Environments/Environment/Applications/Application/Jobs/Job">
    <xsl:value-of select="../../../../@name" /><xsl:value-of select="$delimCSV" />              <!-- EnvironmentName -->
    <xsl:value-of select="../../@name" /><xsl:value-of select="$delimCSV" />                    <!-- ApplicationName -->
    <xsl:value-of select="@name" /><xsl:value-of select="$delimCSV" />                          <!-- JobName -->
    <xsl:value-of select="../../@mode" /><xsl:value-of select="$delimCSV" />                    <!-- ApplicationMode -->
    <xsl:value-of select="@mode" /><xsl:value-of select="$delimCSV" />                          <!-- JobMode -->
    <xsl:value-of select="../../@onDemand" /><xsl:value-of select="$delimCSV" />                <!-- ApplicationOnDemand -->
    <xsl:value-of select="@onDemand" /><xsl:value-of select="$delimCSV" />                      <!-- JobOnDemand -->
    <xsl:value-of select="Script/text()" /><xsl:value-of select="$delimCSV" />                  <!-- Script -->
    <xsl:apply-templates select="Parameters/Parameter" /><xsl:value-of select="$delimCSV" />    <!-- Parameters -->
    <xsl:value-of select="../../../../../../@name" /><xsl:value-of select="$delimCSV" />        <!-- DomainName -->
    <xsl:value-of select="$break" />
  </xsl:template>

  <!-- All Parameter node for Job node -->
  <xsl:template match="Parameters/Parameter">
    <xsl:value-of select="text()" /><xsl:value-of select="$delimParam" />                       <!-- Parameter -->
  </xsl:template>  

</xsl:stylesheet>

Pour appliquer le fichier XSL au fichier XML vtexport VTOM, on peut faire ça assez simplement avec une class Java (Stylizer) fournie par Oracle.

Si vous voulez plus d’information sur la classe et la télécharger, voici le lien Oracle Transforming XML Data with XSLT.

# Compiler le code source java pour créer votre class Stylizer.class, A ne faire qu'une fois. La classe doit se trouver dans votre CLASSPATH (variable d'environnement)
javac Stylizer.java

# Lancer la commande pour transformer votre XML avec le fichier XSL
java Stylizer votrefichier.xsl vtorefichier.xml

Parser le vtexport XML VTOM en “pur” Java (un peu long)

package vtexport_xml_to_csv;

import java.io.File;
import java.io.FileWriter ;
import java.io.IOException;
import java.util.Date;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.xpath.XPath;
import javax.xml.xpath.XPathFactory;
import javax.xml.xpath.XPathConstants ;
import javax.xml.xpath.XPathExpressionException;

import org.w3c.dom.Document;
import org.w3c.dom.NodeList;
import org.w3c.dom.Node;
import org.xml.sax.SAXException;

public class VtexportXML {
	private static String xmlPath ;
	private static Document document;
	private static final String separateurCSV = "£" ;
	private static final String separateurEscape = "§" ;
	private static String domainName;
	
	public static void main(String[] args) throws ParserConfigurationException, SAXException, IOException, XPathExpressionException {
		if (args.length == 1) {
			setXmlPath(args[0]);
		}else{
			System.err.println("Usage : 1 paramètre nécessaire");
			System.err.println("1 : chemin complet du fichier xml");
	        System.exit(1);
		}

        final DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();    	
        final DocumentBuilder builder = factory.newDocumentBuilder();
	    setDocument( builder.parse( new File( getXmlPath() ) ) );
    	listAllJobs();
	}

	public static String getXmlPath() {
		return xmlPath;
	}

	public static void setXmlPath(String xmlPath) {
		VtexportXML.xmlPath = xmlPath;
	}
	
	public static Document getDocument() {
		return document;
	}

	public static void setDocument(Document document) {
		VtexportXML.document = document;
	}
	
	public static void listAllJobs() throws XPathExpressionException, IOException{
		System.out.println(new Date()) ;
		
		File file = new File(getXmlPath() + ".txt");
		// creates the file
		file.createNewFile();
		// creates a FileWriter Object
		FileWriter writer = new FileWriter(file); 
		
		// xPath instance
		XPath xPath =  XPathFactory.newInstance().newXPath();
		// set DomainName 
		setDomainName((String) xPath.compile("/Domain/@name").evaluate( getDocument() ) );
		
		// get all nodelist job
		NodeList nodeList = (NodeList) xPath.compile("/Domain/Environments/Environment/Applications/Application/Jobs/Job").evaluate(getDocument(),XPathConstants.NODESET);	
		
		int percentDone = 1 ;
		System.out.print("0%.");
		
		// loop over nodelist job
		for(int i = 0; i < nodeList.getLength() ; i++){
			
			// print evolution running script %
			if(! ( (i * 100 / nodeList.getLength()) < percentDone ) ){
				percentDone++ ;
				if(percentDone % 10 == 0){
					System.out.print(percentDone + "%");
				}else{
					System.out.print(".");
				}
			}
			
			// job node
			Node jobNode = (Node) nodeList.item(i) ;
			
			// nodelist parameters
			NodeList parametersNodes = (NodeList) xPath.evaluate("Parameters/Parameter",jobNode,XPathConstants.NODESET) ;
			String[] parameters = new String [ parametersNodes.getLength() ] ;
			
			// all parameters as an Array
			for(int j = 0 ; j < parametersNodes.getLength() ; j++){
				parameters[j] = ((Node) parametersNodes.item(j)).getTextContent() ;
			}
			
			writer.write(
				
				separateurEscape + xPath.evaluate("../../../../@name", jobNode) + separateurEscape + separateurCSV +	// envName
				separateurEscape + xPath.evaluate("../../@name", jobNode) + separateurEscape + separateurCSV +			// appName
				separateurEscape + xPath.evaluate("@name", jobNode) + separateurEscape + separateurCSV +				// jobName
				separateurEscape + xPath.evaluate("../../@mode", jobNode) + separateurEscape + separateurCSV +			// AppMode
				separateurEscape + xPath.evaluate("@mode", jobNode) + separateurEscape + separateurCSV +				// JobMode
				separateurEscape + xPath.evaluate("../../@onDemand", jobNode) + separateurEscape + separateurCSV +		// AppOnDemand
				separateurEscape + xPath.evaluate("@onDemand", jobNode) + separateurEscape + separateurCSV +			// JobOnDemand
				separateurEscape + xPath.evaluate("Script",jobNode) + separateurEscape + separateurCSV +				// Script
				separateurEscape + String.join("|", parameters) + separateurEscape + separateurCSV + 					// Parameters
				separateurEscape + getDomainName() + separateurEscape + separateurCSV									// DomainName
				+ "\n"
			);
			
		}

		// Flush the content to the file
		writer.flush();
		writer.close();
		
		// print prompt running script
		System.out.println();
		System.out.println("Fichier en sortie : " + file.getAbsolutePath());
		System.out.println(new Date() + " The end");
	}

	public static String getDomainName() {
		return domainName;
	}

	public static void setDomainName(String domainName) {
		VtexportXML.domainName = domainName;
	}

}

Autre pour moi

Reminder pour moi : consolidation des statistiques VTOM (en attendant que tout soit dans la base postgres, je passe par le vthttpd dump)

plateforme=up2
vthttpdDat=vthttpd_${plateforme}.dat
allJobsSQL=all_jobs.sql
allJobs1to1=all_jobsSID_1to1Param_${plateforme}.txt
allJobsManyTo1=all_jobsSID_manyTo1Param_${plateforme}.txt
outputStats=stats_${plateforme}
vtsgbdPort=30509
hostFilter=HOST1

test -f $vthttpdDat && rm $vthttpdDat
vthttpd -dump $vthttpdDat
sqlite3 $vthttpdDat < $allJobsSQL |  awk 'BEGIN{ FS="|" ; OFS="|" } { l=length($10) ; if(l == 2) { $10="0"$10 ;} ;  if(l == 1){ $10="00"$10 }  ; print}' | sort -g  >  $allJobs1to1

### All jobs manyto1 parameters
awk -F "|" 'BEGIN{ job_sid=null;} {if($1 == job_sid){ printf "|%s",$11 }else{ if(job_sid != null){ printf "\n" } ; printf "%s|%s|%s|%s|%s|%s|%s|%s|%s|%s",$1,$2,$3,$4,$5,$6,$7,$8,$9,$11 } ; job_sid=$1 ;}' $allJobs1to1 | sort > $allJobsManyTo1

# get stats with filters (modify where clauses)   
# select vtobjectsid,vtenvname, vtapplname, vtjobname, vtbegin, (vtend::timestamp - vtbegin::timestamp), vtend, vtexpdatevalue, vthostname, vtusername, vtbqueuename, vtdatename,vtstatus, vterrmess  
~/sgbd/bin/psql -d vtom -p $vtsgbdPort << EOF
\pset tuples_only
\pset footer off
\a
\o $outputStats
select vtobjectsid,vtbegin,(vtend::timestamp - vtbegin::timestamp),vtend,vtexpdatevalue,vtstatus,vterrmess
from vt_stats_job 
where vthostname = '$hostFilter' 
and (vtend::timestamp - vtbegin::timestamp) >= '00:10:00'
order by (vtend::timestamp - vtbegin::timestamp) 
;
EOF

Très long avec Awk (beaucoup d’itération :x)

awk -v fic=$allJobsManyTo1 'BEGIN{
    OFS="|";FS="|";
    i=0 ;
    while ((getline line < fic ) > 0){
        tAllJobsManyTo1[i]=line ;
        i++ ;
    }
    close (fic) ;
    
}{
    if($1 ~ /^APP/){
      print $0;
      next
    }
    jobSID=$1 ;
    lineStats=$0 ;
    
    for (i in tAllJobsManyTo1){
        split(tAllJobsManyTo1[i],tLine,"|");
   
        if( tLine[1] == jobSID ){
          script=tLine[5] ;
          printf "%s|%s\n",lineStats,script ;
          delete  tAllJobsManyTo1[i] ;
          break; 
        }
    }
    
}' /var/tmp/stats

Beaucoup plus rapide avec Pandas - Python :

import pandas

my_cols_csv1 = [ "vtobjectsid","vtbegin","vtduration","vtend","vtexpdatevalue","vtstatus","vterrmess" ]
csv1 = pandas.read_csv('stats_up2',delimiter=r"|",names=my_cols_csv1)
my_cols=["vtobjectsid","env","app","job","script","host","user","queue","vtdatename","param"]
my_cols=my_cols + range(150)
csv2 = pandas.read_csv('all_jobsSID_manyTo1Param_up2.txt',names=my_cols, sep="|")
merge = pandas.merge(csv1,csv2, on='vtobjectsid')
merge.to_csv("output.csv")

	vtobjectsid	vtbegin	vtduration	vtend	vtexpdatevalue	vtstatus	vterrmess	env	app	job	script	host	user	queue	vtdatename	param
0	JOB7ef5b39400006ad956a6113e00014e22	19/03/2016 03:58	00:10:00	19/03/2016 04:08	19/03/2016	3	Termine a 04:08:30	ENV1	poz12daj1	p800ostp1	PATH_DWH_SHELL/OSEF_odi.ksh	HOST1	prdwh12	queue_ksh	ENV1J_12_rdwh	
1	JOB7ef5b39400006ad956a6113e00014e22	03/03/2016 03:29	00:12:24	03/03/2016 03:42	03/03/2016	3	Termine a 03:42:17	ENV1	poz12daj1	p800ostp1	PATH_DWH_SHELL/OSEF_odi.ksh	HOST1	prdwh12	queue_ksh	ENV1_12_rdwh	

Ressource pile

Lister le contenu de la ressource pile VTOM

tpush -name <nom ressource pile> -info
```
valeur         : 1
contenu:
1
2
3
```
Le problème, c’est qu’on a des informations qu’on ne souhaite pas forcément. Pas très pratique pour faire une boucle for par exemple.

On filtre avec awk tous les élements de la ressource pile VTOM qui sont après le mot contenu et où la ligne n’est pas vide (dernière ligne vide dans le résultat de mon tpush)
```
tpush -name <nom ressource pile> -info | awk '\
BEGIN{ligneContenu="x";nbValues=0;}\
($1 ~ /contenu/ || NR > ligneContenu) && $0 != ""\
{\
if(ligneContenu == "x"){ ligneContenu = NR ; next } ;\
print $0;\
}'
1
2
3
```
Compter le nombre d’éléments dans la pile
```
tpush -name <nom ressource pile> -info | awk '\
BEGIN{ligneContenu="x";nbValues=0;}\
($1 ~ /contenu/ || NR > ligneContenu) && $0 != ""\
{\
if(ligneContenu == "x"){ ligneContenu = NR ; next } ;\
nbValues++;\
}\
END{print nbValues}'
3
```
Afficher le premier élément de la ressource pile VTOM

tval -name <nom ressource pile>

Vider le premier élément de la ressource pile VTOM
```
tpop -name <nom ressource pile>
OK: <nom ressource pile>

# le premier élément 1 que j'avais dans ma pile a été supprimé
tpush -name <nom ressource pile> -info
valeur         : 2
contenu:
2
3
```
Ajouter un élément à la fin de la ressource pile VTOM
```
tpush -name <nom ressource pile> -value 1
OK: 1

# la valeur 1 a été rajoutée en fin de pile
tpush -name <nom ressource pile> -info
valeur         : 2
contenu:
2
3
1
```
Vider tous les éléments de la ressource pile VTOM

tempty -name <nom ressource pile>

A quoi ça sert ?

Dans VTOM

Une ressource pile VTOM peut être attendue sur une application ou un traitement
- Présent = au moins un élement dans la pile
- Absent = aucun élément dans la pile
mis à jour sur mon v5.7, on dit "Vide" et "Non vide" au lieu de présent/absent (plus logique remarquez)

Pratique par exemple pour exécuter une cyclique autant de fois que qu’il y a d’éléments dans une pile.

Sur une remarque de nagnag, je me rends compte que ce que je dis peut prêter à confusion. La pile ne se décharge pas automatiquement à chaque exécution de la cyclique. C'est bien un mécanisme perso par tpop (via un job/script) qui doit dépiler à chaque cycle.

Autre exemple plus tordu : on a une pile initialisée avec n éléments (avec n = nombre de couloirs attendus, ces couloirs sont sur des environnements ou des serveurs VTOM différents par exemple), à chaque fois qu’un couloir (une chaine) est terminé, on dépile d’1 élément la ressource ; une autre chaine attend que les n couloirs se soient exécutés (la tête de chaine attend la ressource pile à Absent)

Une ressource pile VTOM peut être ajoutée en tant que paramètre d’un traitement

Le traitement peut prendre en paramètre la ressource pile qui aura comme valeur le premier élément de cette dernière.

Dans les scripts

Et pourquoi pas ?

Exemple : à l’issue d’une sauvegarde, vous empilez le nom de la sauvegarde et son statut (un genre de clé:valeur, tpush -name <nom de la ressource> -value "masave1:OK"). à l’issue de toutes vos sauvegardes, ou le matin, vous faites un reporting en dépilant tous les élements (tval pour récupérer la valeur courante, tpop pour supprimer la valeur courante). Ainsi, par exemple, on peut envoyé par mail un tableau avec le nom de la sauvegarde et OK vert ou KO rouge.

Les axes d’améliorations que j’aimerais voir

C’est bien dommage qu’on soit limité à Présent ou Absent. J’aimerais voir apparaître le $#index [<>=!] value et qui conditionnerait le lancement si le nombre total d’éléments ($#index) était égal (ou autre comparateur) à une certaine valeur (value).

Bien dommage aussi qu’on ne puisse pas supprimer l’index souhaité ou ajouter avant/après l’index souhaité, genre de splice (c’est du FIFO, premier arrivé, premier sorti)
Border Line VTOM

Si vous lisez ces mots, c’est que le côté obscur vous a déjà envahi et que le border line ne vous fait pas peur !

Par conséquent, ce qui va suivre ne vous effraiera point et pourrait même vous intéresser

(mais quand même, attention à vos prod, ne jouez que sur vos bacs à sable !)

Ouvrir les DBF (ne concerne que les versions < v6.1 VTOM)

Les .dbf c’est les fichiers de Table qui constituent la base de données VTOM actuelle (bientôt full Postgres SQL, adieu les .dbf) dans votre répertoire TOM_BASES (ou de votre vtbackup)
- installer simpledbf et pandas pour Python
```
from simpledbf import Dbf5
dbf = Dbf5('/mnt/workspace/temp/monvtbackup/appl.dbf', codec='latin-1')
dbf.to_csv('/mnt/workspace/temp/appl.csv')
```
Restaurer votre pg_dump_sgbd.backup en un fichier SQL exploitable
```
$TOM_HOME/sgbd/bin/pg_restore /mnt/workspace/temp/monvtbackup/pg_dump.bakcup > /mnt/workspace/temp/pg_dump.sql
```
vtexport, vthtools, vtstools, vtping …

On peut tout faire à distance (ou localement pour changer d’instance VTOM si plusieurs VTOM d’installés sur le même serveur).

Il suffit de :
- récupérer les ports dans /etc/services
- avoir à disposition les binaires (user vtom qui charge les variables d’environnement $TOM_ADMIN/vtom_init.ksh ou avoir copié quelque part les binaires)
- exporter les variables
```
export TOM_REMOTE_SERVER=monserveurdistant
export TOM_PORT_vtsgbd=30509
export TOM_PORT_vtserver=30507

# quelques exemples de commandes qui afficheront les résultats comme si on était sur le serveur distant
vtping
vtstools -x -e "01-01-2000 00:00:00 07-06-2016 23:59:00" 
```
plus dangereux, vtaddaccount

Imaginons que j’importe la base de PROD sur mon bac à sable pour faire des tests (je suis un hacker gentil quand même hein).

Imaginons que je n’ai pas de user / mdp pour effectuer des modifications. On rajoute le user TOM avec un profil par défaut.
```
vtaddaccount -l 
vtom@36122a68438c:/mnt/workspace$ vtaddaccount -l
Nom           : ADM_prf
Commentaire   :

Nom           : PIL_PROD_prf
Commentaire   :

Nom           : TOM_prf
Commentaire   :

vtaddaccount -n TOM -p TOM -d ADM_prf
```
Et biensûr, je peux faire ça à distance avec la magie du export TOM_REMOTE_SERVER etc.

Accéder aux stats directement depuis la base VTOM
```
$TOM_HOME/sgbd/bin/psql -d vtom -p VOTRE_PORT_SGBD << EOF
\pset tuples_only
\pset footer off
\a
select *
from vt_stats_job 
limit 1
;
EOF

# autre exemple de requête pour avoir tous les traitements TERMINE ou en ERREUR
\pset footer off
\t
\f ;
\a
\o /var/tmp/20160125-123246_export_stats.csv
select vtenvname,vtapplname,vtjobname,
CASE WHEN vtstatus=4 THEN 'EN-ERREUR'
  WHEN vtstatus=3 THEN 'TERMINE'
END,
to_char(vtbegin,'DD-MM-YYYY HH24:MI:SS'),to_char(vtend,'DD-MM-YYYY HH24:MI:SS'),vterrmess,to_char(vtexpdatevalue,'DD-MM-YYYY HH24:MI:SS'),'MONDOMAINE',vtfamily,vthostname,vtbqueuename,vtusername,vtcomment,''
from vt_stats_job
where vtjobname != ''
and (vtstatus = 3 or vtstatus = 4)
;
```

Formules VTOM

Je rassemble ici un recueil des formules VTOM qui valent le coup d’oeil.

Attention, une formule VTOM dépend du calendrier sur lequel elle s’appuie. (jours fériés et jour chômés)

Veille du premier jour ouvre mois : By Fred

test{(aujourd'hui=1.jour.ouvr.mois-1.jour.cale) ou (aujourd'hui=dern.jour.cale.mois+1.jour.ouvr-1.jour.cale)}

Premier Lundi du mois s’il est ouvré, sinon le jour ouvré qui suit

test { (aujourd'hui=prem.lu.cale.mois et aujourd'hui=ouvr) ou (prem.lu.cale.mois=chom et aujourd'hui=prem.lu.cale.mois+1.jour et aujourd'hui=ouvr) }

version corrigée par Hervé G.

test { (aujourd'hui=prem.lu.cale.mois et aujourd'hui=ouvr) ou (prem.lu.cale.mois=chom et aujourd'hui=prem.lu.cale.mois+1.jour.ouvr ) }
ou plus "simple"
test { aujourd'hui>=prem.lu.cale.mois et aujourd'hui=ouvr et aujourd'hui-1.jour.ouvre<prem.lu.cale.mois}

premier jour ouvré du mois sauf en Janvier, et dernier jour ouvré de Décembre :

test{
(aujourd'hui = prem.jour.ouvr.mois et aujourd'hui <> janvier)
ou
(aujourd'hui = dern.jour.ouvr.annee)
}

les lendemains de jour ouvré avec les dimanches chomés et les jours fériés de france. Calendrier = Dimanche chômés + jours fériés France

test{
 aujourd'hui - 1.jour.cale = ouvr
}

2ème dimanche du mois

 test{ aujourd'hui = 2.di.cale.mois }

Date d'exploitation VTOM ne bascule pas

Les outils pour débugger une date bloquée :
- Vérifier ce qui bloque la date : tchkdate /nom=<nom date> (ou pour avoir un rapide coup d’oeil sur l’état des dates : tlist date -v
- Analyse/Historique : rechercher sur la date pour voir quand et par quel moteur elle a basculé
Pour rappel, une date commune à plusieurs environnements n’est vraiment pas recommandée.

Deux exemples de problèmes :
- Des jobs de l’environnement A avec une date A sont à venir et attendent indéfiniment des ressources (pour x ou y raison)
  - la date ne basculera pas à J+1
  - les jobs de l’environnement B avec la date A resteront bloqués à leur état tant que la date ne basculera pas
- A l’inverse, et au hasard, ça sera le premier moteur, A ou B, qui fera basculer la date A à J+1 (pour peu que tous les jobs liés à cette date soient statués)
  - à J+1 le moteur qui n’aura pas fait basculer la date ne fera pas de treset (mise AVENIR) des jobs liés à cette date. Résultat, vous aurez des jobs à l’état TERMINE (par exemple) avec la date au 25/05 alors qu’ils n’ont tourné que, et seulement que, le 24/05
Une petite astuce pour lister les dates d’exploitation VTOM se retrouvant sur plusieurs jobs de différents environnements. (attention à bien désallouer une date affectée à un environnement non approprié mais à auncune app/job)
```
$ tlist env/date | sort -k"2,2" | awk '{print $2}'| uniq -c | awk '$1 > 1'

$  tlist jobs | sort -u -k"5,5" -k"1,1" | awk '{print $5}' | uniq -c | awk '$1 > 1'
   2 datey
   2 datex
```
Attention aussi aux dates d’exploitation différentes au sein d’un même bloc d’applications (liées entre elles). C’est possible d’avoir des dates différentes (hebdo, mensuelle par ex.) mais il faut savoir ce qu’on fait.

De base, je dirais qu’un bloc d’application devrait avoir la même date d’exploitation (attention aux copiés/collés surtout).

Petit astuce pour les lister :
```
vi env_app_date.sql
.separator /
select e.NAME, a.NAME, d.NAME
from applications a
left join environments e on a.ENV_SID = e.ENV_SID
left join dates d on a.DATE_SID = d.DATE_SID or (ifnull(a.DATE_SID,'') = '' and e.DATE_SID = d.DATE_SID)
;

vtexport -x > vtexport.xml
vthttpd -dump vthttpd.dat
sqlite3 vthttpd.dat < env_app_date.sql > apps_dateexp.txt

while read line
do 
  parent_dateexp=$(egrep "^`echo $line | cut -f1 -d" "`/" apps_dateexp.txt | cut -f3 -d"/");
  child_dateexp=$(egrep "^`echo $line | cut -f2 -d" "`/" apps_dateexp.txt | cut -f3 -d"/") ;
  if test "$child_dateexp" != "$parent_dateexp"
  then
    echo $line $parent_dateexp $child_dateexp
  fi
done < <(sed -e 's|^[        ]*<Link parent="$[^"/]*/[^"/]*$" child="$[^"]*$".*$|\1 \2|g' -e 'tx' -e 'd' -e ':x' vtexport.xml)
```
Platform.sh premières impressions

Avec platform.sh, Orange Cloud for Business nous promet pour nos applications Web :
- un PaaS performant et sécurisé (datacenters situés en France)
- jusqu’a 25% d’économies sur les couts de développements et sur le DevOps
- de permettre aux developpeurs de se concentrer sur le code et non sur la gestion du systeme
- de simplifier au maximum les workflow jusqu’à la livraison du projet
A premiere vue, c’est tres orienté Web et comme il y a un free trial de 30 jours, je vais tester ça !

Comment ça fonctionne ?

Quelques liens vers les white papers et case studies :
- Introduction
- Data Sheet
Ce qu’on pourrait retenir :
- utilise principalement le mécanisme de Git :
  - permet le versioning
  - permet la livraison entre les différents environnements avec le merging
  - permet aux équipes une meilleure communication et moins de documentation a produire (il suffit de voir les différences entre les différentes versions dans l’outil directement)
- fonctionne avec des micro-services comme conteneurs linux LXC (un peu comme Docker)
  - il suffit de référencer les services dans des fichiers de configuration (comme mysql, postgres, etc)
- basiquement, on n’a besoin que de trois fichiers pour initier notre environnement : .platform-app-yaml.html + .platform/services.yaml + .platform/routes.yaml
- l’ensemble .platform-app-yaml.html + .platform/services.yaml ressemble fortement a ce qu’on pourrait faire avec docker-compose
Rentrons dans le vif du sujet, et voyons si ça vaut le coup de s’intéresser a platform.sh.

Exemple : application simple - bonjour

L’administration des projets sur platform.sh

Je dois avouer que tout est pensé pour simplifier au maximum les actions et les configurations.

Je trouve l’interface plutôt sympathique et tres fonctionnelle.

En 4 clics, j’ai créé mon free trial account, créé mon projet “Demo Dev” avec sa branche “master” et sa branche “n-1” (pour la version n-1 par exemple). Je peux presque commencer a écrire ou déployer mon code.

Installer platform CLI pour une meilleure gestion des projets et environnements

Mais d’abord, j’installe mon environnement de dev. Je run mon image Docker Dev mais n’importe quel OS avec Git, php et vos outils de dev devrait suffire.

J’installe platform CLI
```
# install
curl -sS https://platform.sh/cli/installer | php

# configuration
# et je rentre mes informations de compte pour m'authentifier
platform
...

# Je configure mes clés ssh pour Git et acces ssh
platform ssh-keys
Your SSH keys are:
+-------+----------------------------+----------------------------------+
| ID    | Title                      | Fingerprint                      |
+-------+----------------------------+----------------------------------+
| 15718 | ssh-rsa AAAAB3NzaC1yc2EAAA | xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx |
| 15721 | 26d53a922bbd               | xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx |
+-------+----------------------------+----------------------------------+

Add a new SSH key with: platform ssh-key:add
Delete an SSH key with: platform ssh-key:delete [id]

platform ssh-key:add
...
```
```
# Je clone mon projet sur la branch n-1
git clone git clone --branch n-1 nkoaolx5osnio@git.eu.platform.sh:nkoaolx5osnio.git demo-dev
...
```
```
# je regarde la configuration 
cd demo-dev
platform 
Welcome to Platform.sh!

Project title: Demo Dev
Project ID: nkoaolx5osnio
Project dashboard: https://eu.platform.sh/#/projects/nkoaolx5osnio

Your environments are:
+--------+--------+--------+
| ID     | Name   | Status |
+--------+--------+--------+
| master | Master | Active |
| n-1*   | n-1    | Active |
+--------+--------+--------+
* - Indicates the current environment

Check out a different environment by running platform checkout [id]
Branch a new environment by running platform environment:branch [new-name]
Make a snapshot of the current environment by running platform snapshot:create
Merge the current environment by running platform environment:merge
Sync the current environment by running platform environment:synchronize

You can list other projects by running platform projects

Manage your SSH keys by running platform ssh-keys

Type platform list to see all available commands.
```
Configuration de l’application : .platform-app-yaml.html + .platform/services.yaml + .platform/routes.yaml
Pour mon application “bonjour” :
```
|-- .git
|-- .platform
|   |-- local
|   |   |-- README.txt
|   |   `-- project.yaml
|   |-- routes.yaml
|   `-- services.yaml
|-- .platform.app.yaml
|-- index.php

index.php
<?php echo "bonjour" ; ?>

.platform.app.yaml
name: bonjour
type: php
disk: 128
web:
    document_root: "/"
    passthru: "/index.php"

.platform/routes.yaml
"http://{default}/":
    type: upstream
    upstream: "bonjour:php"

"http://www.{default}/":
    type: redirect
    to: "http://{default}/"

.platform/services.yaml
vide (pas de dépendance a d'autres services)
par défaut,  : 
mysql:
    type: mysql:5.5
    disk: 2048

redis:
    type: redis:2.8

solr:
    type: solr:3.6
    disk: 1024
```
mise a jour de l’environnement n-1

Il n’y a plus qu’a push ce qu’on a construit localement.
```
git add --all ; git commit -m "first app bonjour" ; git push
...
# on voit qu'il va plus loin qu'un simple push, il construit l'environnement et le lance comme conteneur (avec les instructions que j'ai défini dans les fichiers de configuration) 
```
Je teste et je merge sur la branch principale

platform.sh s’occupe de tout. Il créé meme une url par environnement et par projet.

Je vérifie que j’ai bien mon rendu d’appli “bonjour” sur version-projet.eu.platform.sh ==> OK !

Je merge l’environnement n-1 vers la branche master.

Et voila !

Autres applications

Il semblerait que les deux projets fournis de base soient Symfony ou Drupal pour le moment. J’ai testé deux minutes et ça semble fonctionner sans qu’on ne touche a rien.

Il n’y a plus qu’a intégrer ses Bundles et a coder.

Pour le reste, il me semble que les services proposés sont suffisants et demandent peu de configuration :
- PHP
- Python
- Ruby
- NodeJS
- Java (with integrated Maven and Ant support)
- Postgres, MySQL, Redis etc.
Conclusion

platform.sh est vraiment intéressant pour les équipes de développements d’applications web de moyenne a grande envergure.

Tous les concepts sont connus (Git, CaaS (container as service), répartition de charge du trafic automatique, automatisation des tâches avec Grunt ou maintien des dépendances de librairies avec Composer, etc).

Ca n’est donc pas une révolution. Cependant, la promesse de simplifier les actions d’administration semble tenue.

Une fois qu’on a bien compris le fonctionnement des trois fichiers de configuration - .platform-app-yaml.html + .platform/services.yaml + .platform/routes.yaml - on peut, effectivement, se concentrer sur le code et la gestion des workflows.

vtplan VTOM

vtplan - affiche la planification des applications ou traitements

# Comme on pourrait le voir dans VTOM (clique droit > planification)
vtom@9b99febd3506:/mnt/User/temp/install$ vtplan /filter TEST -a /format table /range "01-01-2016 31-12-2016"
[Du vendredi 1 janvier 2016 au samedi 31 decembre 2016 (366 jour(s))]

TEST/APP_1

    ANNEE 2016
    ==========

    J  F  M  A  M  J  J  A  S  O  N  D
---------------------------------------
 1  N  O  N  N  N  N  N  O  N  N  N  N
 2  N  N  N  N  O  N  N  N  N  N  N  N
 3  N  N  N  N  N  N  N  N  N  O  N  N
 4  O  N  N  O  N  N  O  N  N  N  N  N
 5  N  N  N  N  N  N  N  N  O  N  N  O
 6  N  N  N  N  N  O  N  N  N  N  N  N
 7  N  N  O  N  N  N  N  N  N  N  O  N
 8  N  N  N  N  N  N  N  N  N  N  N  N
 9  N  N  N  N  N  N  N  N  N  N  N  N
10  N  N  N  N  N  N  N  N  N  N  N  N
11  N  N  N  N  N  N  N  N  N  N  N  N
12  N  N  N  N  N  N  N  N  N  N  N  N
13  N  N  N  N  N  N  N  N  N  N  N  N
14  N  N  N  N  N  N  N  N  N  N  N  N
15  N  N  N  N  N  N  N  N  N  N  N  N
16  N  N  N  N  N  N  N  N  N  N  N  N
17  N  N  N  N  N  N  N  N  N  N  N  N
18  N  N  N  N  N  N  N  N  N  N  N  N
19  N  N  N  N  N  N  N  N  N  N  N  N
20  N  N  N  N  N  N  N  N  N  N  N  N
21  N  N  N  N  N  N  N  N  N  N  N  N
22  N  N  N  N  N  N  N  N  N  N  N  N
23  N  N  N  N  N  N  N  N  N  N  N  N
24  N  N  N  N  N  N  N  N  N  N  N  N
25  N  N  N  N  N  N  N  N  N  N  N  N
26  N  N  N  N  N  N  N  N  N  N  N  N
27  N  N  N  N  N  N  N  N  N  N  N  N
28  N  N  N  N  N  N  N  N  N  N  N  N
29  N  N  N  N  N  N  N  N  N  N  N  N
30  N  -  N  N  N  N  N  N  N  N  N  N
31  N  -  N  -  N  -  N  N  -  N  -  N

# Avec les dates
vtom@9b99febd3506:/mnt/User/temp/install$ vtplan /filter TEST -a /format date /range "01-01-2016 31-12-2016"
[Du vendredi 1 janvier 2016 au samedi 31 decembre 2016 (366 jour(s))]

TEST/APP_1
01-jan-2016 = NON
02-jan-2016 = NON
03-jan-2016 = NON
04-jan-2016 = OUI
05-jan-2016 = NON
06-jan-2016 = NON
07-jan-2016 = NON
08-jan-2016 = NON
09-jan-2016 = NON
10-jan-2016 = NON
11-jan-2016 = NON
12-jan-2016 = NON
13-jan-2016 = NON
14-jan-2016 = NON
15-jan-2016 = NON
16-jan-2016 = NON
17-jan-2016 = NON
18-jan-2016 = NON
19-jan-2016 = NON
20-jan-2016 = NON
21-jan-2016 = NON
22-jan-2016 = NON
... (tronqué)

# EN CSV
vtom@9b99febd3506:/mnt/User/temp/install$ vtplan /filter TEST -a /format csv /range "01-01-2016 31-12-2016"
[Du vendredi 1 janvier 2016 au samedi 31 decembre 2016 (366 jour(s))]
TEST;APP_1;0;0;0;1;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;1;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;1;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;1;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;1;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;1;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;1;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;1;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;1;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;1;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;1;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;1;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0

Statuts dans le vtexport

Lister, afficher, récupérer

les options intéressantes

Quelques commandes FTP

Quelques commandes SFTP

Bug rencontré sur AIX

sinon curl c’est aussi …

Mon besoin en Javascript

Fonction

Exemple

Pour aller plus loin

sort sur un tableau de tableaux sur plusieurs index

Filtrer directement un fichier XML avec un fichier XSL et sortie en texte (pour du csv)

Parser le vtexport XML VTOM en “pur” Java (un peu long)

Autre pour moi

Lister le contenu de la ressource pile VTOM

Compter le nombre d’éléments dans la pile

Afficher le premier élément de la ressource pile VTOM

Vider le premier élément de la ressource pile VTOM

Ajouter un élément à la fin de la ressource pile VTOM

Vider tous les éléments de la ressource pile VTOM

A quoi ça sert ?

Dans VTOM

Une ressource pile VTOM peut être attendue sur une application ou un traitement

Une ressource pile VTOM peut être ajoutée en tant que paramètre d’un traitement

Dans les scripts

Les axes d’améliorations que j’aimerais voir

Ouvrir les DBF (ne concerne que les versions < v6.1 VTOM)

Restaurer votre pg_dump_sgbd.backup en un fichier SQL exploitable

vtexport, vthtools, vtstools, vtping …

plus dangereux, vtaddaccount

Accéder aux stats directement depuis la base VTOM

Comment ça fonctionne ?

Exemple : application simple - bonjour

L’administration des projets sur platform.sh

Installer platform CLI pour une meilleure gestion des projets et environnements

Configuration de l’application : .platform-app-yaml.html + .platform/services.yaml + .platform/routes.yaml

mise a jour de l’environnement n-1

Je teste et je merge sur la branch principale

Autres applications

Conclusion

vtplan - affiche la planification des applications ou traitements