Ejemplos de sustitución de rutinas en DataStage®

Última actualización: 12 mar 2025

Ejemplos de sustitución de rutina en DataStage

Los ejemplos siguientes muestran cómo reescribir rutinas BASIC utilizando la CLI o la API REST de dsjob . Puede volver a escribir las rutinas como funciones de derivador y llamarlas más tarde en los scripts, o utilizar el cuerpo de la función de ejemplo como un mandato por sí mismo.

Ejemplos

Obtener ID de proyecto

Expresión de CIE:

ctx.scope.id

API REST:

En este ejemplo, el nombre del proyecto es "project1." Sustitúyalo por el nombre del proyecto.

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

dsjob CLI:

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

Obtener ID de trabajo

Expresión de CIE:

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

Este mandato imprime una lista de trabajos. Sustituya "testjob" por el nombre del trabajo en los mandatos siguientes.

$ 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
testjob |317dce0d-247a-48aa-bd96-f4ec44cb39fc
$ job_id=`echo ${job#*|}`
$echo $job_id

Obtener ID de ejecución de trabajo

Expresión de CIE:

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

Esto imprime una lista de ejecuciones de trabajo. Seleccione una ejecución basada en la descripción, la hora de creación u otros metadatos.

$ 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

# param1:
# param2: nuevo nombre de variable
# param3: nuevo valor 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="{\"/entidad/entorno/entorno_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

# param1:
# param2: nuevo nombre de variable
# param3: nuevo valor de variable
DSAddEnvVar()
{
cpdctl dsjob update-env-vars --project-id ${proj_id} -n $1 --env $2=$3
}

La sintaxis siguiente añade una nueva variable de entorno al entorno especificado.

$ 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 sintaxis siguiente crea un proyecto nuevo y recupera su ID.

$ proj_id=`DSAddProject "demo-project"`

DSDeleteEnvVar

API REST:

#!/bin/sh

# param1:
# param2: nombre 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="{\"/entidad/entorno/entorno_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

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

La sintaxis siguiente suprime una nueva variable de entorno del entorno especificado.

$ 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 sintaxis siguiente suprime un proyecto. El ID de proyecto es necesario.

$ DSDeleteProject "${proj_id}"

DSExecute

Defina una función de derivador.

#!/bin/sh

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

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

Llame a la función.


$ 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 sintaxis siguiente recupera el ID de trabajo por nombre de trabajo.

$ job_id=`DSGetIdForJob "testjob"``

DSGetJobInfo

Puede reescribir la función BASIC DSGetJobInfo como una función envolvente que utilice la API REST con la siguiente sintaxis. Job_id, run_id y project_id son necesarios para recuperar la información de trabajo. Información como, por ejemplo, DSJ.JOBSTARTTIMESTAMP, no está soportado.

#!/bin/sh

DSGetJobInfo()
{
  # Obtener los metadatos de ejecución del trabajo
  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}"`

  # Analizar y extraer la información
  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
}

También puede reescribir DSGetJobInfo como una función envolvente que utiliza la CLI djsob con la siguiente sintaxis.

#!/bin/sh

