Esempi di sostituzione di routine in DataStage®

Gli esempi seguenti mostrano come riscrivere le routine BASIC utilizzando la dsjob CLI o l'API REST. È possibile riscrivere le routine come funzioni wrapper e richiamarle successivamente negli script oppure utilizzare il corpo della funzione di esempio come comando autonomo.

Esempi

Ottieni l'ID del progetto

Espressione CEL:

ctx.scope.id

API REST:

In questo esempio il nome del progetto è " project1 " Sostituisci con il nome del tuo progetto.

$ 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 $proj_id

dsjob CLI:

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

Ottieni l'ID del lavoro

Espressione 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 $joblist |jq

Questo comando stampa un elenco dei lavori. Sostituisci "testjob" con il nome del tuo lavoro nei seguenti comandi.

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

dsjob CLI:

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

Ottieni l'ID di esecuzione del processo

Espressione 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 $runlist

Questo comando stampa un elenco delle esecuzioni dei lavori. Seleziona una corsa in base alla descrizione, alla data di creazione o ad altri metadati.

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

dsjob CLI:

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

DSAddEnvVar

API REST:

#!/bin/sh

# Nome dell'ambiente param1:
# param2: nuovo nome variabile
# param3: nuovo valore della variabile
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} "
}

dsjob CLI:

#!/bin/sh

# Nome dell'ambiente param1:
# param2: nuovo nome variabile
# param3: nuovo valore della variabile
DSAddEnvVar()
{
cpdctl dsjob update-env-vars --project-id $ {proj_id} -n $1 --env $2=$3
}

La seguente sintassi aggiunge una nuova variabile d'ambiente all'ambiente specificato.

$ DSAddEnvVar "default_datastage_px" "newvar" "val"

DSAddProject

API REST:

#!/bin/sh

DSAddProject()
{
  data="{\"name\": \"$1\", \"generator\": \"customer\", \"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} '
}

dsjob CLI:

#!/bin/sh

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

La seguente sintassi crea un nuovo progetto e ne recupera l'ID.

$ proj_id=`DSAddProject "demo-project"`

DSDeleteEnvVar

API REST:

#!/bin/sh

# Nome dell'ambiente param1:
# Nome variabile param2:
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} "
}

dsjob CLI:

#!/bin/sh

# Nome dell'ambiente param1:
# Nome variabile param2:
DSDeleteEnvVar()
{
cpdctl dsjob delete-env-vars --project-id $ {proj_id} -n $1 --env $2
}

La seguente sintassi elimina una nuova variabile di ambiente dall'ambiente specificato.

$ 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 seguente sintassi elimina un progetto. È necessario l'ID del progetto.

$ DSDeleteProject "${proj_id}"

DSExecute

Definire una funzione wrapper.

#!/bin/sh

DSExecute()
{
shelltype=$1
command=$2
output=$3

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

Chiama la funzione.


$ 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"
}

dsjob CLI:

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

La seguente sintassi recupera l'ID del lavoro in base al nome del lavoro.

$ job_id=`DSGetIdForJob "testjob"``

DSGetJobInfo

È possibile riscrivere la funzione BASIC DSGetJobInfo come funzione wrapper che utilizza l'API REST con la seguente sintassi. Per recuperare le informazioni sul lavoro sono necessari i campi job_id, run_id e project_id. Alcune informazioni, come DSJ.JOBSTARTTIMESTAMP, non sono supportate.

#!/bin/sh

DSGetJobInfo()
{
  # Ottieni i metadati di esecuzione del lavoro
  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} "`

  # Analizza ed estrai le informazioni
  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
}

È anche possibile riscrivere DSGetJobInfo come funzione wrapper che utilizza la CLI djsob con la seguente sintassi.

#!/bin/sh

