Exemples de remplacement de routine dans DataStage®

Exemples

Obtenir l'ID de projet

Expression CEL:

ctx.scope.id

API REST :

Dans cet exemple, le nom du projet est "project1." Remplacez-le par le nom de votre projet.

$ project=`curl --request GET "${CPD_URL}/v2/projects?name=project1" -H "Authorization : Bearer ${bearer_token}" -k -s`
proj_id=``echo $project | jq -r '.resources|.[0].metadata.guid'`
$ echo $ID_projet 

Interface CLI dsjob:

$ project=`cpdctl dsjob list-projects --with-id |grep project1`
$ proj_id=`echo ${project#*|}``
$ echo $ID_projet

Obtenir l'ID de travail

Expression CEL:

ctx.job.id

API REST :

$ joblist=`curl --request GET "${CPD_URL}/v2/jobs?project_id=${proj_id}" --header "Authorization : Bearer ${bearer_token}" -k -s`
$ echo $liste_travaux |jq 

Cette commande permet d'imprimer une liste de travaux. Remplacez "testjob" par le nom de votre travail dans les commandes suivantes.

$ echo $joblist|jq -r '.results[].metadata|select(.name=="testjob" ?) |.asset_id'

Interface CLI dsjob:

$ job=`cpdctl dsjob list-jobs --project-id ${proj_id} --with-id | grep testjob`
$ echo $job
testjob |317dce0d-247a-48aa-bd96-f4ec44cb39fc
job_id=`echo ${job#*|}``
$ echo $ID_travail

Obtenir l'ID d'exécution de travail

Expression CEL:

ctx.job_run.id

API REST :

$ runlist=`curl --request GET "${CPD_URL}/v2/jobs/${job_id}/runs?project_id=${proj_id}" --header "Authorization : Bearer ${bearer_token}" -k -s`
$ echo $listre_exécution

Cette commande permet d'imprimer la liste des exécutions de travail. Sélectionnez une exécution en fonction de la description, de l'heure de création ou d'autres métadonnées.

$ echo $runlist|jq -r '.results[]|select(.metadata.description=="Initial run" ?)

Interface CLI dsjob:

$ cpdctl dsjob list-jobruns --project-id ${proj_id} --id $job_id --detail

DSAddEnvVar

API REST :

#!/bin/sh

# param1: nom de l'environnement
# param2: nouveau nom de variable
# param3: nouvelle valeur de variable
DSAddEnvVar()
{
envs=`curl -k -s --request GET "${CPD_URL}/v2/environments?project_id=${proj_id}" --header "Authorization : Bearer ${bearer_token}"`
env_id=``echo $envs|jq -r ".resources[] | select(.metadata.name=="$1\") | .metadata.asset_id"`

existingvars=`echo $envs|jq -r ".resources[] | select(.metadata.name==\"$env_name\") | .entity.environment.environment_variables"`
updatevars= ` echo $existingvars |jq ". $2 = \" $3 \" " `
data="{\"/entity/environment/environment_variables\" : ${updatevars}}"

curl -k -s --request PATCH "${CPD_URL}/v2/environments/${env_id} ?project_id=${proj_id}&environment_guid=${proj_id}" --header 'Content-Type : application/json' --header "Authorization : Bearer ${bearer_token}" --data-raw "${data}"
}

Interface CLI dsjob:

#!/bin/sh

# param1: nom de l'environnement
# param2: nouveau nom de variable
# param3: nouvelle valeur de variable
DSAddEnvVar()
{
cpdctl dsjob update-env-vars --project-id ${proj_id} -n $1 --env $2=$3
}

La syntaxe suivante ajoute une nouvelle variable d'environnement à l'environnement spécifié.

$ DSAddEnvVar "default_datastage_px" "newvar" "val"

DSAddProject

API REST :

#!/bin/sh

DSAddProject()
{
  data=" { \" name \": \" $1 \ ", \" generator \": \" client \", \" storage \": {\"type\": \"assetfiles\"}}"
  proj=`curl -k -s --request POST "${CPD_URL}/transactional/v2/projects" --header "Authorization : Bearer ${bearer_token}" -d "$data" --header 'Content-Type : application/json'`
  echo $proj|jq -r ".location" |awk -F '/' '{print $4}'
}

Interface CLI dsjob:

#!/bin/sh

DSAddProject()
{
  proj_id=`cpdctl dsjob create-project -n "$1"`
  echo $ID_projet
}

La syntaxe suivante crée un nouveau projet et extrait son ID.

$ proj_id=`DSAddProject "demo-project"`

DSDeleteEnvVar

API REST :

#!/bin/sh

