Esempi di sostituzione di routine in DataStage®

Esempi

Ottieni ID progetto

Espressione CEL:

ctx.scope.id

API REST:

In questo esempio il nome del progetto è "project1." Sostituisci con nome del 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 

CLI dsjob:

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

Ottieni ID lavoro

Espressione CEL:

ctx.job.id

API REST:

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

Questo comando stampa un elenco di lavori. Sostituire "testjob" con il nome del lavoro nei seguenti comandi.

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

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_lavoro

Acquisisci ID esecuzione lavoro

Espressione CEL:

ctx.job_run.id

API REST:

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

Viene stampato un elenco di esecuzioni di lavori. Selezionare un'esecuzione in base alla descrizione, all'ora di creazione o ad altri metadati.

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

CLI dsjob:

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

DSAddEnvVar

API REST:

#!/bin/sh

# param1: nome ambiente
# param2: nuovo nome di variabile
# param3: nuovo valore della variabile
DSAddEnvVar()
{
envs=`curl -k -s --request GET "${CPD_URL}/v2/environments?project_id=${proj_id}" --header "Autorizzazione: 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="{\"/entità/ambiente/ambient_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} "
}

CLI dsjob:

#!/bin/sh

# param1: nome ambiente
# param2: nuovo nome di 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 di 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 "Autorizzazione: Bearer ${bearer_token}" -d "$data" --header 'Content-Type: application/json'`
  echo $proj|jq -r ".location" |awk -F '/' ' {print $4} '
}

CLI dsjob:

#!/bin/sh

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

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

$ proj_id=`DSAddProject "demo-project"`

DSDeleteEnvVar

API REST:

#!/bin/sh

# param1: nome ambiente
# param2:
DSDeleteEnvVar()
{
envs=`curl -k -s --request GET "${CPD_URL}/v2/environments?project_id=${proj_id}" --header "Autorizzazione: 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="{\"/entità/ambiente/ambient_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} "
}

CLI dsjob:

#!/bin/sh

# param1: nome ambiente
# 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 "Autorizzazione: Bearer ${bearer_token}"
}

La seguente sintassi elimina un progetto. L'id progetto è obbligatorio.

$ DSDeleteProject "${proj_id}"

Esecuzione DS

Definire una funzione wrapper.

#!/bin/sh

Esecuzione DS ()
{
shelltype=$1
command=$2
output=$3

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

Richiamare 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 "Autorizzazione: Bearer ${bearer_token}" -k -s`
  echo $joblist|jq -r ".results[].metadata|select(.name=="$1\") |.asset_id"
}

CLI dsjob:

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

La seguente sintassi richiama l'ID lavoro per nome lavoro.

$ job_id=`DSGetIdForJob "testjob"``

DSGetJobInfo

È possibile riscrivere la funzione BASIC DSGetJobInfo come funzione wrapper che utilizza l'API REST con la seguente sintassi. Job_id, run_id e project_id sono richiesti per richiamare le informazioni sul lavoro. Alcune informazioni, ad esempio DSJ.JOBSTARTTIMESTAMP, non è supportato.

#!/bin/sh

DSGetJobInfo()
{
  # Richiamare i metadati di esecuzione del job
  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 "Autorizzazione: Bearer ${bearer_token}"`

  # Analizzare ed estrarre 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()
{
  # Richiamare i metadati di esecuzione del job
  jobrun=`cpdctl dsjob jobrunstat --project-id $ {proj_id} --id $ {job_id} --run-id $ {run_id} --output json --with-metadata | sed '$d'`

  # Analizzare ed estrarre 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 richiama lo stato del lavoro.

$ jobstatus=`DSGetJobInfo "DSJ.JOBSTATUS"`

DSGetUserStatus

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

esporta CPDCTL_ENABLE_DSJOB=1

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

  # richiamare i metadati jobrun mediante 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 `

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

userstatus=`DSGetUserStatus`

DSGetLinkInfo

Per richiamare il nome di un link e il numero di righe che hanno inoltrato un link, richiamare l'id progetto, l'ID job, l'ID esecuzione e il nome link. È 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
}

CLI dsjob:

#!/bin/sh

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

  # Analizzare ed estrarre 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 alla funzione richiama il numero di righe di link per Link_1.

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

DSGetLogEntry, DSGetLogEntryFull, DSGetLogEventIds, DSGetLogSummary, DSGetNewestLogId