DSGetJobInfo()
{
  # Ottieni i metadati di esecuzione del lavoro
  jobrun=`cpdctl dsjob jobrunstat --project-id $ {proj_id} --id $ {job_id} --run-id $ {run_id} --output json --with-metadata | sed '$d'`

  # Analizza ed estrai le informazioni
  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 seguente sintassi recupera lo stato del processo.

$ jobstatus=`DSGetJobInfo "DSJ.JOBSTATUS"`

DSGetUserStatus

Per ottenere lo stato utente di un processo DataStage nello script di un nodo Run Bash script, ottenere l'ID del progetto (ctx.scope.id). Se il flusso Run DataStage è denominato run_datastage_flow, l'ID del processo è tasks.run_datastage_flow.results.jobe l'ID dell'esecuzione è tasks.run_datastage_flow.results.job_run. La seguente sintassi utilizza questi parametri per recuperare lo stato dell'utente.

esporta CPDCTL_ENABLE_DSJOB=1

DSGetUserStatus()
{
  # ottieni gli ultimi 36 caratteri della stringa di output, che contiene l'ID del processo o l'ID di esecuzione del processo del flusso Datastage
  flowid=$ {ds_job_id:0-36:36}
  flowrunid=$ {ds_job_run_id:0-36:36}

  # ottenere i metadati di jobrun tramite il comando dsjob o l'API REST
  jobrun=`cpdctl dsjob get-jobrun --project-id $project_id --id $flowid --run-id $flowrunid --output json --with-metadata `

  # estrai il messaggio " userStatus " dall'esecuzione del processo
  echo $jobrun | jq -r '.entity.job_run.configuration.userStatus'
}

userstatus=`DSGetUserStatus`

DSGetLinkInfo

Per recuperare il nome di un collegamento e il numero di righe che sono state trasmesse tramite un collegamento, ottenere l'ID del progetto, l'ID del lavoro, l'ID dell'esecuzione e il nome del collegamento. È possibile riscrivere DSGetLinkInfo in una funzione wrapper utilizzando la seguente sintassi.

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
}

dsjob CLI:

#!/bin/sh

DSGetLinkInfo()
{
  # Ottieni i metadati di esecuzione del lavoro
  jobrun=`cpdctl dsjob get-jobrun --project-id $ {proj_id} --id $ {job_id} --run-id $ {run_id} --output json`

  # Analizza ed estrai le informazioni
  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
}

La seguente chiamata di funzione ottiene il numero di righe del collegamento per Link_1.

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

DSGetLogEntry, DSGetLogEntryFull, DSGetLogEventIds, DSGetLogSummary, DSGetNewestLogId

Per ottenere i log di un'esecuzione di un lavoro, procurati l'ID del progetto, l'ID del lavoro e l'ID dell'esecuzione. È possibile scrivere funzioni wrapper per recuperare ID log, ID eventi, voci e riepiloghi con la seguente sintassi.

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(\"\\\\\")"
}

dsjob CLI:

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 $entry
}

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

Le seguenti chiamate di funzione ottengono le informazioni di log.

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

DSGetParamInfo

Per ottenere il valore corrente di un parametro, recupera l'ID del progetto, l'ID del lavoro e l'ID dell'esecuzione. Scrivi una funzione wrapper per recuperare i metadati di esecuzione del processo.

Il parametro accetta come input sia job-id e run-id, sia job-name e run-name. Il nome e l'ID del lavoro sono obbligatori, mentre il nome e l'ID dell'esecuzione sono facoltativi. È possibile fornire solo il nome del processo con il suffisso oppure il nome del processo con il nome di invocazione, ad esempio Flow1.DataStagejob o Flow1.DataStage job.invocationName. È anche possibile fornire separatamente il nome del lavoro e il nome dell'esecuzione. Se non si fornisce il nome dell'esecuzione o l'ID dell'esecuzione, verrà utilizzata per impostazione predefinita l'ultima esecuzione disponibile.

Esempi:

DSGetParamInfo.sh <param_name> --job-id=<job id> --run-id=<id of job run>

DSGetParamInfo.sh <param_name> --job-name=<jobname> --run-name=<invocation id> or <run name>

Per richiamare la funzione nelle subroutine before/after job, aggiungere il parametro $ENABLE_CPDCTL=1 a livello di flusso. Per ulteriori informazioni sulle subroutine before/after, consultare Impostazione delle subroutine before-job e after-job in DataStage.

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}'
}

dsjob CLI:

DSGetParamInfo()
{
  # Ottieni i metadati di esecuzione del lavoro
  jobrun=`cpdctl dsjob get-jobrun --project-id $proj_id --id $job_id --run-id $run_id --output json`

  # Estrai il valore del parametro
  params=`echo $jobrun |jq -r '. job_run.configuration.job_parameters []' | grep "$ {1} ="`
  echo $params | awk -F '=' ' {print $2} '
}

DSGetProjectInfo

Per ottenere il nome del progetto corrente e un elenco separato da virgole dei lavori del progetto, è necessario l'ID del progetto. Queste funzioni wrapper restituiscono il nome e l'elenco.

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
}

dsjob CLI:

#!/bin/sh