DSGetJobInfo()
{
  # Obtener los metadatos de ejecución del trabajo
  jobrun=`cpdctl dsjob jobrunstat --project-id ${proj_id} --id ${job_id} --run-id ${run_id} --output json --with-metadata | sed '$d'`

  # Analizar y extraer la información
  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 sintaxis siguiente recupera el estado del trabajo.

$ jobstatus=`DSGetJobInfo "DSJ.JOBSTATUS"`

DSGetUserStatus

Para obtener el estado de usuario de un trabajo de DataStage en el script de un nodo de script Ejecutar Bash, obtenga el ID de proyecto (ctx.scope.id). Si el flujo Ejecutar DataStage se denomina run_datastage_flow, el ID de trabajo es tasks.run_datastage_flow.results.joby el ID de ejecución es tasks.run_datastage_flow.results.job_run. La sintaxis siguiente utiliza estos parámetros para recuperar el estado del usuario.

export CPDCTL_ENABLE_DSJOB=1

DSGetUserStatus()
{
  # obtener los últimos 36 caracteres de la serie de salida, que contiene el ID de trabajo o el ID de ejecución de trabajo del flujo de datastage
  flowid= ${ds_job_id:0-36:36}
  flowrunid= ${ds_job_run_id:0-36:36}

  # obtener metadatos jobrun mediante el mandato dsjob o la API REST
  jobrun=`cpdctl dsjob get-jobrun --project-id $project_id --id $flowid --run-id $flowrunid --output json --with-metadata`

  # extrae el mensaje userStatus de la ejecución del trabajo
  echo $jobrun | jq -r '.entity.job_run.configuration.userStatus'
}

userstatus=`DSGetUserStatus`

DSGetLinkInfo

Para recuperar el nombre de un enlace y el número de filas que han pasado un enlace, obtenga el ID de proyecto, el ID de trabajo, el ID de ejecución y el nombre de enlace. Puede reescribir DSGetLinkInfo en una función envolvente utilizando la siguiente sintaxis.

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()
{
  # Obtener los metadatos de ejecución del trabajo
  jobrun=`cpdctl dsjob get-jobrun --project-id ${proj_id} --id ${job_id} --run-id ${run_id} --output json`

  # Analizar y extraer la información
  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 siguiente llamada a función obtiene el recuento de filas de enlace para Link_1.

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

DSGetLogEntry, DSGetLogEntryFull, DSGetLogEventIds, DSGetLogSummary, DSGetNewestLogId

Para obtener los registros de una ejecución de trabajo, obtenga el ID de proyecto, el ID de trabajo y el ID de ejecución. Puede escribir funciones de derivador para recuperar ID de registro, ID de suceso, entradas y resúmenes con la sintaxis siguiente.

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
}

Las siguientes llamadas de función obtienen la información de registro.

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

DSGetParamInfo

Para obtener el valor actual de un parámetro, obtenga el ID de proyecto, el ID de trabajo y el ID de ejecución. Escriba una función de derivador para recuperar los metadatos de ejecución del trabajo.

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()
{
  # Obtener los metadatos de ejecución del trabajo
  jobrun=`cpdctl dsjob get-jobrun --project-id $proj_id --id $job_id --run-id $run_id --output json`

  # Extraer el valor del parámetro
  params=`echo $jobrun |jq -r '.job_run.configuration.job_parameters[]' | grep "${1}="`
  echo $params | awk -F '=' '{print $2}'
}

Llame a la función para obtener un valor de parámetro.

$ value=`DSGetParamInfo "param_name"`

DSGetProjectInfo

Para obtener el nombre del proyecto actual y una lista separada por comas de los trabajos del proyecto, necesita el ID de proyecto. Estas funciones de derivador devuelven el nombre y la lista.

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"]; a continuación,
    # Listar proyectos y recoger los necesarios basándose en el ID de proyecto
    proj=`cpdctl dsjob list-projects --with-id |grep $proj_id`
    # Analizar la salida y extraer el nombre
    echo $proj|awk '{print $1}'
  elif [ "$1" = "DSJ.JOBLIST" ]; then
    # Obtener la lista de flujos y extraer los nombres de flujo
    flows=`cpdctl dsjob list-flows --project-id ${proj_id} | tac | sed '1,4d;$d' | tac`
    echo $flows
  fi
}

Llame a la función para obtener el nombre de proyecto o la lista de flujos.

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

DSGetVersionInfo

La siguiente función utiliza la API REST para obtener la versión del producto.

DSGetVersionInfo()
{
  if ["$1" = "DSJ.VER.DS"]; a continuación
    prod="DataStage"
  elif ["$1" = "DSJ.VER.DATAREP"]; a continuación
    prod="replicación de datos "
  elif ["$1" = "DSJ.VER.PIPELINE"]; a continuación
    prod= "Watson Studio Pipelines"
  elif ["$1" = "DSJ.VER.CORE"]; a continuación
    prod="Common Core Services "
  elif ["$1" = "DSJ.VER.CONTROL"]; a continuación
    prod="Plano de control "
  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"
}

Llame a la función para obtener la versión del producto.

$ DSGetVersionInfo "DSJ.VER.DS"
4.6.0

DSJobNameFromJobId

Para obtener un nombre de trabajo, necesita el ID de proyecto y el ID de trabajo. Las funciones siguientes recuperan un nombre de trabajo.

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

Llame a la función para obtener el nombre del trabajo.