# param1: nom de l'environnement
# param2: nom de variable
DSDeleteEnvVar()
{
envs=`curl -k -s --request GET "${CPD_URL}/v2/environments?project_id=${proj_id}" --header "Authorization : Bearer ${bearer_token}"`
env_id=``echo $envs|jq -r ".resources[] | select(.metadata.name=="$1\") | .metadata.asset_id"`

existingvars=`echo $envs|jq -r ".resources[] | select(.metadata.name==\"$env_name\") | .entity.environment.environment_variables"`
updatevars= ` echo $existingvars |jq "del (. $2)" `
data="{\"/entity/environment/environment_variables\" : ${updatevars}}"

curl -k -s --request PATCH "${CPD_URL}/v2/environments/${env_id} ?project_id=${proj_id}&environment_guid=${proj_id}" --header 'Content-Type : application/json' --header "Authorization : Bearer ${bearer_token}" --data-raw "${data}"
}

Interface CLI dsjob:

#!/bin/sh

# param1: nom de l'environnement
# param2: nom de variable
DSDeleteEnvVar()
{
cpdctl dsjob delete-env-vars --project-id ${proj_id} -n $1 --env $2
}

La syntaxe suivante supprime une nouvelle variable d'environnement de l'environnement spécifié.

$ DSDeleteEnvVar "default_datastage_px" "uservar1"

DSDeleteProject

API REST :

#!/bin/sh

DSDeleteProject()
{
  curl -k -s --request DELETE "${CPD_URL}/transactional/v2/projects/$1?project_id=$1" --header "Authorization : Bearer ${bearer_token}"
}

La syntaxe suivante supprime un projet. L'ID de projet est obligatoire.

$ DSDeleteProject "${proj_id}"

Exécution de fichier

Définissez une fonction d'encapsuleur.

#!/bin/sh

Exécution de fichier ()
{
shelltype=$1
command=$2
output=$3

sh -c $command > $output 2>&1
}

Appelez la fonction.

$ DSExecute "UNIX" "echo someinfo" "output.log"
$ returnCode=$?

DSGetIDForJob

API REST :

DSGetIdForJob()
{
  joblist=`curl --request GET "${CPD_URL}/v2/jobs?project_id=${proj_id}" --header "Authorization : Bearer ${bearer_token}" -k -s`
  echo $joblist|jq -r ".results[].metadata|select(.name=="$1\") |.asset_id"
}

Interface CLI dsjob:

DSGetIdForJob()
{
  job=`cpdctl dsjob list-jobs --project-id ${proj_id} --with-id | grep $1`
  echo ${job#*|}
}

La syntaxe suivante extrait l'ID de travail par nom de travail.

$ job_id=`DSGetIdForJob "testjob"``

DSGetJobInfo

Vous pouvez réécrire la fonction BASIC DSGetJobInfo comme une fonction enveloppante qui utilise l'API REST avec la syntaxe suivante. Les éléments job_id, run_id et project_id sont requis pour extraire les informations de travail. Certaines informations, telles que DSJ.JOBSTARTTIMESTAMPn'est pas pris en charge.

#!/bin/sh

DSGetJobInfo()
{
  # Obtenir les métadonnées d'exécution de travail
  jobrun=`curl --request GET "${CPD_URL}/v2/jobs/${job_id}/runs/${run_id} ?job_id=${job_id}&run_id=${run_id}&project_id=${proj_id}" --header "Authorization : Bearer ${bearer_token}"`

  # Analyse et extraction des informations
  if [ "$1" = "DSJ.JOBSTATUS" ] ; then
    echo $jobrun|jq -r '.entity.job_run.state'
  elif [ "$1" = "DSJ.JOBNAME" ] ; then
    echo $jobrun|jq -r '.entity.job_run.job_name'
  elif [ "$1" = "DSJ.PARAMLIST" ] ; then
    echo $jobrun|jq -r '.entity.job_run.configuration.job_parameters[]''
  elif ["$1" = "DSJ.STAGELIST" ] || [$1 = "DSJ.FULLSTAGELIST"] ; then
    echo $jobrun|jq -r '.entity.job_run.configuration.metrics.stage_metrics[].stage_name'
  elif [ "$1" = "DSJ.USERSTATUS" ] ; then
    echo $jobrun|jq -r '.entity.job_run.configuration.userStatus'
  elif ["$1" = "DSJ.JOBDESC" ] || ["$1" = "DSJ.JOBFULLDESC"] ; then
    echo $jobrun|jq -r '.metadata.description'
  elif [ "$1" = "DSJ.JOBELAPSED" ] ; then
    echo $jobrun|jq -r '.entity.job_run.duration'
  fi
}

Vous pouvez également réécrire DSGetJobInfo comme une fonction enveloppante qui utilise la CLI djsob avec la syntaxe suivante.

#!/bin/sh

DSGetJobInfo()
{
  # Obtenir les métadonnées d'exécution de travail
  jobrun=`cpdctl dsjob jobrunstat --project-id ${proj_id} --id ${job_id} --run-id ${run_id} --output json --with-metadata sed '$d'``

  # Analyse et extraction des informations
  if [ "$1" = "DSJ.JOBSTATUS" ] ; then
    echo $jobrun|jq -r '.entity.job_run.state'
  elif [ "$1" = "DSJ.JOBNAME" ] ; then
    echo $jobrun|jq -r '.entity.job_run.job_name'
  elif [ "$1" = "DSJ.PARAMLIST" ] ; then
    echo $jobrun|jq -r '.entity.job_run.configuration.job_parameters[]''
  elif ["$1" = "DSJ.STAGELIST" ] || [$1 = "DSJ.FULLSTAGELIST"] ; then
    echo $jobrun|jq -r '.entity.job_run.configuration.metrics.stage_metrics[].stage_name'
  elif [ "$1" = "DSJ.USERSTATUS" ] ; then
    echo $jobrun|jq -r '.entity.job_run.configuration.userStatus'
  elif ["$1" = "DSJ.JOBDESC" ] || ["$1" = "DSJ.JOBFULLDESC"] ; then
    echo $jobrun|jq -r '.metadata.description'
  elif [ "$1" = "DSJ.JOBELAPSED" ] ; then
    echo $jobrun|jq -r '.entity.job_run.duration'
  fi
}

La syntaxe suivante extrait le statut du travail.

$ jobstatus=`DSGetJobInfo "DSJ.JOBSTATUS"`

DSGetUserStatus

Pour obtenir le statut utilisateur d'un travail DataStage dans le script d'un noeud de script Run Bash, obtenez l'ID de projet (ctx.scope.id). Si le flux d'exécution DataStage est nommé run_datastage_flow, l'ID de travail est tasks.run_datastage_flow.results.jobet l'ID d'exécution est tasks.run_datastage_flow.results.job_run. La syntaxe suivante utilise ces paramètres pour extraire le statut de l'utilisateur.

export CPDCTL_ENABLE_DSJOB=1

DSGetUserStatus()
{
  # obtenir les 36 derniers caractères de la chaîne de sortie, qui contient l'ID de travail ou l'ID d'exécution de travail du flux de l'étape de données
  flowid= ${ds_job_id:0-36:36}
  flowrunid= ${ds_job_run_id:0-36:36}

  # obtenir les métadonnées jobrun par la commande dsjob ou l'API REST
  jobrun=`cpdctl dsjob get-jobrun --project-id $project_id --id $flowid --run-id $flowrunid --output json --with-metadata`

  # extrait le message userStatus de l'exécution du travail
  echo $jobrun | jq -r '.entity.job_run.configuration.userStatus'
}

userstatus=`DSGetUserStatus`

DSGetLinkInfo

Pour extraire le nom d'un lien et le nombre de lignes qui ont transmis un lien, obtenez l'ID de projet, l'ID de travail, l'ID d'exécution et le nom de lien. Vous pouvez réécrire DSGetLinkInfo en une fonction enveloppante à l'aide de la syntaxe suivante.

API REST :

#!/bin/sh

DSGetLinkInfo()
{
  # Get the job run metadata
  jobrun=`curl -k -s --request GET "${CPD_URL}/v2/jobs/${job_id}/runs/${run_id}?job_id=${job_id}&run_id=${run_id}&project_id=${proj_id}" --header "Authorization: Bearer ${bearer_token}"`

  # Parse and extract the information
  if [ "$1" = "DSJ.LINKNAME" ]; then
    echo $jobrun|jq -r ".entity.job_run.configuration.metrics.link_metrics[]|select(.link_name==\"$2\"?) |.link_name"
  elif [ "$1" = "DSJ.LINKROWCOUNT" ]; then
    echo $jobrun|jq -r ".entity.job_run.configuration.metrics.link_metrics[]|select(.link_name==\"$2\"?) |.rows_written"
  fi
}

Interface CLI dsjob:

#!/bin/sh

DSGetLinkInfo()
{
  # Obtenir les métadonnées d'exécution de travail
  jobrun=`cpdctl dsjob get-jobrun --project-id ${proj_id} --id ${job_id} --run-id ${run_id} --output json`

  # Analyse et extraction des informations
  if [ "$1" = "DSJ.LINKNAME" ] ; then
    echo $jobrun|jq -r ".job_run.configuration.metrics.link_metrics[]|select(.link_name=="$2\" ?) |.link_name"
  elif [ "$1" = "DSJ.LINKROWCOUNT" ] ; then
    echo $jobrun|jq -r ".job_run.configuration.metrics.link_metrics[]|select(.link_name=="$2\" ?) |.rows_written"
  fi
}

L'appel de fonction suivant obtient le nombre de lignes de lien pour Link_1.

$ rows=`DSGetLinkInfo "DSJ.LINKROWCOUNT" "Link_1"`

DSGetLogEntry, DSGetLogEntryFull, DSGetLogEventIds, DSGetLogSummary, DSGetNewestLogId

Pour obtenir les journaux d'une exécution de travail, obtenez l'ID de projet, l'ID de travail et l'ID d'exécution. Vous pouvez écrire des fonctions d'encapsuleur pour extraire des ID de journal, des ID d'événement, des entrées et des récapitulatifs avec la syntaxe suivante.

API REST :

#!/bin/sh

GetAllLogs()
{
  logs=`curl -k -s --request GET "${CPD_URL}/v2/jobs/${job_id}/runs/${run_id}/logs?job_id=${job_id}&run_id=${run_id}&project_id=${proj_id}" --header "Authorization: Bearer ${bearer_token}"`
  logs_strip=${logs#*results\":\[\"}
  logs_strip=${logs_strip%\"\],\"total_count*}
  logs_array=${logs_strip//\\\"/\"}
  logs_array=${logs_array//\\\\\"/\\\"}
  logs_array=${logs_array//\\\\n/\\n}
  echo $logs_array | jq
}

DSGetLogEventIds()
{
  # Get the job run logs metadata
  logs_array=`GetAllLogs`

  # Parse and extract the information
  idlist=`echo $logs_array | jq -r '.[].eventID'`
  echo $idlist
}

DSGetNewestLogId()
{
  # Get the job run logs metadata
  logs_array=`GetAllLogs`

  # Parse and extract the information
  echo $logs_array | jq -r "max_by(.eventID|tonumber)|.eventID"
}

DSGetLogEntry()
{
  # Get the job run logs metadata
  logs_array=`GetAllLogs`

  # Parse and extract the information
  echo $logs_array | jq -r ".[]|select(.eventID==\"$1\")|[.occurredAt,.user,.eventType,.eventDetail]|join(\"\\\\\")"
}

DSGetLogSummary()
{
  # Get the job run logs metadata
  logs_array=`GetAllLogs`

  # Parse and extract the information
  echo $logs_array | jq -r ".[]|[.eventID,.eventType,(.eventDetail|split(\"\n\")[0])]|join(\"\\\\\")"
}

Interface CLI dsjob:

DSGetLogEventIds()
{
  logsum=`cpdctl dsjob logsum --project-id $proj_id --job-id $job_id --run-id $run_id``
  echo $logsum | awk '{print $3}' | sed '$d'
}

DSGetNewestLogId()
{
  logsum=`cpdctl dsjob logsum --project-id $proj_id --job-id $job_id --run-id $run_id``
  echo $logsum | awk '{print $3}' | tac | sed '1,2d' | head -n 1
}

DSGetLogEntry()
{
  entry=`cpdctl dsjob logdetail --project-id $proj_id --job-id $job_id --run-id $run_id --eventrange $1-$1`
  echo $entrée
}

DSGetLogSummary()
{
  logsum=`cpdctl dsjob logsum --project-id $proj_id --job-id $job_id --run-id $run_id``
  echo $logsum
}

Les appels de fonction suivants obtiennent les informations de journal.

$ logids=`DSGetLogEventIds`
$ lastid=`DSGetNewestLogId`
$ logstr=`DSGetLogEntry $lastid`
$ logsum=`DSGetLogSummary`

DSGetParamInfo

Pour obtenir la valeur en cours d'un paramètre, obtenez l'ID de projet, l'ID de travail et l'ID d'exécution. Ecrivez une fonction d'encapsuleur pour extraire les métadonnées d'exécution de travail.

API REST :

DSGetParamInfo()
{
  # Get the job run metadata
  jobrun=`curl -k -s --request GET "${CPD_URL}/v2/jobs/${job_id}/runs/${run_id}?job_id=${job_id}&run_id=${run_id}&project_id=${proj_id}" --header "Authorization: Bearer ${bearer_token}"`

  # Extract the parameter value
  params=`echo $jobrun |jq -r '.entity.job_run.configuration.job_parameters[]' | grep "${1}="`
  echo $params | awk -F '=' '{print $2}'
}

Interface CLI dsjob:

DSGetParamInfo()
{
  # Obtenir les métadonnées d'exécution de travail
  jobrun=`cpdctl dsjob get-jobrun --project-id $proj_id --id $job_id --run-id $run_id --output json`

  # Extraction de la valeur de paramètre
  params=`echo $jobrun |jq -r '.job_run.configuration.job_parameters[]'' | grep "${1}="`"
  echo $params | awk -F '=' '{print $2}'
}

Appelez la fonction pour obtenir une valeur de paramètre.

$ value=`DSGetParamInfo "param_name"`

DSGetProjectInfo

Pour obtenir le nom du projet en cours et une liste séparée par des virgules des travaux du projet, vous avez besoin de l'ID de projet. Ces fonctions d'encapsuleur renvoient le nom et la liste.

API REST :

#!/bin/sh

DSGetProjectInfo()
{
  if [ "$1" = "DSJ.PROJECTNAME" ]; then
    # Get the project metadata
    proj=`curl -k -s --request GET "${CPD_URL}/v2/projects/${proj_id}?project_id=${proj_id}" --header "Authorization: Bearer ${bearer_token}"`
    # Parse and extract the name
    echo $proj |jq -r '.entity.name'
  elif [ "$1" = "DSJ.JOBLIST" ]; then
    # Get the flow list metadata
    flows=`curl -k -s --request GET "${CPD_URL}/data_intg/v3/data_intg_flows?project_id=${proj_id}" --header "Authorization: Bearer ${bearer_token}"`
    # Parse and extract the flow names
    echo $flows|jq -r '.data_flows[].metadata.name'
  fi
}

Interface CLI dsjob:

#!/bin/sh

DSGetProjectInfo()
{
  if [ "$1" = "DSJ.PROJECTNAME" ] ; puis
    # Répertorier les projets et en sélectionner un en fonction de l'ID de projet
    proj=`cpdctl dsjob list-projects --with-id |grep $proj_id`
    # Analyser la sortie et extraire le nom
    echo $proj|awk '{print $1}'
  elif [ "$1" = "DSJ.JOBLIST" ] ; then
    # Obtenir la liste de flux et extraire les noms de flux
    flows=`cpdctl dsjob list-flows --project-id ${proj_id} | tac | sed '1,4d;$d' | tac`
    echo $flux
  fi
}

Appelez la fonction pour obtenir le nom du projet ou la liste de flux.

$ projectname=`DSGetProjectInfo "DSJ.PROJECTNAME"`
$ flowlist=`DSGetProjectInfo "DSJ.JOBLIST"`

DSGetVersionInfo

La fonction suivante utilise l'API REST pour obtenir la version du produit.

DSGetVersionInfo()
{
  if [ "$1" = "DSJ.VER.DS" ] ; puis
    prod="DataStage"
  elif [ "$1" = "DSJ.VER.DATAREP" ] ; puis
    prod="réplication de données "
  elif [ "$1" = "DSJ.VER.PIPELINE" ] ; puis
    prod= "Watson Studio Pipelines"
  elif [ "$1" = "DSJ.VER.CORE" ] ; puis
    prod="Common Core Services "
  elif [ "$1" = "DSJ.VER.CONTROL" ] ; puis
    prod="Plan de contrôle "
  fi
  versions=`curl -k -s --request GET "${CPD_URL}/zen-data/v1/extensions?extension_point_id=zen_services_info" --header "Authorization : Bearer ${bearer_token}"`
  echo $versions | jq -r ".data[]|select(.display_name=="$prod\")|.details.version"
}

Appelez la fonction pour obtenir la version du produit.

$ DSGetVersionInfo "DSJ.VER.DS"
4.6.0

DSJobNameFromJobId

Pour obtenir un nom de travail, vous avez besoin de l'ID de projet et de l'ID de travail. Les fonctions suivantes extraient un nom de travail.

API REST :

DSJobNameFromJobId()
{
  job=`curl --request GET "${CPD_URL}/v2/jobs/${job_id}?project_id=${proj_id}&job_id=${job_id}" --header "Authorization: Bearer ${bearer_token}" -k -s`
  echo $job | jq -r '.metadata.name'
}

Interface CLI dsjob:

DSJobNameFromJobId()
{
  job=`cpdctl dsjob get-job --project-id $proj_id --id $job_id --output json --with-metadata | sed '$d'``
  echo $job | jq -r '.metadata.name'
}

Appelez la fonction pour obtenir le nom du travail.

jobname=`DSJobNameFromJobId``

DSListEnvVars

Pour répertorier les variables d'environnement, vous avez besoin de l'ID de projet.

API REST :

#!/bin/sh

# param1: environment name
DSListEnvVars()
{
  envs=`curl -k -s --request GET "${CPD_URL}/v2/environments?project_id=${proj_id}" --header "Authorization: Bearer ${bearer_token}"`
  vars=`echo $envs|jq -r ".resources[] | select(.metadata.name==\"$1\") | .entity.environment.environment_variables"`
  echo $vars
}

Interface CLI dsjob:

#!/bin/sh

# param1: nom de l'environnement
DSListEnvVars()
{
  output=`cpdctl dsjob list-env-vars --project-id ${proj_id} -n $1`
  vars=`echo $output |sed '1d' |tac | sed '1,4d'``
  echo $vars
}

Appelez la fonction pour obtenir la liste.

$ DSListEnvVars "default_datastage_px"

DSMakeJobReport

Pour créer un rapport de travail, définissez DSGetJobInfo, DSGetStageInfo et DSGetLinkInfo. La fonction suivante affiche l'état d'une exécution de travail.

DSMakeJobReport()
{
  # job basic info
  jobname=`DSGetJobInfo "DSJ.JOBNAME"`
  jobelapsed=`DSGetJobInfo "DSJ.JOBELAPSED"`
  jobstatus=`DSGetJobInfo "DSJ.JOBSTATUS"`
  userstatus=`DSGetJobInfo "DSJ.USERSTATUS"`

  echo "STATUS REPORT FOR JOB: ${jobname}"
  echo "Job elapsed time=${jobelapsed}"
  echo "Job status=${jobstatus}"
  if [ "$userstatus" != "" ]; then
    echo "User status=${userstatus}"
  fi

  if [ "$1" != "1" ]; then
    exit 0
  fi

  # stage and link detail
  stagelist=`DSGetJobInfo "DSJ.STAGELIST"`
  stagearray=($stagelist)
  for stage in ${stagearray[@]}
  do
    rows=`DSGetStageInfo "DSJ.STAGEINROWNUM" "${stage}"`
    echo "  Stage: ${stage}, ${rows} rows input"

    links=`DSGetStageInfo "DSJ.LINKLIST" "${stage}"`
    linkarray=($links)
    for link in ${linkarray[@]}
    do
      rows=`DSGetLinkInfo "DSJ.LINKROWCOUNT" ${link}`
      echo "    Link: ${link}, ${rows} rows"
    done
  done
}

Appelez la fonction pour obtenir la liste.

DSMakeJobReport "1"

DSRunJob

API REST :

#!/bin/sh

DSRunJob()
{
if [ "$1" = "" ] ; alors
envs ='{ }'
else
envs=" { \" job_run \": { \" configuration \": {\"env_variables\": [\"$1\"]}} }"
fi

jobrun=`curl -k -s --request POST "${CPD_URL}/v2/jobs/${job_id}/runs ?job_id=${job_id}&project_id=${proj_id}" --header 'Content-Type : application/json' --header "Authorization : Bearer ${bearer_token}" -d "$envs"`
run_id=``echo $jobrun | jq -r '.metadata.asset_id'``
echo $ID_exécution
}

Interface CLI dsjob:

#!/bin/sh

DSRunJob()
{
if [ "$1" = "" ] ; alors
envs= ""
else
envs=" -- env $ 1 "
fi

output=`cpdctl dsjob run --project-id ${proj_id} --job-id ${job_id} $envs`
run_id=`echo $output | grep 'ID' | awk '{print $4}'`
echo $ID_exécution
}

La syntaxe suivante exécute un travail spécifié.

# get the job_id according to job name
$ joblist=`curl --request GET "${CPD_URL}/v2/jobs?project_id=${proj_id}" --header "Authorization: Bearer ${bearer_token}" -k -s`
$ job_id=`echo $joblist|jq -r '.results[].metadata|select(.name=="dstestjob"?) |.asset_id'`
# run job
$ run_id=`DSRunJob "key1=value1"`

DSSetEnvVar

API REST :

#!/bin/sh

# param1: nom de l'environnement
# param2: nom de variable
# param3: valeur de variable
DSSetEnvVar()
{
envs=`curl -k -s --request GET "${CPD_URL}/v2/environments?project_id=${proj_id}" --header "Authorization : Bearer ${bearer_token}"`
env_id=``echo $envs|jq -r ".resources[] | select(.metadata.name=="$1\") | .metadata.asset_id"`

existingvars=`echo $envs|jq -r ".resources[] | select(.metadata.name==\"$env_name\") | .entity.environment.environment_variables"`
updatevars= ` echo $existingvars |jq ". $2 = \" $3 \" " `
data="{\"/entity/environment/environment_variables\" : ${updatevars}}"

curl -k -s --request PATCH "${CPD_URL}/v2/environments/${env_id} ?project_id=${proj_id}&environment_guid=${proj_id}" --header 'Content-Type : application/json' --header "Authorization : Bearer ${bearer_token}" --data-raw "${data}"
}

Interface CLI dsjob:

#!/bin/sh

# param1: nom de l'environnement
# param2: nom de variable
# param3: valeur de variable
DSSetEnvVar()
{
cpdctl dsjob update-env-vars --project-id ${proj_id} -n $1 --env $2=$3
}

La syntaxe suivante définit une variable d'environnement sur la valeur spécifiée.

$ DSSetEnvVar "default_datastage_px" "uservar" "newval"

DSSetIdForJob

Utilisez l'API REST pour définir un nom défini par l'utilisateur pour un travail.

#!/bin/sh

#param1:
#param2: nouveau nom de travail
DSSetIdForJob()
{
  data="[{\"op\": \"replace\", \"path\": \"/metadata/name\", \"value\": $2}]"
  curl -k -s --request PATCH "${CPD_URL}/v2/jobs/$1?job_id=$1&project_id=${proj_id}" --header 'Content-Type : application/json' --header "Authorization : Bearer ${bearer_token}" --data-raw "${data}"
}

Appelez la fonction pour définir le nom.

$ DSSetIdForJob $job_id "new_job_name"

DSSetParam

Utilisez l'API REST pour spécifier des valeurs de paramètre de travail.

#!/bin/sh

#param1:
#param2:
#param3:
DSSetParam()
{
  vars=(`curl -k -s --request GET "${CPD_URL}/v2/jobs/$1?job_id=$1&project_id=${proj_id}" --header "Authorization : Bearer ${bearer_token}" | jq '.entity.job.configuration.job_parameters[]'`)
  for i in "${!vars[@]}" ;
  do
    if [[ ${vars[$i]} == \"$2=* ]] ; then
      newvars [ $i ] = \ "$2 = $3 \"
    else
      newvars[$i]=${vars[$i]}
    fi
  done
  varstr=$(printf ",%s" "${newvars[@]}")
  varstr="[${varstr:1}]"
  data="[{\"op\" : \N "replace\N", \N "path\N" : \N"/entity/job/configuration/job_parameters", \N "value\N" : ${varstr}}]"
  curl -k -s --request PATCH "${CPD_URL}/v2/jobs/$1?job_id=$1&project_id=${proj_id}" --header 'Content-Type : application/json' --header "Authorization : Bearer ${bearer_token}" --data-raw "${data}"
}

Appelez la fonction pour définir la valeur.

$ DSSetParam $job_id "param" "newvalue"

DSStopJob

API REST :

#!/bin/sh

DSStopJob()
{
output=`curl -k -s --request POST "${CPD_URL}/v2/jobs/${job_id}/runs/${run_id}/cancel ?job_id=${job_id}&project_id=${proj_id}&run_id=${run_id}" --header 'Content-Type : application/json' --header "Authorization : Bearer ${bearer_token}" -d '{}'`
echo $output
}

Interface CLI dsjob:

#!/bin/sh

DSStopJob()
{
output=`cpdctl dsjob stop --project-id $proj_id --job-id $job_id --run-id $run_id``
echo $output
}

La syntaxe suivante arrête un travail. Le travail arrêté est celui spécifié dans le paramètre job_id.

$ DSStopJob

DSTranslateCode

Définissez une fonction de conversion pour convertir un statut de contrôle de travail ou un code d'erreur en explication textuelle.

#!/bin/sh

DSTranslateCode()
{
  case $1 in
    0)
      echo "En cours d'exécution"
      ;;
    1)
      echo "Terminé OK"
      ;;
    2)
      echo "Terminé avec des avertissements"
      ;;
    3)
      echo "Abandonné"
      ;;
    4)
      echo "Mis en file d'attente"
      ;;
    11)
      echo "Validé OK"
      ;;
    12)
      echo "Validé avec des avertissements"
      ;;
    13)
      echo "Echec de la validation"
      ;;
    21)
      echo "A été réinitialisé"
      ;;
    96)
      echo "Crashed"
      ;;
    97)
      echo "Arrêté par l'opérateur"
      ;;
    98)
      echo "Non compilé"
      ;;
    99)
      echo "Pas en cours d'exécution"
      ;;
    -1)
      echo "Invalide JobHandle"
      ;;
    -2)
      echo "Le travail n'est pas à l'état correct (compilé et non en cours d'exécution)"
      ;;
    -3)
      echo "ParamName ne fait pas référence à un paramètre connu du travail"
      ;;
    -4)
      echo "ParamValue/Limitvalue n'est pas approprié"
      ;;
    -5)
      echo "Token in LimitType/RunMode/InfoType not recognized"
      ;;
    -6)
      echo "Le travail n'a pas été exécuté à partir du travail en cours"
      ;;
    -7)
      echo "StageName ne fait pas référence à une étape connue du travail"
      ;;
    -8)
      echo "StageName was DSJ.ME and the caller is not running within a stage"
      ;;
    -9)
      echo "LinkName ne fait pas référence à un lien connu de la scène"
      ;;
    -10)
      echo "JobHandle fait référence à un travail verrouillé par un autre utilisateur"
      ;;
    -11)
      echo "JobHandle fait référence à un travail qui a été supprimé"
      ;;
    -12)
      echo "JobName mal formé ou job n'existe pas"
      ;;
    -13)
      echo "Un paramètre TimeStamp a été mal formé"
      ;;
    -14)
      echo "Délai d'attente d'un événement"
      ;;
    -15)
      echo "Echec du déchiffrement de la valeur chiffrée"
      ;;
    -16)
      echo "Impossible d'obtenir des valeurs, des valeurs par défaut ou des valeurs par défaut de conception pour un travail à l'exception du travail en cours"
      ;;
    -17)
      echo "Fichier modèle introuvable"
      ;;
    -18)
      echo "Erreur lors du traitement du fichier modèle"
      ;;
    -19)
      echo "Le nom de paramètre est manquant-la zone ne ressemble pas à'name:value'"
      ;;
    -20)
      echo "Le chemin d'accès au fichier n'est pas indiqué"
      ;;
    -21)
      echo "Erreur lors de l'exécution de la commande externe"
      ;;
    -99)
      echo "Interface de référentiel générale'autre erreur'"
      ;;
    *)
      echo "Statut inconnu $ 1"
      ;;
  esac
}

DSWaitForJob

API REST :

$ jobrun=`curl -k -s --request GET "${CPD_URL}/v2/jobs/${job_id}/runs/${run_id}?job_id=${job_id}&run_id=${run_id}&project_id=${proj_id}" --header "Authorization: Bearer ${bearer_token}"`
$ status=`echo $jobrun | jq -r '.entity.job_run.state'`
$ echo $status

Interface CLI dsjob:

$ jobrun=`cpdctl dsjob get-jobrun --project-id ${proj_id} -N ${job_id} --run-id ${run_id} --output json`
$ status=`echo $jobrun | jq -r '.job_run.state'`
$ echo $status

Fonction d'encapsuleur:

#!/bin/sh

#param1:
#param2:
#param3:
DSWaitForJob()
{
OLD_IFS = "$IFS"
IFS= ","
jobarr = ($ 1)
runarr = ($ 2)
IFS=" $OLD_IFS "

len= ${#jobarr[@]}
start=$ (date +%s)

alors que true
do
now=$ (date +%s)
time=$ (($now-$start))
si [ $time -ge $ 3 ] ; alors
return 1
fi

result=0
for ((i=0;i<len;i++)) do
if [ ! -z "${statarr[i]}" ] && [ ${statarr[i]} = "Terminé" ] ; then
result=$(($result+1)) 
poursuivre
fi
job_id=${jobarr[i]}
run_id=${runarr[i]}
jobrun=`cpdctl dsjob get-jobrun --project-id ${proj_id} -N ${job_id} --run-id ${run_id} --output json`
status=`echo $jobrun | jq -r '.job_run.state'`
statarr [ i ] = $status
if [ ${statarr[i]} = "Completed" ] ; then
result=$(($result+1))
elif [ ${statarr[i]} = "Completed" ] ; then
return 1
fi
fait ;

if [ $result -eq $len ] ; alors
return 0
fi

done

}

La syntaxe suivante attend un travail spécifié.

$ DSWaitForJob "${jobid1},${jobid2}" "${runid1},${runid2}" "600"

DSJobLinkInfo

Utilisez l'API REST pour obtenir des informations de lien à partir des métadonnées d'exécution de travail.

DSJobLinkInfo()
{
  # Obtenir les métadonnées d'exécution de travail
  jobrun=`curl -k -s --request GET "${CPD_URL}/v2/jobs/${job_id}/runs/${run_id} ?job_id=${job_id}&run_id=${run_id}&project_id=${proj_id}" --header "Authorization : Bearer ${bearer_token}"`

  # Obtenir des informations de lien
  echo $jobrun | jq -r ".entity.job_run.configuration.metrics.link_metrics[]|(\"Link name:\" + .link_name + \", source:\" + .source + \N", dest:\N" + .dest + \N", state:\N" + .state + \N", rows read:\N" + (.rows_read|tostring) + \N", rows written:\N" + (.rows_written|tostring))"
}

Appelez la fonction pour obtenir les informations de lien.

$ rows=`DSJobLinkInfo`