DSGetProjectInfo()
{
  if [ "$1" = " DSJ.PROJECTNAME " ]; then
    # Elenca i progetti e seleziona quello necessario in base all'ID del progetto
    proj=`cpdctl dsjob list-projects --with-id |grep $proj_id`
    # Analizza l'output ed estrai il nome
    echo $proj|awk ' {print $1} '
  elif [ "$1" = " DSJ.JOBLIST " ]; then
    # Ottieni l'elenco dei flussi ed estrai i nomi dei flussi
    flows=`cpdctl dsjob list-flows --project-id $ {proj_id} | tac | sed ' 1,4d;$d ' | tac`
    echo $flussi
  fi
}

Chiama la funzione per ottenere il nome del progetto o l'elenco dei flussi.

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

DSGetVersionInfo

La seguente funzione utilizza l'API REST per ottenere la versione del prodotto.

DSGetVersionInfo()
{
  if [ "$1" = " DSJ.VER.DS " ]; then
    prod="DataStage"
  elif [ "$1" = " DSJ.VER.DATAREP " ]; then
    prod="replica dei dati"
  elif [ "$1" = " DSJ.VER.PIPELINE " ]; then
    prod=" Watson Studio Pipelines "
  elif [ "$1" = " DSJ.VER.CORE " ]; then
    prod="Servizi comuni di base"
  elif [ "$1" = " DSJ.VER.CONTROL " ]; then
    prod="Piano di controllo"
  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
}

Chiama la funzione per ottenere la versione del prodotto.

$ DSGetVersionInfo "DSJ.VER.DS"
4.6.0

DSJobNameFromJobId

Per ottenere il nome di un lavoro, è necessario l'ID del progetto e l'ID del lavoro. Le seguenti funzioni recuperano il nome di un lavoro.

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'
}

dsjob CLI:

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 '
}

Chiama la funzione per ottenere il nome del lavoro.

jobname=`DSJobNameFromJobId``

DSListEnvVars

Per elencare le variabili di ambiente, è necessario l'ID del progetto.

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
}

dsjob CLI:

#!/bin/sh

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

Chiama la funzione per ottenere l'elenco.

$ DSListEnvVars "default_datastage_px"

DSMakeJobReport

Per creare un report di lavoro, definire DSGetJobInfo, DSGetStageInfo e DSGetLinkInfo. La seguente funzione mostra lo stato di un processo in esecuzione.

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
}

Chiama la funzione per ottenere l'elenco.

DSMakeJobReport "1"

DSRunJob

API REST:

#!/bin/sh

DSRunJob()
{
if [ "$1" = "" ]; then
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 $run_id
}

dsjob CLI:

#!/bin/sh

DSRunJob()
{
if [ "$1" = "" ]; then
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 $run_id
}

La seguente sintassi esegue un lavoro specificato.


# 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

# Nome dell'ambiente param1:
# Nome variabile param2:
# Valore variabile param3:
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} "
}

dsjob CLI:

#!/bin/sh

# Nome dell'ambiente param1:
# Nome variabile param2:
# Valore variabile param3:
DSSetEnvVar()
{
cpdctl dsjob update-env-vars --project-id $ {proj_id} -n $1 --env $2=$3
}

La seguente sintassi imposta una variabile d'ambiente al valore specificato.

$ DSSetEnvVar "default_datastage_px" "uservar" "newval"

DSSetIdForJob

Utilizza l'API REST per impostare un nome definito dall'utente per un lavoro.

#!/bin/sh

#param1: ID lavoro
#param2: nuovo nome del lavoro
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} "
}

Chiama la funzione per impostare il nome.

$ DSSetIdForJob $job_id "new_job_name"

DSSetParam

Utilizza l'API REST per specificare i valori dei parametri di lavoro.

#!/bin/sh

#param1: ID lavoro
#param2: nome del parametro
#param3: valore del parametro
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 []'`)
  per i in "$ {!vars[@]} ";
  eseguire
    if [[ $ {vars[$i]} == \"$2=* ]]; then
      newvars[$i]=\"$2=$3\"
    else
      newvars[$i]=$ {vars[$i]}
    fi
  fatto
  varstr=$(printf ", %s " "$ {newvars[@]} ")
  varstr="[$ {varstr:1} ]"
  data="[{\"op\": \"replace\", \"path\": \"/entity/job/configuration/job_parameters\", \"value\": $ {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} "
}

Chiama la funzione per impostare il valore.

$ 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
}

dsjob CLI:

#!/bin/sh

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

La seguente sintassi interrompe un processo. Il processo interrotto è quello specificato nel parametro job_id.

$ DSStopJob

DSTranslateCode

Definire una funzione di traduzione per convertire lo stato di controllo di un lavoro o un codice di errore in una spiegazione testuale.