jobname=`DSJobNameFromJobId``

DSListEnvVars

Para listar variables de entorno, necesita el ID de proyecto.

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

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

Llame a la función para obtener la lista.

$ DSListEnvVars "default_datastage_px"

DSMakeJobReport

Para realizar un informe de trabajo, defina DSGetJobInfo, DSGetStageInfo y DSGetLinkInfo. La función siguiente muestra el estado de una ejecución de trabajo.

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
}

Llame a la función para obtener la lista.

DSMakeJobReport "1"

DSRunJob

API REST:

#!/bin/sh

DSRunJob()
{
si ["$1" = ""]; entonces
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()
{
si ["$1" = ""]; entonces
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 sintaxis siguiente ejecuta un trabajo especificado.


# 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:
# param2: nombre de variable
# param3: valor 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="{\"/entidad/entorno/entorno_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

# param1:
# param2: nombre de variable
# param3: valor de variable
DSSetEnvVar()
{
cpdctl dsjob update-env-vars --project-id ${proj_id} -n $1 --env $2=$3
}

La sintaxis siguiente establece una variable de entorno en el valor especificado.

$ DSSetEnvVar "default_datastage_px" "uservar" "newval"

DSSetIdForJob

Utilice la API REST para establecer un nombre definido por el usuario para un trabajo.

#!/bin/sh

#param1:
#param2: nuevo nombre de trabajo
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}"
}

Llame a la función para establecer el nombre.

$ DSSetIdForJob $job_id "new_job_name"

DSSetParam

Utilice la API REST para especificar valores de parámetro de trabajo.

#!/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\": \"replace", "path": \"/entidad/trabajo/configuración/trabajo_parámetros", \"valor": ${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}"
}

Llame a la función para establecer el valor.

$ 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 sintaxis siguiente detiene un trabajo. El trabajo detenido es el especificado en el parámetro job_id.

$ DSStopJob

DSTranslateCode

Defina una función de conversión para convertir un estado de control de trabajo o un código de error en una explicación de texto.

#!/bin/sh

DSTranslateCode()
{
  case $1 in
    0)
      echo "En ejecución"
      ;;
    1)
      echo "Finalizado correcto"
      ;;
    2)
      echo "Finalizado con avisos"
      ;;
    3)
      echo "Terminado anormalmente"
      ;;
    4)
      echo "En cola"
      ;;
    11)
      echo "Validado correcto"
      ;;
    12)
      echo "Validado con avisos"
      ;;
    13)
      echo "Validación fallida"
      ;;
    21)
      echo "Se ha restablecido"
      ;;
    96)
      echo "Crashed"
      ;;
    97)
      echo "Detenido por operador"
      ;;
    98)
      echo "No compilado"
      ;;
    99)
      echo "No en ejecución"
      ;;
    -1)
      echo "Invalid JobHandle"
      ;;
    -2)
      echo "El trabajo no está en el estado correcto (compilado y no en ejecución)"
      ;;
    -3)
      echo "ParamName no hace referencia a un parámetro conocido del trabajo"
      ;;
    -4)
      echo "ParamValue/Limitvalue no es apropiado"
      ;;
    -5)
      echo "Token en LimitType/RunMode/InfoType no reconocido"
      ;;
    -6)
      echo "El trabajo no se ha ejecutado desde dentro del trabajo actual"
      ;;
    -7)
      echo "StageName no hace referencia a una etapa conocida del trabajo"
      ;;
    -8)
      echo "StageName was DSJ.ME and the caller is not running within a stage"
      ;;
    -9)
      echo "LinkName no hace referencia a un enlace conocido del escenario"
      ;;
    -10)
      echo "JobHandle hace referencia a un trabajo que está bloqueado por otro usuario"
      ;;
    -11)
      echo "JobHandle hace referencia a un trabajo que ya ha sido eliminado"
      ;;
    -12)
      echo "JobName mal formado o el trabajo no existe"
      ;;
    -13)
      echo "Un parámetro TimeStamp estaba mal formado"
      ;;
    -14)
      echo "Se ha excedido el tiempo de espera mientras se esperaba un suceso"
      ;;
    -15)
      echo "No se ha podido descifrar el valor cifrado"
      ;;
    -16)
      echo "No se pueden obtener valores, valores predeterminados o valores predeterminados de diseño para cualquier trabajo excepto el trabajo actual"
      ;;
    -17)
      echo "No se puede encontrar el archivo de plantilla"
      ;;
    -18)
      echo "Se ha encontrado un error al procesar el archivo de plantilla"
      ;;
    -19)
      echo "Falta el nombre de parámetro-el campo no tiene el aspecto de 'name:value'"
      ;;
    -20)
      echo "Nombre de vía de acceso de archivo no proporcionado"
      ;;
    -21)
      echo "Error al ejecutar el mandato externo"
      ;;
    -99)
      echo "Interfaz de repositorio general 'otro error'"
      ;;
    *)
      echo "Estado desconocido $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

Función de derivador:

#!/bin/sh

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

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

mientras es verdadero
do
now=$ (fecha +%s)
time=$ (($now-$start))
if [$time -ge $3]; entonces
return 1
fi

result=0
for ((i=0;i<len;i++)) do
¡if [ ! -z "${statarr[i]}" ] && [ ${statarr[i]} = "Completado" ]; then
result=$(($result+1)) 
continuar
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]} = "Completado" ]; then
result=$(($result+1))
elif [ ${statarr[i]} = "Completado" ]; then
return 1
fi
hecho;

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

done

}

La sintaxis siguiente espera un trabajo especificado.

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

DSJobLinkInfo

Utilice la API REST para obtener información de enlace de metadatos de ejecución de trabajo.

DSJobLinkInfo()
{
  # Obtener los metadatos de ejecución del trabajo
  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}"`

  # Obtener información de enlace
  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))"
}

Llame a la función para obtener la información de enlace.