Per ottenere i log di un'esecuzione del job, richiamare ID progetto, ID lavoro e ID esecuzione. È possibile scrivere funzioni wrapper per richiamare ID log, ID evento, 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(\"\\\\\")"
}

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()
{
  voce=`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, richiamare l'ID progetto, l'id job e l'ID esecuzione. Scrivere una funzione wrapper per richiamare i metadati di esecuzione del lavoro.

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

CLI dsjob:

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

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

Richiamare la funzione per ottenere un valore di parametro.

$ value=`DSGetParamInfo "param_name"`

DSGetProjectInfo

Per ottenere il nome del progetto corrente e un elenco separato da virgole dei lavori del progetto, è necessario l'ID 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
}

CLI dsjob:

#!/bin/sh

DSGetProjectInfo()
{
  if [ "$1" = "DSJ.PROJECTNAME"]; quindi
    # Elencare i progetti e selezionarne uno necessario in base all'ID progetto
    proj=`cpdctl dsjob list-projects --with-id |grep $proj_id`
    # Analizzare l'emissione ed estrarre il nome
    echo $proj|awk ' {print $1} '
  elif [ "$1" = " DSJ.JOBLIST " ]; then
    # Richiamare l'elenco dei flussi ed estrarre i nomi dei flussi
    flows=`cpdctl dsjob list-flows --project-id $ {proj_id} | tac | sed ' 1,4d;$d ' | tac`
    echo $flussi
  fi
}

Richiamare la funzione per ottenere il nome del progetto o l'elenco del flusso.

$ 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"]; quindi
    prod="DataStage"
  elif [ "$1" = "DSJ.VER.DATAREP"]; quindi
    prod="replica-dati "
  elif [ "$1" = "DSJ.VER.PIPELINE"]; quindi
    prod= "Watson Studio Pipelines"
  elif [ "$1" = "DSJ.VER.CORE"]; quindi
    prod="Common Core Services "
  elif [ "$1" = "DSJ.VER.CONTROL"]; quindi
    prod="Piano di controllo "
  fi
  versions=`curl -k -s --request GET "${CPD_URL}/zen-data/v1/extensions?extension_point_id=zen_services_info" --header "Autorizzazione: Bearer ${bearer_token}"`
  echo $versioni | jq -r ".data[]|select(.display_name==="$prod\")|.details.version"
}

Richiamare la funzione per ottenere la versione del prodotto.

$ DSGetVersionInfo "DSJ.VER.DS"
4.6.0

DSJobNameFromJobId

Per ottenere un nome lavoro, è necessario l'id progetto e l'id lavoro. Le seguenti funzioni richiamano un nome 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'
}

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

Richiamare la funzione per ottenere il nome lavoro.

jobname=`DSJobNameFromJobId``

DSListEnvVars

Per elencare le variabili di ambiente, è necessario l'id 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
}

CLI dsjob:

#!/bin/sh

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

Richiamare la funzione per richiamare l'elenco.

$ DSListEnvVars "default_datastage_px"

DSMakeJobReport

Per creare un rapporto di lavoro, definire DSGetJobInfo, DSGetStageInfo e DSGetLinkInfo. La seguente funzione mostra lo stato di un'esecuzione lavoro.

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
}

Richiamare la funzione per richiamare l'elenco.

DSMakeJobReport "1"

DSRunJob

API REST:

#!/bin/sh

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

CLI dsjob:

#!/bin/sh