#!/bin/sh

DSTranslateCode()
{
  caso $1 in
    0)
      echo "In esecuzione"
      ;;
    1)
      echo "Operazione completata con successo"
      ;;
    2)
      echo "Terminato con avvisi"
      ;;
    3)
      echo "Interrotto"
      ;;
    4)
      echo "In coda"
      ;;
    11)
      echo "Convalidato OK"
      ;;
    12)
      echo "Convalidato con avvisi"
      ;;
    13)
      echo "Convalida non riuscita"
      ;;
    21)
      echo "È stato ripristinato"
      ;;
    96)
      echo "Si è bloccato"
      ;;
    97)
      echo "Interrotto dall'operatore"
      ;;
    98)
      echo "Non compilato"
      ;;
    99)
      echo "Non in esecuzione"
      ;;
    -1)
      echo " JobHandle"" non valido
      ;;
    -2)
      echo "Il lavoro non è nello stato corretto (compilato e non in esecuzione)"
      ;;
    -3)
      echo ""ParamName non fa riferimento a un parametro noto del lavoro"
      ;;
    -4)
      echo " ""ParamValue/Limitvalue e non appropriato"
      ;;
    -5)
      echo "Token non riconosciuto nell' LimitType/RunMode/InfoType "
      ;;
    -6)
      echo "Il lavoro non è stato eseguito dall'interno del lavoro corrente"
      ;;
    -7)
      echo ""StageName non fa riferimento a una fase nota nel lavoro"
      ;;
    -8)
      echo ""StageName era DSJ.ME e il chiamante non è in esecuzione all'interno di uno stage"
      ;;
    -9)
      echo ""LinkName non fa riferimento a un collegamento noto dello stage"
      ;;
    -10)
      echo ""JobHandle si riferisce a un processo bloccato da un altro utente"
      ;;
    -11)
      echo ""JobHandle si riferisce a un lavoro che è stato ora eliminato"
      ;;
    -12)
      echo " ""JobName e malformato o lavoro inesistente"
      ;;
    -13)
      echo "Un parametro TimeStamp era mal formato"
      ;;
    -14)
      echo "Timeout durante l'attesa di un evento"
      ;;
    -15)
      echo "Decrittografia del valore crittografato non riuscita"
      ;;
    -16)
      echo "Impossibile ottenere valori, valori predefiniti o valori predefiniti di progettazione per qualsiasi lavoro eccetto quello corrente"
      ;;
    -17)
      echo "Impossibile trovare il file modello"
      ;;
    -18)
      echo "Errore durante l'elaborazione del file modello"
      ;;
    -19)
      echo "Nome parametro mancante - il campo non ha il formato 'nome:valore'"
      ;;
    -20)
      echo "Nome percorso file non specificato"
      ;;
    -21)
      echo "Errore durante l'esecuzione del comando esterno"
      ;;
    -99)
      echo "Interfaccia generale del repository 'altro errore'"
      ;;
    *)
      echo "Stato sconosciuto $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

dsjob CLI:

$ 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

Funzione wrapper:

#!/bin/sh

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

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

mentre vero
eseguire
ora=$(data + %s e)
time=$(( $ora - $inizio ))
if [ $time -ge $3 ]; then
restituisci 1
fi

result=0
per (( i=0;i<len;i++ )) fare
if [! -z "$ {statarr[i]} " ] && [ $ {statarr[i]} = "Completed" ]; then
risultato=$(( $result+1 )) 
continuare
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]} = "Completato" ]; then
risultato=$(( $result+1 ))
elif [ $ {statarr[i]} = "Completato" ]; allora
restituisci 1
fi
fatto;

if [ $result -eq $len ]; then
restituisci 0
fi

fatto

}

La sintassi seguente attende un lavoro specificato.

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

DSJobLinkInfo

Utilizza l'API REST per ottenere informazioni sui collegamenti dai metadati di esecuzione dei lavori.

DSJobLinkInfo()
{
  # Ottieni i metadati di esecuzione del lavoro
  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} "`

  # Ottieni informazioni sul link
  echo $jobrun | jq -r ". entity.job_run.configuration.metrics.link_metrics []|(\"Nome collegamento:\" +.link_name + \", origine:\" +.source + \", destinazione:\" +.dest + \", stato:\" +.state + \", righe lette:\" + (.rows_read|tostring) + \", righe scritte:\" + (.rows_written|tostring))"
}

Chiama la funzione per ottenere le informazioni sul link.

$ rows=`DSJobLinkInfo`