DSRunJob()
{
se [ "$1" = ""]; allora
invii = ""
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 job 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

# param1: nome ambiente
# param2:
# param3: valore variabile
DSSetEnvVar()
{
envs=`curl -k -s --request GET "${CPD_URL}/v2/environments?project_id=${proj_id}" --header "Autorizzazione: 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="{\"/entità/ambiente/ambient_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} "
}

CLI dsjob:

#!/bin/sh

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

La seguente sintassi imposta una variabile di ambiente sul valore specificato.

$ DSSetEnvVar "default_datastage_px" "uservar" "newval"

DSSetIdForJob

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

#!/bin/sh

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

Richiamare la funzione per impostare il nome.

$ DSSetIdForJob $job_id "new_job_name"

DSSetParam

Utilizzare l'API REST per specificare i valori del parametro del lavoro.

#!/bin/sh

#param1:
#param2: nome parametro
#param3: valore parametro
DSSetParam()
{
  vars=(`curl -k -s --request GET "${CPD_URL}/v2/jobs/$1?job_id=$1&project_id=${proj_id}" --header "Autorizzazione: Bearer ${bearer_token}" | jq '.entity.job.configuration.job_parameters[]'`)
  per i in "${!vars[@]}";
  eseguire
    se [[ $ {vars[$i]} == \"$2=* ]]; allora
      newvars [ $I] = \ "$2 = $3 \"
    else
      newvars[$i]=$ {vars[$i]}
    fi
  fatto
  varstr=$(printf ", %s " "$ {newvars[@]} ")
  varstr="[$ {varstr:1} ]"
  data="[{"op": \"replace", \"path": \"/entità/lavoro/configurazione/parametri_lavoro", \"valore": ${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} "
}

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

CLI dsjob:

#!/bin/sh

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

La seguente sintassi arresta un lavoro. Il lavoro arrestato è quello specificato nel parametro job_id.

$ DSStopJob

DSTranslateCode

Definire una funzione di traduzione per convertire uno stato di controllo del lavoro o un codice di errore in una spiegazione di testo.

#!/bin/sh

DSTranslateCode()
{
  caso $1 in
    0)
      echo "In esecuzione"
      ;;
    1)
      echo "Terminato correttamente"
      ;;
    2)
      echo "Terminato con avvertenze"
      ;;
    3)
      echo "Interrotto"
      ;;
    4)
      echo "In coda"
      ;;
    11)
      echo "Convalida OK"
      ;;
    12)
      echo "Convalidato con avvertenze"
      ;;
    13)
      echo "Convalida non riuscita"
      ;;
    21)
      echo "È stato reimpostato"
      ;;
    96)
      echo "Artato"
      ;;
    97)
      echo "Arrestato dall'operatore"
      ;;
    98)
      echo "Non compilato"
      ;;
    99)
      echo "Non in esecuzione"
      ;;
    -1)
      echo "Invalido JobHandle"
      ;;
    -2)
      echo "Il lavoro non è nello stato corretto (compilato e non in corso)"
      ;;
    -3)
      echo "ParamName non fa riferimento a un parametro noto del lavoro"
      ;;
    -4)
      echo "ParamValue/Limitvalue non è appropriato"
      ;;
    -5)
      echo "Il token in LimitType/RunMode/InfoType non è stato riconosciuto"
      ;;
    -6)
      echo "Il lavoro non è stato eseguito dal lavoro corrente"
      ;;
    -7)
      echo "StageName non si riferisce a una fase nota del lavoro"
      ;;
    -8)
      echo "StageName era DSJ.ME e il chiamante non è in esecuzione all'interno di uno stage"
      ;;
    -9)
      echo "LinkName non si riferisce a un collegamento noto dello stage"
      ;;
    -10)
      echo "JobHandle si riferisce a un lavoro bloccato da un altro utente"
      ;;
    -11)
      echo "JobHandle si riferisce a un lavoro che è stato cancellato"
      ;;
    -12)
      echo "JobName mal formato o lavoro inesistente"
      ;;
    -13)
      echo "Un parametro TimeStamp è stato formato male"
      ;;
    -14)
      echo "Timeout durante l'attesa di un evento"
      ;;
    -15)
      echo "Decodifica del valore codificato non riuscita"
      ;;
    -16)
      echo "Impossibile ottenere valori, valori predefiniti o valori predefiniti di progettazione per qualsiasi job tranne il job corrente"
      ;;
    -17)
      echo "Impossibile trovare file modello"
      ;;
    -18)
      echo "Errore durante l'elaborazione del file di modello"
      ;;
    -19)
      echo "Nome parametro mancante - il campo non è simile a 'nome:valore'"
      ;;
    -20)
      echo "Nome percorso file non fornito"
      ;;
    -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

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

Funzione wrapper:

#!/bin/sh

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

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

mentre true
eseguire
now=$ (data +%s)
time=$ (($now - $start))
if [ $-ge $3]; allora
restituisci 1
fi

result=0
per (( i=0;i<len;i++ )) fare
se [ ! -z "${statarr[i]}" ] && [ ${statarr[i]} = "Completato" ]; 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" ]; then
restituisci 1
fi
eseguito;

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

fatto

}

La seguente sintassi attende un lavoro specificato.

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

DSJobLinkInfo

Utilizzare l'API REST per ottenere informazioni sul link dai metadati di esecuzione del lavoro.

DSJobLinkInfo()
{
  # Richiamare i metadati di esecuzione del job
  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 "Autorizzazione: Bearer ${bearer_token}"`

  # Ottieni informazioni sul collegamento
  echo $jobrun | jq -r ". entity.job_run.configuration.metrics.link_metrics []|(\"Link name:\" +.link_name + \", source:\" +.source + \", dest:\" +.dest + \", state:\" +.state + \", rows read:\" + (.rows_read|tostring) + \", rows written:\" + (.rows_written|tostring))"
}

Richiamare la funzione per ottenere le informazioni sul link.

$ rows=`DSJobLinkInfo`