Job types

The following series of sections provide details about the available types of jobs that you can define and the parameters that you use to define each type of job.

Job:Command

The following example shows how to use the Job:Command to run operating system commands.

	"JobName": {
		"Type" : "Job:Command",
    	"Command" : "echo hello",
        "PreCommand": "echo before running main command",
        "PostCommand": "echo after running main command",
    	"Host" : "myhost.mycomp.com",
    	"RunAs" : "user1"  
	}

_{Back to top}

Job:Script

 The following example shows how to use Job:Script to run a script from a specified script file.

    "JobWithPreAndPost": {
        "Type" : "Job:Script",
        "FileName" : "task1123.sh",
        "FilePath" : "/home/user1/scripts",
        "PreCommand": "echo before running script",
        "PostCommand": "echo after running script",
        "Host" : "myhost.mycomp.com",
        "RunAs" : "user1" 
		"Arguments":[
			"arg1",
        	"arg2" 
		]  
    }

_{Back to top}

Job:EmbeddedScript

The following example shows how to use Job:EmbeddedScript to run a script that you include in the JSON code. Control-M deploys this script to the Agent host during job submission. This eliminates the need to deploy scripts as part of your application stack.

    "EmbeddedScriptJob":{
        "Type":"Job:EmbeddedScript",
        "Script":"#!/bin/bash\\necho \"Hello world\"",
        "Host":"myhost.mycomp.com",
        "RunAs":"user1",
        "FileName":"myscript.sh",
        "PreCommand": "echo before running script",
        "PostCommand": "echo after running script"
    }

_{Back to top}

Job:FileTransfer

The following example shows a Job:FileTransfer for a file transfer from a local filesystem to an SFTP server:

{
  "FileTransferFolder" :
  {
	"Type" : "Folder",
	"Application" : "aft",
	"TransferFromLocalToSFTP" :
	{
		"Type" : "Job:FileTransfer",
		"ConnectionProfileSrc" : "LocalConn",
		"ConnectionProfileDest" : "SftpConn",
        "NumberOfRetries": "3",
		"Host": "AgentHost",
		"FileTransfers" :
		[
			{
				"Src" : "/home/controlm/file1",
				"Dest" : "/home/controlm/file2",
				"TransferType": "Binary",
				"TransferOption": "SrcToDest"
			},
			{
				"Src" : "/home/controlm/otherFile1",
				"Dest" : "/home/controlm/otherFile2",
				"TransferOption": "DestToSrc"
			}
		]
	}
  }
}

Here is another example for a file transfer from an S3 storage service to a local filesystem:

{
 "MyS3AftFolder": {
   "Type": "Folder",
   "Application": "aft",
   "TransferFromS3toLocal": 
   {
      "Type": "Job:FileTransfer",
      "ConnectionProfileSrc": "amazonConn",
      "ConnectionProfileDest": "LocalConn",
      "NumberOfRetries": "4",
      "S3BucketName": "bucket1",
      "Host": "agentHost",
      "FileTransfers": [
         {
			"Src" : "folder/sub_folder/file1",
			"Dest" : "folder/sub_folder/file2"
         }
      ]
   }
 }
}

Here is another example for a file transfer from an S3 storage service to another S3 storage service:

{
 "MyS3AftFolder": {
   "Type": "Folder",
   "Application": "aft",
   "TransferFromS3toS3": 
   {
      "Type": "Job:FileTransfer",
      "ConnectionProfileSrc": "amazonConn",
      "ConnectionProfileDest": "amazon2Conn",
      "NumberOfRetries": "6",
      "S3BucketNameSrc": "bucket1",
      "S3BucketNameDest": "bucket2",
      "Host": "agentHost",
      "FileTransfers": [
         {
			"Src" : "folder/sub_folder/file1",
			"Dest" : "folder/sub_folder/file2"
         }
      ]
   }
 }
}

AAnd here is another example for a file transfer from a local filesystem to an AS2 server.

Note: File transfers that use the AS2 protocol are supported only in one direction — from a local filesystem to an AS2 server.

{
  "MyAs2AftFolder": {
    "Type": "Folder",
    "Application": "AFT",
    "MyAftJob_AS2": 
    {
      "Type": "Job:FileTransfer",
      "ConnectionProfileSrc": "localAConn",
      "ConnectionProfileDest": "as2Conn",
      "NumberOfRetries": "Default",
      "Host": "agentHost",
      "FileTransfers": [
        {
          "Src": "/dev",
          "Dest": "/home/controlm/",
          "As2Subject": "Override subject",
          "As2Message": "Override conntent type"
        }
      ]
    }
  }
}

The following parameters were used in the examples above:

The following example presents a File Transfer job in which the transferred file is watched using the File Watcher utility:

{
  "FileTransferFolder" :
  {
	"Type" : "Folder",
	"Application" : "aft",
	"TransferFromLocalToSFTPBasedOnEvent" :
	{
		"Type" : "Job:FileTransfer",
		"Host" : "AgentHost",
		"ConnectionProfileSrc" : "LocalConn",
		"ConnectionProfileDest" : "SftpConn",
        "NumberOfRetries": "3",
		"FileTransfers" :
		[
			{
				"Src" : "/home/sftp/file1",
				"Dest" : "/home/sftp/file2",
				"TransferType": "Binary",
				"TransferOption" : "SrcToDestFileWatcher",
				"PreCommandDest" :
				{
					"action" : "rm",
					"arg1" : "/home/sftp/file2"
				},
				"PostCommandDest" :
				{
					"action" : "chmod",
					"arg1" : "700",
					"arg2" : "/home/sftp/file2"
				},
				"FileWatcherOptions":
				{
					"MinDetectedSizeInBytes" : "200",
					"TimeLimitPolicy" : "WaitUntil",
					"TimeLimitValue" : "2000",
					"MinFileAge" : "3Min",
					"MaxFileAge" : "10Min",
					"AssignFileNameToVariable" : "FileNameEvent",
					"TransferAllMatchingFiles" : true
				}
			}
		]
	}
  }
}

This example contains the following additional optional parameters: 

_{Back to top}

Job:FileWatcher

A File Watcher job enables you to detect the successful completion of a file transfer activity that creates or deletes a file. The following example shows how to manage File Watcher jobs using Job:FileWatcher:Create and Job:FileWatcher:Delete. 

    "FWJobCreate" : {
	    "Type" : "Job:FileWatcher:Create",
		"RunAs":"controlm",
 	    "Path" : "C:/path*.txt",
	    "SearchInterval" : "45",
	    "TimeLimit" : "22",
	    "StartTime" : "201705041535",
	    "StopTime" : "201805041535",
	    "MinimumSize" : "10B",
	    "WildCard" : true,
	    "MinimalAge" : "1Y",
	    "MaximalAge" : "1D2H4MIN"
    },
    "FWJobDelete" : {
        "Type" : "Job:FileWatcher:Delete",
        "RunAs":"controlm",
        "Path" : "C:/path.txt",
        "SearchInterval" : "45",
        "TimeLimit" : "22",
        "StartTime" : "201805041535",
        "StopTime" : "201905041535"
    }

This example contains the following parameters:

_{Back to top}

Job:Database

The following types of database jobs are available:

• Embedded Query job, using Job:Database:EmbeddedQuery
• SQL Script job, using Job:Database:SQLScript
• Stored Procedure job, using Job:Database:StoredProcedure
• MSSQL Agent job, using Job:Database:MSSQL:AgentJob
• SSIS Package job, using Job:Database:MSSQL:SSIS

Job:Database:EmbeddedQuery

The following example shows how to create a database job that runs an embedded query.

{
    "PostgresDBFolder": {  
		"Type": "Folder",
        "EmbeddedQueryJobName": {
          "Type": "Job:Database:EmbeddedQuery",
          "ConnectionProfile": "POSTGRESQL_CONNECTION_PROFILE",
          "Query": "SELECT %%firstParamName AS VAR1 \\n FROM DUMMY \\n ORDER BY \\t VAR1 DESC",
          "Host": "${agentName}",
          "RunAs": "PostgressCP",
          "Variables": [
             {
			   "firstParamName": "firstParamValue"
             }
          ],
		  "Autocommit": "N",
		  "OutputExecutionLog": "Y",
		  "OutputSQLOutput": "Y",
		  "SQLOutputFormat": "XML"
     } 
}

This example contains the following parameters:

The following optional parameters are also available for all types of database jobs:

Job:Database:SQLScript

The following example shows how to create a database job that runs a SQL script from a file system.

{
	"OracleDBFolder": {
		"Type": "Folder",
		"testOracle": {
			"Type": "Job:Database:SQLScript",
			"Host": "AgentHost",
			"SQLScript": "/home/controlm/sqlscripts/selectOrclParm.sql",
			"ConnectionProfile": "ORACLE_CONNECTION_PROFILE",
			"Parameters": [
				{"firstParamName": "firstParamValue"},
				{"secondParamName": "secondParamValue"}
			]
		}
	}
}

This example contains the following parameters:

For additional optional parameters, see above.

Another example:

{
	"OracleDBFolder": {
		"Type": "Folder",
		"testOracle": {
			"Type": "Job:Database:SQLScript",
			"Host": "app-redhat",
			"SQLScript": "/home/controlm/sqlscripts/selectOrclParm.sql",
			"ConnectionProfile": "ORACLE_CONNECTION_PROFILE"
		}
	}
}

Job:Database:StoredProcedure

The following example shows how to create a database job that runs a program that is stored on the database.

{
	"storeFolder": {
		"Type": "Folder",
		"jobStoredProcedure": {
			"Type": "Job:Database:StoredProcedure",
			"Host": "myhost.mycomp.com",
			"StoredProcedure": "myProcedure",
			"Parameters": [ "value1","variable1",["value2","variable2"]],
			"ReturnValue":"RV",
			"Schema": "public",
			"ConnectionProfile": "DB-PG-CON"
		}
	}
}

This example contains the following parameters:

For additional optional parameters, see above.

Job:Database:MSSQL:AgentJob

The following example shows how to create an MSSQL Agent job, for management of a job defined in the SQL server.

{
    "MSSQLFolder": {
        "Type": "Folder",
        "ControlmServer": "IN01",
        "MSSQLAgentJob": {
            "Type": "Job:Database:MSSQL:AgentJob",
            "ConnectionProfile": "MSSQL-WE-EXAMPLE",
            "Host": "agentHost",
            "JobName": "get_version",
            "Category": "Data Collector"
        }
    }
}

This example contains the following parameters:

For additional optional parameters, see above.

Job:Database:MSSQL:SSIS

The following example shows how to create SSIS Package jobs for execution of SQL Server Integration Services (SSIS) packages:

{
   "MSSQLFolder": {
       "Type": "Folder",
       "ControlmServer": "IN01",
       "SSISCatalog": {
            "Type": "Job:Database:MSSQL:SSIS",
            "ConnectionProfile": "MSSQL-CP-NAME",
            "Host": "agentHost",
            "PackageSource": "SSIS Catalog",
            "PackageName": "\\Data Collector\\SqlTraceCollect",
            "CatalogEnv": "ENV_NAME",
            "ConfigFiles": [
                "C:\\Users\\dbauser\\Desktop\\test.dtsConfig",
                "C:\\Users\\dbauser\\Desktop\\test2.dtsConfig"
            ],
            "Properties": [
                {
                    "PropertyName": "PropertyValue"
                },
                {
                    "PropertyName2": "PropertyValue2"
                }
            ]
        },
        "SSISPackageStore": {
            "Type": "Job:Database:MSSQL:SSIS",
            "ConnectionProfile": "MSSQL-CP-NAME",
            "Host": "agentHost",
            "PackageSource": "SSIS Package Store",
            "PackageName": "\\Data Collector\\SqlTraceCollect",
            "ConfigFiles": [
                "C:\\Users\\dbauser\\Desktop\\test.dtsConfig",
                "C:\\Users\\dbauser\\Desktop\\test2.dtsConfig"
            ],
            "Properties": [
                {
                    "PropertyName": "PropertyValue"
                },
                {
                    "PropertyName2": "PropertyValue2"
                }
            ]
        }    
    }
} 

This example contains the following parameters:

For additional optional parameters, see above.

_{Back to top}

Job:Hadoop

Various types of Hadoop jobs are available for you to define using the Job:Hadoop objects:

• Spark Python
• Spark Scala or Java
• Pig
• Sqoop
• Hive
• DistCp (distributed copy)
• HDFS commands
• HDFS File Watcher
• Oozie
• MapReduce
• MapReduce Streaming

Job:Hadoop:Spark:Python

The following example shows how to use Job:Hadoop:Spark:Python to run a Spark Python program.

    "ProcessData": {
        "Type": "Job:Hadoop:Spark:Python",
        "Host" : "edgenode",
        "ConnectionProfile": "DEV_CLUSTER",

        "SparkScript": "/home/user/processData.py"
    }

Optional parameters:

 "ProcessData1": {
    "Type": "Job:Hadoop:Spark:Python",
    "Host" : "edgenode",
    "ConnectionProfile": "DEV_CLUSTER",
    "SparkScript": "/home/user/processData.py",            
    "Arguments": [
        "1000",
        "120"
    ],            

    "PreCommands": {
        "FailJobOnCommandFailure" :false,
        "Commands" : [
            {"get" : "hdfs://nn.example.com/user/hadoop/file localfile"},
            {"rm"  : "hdfs://nn.example.com/file /user/hadoop/emptydir"}
        ]
    },

    "PostCommands": {
        "FailJobOnCommandFailure" :true,
        "Commands" : [
            {"put" : "localfile hdfs://nn.example.com/user/hadoop/file"}
        ]
    },

    "SparkOptions": [
        {"--master": "yarn"},
        {"--num":"-executors 50"}
    ]
 }

_{Back to top}

Job:Hadoop:Spark:ScalaJava

The following example shows how to use Job:Hadoop:Spark:ScalaJava to run a Spark Java or Scala program.

 "ProcessData": {
  	"Type": "Job:Hadoop:Spark:ScalaJava",
    "Host" : "edgenode",
    "ConnectionProfile": "DEV_CLUSTER",

    "ProgramJar": "/home/user/ScalaProgram.jar",
	"MainClass" : "com.mycomp.sparkScalaProgramName.mainClassName" 
}

Optional parameters:

 "ProcessData1": {
  	"Type": "Job:Hadoop:Spark:ScalaJava",
    "Host" : "edgenode",
    "ConnectionProfile": "DEV_CLUSTER",

    "ProgramJar": "/home/user/ScalaProgram.jar"
	"MainClass" : "com.mycomp.sparkScalaProgramName.mainClassName",

    "Arguments": [
        "1000",
        "120"
    ],            

    "PreCommands": {
        "FailJobOnCommandFailure" :false,
        "Commands" : [
            {"get" : "hdfs://nn.example.com/user/hadoop/file localfile"},
            {"rm"  : "hdfs://nn.example.com/file /user/hadoop/emptydir"}
        ]
    },

    "PostCommands": {
        "FailJobOnCommandFailure" :true,
        "Commands" : [
            {"put" : "localfile hdfs://nn.example.com/user/hadoop/file"}
        ]
    },

    "SparkOptions": [
        {"--master": "yarn"},
        {"--num":"-executors 50"}
    ]
 }

_{Back to top}

Job:Hadoop:Pig

The following example shows how to use Job:Hadoop:Pig to run a Pig script.

"ProcessDataPig": {
    "Type" : "Job:Hadoop:Pig",
    "Host" : "edgenode",
    "ConnectionProfile": "DEV_CLUSTER",

    "PigScript" : "/home/user/script.pig" 
}

Optional parameters:

    "ProcessDataPig1": {
        "Type" : "Job:Hadoop:Pig",
        "ConnectionProfile": "DEV_CLUSTER",
        "PigScript" : "/home/user/script.pig",            
        "Host" : "edgenode",
        "Parameters" : [
            {"amount":"1000"},
            {"volume":"120"}
        ],            
        "PreCommands": {
            "FailJobOnCommandFailure" :false,
            "Commands" : [
                {"get" : "hdfs://nn.example.com/user/hadoop/file localfile"},
                {"rm"  : "hdfs://nn.example.com/file /user/hadoop/emptydir"}
            ]
        },
        "PostCommands": {
            "FailJobOnCommandFailure" :true,
            "Commands" : [
                {"put" : "localfile hdfs://nn.example.com/user/hadoop/file"}
            ]
        }
    }

_{Back to top}

Job:Hadoop:Sqoop

The following example shows how to use Job:Hadoop:Sqoop to run a Sqoop job.

    "LoadDataSqoop":
    {
      "Type" : "Job:Hadoop:Sqoop",
	  "Host" : "edgenode",
      "ConnectionProfile" : "SQOOP_CONNECTION_PROFILE",

      "SqoopCommand" : "import --table foo --target-dir /dest_dir" 
    }

Optional parameters:

    "LoadDataSqoop1" :
    {
        "Type" : "Job:Hadoop:Sqoop",
        "Host" : "edgenode",
        "ConnectionProfile" : "SQOOP_CONNECTION_PROFILE",

        "SqoopCommand" : "import --table foo",
		"SqoopOptions" : [
			{"--warehouse-dir":"/shared"},
			{"--default-character-set":"latin1"}
		],
 
        "SqoopArchives" : "",
        
        "SqoopFiles": "",
        
        "PreCommands": {
            "FailJobOnCommandFailure" :false,
            "Commands" : [
                {"get" : "hdfs://nn.example.com/user/hadoop/file localfile"},
                {"rm"  : "hdfs://nn.example.com/file /user/hadoop/emptydir"}
            ]
        },
        "PostCommands": {
            "FailJobOnCommandFailure" :true,
            "Commands" : [
                {"put" : "localfile hdfs://nn.example.com/user/hadoop/file"}
            ]
        }
    }

_{Back to top}

Job:Hadoop:Hive

The following example shows how to use Job:Hadoop:Hive to run a Hive beeline job.

    "ProcessHive":
    {
      "Type" : "Job:Hadoop:Hive",
      "Host" : "edgenode",
      "ConnectionProfile" : "HIVE_CONNECTION_PROFILE",

      "HiveScript" : "/home/user1/hive.script"
    }

Optional parameters:

   "ProcessHive1" :
    {
        "Type" : "Job:Hadoop:Hive",
        "Host" : "edgenode",
        "ConnectionProfile" : "HIVE_CONNECTION_PROFILE",


        "HiveScript" : "/home/user1/hive.script", 
        "Parameters" : [
            {"ammount": "1000"},
            {"topic": "food"}
        ],

        "HiveArchives" : "",
        
        "HiveFiles": "",
        
        "HiveOptions" : [
            {"hive.root.logger": "INFO,console"}
        ],

        "PreCommands": {
            "FailJobOnCommandFailure" :false,
            "Commands" : [
                {"get" : "hdfs://nn.example.com/user/hadoop/file localfile"},
                {"rm"  : "hdfs://nn.example.com/file /user/hadoop/emptydir"}
            ]
        },
        "PostCommands": {
            "FailJobOnCommandFailure" :true,
            "Commands" : [
                {"put" : "localfile hdfs://nn.example.com/user/hadoop/file"}
            ]
        }
    }

_{Back to top}

Job:Hadoop:DistCp

The following example shows how to use Job:Hadoop:DistCp to run a DistCp job. DistCp (distributed copy) is a tool used for large inter/intra-cluster copying.

        "DistCpJob" :
        {
            "Type" : "Job:Hadoop:DistCp",
            "Host" : "edgenode",
            "ConnectionProfile": "DEV_CLUSTER",
         
            "TargetPath" : "hdfs://nns2:8020/foo/bar",
            "SourcePaths" :
            [
                "hdfs://nn1:8020/foo/a"
            ]
        }  

Optional parameters:

    "DistCpJob" :
    {
        "Type" : "Job:Hadoop:DistCp",
        "Host" : "edgenode",
        "ConnectionProfile" : "HADOOP_CONNECTION_PROFILE",
        "TargetPath" : "hdfs://nns2:8020/foo/bar",
        "SourcePaths" :
        [
            "hdfs://nn1:8020/foo/a",
            "hdfs://nn1:8020/foo/b"
        ],
        "DistcpOptions" : [
            {"-m":"3"},
            {"-filelimit ":"100"}
        ]
    }

_{Back to top}

Job:Hadoop:HDFSCommands

The following example shows how to use Job:Hadoop:HDFSCommands to run a job that executes one or more HDFS commands.

        "HdfsJob":
        {
            "Type" : "Job:Hadoop:HDFSCommands",
            "Host" : "edgenode",
            "ConnectionProfile": "DEV_CLUSTER",

            "Commands": [
                {"get": "hdfs://nn.example.com/user/hadoop/file localfile"},
                {"rm": "hdfs://nn.example.com/file /user/hadoop/emptydir"}
            ]
        }

_{Back to top}

Job:Hadoop:HDFSFileWatcher

The following example shows how to use Job:Hadoop:HDFSFileWatcher to run a job that waits for HDFS file arrival.

    "HdfsFileWatcherJob" :
    {
        "Type" : "Job:Hadoop:HDFSFileWatcher",
        "Host" : "edgenode",
        "ConnectionProfile" : "DEV_CLUSTER",

        "HdfsFilePath" : "/inputs/filename",
        "MinDetecedSize" : "1",
        "MaxWaitTime" : "2"
    }

_{Back to top}

Job:Hadoop:Oozie

The following example shows how to use Job:Hadoop:Oozie to run a job that submits an Oozie workflow.

    "OozieJob": {
        "Type" : "Job:Hadoop:Oozie",
        "Host" : "edgenode",
        "ConnectionProfile": "DEV_CLUSTER",


        "JobPropertiesFile" : "/home/user/job.properties",
        "OozieOptions" : [
          {"inputDir":"/usr/tucu/inputdir"},
          {"outputDir":"/usr/tucu/outputdir"}
        ]
    }

Optional parameters:

_{Back to top}

Job:Hadoop:MapReduce

 The following example shows how to use Job:Hadoop:MapReduce to execute a Hadoop MapReduce job.

    "MapReduceJob" :
    {
       "Type" : "Job:Hadoop:MapReduce",
        "Host" : "edgenode",
        "ConnectionProfile": "DEV_CLUSTER",


        "ProgramJar" : "/home/user1/hadoop-jobs/hadoop-mapreduce-examples.jar",
        "MainClass" : "pi",
        "Arguments" :[
            "1",
            "2"]
    }

Optional parameters:

   "MapReduceJob1" :
    {
        "Type" : "Job:Hadoop:MapReduce",
        "Host" : "edgenode",
        "ConnectionProfile": "DEV_CLUSTER",


        "ProgramJar" : "/home/user1/hadoop-jobs/hadoop-mapreduce-examples.jar",
        "MainClass" : "pi",
        "Arguments" :[
            "1",
            "2"
        ],
        "PreCommands": {
            "FailJobOnCommandFailure" :false,
            "Commands" : [
                {"get" : "hdfs://nn.example.com/user/hadoop/file localfile"},
                {"rm"  : "hdfs://nn.example.com/file /user/hadoop/emptydir"}
            ]
        },
        "PostCommands": {
            "FailJobOnCommandFailure" :true,
            "Commands" : [
                {"put" : "localfile hdfs://nn.example.com/user/hadoop/file"}
            ]
        }    
    }

_{Back to top}

Job:Hadoop:MapredStreaming

The following example shows how to use Job:Hadoop:MapredStreaming to execute a Hadoop MapReduce Streaming job.

     "MapredStreamingJob1": {
        "Type": "Job:Hadoop:MapredStreaming",
        "Host" : "edgenode",
        "ConnectionProfile": "DEV_CLUSTER",


        "InputPath": "/user/robot/input/*",
        "OutputPath": "/tmp/output",
        "MapperCommand": "mapper.py",
        "ReducerCommand": "reducer.py",
        "GeneralOptions": [
            {"-D": "fs.permissions.umask-mode=000"},
            {"-files": "/home/user/hadoop-streaming/mapper.py,/home/user/hadoop-streaming/reducer.py"}   
        ]
    }

Optional parameters:

_{Back to top}

Job:SAP

SAP-type jobs enable you to manage SAP processes through the Control-M environment. To manage SAP-type jobs, you must have the SAP plug-in installed.

The following JSON objects are available for creating SAP-type jobs:

• Job:SAP:R3:CREATE— Creates a new SAP R3 job
  
• Job:SAP:R3:COPY — Creates an SAP R3 job by copying an existing job
  
• Job:SAP:BW:ProcessChain — Defines a job to run and monitor a Process Chain in SAP Business Warehouse (SAP BW)
  
• Job:SAP:BW:InfoPackage — Defines a job to run and monitor SAP InfoPackage that is pre-defined in SAP Business Warehouse (SAP BW)

Job:SAP:R3:CREATE

This job type enables you to create a new SAP R3 job.

The following example is a simple job that relies mostly on default settings and contains one step that executes an external command.

    "SAPR3_external_command": {
      "Type": "Job:SAP:R3:CREATE",
      "ConnectionProfile": "SAPCP",
      "SapJobName": "SAP_job",
      "CreatedBy": "user1",
      "Steps": [
        {
          "StepType": "ExternalCommand",
          "UserName": "user01",
          "TargetHost": "host01",
          "ProgramName": "PING"
        }
      ],
      "SpoolListRecipient": {
        "ReciptNoForwarding": false
      }
    }

The following example is a more complex job that contains two steps that run ABAP programs. Each of the ABAP steps has an associated variant that contains variable definitions.

  "SapR3CreateComplete": {
      "Type": "Job:SAP:R3:CREATE",
      "ConnectionProfile": "SAPCP",
      "SapJobName": "SAP_job2",
      "StartCondition": "Immediate",
      "RerunFromStep": "3",
      "Target": "controlmserver",
      "CreatedBy": "user1",
      "Steps": [
        {
          "StepType": "ABAP",
          "TimeToPrint": "PrintLater",
          "CoverPrintPage": true,
          "OutputDevice": "prt",
          "UserName": "user",
          "SpoolAuthorization": "Auth",
          "CoverDepartment": "dpt",
          "SpoolListName": "spoolname",
          "OutputNumberRows": "62",
          "NumberOfCopies": "5",
          "NewSpoolRequest": false,
          "PrintArchiveMode": "PrintAndArchive",
          "CoverPage": "Print",
          "ArchiveObjectType": "objtype",
          "SpoolListTitles": "titles",
          "OutputLayout": "layout",
          "CoverSheet": "Print",
          "ProgramName": "ABAP_PROGRAM",
          "Language": "e",
          "ArchiveInformationField": "inf",
          "DeleteAfterPrint": true,
          "PrintExpiration": "3",
          "OutputNumberColumns": "88",
          "ArchiveDocumentType": "doctype",
          "CoverRecipient": "recipient",
          "VariantName": "NameOfVariant",
          "VariantParameters": [
            {
              "Type": "Range",
              "High": "2",
              "Sign": "I",
              "Option": "BT",
              "Low": "1",
              "Name": "var1",
              "Modify": false
            },
            {
              "Low": "5",
              "Type": "Range",
              "Option": "BT",
              "Sign": "I",
              "Modify": true,
              "High": "6",
              "Name": "var3"
            }
          ]
        },
        {
          "StepType": "ABAP",
          "PrintArchiveMode": "Print",
          "ProgramName": "ABAP_PROGRAM2",
          "VariantName": "Myvar_with_temp",
          "TemporaryVariantParameters": [
            {
              "Type": "Simple",
              "Name": "var",
              "Value": "P11"
            },
            {
              "Type": "Simple",
              "Name": "var2",
              "Value": "P11"
            }
          ]
        }
      ],
      "PostJobAction": {
        "JobLog": "CopyToFile",
        "JobCompletionStatusWillDependOnApplicationStatus": true,
        "SpoolSaveToPDF": true,
        "JobLogFile": "fileToCopy.txt"
      },
      "SpoolListRecipient": {
        "ReciptNoForwarding": false
      }
    }

The following table lists the parameters that can be used in SAP jobs of this type:

The following additional parameters are available f or steps that involve the execution of an ABAP program. Most of these parameters are optional.

The following additional parameters are available for steps that involve the execution of an external program or an external command:

Job:SAP:R3:COPY

This job type enables you to create a new SAP R3 job by duplicating an existing job. The following example shows how to use Job:SAP:R3:COPY:

"JobSapR3Copy" : {
    "Type" : "Job:SAP:R3:COPY",
    "ConnectionProfile":"SAP-CON",
    "SapJobName" : "CHILD_1",
    "Exec": "Server",
    "Target" : "Server-name",
    "JobCount" : "SpecificJob",
    "JobCountSpecificName" : "sap-job-1234",
    "NewJobName" : "My-New-Sap-Job",
    "StartCondition" : "AfterEvent",
    "AfterEvent" : "HOLA",
    "AfterEventParameters" : "parm1 parm2",
    "RerunFromPointOfFailure": true,
    "CopyFromStep" : "4",
    "PostJobAction" : {
        "Spool" : "CopyToFile",
        "SpoolFile": "spoolfile.log",
        "SpoolSaveToPDF" : true,
        "JobLog" : "CopyToFile",
        "JobLogFile": "Log.txt",
        "JobCompletionStatusWillDependOnApplicationStatus" : true
    },
    "DetectSpawnedJob" : {
        "DetectAndCreate": "SpecificJobDefinition",
        "JobName" : "Specific-Job-123",
        "StartSpawnedJob" : true,
        "JobEndInControlMOnlyAftreChildJobsCompleteOnSap" : true,
        "JobCompletionStatusDependsOnChildJobsStatus" : true
    }
}

This SAP job object uses the following parameters:

Job:SAP:BW:ProcessChain

This job type runs and monitors a Process Chain in SAP Business Warehouse (SAP BW).

NOTE: For the job that you define through Control-M Automation API to work properly, ensure that the Process Chain defined in the SAP BW system has Start Using Meta Chain or API as the start condition for the trigger process (Start Process) of the Process Chain. To configure this parameter, from the SAP transaction RSPC, right-click the trigger process and select Maintain Variant.

The following example shows how to use Job:SAP:BW:ProcessChain:

"JobSapBW": {
    "Type": "Job:SAP:BW:ProcessChain",
    "ConnectionProfile": "PI4-BW",
    "ProcessChainDescription": "SAP BW Process Chain",
    "Id": "123456",
    "RerunOption": "RestartFromFailiurePoint",
    "EnablePeridoicJob": true,
    "ConsiderOnlyOverallChainStatus": true,
    "RetrieveLog": false,
    "DetectSpawnedJob": {
        "DetectAndCreate": "SpecificJobDefinition",
        "JobName": "ChildJob",
        "StartSpawnedJob": false,
        "JobEndInControlMOnlyAftreChildJobsCompleteOnSap": false,
        "JobCompletionStatusDependsOnChildJobsStatus": false
        }
    }

This SAP job object uses the following parameters:

  Job:SAP:BW:InfoPackage

This job type runs and monitors an InfoPackage that is pre-defined in SAP Business Warehouse (SAP BW).

The following example shows how to use Job:SAP:BW:InfoPackage

"JobSapBW": {
	"Type": "Job:SAP:BW:InfoPackage",
	"ConnectionProfile": "PI4-BW",
	"CreatedBy": "emuser1",
	"Description": "description of the job",
	"RunAs": "ProductionUser",
	"InfoPackage": {
		"BackgroundJobName": "Background job name",
		"Description": "description of the InfoPackage",
		"TechName": "LGXT565_TGHBNS453BGHJ784"
	}
}

This SAP job object uses the following parameters:

_{Back to top}

Job:PeopleSoft

PeopleSoft-type jobs enable you to manage PeopleSoft jobs and processes through the Control-M environment. To manage PeopleSoft-type jobs, you must have the Control-M for PeopleSoft plug-in installed.

The following example shows the JSON code used to define a PeopleSoft job.

"PeopleSoft_job": {
     "Type": "Job:PeopleSoft",
     "ConnectionProfile": "PS_CONNECT",
     "User": "PS_User3",
     "ControlId": "ControlId",
     "ServerName": "ServerName",
     "ProcessType": "ProcessType",
     "ProcessName": "ProcessName",
     "AppendToOutput": false,
     "BindVariables": ["value1","value2"],
     "RunAs": "controlm"
}

This PeopleSoft job object uses the following parameters:

_{Back to top}

Job:Airflow

The Airflow job enables you to monitor and manage DAG workflows. To manage Airflow-type jobs, you must have the Control-M for Airflow plug-in installed in your Control-M environment.

The following example shows the JSON code used to define an Airflow job.

"AirflowJob": {
   "Type": "Job:Airflow",
   "Host": "AgentHost",
   "ConnectionProfile": "AIRFLOW_CONNECTION_PROFILE",
   "DagId": "example_bash_operator",
   "ConfigurationJson": "\{\"key1\":1, \"key2\":2, \"key3\":\"value3\"\}",
   "OutputDetails": "FAILED_TASKS"
}

The Airflow job object uses the following parameters:

_{Back to top}

Job:ApplicationIntegrator

Use Job:ApplicationIntegrator:<JobType> to define a job of a custom type using the Control-M Application Integrator designer. For information about designing job types, see Job Type Definition in the section about Application Integrator in the Helix Control-M Online Help.

The following example shows the JSON code used to define a job type named AI Monitor Remote Job:

"JobFromAI" : {
    "Type": "Job:ApplicationIntegrator:AI Monitor Remote Job",
    "ConnectionProfile": "AI_CONNECTION_PROFILE",
    "AI-Host": "Host1",
    "AI-Port": "5180",
    "AI-User Name": "admin",
    "AI-Password": "*******",
    "AI-Remote Job to Monitor": "remoteJob5",
    "RunAs": "controlm"
}

In this example, the ConnectionProfile and RunAs properties are standard job properties used in Control-M Automation API jobs. The other job properties will be created in the Application Integrator, and they must be prefixed with "AI-" in the .json code.

The following images show the corresponding settings in the Control-M Application Integrator, for reference purposes.

_{Back to top}

Job:Informatica

Informatica-type jobs enable you to automate Informatica workflows through the Control-M environment. To manage Informatica-type jobs, you must have the Informatica plug-in installed.

The following example shows the JSON code used to define an Informatica job.

"InformaticaApiJob": {
    "Type": "Job:Informatica",
    "ConnectionProfile": "INFORMATICA_CONNECTION",
    "RepositoryFolder": "POC",
    "Workflow": "WF_Test",
    "InstanceName": "MyInstamce",
    "OsProfile": "MyOSProfile",
    "WorkflowExecutionMode": "RunSingleTask",
    "RunSingleTask": "s_MapTest_Success",
    "WorkflowRestartMode": "ForceRestartFromSpecificTask",
    "RestartFromTask": "s_MapTest_Success",
    "WorkflowParametersFile": "/opt/wf1.prop",
}

This Informatica job object uses the following parameters:

_{Back to top}

Job: Informatica CS

Informatica Cloud Services (CS) jobs enable you to automate your Informatica workflows for multi-cloud and on-premises data integration through the Control-M environment.

To deploy and run an Informatica CS job, ensure that you have installed the Informatica CS plug-in using the provision image command or the provision agent::update command. 

The following example shows the JSON code used to define an Informatica CS job:

"InformaticaCloudCSJob": {
    "Type": "Job:Informatica CS",
    "ConnectionProfile": "INFORMATICA_CS_CONNECTION", 
    "Task Type": "Synchronization task", 
    "Use Federation ID": "checked",
    "Task Name": "",
    "Folder Path": "Default/defualt-MappingTask1", 
    "Call Back URL": "", 
    "Status Polling Frequency": "10"
  }

The following example shows the JSON code used to define an Informatica CS job for a taskflow:

"InformaticaCloudCSJob": {
    "Type": "Job:Informatica CS",
    "ConnectionProfile": "INFORMATICA_CS_CONNECTION", 
    "Task Type": "Taskflow",
    "TaskFlow URL": "https://xxx.dm-xx.informaticacloud.com/active-bpel/rt/xyz",
    "Input Fields": "input1=val1&input2=val2&input3=val3",
    "Call Back URL": "", 
    "Rerun suspended Taskflow": "checked",
    "Rerun Run ID": "RUN-UCM-RUNID",
    "Status Polling Frequency": "10"
  }

The Informatica CS job object uses the following parameters:

_{Back to top}

Job:AWS

AWS-type jobs enable you to automate a select list of AWS services through Control-M Automation API. To manage AWS-type jobs, you must have the AWS plug-in installed.

The following JSON objects are available for creating AWS-type jobs:

• Job:AWS:Lambda
• Job:AWS:StepFunction
• Job:AWS:Batch

For the following additional job types you must have installed the relevant plug-ins using the provision image command or the provision agent::update command.

• Job:AWS Batch
• Job:AWS Glue
• Job:AWS Glue DataBrew

• Job:AWS Data Pipeline

• Job:AWS EMR
• Job:AWSEC2
• Job:AWS ECS
• Job:AWS Step Functions
• Job:AWS QuickSight
• Job:AWS Sagemaker
• Job:AWS Athena
• Job:AWS Mainframe Modernization
• Job:AWS CloudFormation

Job:AWS:Lambda

The following example shows how to define a job that executes an AWS Lambda service on an AWS server.

"AwsLambdaJob": {
    "Type": "Job:AWS:Lambda",
    "ConnectionProfile": "AWS_CONNECTION",
    "FunctionName": "LambdaFunction",
    "Version": "1",
    "Payload" : "{\"myVar\" :\"value1\" \\n\"myOtherVar\" : \"value2\"}" 
    "AppendLog": true
}

This AWS job object uses the following parameters:

Job:AWS:StepFunction

The following example shows how to define a job that executes an AWS Step Function service on an AWS server.

"AwsStepFunctionJob": {
    "Type": "Job:AWS:StepFunction",
    "ConnectionProfile": "AWS_CONNECTION",
    "StateMachine": "StateMachine1",
    "ExecutionName": "Execution1",
    "Input": ""{\"myVar\" :\"value1\" \\n\"myOtherVar\" : \"value2\"}" ",
    "AppendLog": true
}

This AWS job object uses the following parameters :

Job:AWS:Batch

The following example shows how to define a job that executes an AWS Batch service on an AWS server.

"AwsBatchJob": {
    "Type": "Job:AWS:Batch",
    "ConnectionProfile": "AWS_CONNECTION",
    "JobName": "batchjob1",
    "JobDefinition": "jobDef1",
    "JobDefinitionRevision": "3",
    "JobQueue": "queue1",
    "AWSJobType": "Array",
    "ArraySize": "100",
    "DependsOn": {
        "DependencyType": "Standard",
        "JobDependsOn": "job5"
        },
    "Command": [ "ffmpeg", "-i" ],
    "Memory": "10",
    "vCPUs": "2",
    "JobAttempts": "5",
    "ExecutionTimeout": "60",
    "AppendLog": false
}

This AWS job object uses the following parameters :

Job:AWS Batch 

The following examples show how to define an AWS Batch job, which enables you to manage and run batch computing workloads in AWS.

To deploy and run an AWS Batch job, ensure that you have installed the AWS Batch plug-in using the provision image command or the provision agent::update command.

The following example defines a Batch job with basic parameters:

"AWS_Batch_Job_basic": {
   "Type": "Job:AWS Batch",
   "ConnectionProfile": "AWS_BATCH",
   "Use Advanced JSON Format": "unchecked",
   "Job Name": "job1",
   "Job Definition and Revision": "ctm-batch-job-definition:1",
   "Job Queue": "ctm-batch-job-queue",
   "Container Overrides Command": "[\"echo\", \"hello from control-m\"]",
   "Job Attempts": "2",
   "Execution Timeout": "65",
   "Status Polling Frequency": "20"
} 

In the following example, various job parameters are provided through a submitted JSON body:

"AWS_Batch_Job_advanced": {
   "Type": "Job:AWS Batch",
   "ConnectionProfile": "AWS_BATCH",
   "Use Advanced JSON Format": "checked", 
   "JSON Format": "{\"containerOverrides\":{\"command\":[\"echo\",\"Hello, from Control-M\"],\"resourceRequirements\":[{\"type\":\"VCPU\",\"value\":\"2\"}]},\"jobDefinition\": \"ctm-batch-jobdefinition:1\",\"jobName\": \"job1\",\"jobQueue\": \"ctm-batch-job-queue\",\"timeout\": {\"attemptDurationSeconds\": 70}}",
   "Status Polling Frequency": "20"
}

The AWS Batch job object uses the following parameters :

Job:AWS Glue

The following example shows how to define a job that executes Amazon Web Services (AWS) Glue, a serverless data integration service.

To deploy and run an AWS Glue job, ensure that you have installed the AWS Glue plug-in using the provision image command or the provision agent::update command.

"AwsGlueJob": {
   "Type": "Job:AWS Glue",
   "ConnectionProfile": "GLUECONNECTION",
   "Glue Job Name": "AwsGlueJobName",
   "Glue Job Arguments": "checked",
   "Arguments": "{\"--myArg1\": \"myVal1\", \"--myArg2\": \"myVal2\"}",
   "Status Polling Frequency": "20",
   "Failure Tolerance": "2" 
}

The AWS Glue job object uses the following parameters :

_{Back to top}

Job:AWS Glue DataBrew

The following example shows how to define an AWS Glue DataBrew job that you can use to visualize your data and publish it to the Amazon S3 Data Lake. 

To deploy and run an AWS Glue DataBrew job, ensure that you have installed the AWS Glue DataBrew plug-in using the provision image command or the provision agent::update command.

"AWS Glue DataBrew_Job": {
	"Type": "Job:AWS Glue DataBrew",
	"ConnectionProfile": "AWSDATABREW",
	"Job Name": "databrew-job",
	"Output Job Logs": "checked",
	"Status Polling Frequency": "10",
	"Failure Tolerance": "2"
}

The AWS Glue DataBrew job object uses the following parameters:

Job:AWS Data Pipeline

The following examples show how to define an AWS Data Pipeline job that you can use to automate the transfer, processing, and storage of your data.

To deploy and run an AWS Data Pipeline job, ensure that you have installed the AWS Data Pipeline plug-in using the provision image command or the provision agent::update command.

The following example shows a job for the creation of a pipeline:

"AWS Data Pipeline_Job": {
	"Type": "Job:AWS Data Pipeline",
	"ConnectionProfile": "AWSDATAPIPELINE",
	"Action": "Create Pipeline",
	"Pipeline Name": "demo-pipeline",
	"Pipeline Unique Id": "235136145",
 	"Parameters": { 
	   "parameterObjects": [ 
		  { 
			 "attributes": [ 
				{ 
				   "key": "description",
				   "stringValue": "S3outputfolder"
				}
			 ],
			 "id": "myS3OutputLoc"
		  }
	   ],
	   "parameterValues": [ 
		  { 
			 "id": "myShellCmd",
			 "stringValue": "grep -rc \"GET\" ${INPUT1_STAGING_DIR}/* > ${OUTPUT1_STAGING_DIR}/output.txt"
		  }
	   ],
	   "pipelineObjects": [ 
		  { 
			 "fields": [ 
				{
				   "key":"input",
				   "refValue":"S3InputLocation"
				},
				{
				   "key":"stage",
				   "stringValue":"true"
				}
			 ],
			 "id": "ShellCommandActivityObj",
			 "name": "ShellCommandActivityObj"
		  }
	   ]
	}  
	"Trigger Created Pipeline": "checked",
	"Status Polling Frequency": "20",
	"Failure Tolerance": "3"
}

The following example shows a job for triggering an existing pipeline:

"AWS Data Pipeline_Job": {
	"Type": "Job:AWS Data Pipeline",
	"ConnectionProfile": "AWSDATAPIPELINE",
	"Action": "Trigger Pipeline",
 	"Pipeline ID": "df-020488024DNBVFN1S2U",
	"Trigger Created Pipeline": "unchecked",
	"Status Polling Frequency": "20",
	"Failure Tolerance": "3"
}

The AWS Data Pipeline job object uses the following parameters:

Job:AWS EMR

The following example shows how to define a job that executes Amazon Web Services (AWS) EMR to run big data frameworks .

To deploy and run an AWS EMR job, ensure that you have installed the AWS EMR plug-in using the provision image command or the provision agent::update command.

"AWS EMR_Job_2": {
  "Type": "Job:AWS EMR",
  "ConnectionProfile": "AWS_EMR",
  "Cluster ID": "j-21PO60WBW77GX",
  "Notebook ID": "e-DJJ0HFJKU71I9DWX8GJAOH734",
  "Relative Path": "ShowWaitingAndRunningClusters.ipynb",
  "Notebook Execution Name": "TestExec",
  "Service Role": "EMR_Notebooks_DefaultRole",
  "Use Advanced JSON Format": "unchecked",
}

The AWS EMR job object uses the following parameters :

{
   "EditorId": "e-DJJ0HFJKU71I9DWX8GJAOH734",
   "RelativePath": "ShowWaitingAndRunningClustersTest2.ipynb",
   "NotebookExecutionName":"Tests",
   "ExecutionEngine": {
      "Id": "j-AR2G6DPQSGUB"
   },
   "ServiceRole": "EMR_Notebooks_DefaultRole"
}

Job:AWSEC2

The following example shows how to define a job that performs operations on an AWS EC2 Virtual Machine (VM).

To deploy and run an AWS EC2 job, ensure that you have installed the AWS EC2 plug-in using the provision image command or the provision agent::update command.

}
"AWSEC2_create": {
   "Type": "Job:AWSEC2",
   "ConnectionProfile": "AWSEC2",
   "Operations": "Create",
   "Placement Availability Zone": "us-west-2c",
   "Instance Type": "m1.small",
   "Subnet ID": "subnet-00aa899a7db25494d",
   "Key Name": "ctm-aws-ec2-key-pair",
   "Get Instances logs": "unchecked"
}

The AWS EC2 job object uses the following parameters :

Job:AWS ECS

The following example shows how to define an AWS ECS job. AWS Elastic Container Service (ECS) is a container management service that enables you to run, stop, manage, and monitor containerized applications in a cluster.

To deploy and run an AWS ECS job, ensure that you have installed the AWS ECS plug-in using the provision image command or the provision agent::update command.

The following example defines an AWS ECS job using parameters that are preset in Control-M:

"AWS ECS_Job_1": {
   "Type": "Job:AWS ECS",
   "ConnectionProfile": "ECS",
   "Action": "Preset Json",
   "ECS Cluster Name": "ECSIntegrationCluster",
   "ECS Task Definition": "ECSIntegrationTask",
   "Launch Type": "FARGATE",
   "Assign Public IP": "True",
   "Network Security Groups": "\"sg-01e4a5bfac4189d10\"",
   "Network Subnets": "\"subnet-045ddaf41d4852fd7\", \"subnet-0b574cca721d462dc\", \"subnet-0e108b6ba4fc0c4d7\"",
   "Override Container": "IntegrationURI",
   "Override Command": "\"/bin/sh -c 'whoami'\"",
   "Environment Variables": "{\"name\": \"var1\", \"value\": \"1\"}",
   "Logs": "Get Logs",
   "Status Polling Frequency":"10",
   "Failure Tolerance":"5"
}

In the following example, various job parameters are provided through a submitted JSON body:

"AWS ECS_Job_2": {
   "Type": "Job:AWS ECS",
   "ConnectionProfile": "ECS",
   "Action": "Manual Json",
   "Parameters":{"cluster":"ECSIntegrationCluster","launchType":"FARGATE","networkConfiguration":{"awsvpcConfiguration":{"assignPublicIp":"ENABLED","securityGroups":["sg-01e4a5bfac4189d10"],"subnets":["subnet-045ddaf41d4852fd7","subnet-0b574cca721d462dc","subnet-0e108b6ba4fc0c4d7"]}},"overrides":{"containerOverrides":[{"command":["/bin/sh -c 'whoami'"],"environment":[{"name":"var1","value":"hello"}],"name":"IntegrationURI"}]},"taskDefinition":"ECSIntegrationTask"},
   "Logs": "Get Logs",
   "Status Polling Frequency":"10",
   "Failure Tolerance":"5"
}

The AWS ECS job object uses the following parameters:

Job:AWS Step Functions

The following example shows how to define an AWS Step Functions job that you can use to create visual workflows that can integrate other AWS services. 

To deploy and run an AWS Step Functions job, ensure that you have installed the AWS Step Functions plug-in using the provision image command or the provision agent::update command.

"AWS Step Functions_Job_2": {
    "Type": "Job:AWS Step Functions",
    "ConnectionProfile": "STEPFUNCTIONSCCP",
    "Execution Name": "Step Functions Exec",
    "State Machine ARN": "arn:aws:states:us-east-1:155535555553:stateMachine:MyStateMachine",
    "Parameters": "{\\\"parameter1\\\":\\\"value1\\\"}",
    "Show Execution Logs": "checked",
    "Status Polling Frequency":"10",
    "Failure Tolerance":"2"
}

The AWS Step Functions job object uses the following parameters:

Job:AWS QuickSight

The following example shows how to define an AWS QuickSight job that you can use to visualize, analyze, and share large workloads of data. 

To deploy and run an AWS QuickSight job, ensure that you have installed the AWS QuickSight plug-in using the provision image command or the provision agent::update command.

"AWS QuickSight_Job_2": {
    "Type": "Job:AWS QuickSight",
    "ConnectionProfile": "QUICKSIGHT",
    "AWS Dataset ID": "f351ce9e-1500-4291-b0e1-78b2d6f48861",
    "Refresh Type": "Full Refresh",
    "Status Polling Frequency": "30",
    "Failure Tolerance": "2"
}

The AWS QuickSight job object uses the following parameters:

Job:AWS Sagemaker

The following example shows how to define an AWS SageMaker job, which enables you to create and manage machine learning models.

To deploy and run an AWS SageMaker job, ensure that you have installed the AWS SageMaker plug-in using the provision image command or the provision agent::update command.

"AWS Sagemaker_Job": {
   "Type": "Job:AWS Sagemaker",
   "ConnectionProfile": "AWSSAGEMAKER",
   "Pipeline Name": "SageMaker_Pipeline",
   "Idempotency Token": "Token_Control-M_for_SageMaker%%ORDERID",
   "Add Parameters": "checked",
   "Parameters": "{"Name":"string1", "value":"string2"}",
   "Retry Pipeline Execution": "checked",
   "Pipeline Execution ARN": "arn:aws:sagemaker:us-east-1:122343283363:pipeline/test-123-p-ixxyfil39d9o/execution/4tl5r9q0ywpw",
   "Status Polling Frequency": "30",
   "Failure Tolerance": "2"
}

The AWS Sagemaker job object uses the following parameters:

Job:AWS Athena

The following example shows how to define an AWS Athena job, which enables you to process, analyze, and store your data in the cloud.

To deploy and run an AWS Athena job, ensure that you have installed the AWS Athena plug-in using the provision image command or the provision agent::update command.

The following example shows a job that executes a SQL-based query:

"AWS Athena_Job_2": {
   "Type": "Job:AWS Athena",
   "ConnectionProfile": "AWSATHENA",
   "Athena Client Request Token": "aws-athena-client-request-token-%%ORDERID-%%TIME",
   "DB Catalog Name": "DB_Catalog_Athena",
   "Database Name": "DB_Athena",
   "Action": "Query",
   "Query": "Select * from Athena_Table",
   "Output Location": "s3://{BucketPath}",
   "Workgroup": "Primary",
   "Add Configurations": "checked",
   "S3 ACL Option": "BUCKET_OWNER_FULL_CONTROL",
   "Encryption Options": "SSE_KMS",
   "KMS Key": "arn:aws:kms:us-west-2:123456789012:key/abcd1234-5678-9012-efgh-ijklmnopqrst",
   "Bucket Owner": "Account_ID",
   "Show JSON Output": "unchecked",
   "Status Polling Frequency": "10",
   "Tolerance": "2"
}

The AWS Athena job object uses the following parameters:

Job:AWS Mainframe Modernization

The following examples show how to define an AWS Mainframe Modernization job, which enables you to migrate, manage, and run mainframe applications in the AWS cloud.

To deploy and run an AWS Mainframe Modernization job, ensure that you have installed the AWS Mainframe Modernization plug-in using the provision image command or the provision agent::update command.

The following example shows a job that executes a batch job for an application:

"AWS Mainframe Modernization_batch_job": {
    "Type": "Job:AWS Mainframe Modernization",
    "ConnectionProfile": "AWS_MAINFRAME",
    "Application Name": "Demo",
    "Action": "Start Batch Job",
    "JCL Name": "DEMO.JCL",
    "Retrieve CloudWatch Logs": "checked",
	"Status Polling Frequency": "15",
	"Tolerance": "3"
}

The following example shows a job that deploys the newest version of an application:

"AWS Mainframe Modernization_deploy_app": {
    "Type": "Job:AWS Mainframe Modernization",
    "ConnectionProfile": "AWS_MAINFRAME",
    "Application Name": "Demo",
    "Action": "Application Management",
    "Application Action": "Deploy Application",
    "Client Token": "Token_Mainframe_%%ORDERID",
    "Application Version": "1",
    "Environment ID": "sdfywxdeg4wer238634",
	"Status Polling Frequency": "15",
	"Tolerance": "3"
}

Job:AWS CloudFormation

The following example shows how to define an AWS CloudFormation job, which enables you to create, configure, test, and manage your AWS infrastructure (a collection of AWS services and resources).

To deploy and run an AWS CloudFormation job, ensure that you have installed the AWS CloudFormation plug-in using the provision image command or the provision agent::update command.

"AWS CloudFormation_Job": {
    "Type": "Job:AWS CloudFormation",
    "ConnectionProfile": "CLOUDFORMATION",
    "Action": "Update Stack",
    "Stack Name": "Demo",
    "Stack Parameters": "Template URL",
    "Template URL": "https://ayatest.s3.amazonaws.com/dynamodbDemo.yml",
    "Template Body": "",
    "Role ARN": "arn:aws:iam::12343567890:role/AWS-QuickSetup-StackSet-Local-AdministrationRole",
    "Capabilities Type": "Capability Named IAM",
    "Enable Termination Protection": "unchecked",
    "On Failure": "Delete",
    "Status Polling Frequency": "15",
    "Failure Tolerance": "2",
}

AWSTemplateFormatVersion: 2010-09-09
Resources:
  OrdersTable:
    Type: AWS::DynamoDB::Table
    Properties:
      TableName: AuthorsTable_prod_Tt
      AttributeDefinitions:
        - AttributeName: "AuthorName"
          AttributeType: "S"
        - AttributeName: "BookTitle"
          AttributeType: "S"
      KeySchema:
        - AttributeName: "AuthorName"
          KeyType: "HASH"
        - AttributeName: "BookTitle"
          KeyType: "RANGE"
      TimeToLiveSpecification:
        AttributeName: "ExpirationTime"
        Enabled: true
      ProvisionedThroughput:
        ReadCapacityUnits: "10"
        WriteCapacityUnits: "5"
    DependsOn:
      - DynamoDBQueryPolicy
  DynamoDBQueryPolicy:
    Type: "AWS::IAM::Policy"
    Properties:
      PolicyName: DynamoDBQueryPolicy
      PolicyDocument:
        Version: "2012-10-17"
        Statement:
          - Effect: "Allow"
            Action: "dynamodb:Query"
            Resource: "*"
      Roles:
        - Ref: "OrdersTableQueryRole"
  OrdersTableQueryRole:
    Type: "AWS::IAM::Role"
    Properties:
      AssumeRolePolicyDocument:
        Version: "2012-10-17"
        Statement:
          - Effect: "Allow"
            Principal:
              Service:
                - "dynamodb.amazonaws.com"
            Action:
              - "sts:AssumeRole"
      Path: "/"

_{Back to top}

Job:Azure

The Azure job type enables you to automate workflows that include a select list of Azure services. To manage Azure-type jobs, you must have the Azure plug-in installed.

The following JSON objects are available for creating Azure-type jobs:

• Job:Azure:Function
• Job:Azure:LogicApps
• Job:Azure:BatchAccount

Additional job types are provided for the following Azure services. To support these job types, you must have installed the relevant plug-ins using the provision image command or the provision agent::update command.

• Job:ADF (Azure Data Factory)
• Job:Azure Databricks
• Job:AzureFunctions
• Job:Azure Batch Accounts

• Job:Azure Logic Apps

• Job:Azure Machine Learning
• Job:Azure Synapse
• Job:Azure HDInsight

• Job:Azure VM

• Job:Azure Backup
• Job:Azure Resource Manager

Job:Azure:Function

The following example shows how to define a job that executes an Azure function service.

"AzureFunctionJob": {
  "Type": "Job:Azure:Function",
  "ConnectionProfile": "AZURE_CONNECTION",
  "AppendLog": false,
  "Function": "AzureFunction",
  "FunctionApp": "AzureFunctionApp",
  "Parameters": [
      {"firstParamName": "firstParamValue"},
	  {"secondParamName": "secondParamValue"}
  ]
}

This Azure job object uses the following parameters :

Job:Azure:LogicApps

The following example shows how to define a job that executes an Azure Logic App service.

"AzureLogicAppJob": {
  "Type": "Job:Azure:LogicApps",
  "ConnectionProfile": "AZURE_CONNECTION",
  "LogicAppName": "MyLogicApp",
  "RequestBody": "{\\n  \"name\": \"BMC\"\\n}",
  "AppendLog": false
}

This Azure job object uses the following parameters :

Job:Azure:BatchAccount

The following example shows how to define a job that executes an Azure Batch Account service.

"AzureBatchJob": {
  "Type": "Job:Azure:BatchAccount",
  "ConnectionProfile": "AZURE_CONNECTION",
  "JobId": "AzureJob1",
  "CommandLine": "echo \"Hello\"",
  "AppendLog": false,
  "Wallclock": {
    "Time": "770",
    "Unit": "Minutes"
  },
  "MaxTries": {
    "Count": "6",
    "Option": "Custom"
  },
  "Retention": {
    "Time": "1",
    "Unit": "Hours"
  }
}

This Azure job object uses the following parameters :

  Job:ADF

The following example shows how to define a job that executes an Azure Data Factory (ADF) service, a cloud-based ETL and data integration service that allows you to create data-driven workflows to automate the movement and transformation of data.

To deploy and run an ADF job, ensure that you have installed the ADF plug-in using the provision image command or the provision agent::update command.

"AzureDataFactoryJob": {
      "Type": "Job:ADF",
      "ConnectionProfile": "DataFactoryConnection",
      "Resource Group Name": "AzureResourceGroupName",
      "Data Factory Name": "AzureDataFactoryName",
      "Pipeline Name": "AzureDataFactoryPipelineName",
      "Parameters": "{\"myVar\":\"value1\", \"myOtherVar\": \"value2\"}",
      "Status Polling Frequency": "20",
      "Failure Tolerance": "3"
}

The ADF job object uses the following parameters :

Job:Azure Databricks

The following example shows how to define a job that executes the Azure Databricks service, a cloud-based data analytics platform that enables you to process large workloads of data.

To deploy and run an Azure Databricks job, ensure that you have installed the Azure Databricks plug-in using the provision image command or the provision agent::update command.

"Azure Databricks notebook": {
      "Type": "Job:Azure Databricks",
      "ConnectionProfile": "AZURE_DATABRICKS",
      "Databricks Job ID: "65",
      "Parameters": "\"notebook_params\":{\"param1\":\"val1\", \"param2\":\"val2\"}",
      "Idempotency Token": "Control-M-Idem_%%ORDERID",
      "Status Polling Frequency": "30"
}

The Azure Databricks job object uses the following parameters :

Job:AzureFunctions

The following example shows how to define a job that executes a cloud-based Azure Function for serverless application development.

To deploy and run an Azure Functions job, ensure that you have installed the Azure Functions plug-in using the provision image command or the provision agent::update command.

"AzureFunction": {
      "Type": "Job:AzureFunctions", 
      "ConnectionProfile": "AZUREFUNCTIONS", 
      "Function App": "new-function", 
      "Function Name": "Hello", 
      "Optional Input Parameters": "\"{\"param1\":\"val1\", \"param2\":\"val2\"}\"",
      "Function Type":"activity",
      "Status Polling Frequency": "20",
      "Failure Tolerance": "2"
}

The Azure Functions job object uses the following parameters :

Job:Azure Batch Accounts

The following example shows how to define a job that executes cloud-based Azure Batch Accounts for large-scale compute-intensive tasks.

To deploy and run an Azure Batch Accounts job, ensure that you have installed the Azure Batch Accounts plug-in using the provision image command or the provision agent::update command.

"Azure Batch Accounts_Job_2": {
  "Type": "Job:Azure Batch Accounts",
  "ConnectionProfile": "AZURE_BATCH",
  "Batch Job ID": "abc-jobid",
  “Task ID Prefix”: "ctm",
  "Task Command Line": "cmd /c echo hello from Control-M",
  "Max Wall Clock Time": "Custom",
  "Max Wall Time Digits": "3",
  "Max Wall Time Unit": "Minutes",
  "Max Task Retry Count": "Custom",
  "Retry Number": "3",
  "Retention Time": "Custom",
  "Retention Time Digits": "4",
  "Retention Time Unit": "Days",
  "Append Log to Output": "checked",
  "Status Polling Interval": "20"
  }

The Azure Batch Accounts job object uses the following parameters :

Job:Azure Logic Apps

The following example shows how to define a job that executes an Azure Logic Apps service, which enables you to design and automate cloud-based workflows and integrations.

To deploy and run an Azure Logic Apps job, ensure that you have installed the Azure Logic Apps plug-in using the provision image command or the provision agent::update command.

"Azure Logic Apps Job": {
	"Type": "Job:Azure Logic Apps",
	"ConnectionProfile": "AZURE_LOGIC_APPS",
	"Workflow": "tb-logic",
	"Parameters": "{\"bodyinfo\":\"hello from CM\",\"param2\":\"value2\"}",
	"Get Logs": "unchecked",
	"Status Polling Frequency": "20",
 	"Failure Tolerance": "2" 
}

This Azure job object uses the following parameters :

Job:Azure Machine Learning

The following example shows how to define an Azure Machine Learning job, which enables you to create and manage machine learning models.

To deploy and run an Azure Machine Learning job, ensure that you have installed the Azure Machine Learning plug-in using the provision image command or the provision agent::update command.

The following example shows a job for a Compute Management action:

"Azure Machine Learning_Job": {
   "Type": "Job:Azure Machine Learning",
   "ConnectionProfile": "AZURE_ML",
   "Workspace Name": "testML2",
   "Resource Group Name": "My_Resource_Group",
   "Action": "Compute Management",
   "Compute Name": "Compute_Name",
   "Compute Action": "Stop",
   "Status polling interval": "20",
   "Failure Tolerance": "2"
}

The following example shows a job for triggering an endpoint pipeline:

"Azure Machine Learning_Job_2": {
   "Type": "Job:Azure Machine Learning",
   "ConnectionProfile": "AZURE_ML",
   "Workspace Name": "testML2",
   "Resource Group Name": "My_Resource_Group",
   "Action": "Trigger Endpoint Pipeline",
   "Pipeline Endpoint Id": "353c4707-fd23-40f6-91e2-83bf7cba764c",
   "Parameters": "{"ExperimentName":"test", "DisplayName":"test1123"}",
   "Status polling interval": "20",
   "Failure Tolerance": "2"
}

The Azure Machine Learning job object uses the following parameters :

Job:Azure Synapse

The following example shows how to define a job that performs data integration and analytics using the Azure Synapse Analytics service.

To deploy and run an Azure Synapse job, ensure that you have installed the Azure Synapse plug-in using the provision image command or the provision agent::update command.

"Azure Synapse_Job": {
    "Type": "Job:Azure Synapse",
    "ConnectionProfile": "AZURE_SYNAPSE",
    "Pipeline Name": "ncu_synapse_pipeline",
    "Parameters": "{\"periodinseconds\":\"40\", \"param2\":\"val2\"}",
    "Status Polling Interval": "20"
}

The Azure Synapse job object uses the following parameters :

Job:Azure HDInsight 

The following example shows how to define a job that collaborates with Azure HDInsight to run an Apache Spark batch job for big data analytics. 

To deploy and run an Azure HDInsight job, ensure that you have installed the Azure HDInsight plug-in using the provision image command or the provision agent::update command.

"Azure HDInsight_Job": {
    "Type": "Job:Azure HDInsight",
    "ConnectionProfile": "AZUREHDINSIGHT",
    "Parameters": "{  
	   "file" : "wasb://<BlobStorageContainerName>@<StorageAccountName>.blob.core.windows.net/sample.jar", 
	   "args" : ["arg0", "arg1"], 
	   "className" : "com.sample.Job1", 
	   "driverMemory" : "1G", 
	   "driverCores" : 2, 
	   "executorMemory" : "1G", 
	   "executorCores" : 10,
	   "numExecutors" : 10
     }",
    "Status Polling Interval": "10",
    "Bring job logs to output": "checked" 
}

The Azure HDInsight job object uses the following parameters:

Job:Azure VM

The following example shows how to define a job that performs operations on an Azure Virtual Machine (VM).

To deploy and run an Azure VM job, ensure that you have installed the Azure VM plug-in using the provision image command or the provision agent::update command.

"Azure VM_update": {
    "Type": "Job:Azure VM",
    "ConnectionProfile": "AZUREVM",
    "VM Name": "tb-vm1",
    "Operation": "Create\\Update",
    "Input Parameters": "{\"key\": \"val\"}", 
    "Get Logs": "checked",
    "Verification Poll Interval": "10",
    "Tolerance": "3"
}

The Azure VM job object uses the following parameters :

Job:Azure Backup

The following examples show how to define an Azure Backup job, which enables you to back up and restore your data in the Microsoft Azure cloud.

To deploy and run an Azure Backup job, ensure that you have installed the Azure Backup plug-in using the provision image command or the provision agent::update command.

The following example shows a job for a Backup action:

"Azure Backup_Job": {
   "Type": "Job:Azure Backup",
   "ConnectionProfile": " ABK_CCP_SERVICE_PRINCIPAL",
   "Action": "Backup",
   "Vault Resource Group": "ncu-if",
   "Vault Name": "Test",
   "VM Resource Group": "ncu-if",
   "VM Name": "ncu-if-squid-proxy",
   "Policy Name": "DefaultPolicy", 
   "Include Or Exclude Disks": "Include",
   "Disk List": "0,1,2",
   "Status Polling Frequency": "300",
   "Failure Tolerance": "2" 
}

The following example shows a job for a Restore action:

"Azure Backup_restore": {
   "Type": "Job:Azure Backup",
   "ConnectionProfile": " ABK_CCP_SERVICE_PRINCIPAL ",
   "Action": "Restore From Backup",
   "Vault Resource Group": "ncu-if",
   "Vault Name": "Test",
   "VM Resource Group": "ncu-if",
   "VM Name": "ncu-if-squid-proxy",
   "Restore to Latest Recovery Point": "checked",
   "Recovery Point Name": "123245428486171",
   "Storage Account Name": "stasaccount",
   "Restore Region": "UK South",
   "Disk List": "0,1,2", 
   "Status Polling Frequency": "300",
   "Failure Tolerance": "2" 
}

The Azure Backup job object uses the following parameters:

Job:Azure Resource Manager

The following example shows how to define an Azure Resource Manager job, which enables you to create, configure, test, and manage your Azure resources infrastructure.

To deploy and run an Azure Resource Manager job, ensure that you have installed the Azure Resource Manager plug-in using the provision image command or the provision agent::update command.

"Azure Resource Manager_Job_2": {
    "Type": "Job:Azure Resource Manager",
    "ConnectionProfile": "AZURE_RESOURCE_MANAGER",
    "Action": "Create Deployment",
    "Resource Group Name": "my_Resource_Group",
    "Deployment Name": "Demo",
    "Deployment Properties": "{
        "properties": {
              "templateLink": {
                  "uri": "https://123.blob.core.windows.net/test123/123.json?sp=r&st=2023-05-23T08:39:09Z&se=2023-06-10T16:39:09Z&sv=2022-11-02&sr=b&sig=RqrATxi4Sic2UwQKFu%2FlwaQS7fg5uPZyJCQiWX2D%2FCc%3D",
              "queryString": "sp=r&st=2023-05-23T08:39:09Z&se=2023-06-10T16:39:09Z&sv=2022-11-02&sr=b&sig=RqrATxi4Sic2UwQKFu%2FlwaQS7fg5uPZyJCQiWX2D%1234"
              },
        "parameters": {},
        "mode": "Incremental"
        }
    }",
    "Failure Tolerance": "2",
    "Status Polling Frequency": "15"
}

The Azure Resource Manager job object uses the following parameters :

_{Back to top}

Job:Web Services REST

The following examples shows how to define a Web Services REST job, which enables you to design and execute a single REST API call.

To deploy and run an Web Services REST job, ensure that you have installed the Web Services REST plug-in using the provision image command or the provision agent::update command.

"Web Services REST_output_parameters": {
    "Type": "Job:Web Services REST",
    "ConnectionProfile": "REST_OAUTH2",
    "Method": "POST",
    "Append Request": "checked",
    "Append Response": "checked",
    "Endpoint URL": "https://6943019930999707.net",
    "URL Request Path": "/api/2.1/jobs/run-now",
    "Variables": [
      {
        "UCM-BODY_REQ_TYPE": "text"
      },
      {
        "UCM-BODY_BODY_REQUEST": "{%4E  \"job_id\": 298,%4E   \"params\":{}%4E}"
      },
      {
        "UCM-HEADERS_KEY_001": "Authorization"
      }
    ],
    "OutputHandling": [
      {
        "HttpCode": "*",
        "Parameter": "$.run_id",
        "Variable": "file:/home/dbauser/temp.txt"
      },
      {
        "HttpCode": "*",
        "Parameter": "$.run_id",
        "Variable": "LOCAL_CTM_VAR"
      },
      {
        "HttpCode": "*",
        "Parameter": "$.run_id",
        "Variable": "\\GLOBAL_CTM_VAR"
      }
    ]
}

_{Back to top}

Job:Web Services SOAP

The following example shows how to define a Web Services SOAP job, which enables you to design and execute a single SOAP API call.

To deploy and run an Web Services SOAP job, ensure that you have installed the Web Services SOAP plug-in using the provision image command or the provision agent::update command.

"Web Services SOAP_Job_2": {
    "Type": "Job:Web Services SOAP",
    "ConnectionProfile": "SOAP_BASIC_AUTH",
    "Endpoint URL": "http://vw-usr1:8091/ws/register",
    "Append Request": "unchecked",
    "Append Response": "unchecked",
    "SOAP Action": "http://www.bmc.com/ctmem/#register",
    "Variables": [
      {
        "UCM-SOAP_REQUEST_REQ_TYPE": "xml"
      },
      {
        "UCM-SOAP_REQUEST_SOAP_REQUEST": "<soapenv:Envelope xmlns:soapenv=\"http://schemas.xmlsoap.org/soap/envelope/\" xmlns:sch=\"http://www.bmc.com/ctmem\">%4E   <soapenv:Header/>%4E   <soapenv:Body>%4E      <sch:request_register>%4E         <!--Optional:-->%4E         <sch:component>?</sch:component>%4E         <sch:user_name>?</sch:user_name>%4E         <sch:password>?</sch:password>%4E         <sch:timeout>?</sch:timeout>%4E         <!--Optional:-->%4E         <sch:hostname>?</sch:hostname>%4E      </sch:request_register>%4E   </soapenv:Body>%4E</soapenv:Envelope>"
      }
    ],
    "OutputHandling": [
      {
        "HttpCode": "200",
        "Parameter": "//sch:error_message",
        "Variable": "CTM_VAR_RESULT"
      },
      {
        "HttpCode": "200",
        "Parameter": "//sch:error_message",
        "Variable": "file:/home/dbauser/soap_result.txt"
      }
    ],
}

<operation name="AddInteger">
<soap:operation soapAction="http://tempuri.org/SOAP.Demo.AddInteger"
 style="document"/>

<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/"
 xmlns:tem="http://tempuri.org">
<soapenv:Header/>
<soapenv:Body>
<tem:AddInteger>
<!-Optional:->
<tem:Arg1>1</tem:Arg1>
<!-Optional:->
<tem:Arg2>2</tem:Arg2>
</tem:AddInteger>
</soapenv:Body>
</soapenv:Envelope>

_{Back to top}

Job:SLAManagement

SLA Management jobs enable you to identify a chain of jobs that comprise a critical service and must complete by a certain time. The SLA Management job is always defined as the last job in the chain of jobs.

To manage SLA Management jobs, you must have the SLA Management add-on (previously known as Control-M Batch Impact Manager) installed in your Control-M environment.

The following example shows the JSON code of a simple chain of jobs that ends with an SLA Management job. In this chain of jobs:

• The first job is a Command job that prints Hello and then adds an event named Hello-TO-SLA_Job_for_SLA-GOOD.
  
• The second (and last) job is an SLA Management job for a critical service named SLA-GOOD. This job waits for the event added by the first job and then deletes it.
  

{
  "SLARobotTestFolder_Good": {
    "Type": "SimpleFolder",
    "ControlmServer": "IN01",
    "Hello": {
      "Type": "Job:Command",
      "CreatedBy": "emuser",
      "RunAs": "controlm",
      "Command": "echo \"Hello\"",
      "eventsToAdd": {
        "Type": "AddEvents",
        "Events": [
          {
            "Event": "Hello-TO-SLA_Job_for_SLA-GOOD"
          }
        ]
      }
    },
    "SLA": {
      "Type": "Job:SLAManagement",
      "ServiceName": "SLA-GOOD",
      "ServicePriority": "1",
      "CreatedBy": "emuser",
      "RunAs": "DUMMYUSR",
      "JobRunsDeviationsTolerance": "2",
      "CompleteIn": {
        "Time": "00:01"
      },
      "eventsToWaitFor": {
        "Type": "WaitForEvents",
        "Events": [
          {
            "Event": "Hello-TO-SLA_Job_for_SLA-GOOD"
          }
        ]
      },
      "eventsToDelete": {
        "Type": "DeleteEvents",
        "Events": [
          {
            "Event": "Hello-TO-SLA_Job_for_SLA-GOOD"
          }
        ]
      }
    }
  }
}

The following table lists the parameters that can be included in an SLA Management job:

      "AverageRunTimeTolerance": {
        "Units": "Percentage",
        "AverageRunTime": "94"

      "AverageRunTimeTolerance": {
        "Units": "Minutes",
        "AverageRunTime": "10"

     "CompleteBy": {
       "Time": "23:51",
       "Days": "3"
     }

      "CompleteIn": {
        "Time": "15:21"
      }

Service Actions

The following example demonstrates a series of Service Actions that are triggered in response to specific occurrences (If statements). Note that this example includes only a select group of If statements and a select group of actions; for the full list, see the tables that follow.

      "ServiceActions": {
        "If:SLA:ServiceIsLate_0": {
          "Type": "If:SLA:ServiceIsLate",
          "Action:SLA:Notify_0": {
            "Type": "Action:SLA:Notify",
            "Severity": "Regular",            
            "Message": "this is a message"    
          },
          "Action:SLA:Mail_1": {
            "Type": "Action:SLA:Mail",
            "Email": "email@okmail.com",       
            "Subject": "this is a subject",   
            "Message": "this is a message"    
        },
        "If:SLA:JobFailureOnServicePath_1": {
          "Type": "If:SLA:JobFailureOnServicePath",
          "Action:SLA:Order_0": {
            "Type": "Action:SLA:Order",       
            "Server": "IN01",        
            "Folder": "folder",               
            "Job": "job",                     
            "Date": "OrderDate",              
            "Library": "library"              
          }
        },
        "If:SLA:ServiceEndedNotOK_5": {
          "Type": "If:SLA:ServiceEndedNotOK",
          "Action:SLA:Set_0": {
            "Type": "Action:SLA:Set",
            "Variable": "varname",            
            "Value": "varvalue"               
          },
          "Action:SLA:Increase_2": {
            "Type": "Action:SLA:Increase",
            "Time": "04:03"                  
          }
        },
        "If:SLA:ServiceLatePastDeadline_6": {
          "Type": "If:SLA:ServiceLatePastDeadline",
          "Action:SLA:Event:Add_0": {
            "Type": "Action:SLA:Event:Add",
            "Server": "IN01",        
            "Name": "addddd",                 
            "Date": "AnyDate"          
        }

The following If statements can be used to define occurrences for which you want to take action:

For each If statement, you define one or more actions to be triggered. The following table lists the available Service Actions:

_{Back to top}

Job:UI Path

The following example shows how to define a UiPath job, which performs robotic process automation (RPA).

To deploy and run a UiPath job, ensure that you have installed the UiPath plug-in using the provision image command or the provision agent::update command.

"UI Path_Job": {
  "Type": "Job:UI Path",
  "ConnectionProfile": "UIPATH_Connect",
  "Folder Name": "Default",
  "Folder Id": "374999",
  "Process Name": "control-m-process",
  "packagekey": "209c467e-1704-4b6y-b613-6c5a2c9acbea",
  "Robot Name": "abc-ctm-bot",
  "Robot Id": "153999",
  "Optional Input Parameters": "{
     "parm1": "Value1",
     "parm2": "Value2", 
     "parm3": "Value3"
     }",
  "Status Polling Frequency": "30",
  "Host": "host1"
  }

The UiPath job object uses the following parameters :

_{Back to top}

Job:Automation Anywhere

The following example shows how to define an Automation Anywhere job, which performs robotic process automation (RPA).

To deploy and run an Automation Anywhere job, ensure that you have installed the Automation Anywhere plug-in using the provision image command or the provision agent::update command.

"Automation Anywhere_Job_2": {
  "Type": "Job:Automation Anywhere",
  "ConnectionProfile": "AACONN",
  "Automation Type": "Bot",
  "Bot to run": "bot123",
  "Bot Input Parameters": "{
	"Param1":{
	   "type": "STRING",
	   "string": "Hello world"
	   },
	"NumParam":{
	   "type": "NUMBER",
	   "integer": 11
	   }
	},
  "Connection timeout": 10,
  "Status Polling Frequency": 5
}

The Automation Anywhere job object uses the following parameters :

_{Back to top}

Job:DBT

The following example shows how to define a DBT job. DBT (Data Build Tool) job is a cloud-based computing platform that enables you to develop, test, schedule, document, and analyze data models. 

To deploy and run a DBT job, ensure that you have installed the DBT plug-in using the provision image command or the provision agent::update command.

"DBT_Job_2": { 
   "Type": "Job:DBT", 
   "ConnectionProfile": "DBT_CP", 
   "DBT Job Id": "12345",
   "Run Comment": "A DBT job",
   "Override Job Commands": "checked", 
   "Variables": [ 
      { 
         "UCM-DefineCommands-N001-element": "dbt test" 
      }, 
      { 
         "UCM-DefineCommands-N002-element": "dbt run" 
      } 
   ],
   "Status Polling Frequency": "10",
   "Failure Tolerance": "2"
}

The DBT job object uses the following parameters:

Job:GCP DataFlow

The following example shows how to define a Google Cloud Platform (GCP) Dataflow job, which performs cloud-based data processing for batch and real-time data streaming applications .

To deploy and run a GCP Dataflow job, ensure that you have installed the GCP Dataflow plug-in using the provision image command or the provision agent::update command.

"GCP DataFlow_Job_1": { 
  "Type": "Job:GCP DataFlow", 
  "ConnectionProfile": "GCPDATAFLOW", 
  "Project ID": "applied-lattice-11111", 
  "Location": "us-central1", 
  "Template Type": "Classic Template", 
  "Template Location (gs://)": "gs://dataflow-templates-us-central1/latest/Word_Count", 
  "Parameters (JSON Format)": { 
    "jobName": "wordcount", 
    "parameters": { 
        "inputFile": "gs://dataflow-samples/shakespeare/kinglear.txt", 
        "output": "gs://controlmbucket/counts" 
        } 
    }
  "Verification Poll Interval (in seconds)": "10", 
  "output Level": "INFO",
  "Host": "host1" 
}

The GCP Dataflow job object uses the following parameters :

_{Back to top}

Job:GCP Dataproc

The following examples show how to define a Google Cloud Platform (GCP) Dataproc job, which performs cloud-based big data processing and machine learning.

To deploy and run a GCP Dataproc job, ensure that you have installed the GCP Dataproc plug-in using the provision image command or the provision agent::update command.

The following example shows a job for a Dataproc task of type Workflow Template:

"GCP Dataproc_Job": {  
  "Type": "Job:GCP Dataproc",
  "ConnectionProfile": "GCPDATAPROC",
  "Project ID": "gcp_projectID",
  "Account Region": "us-central1",
  "Dataproc task type": "Workflow Template",
  "Workflow Template": "Template2",
  "Verification Poll Interval (in seconds)": "20",
  "Tolerance": "2"
}

The following example shows a job for a Dataproc task of type Job:

"GCP Dataproc_Job": { 
      "Type": "Job:GCP Dataproc", 
      "ConnectionProfile": "GCPDATAPROC", 
      "Project ID": "gcp_projectID", 
      "Account Region": "us-central1",  
      "Dataproc task type": "Job", 
      "Parameters (JSON Format)": {
		"job": { 
		  "placement": {}, 
		  "statusHistory": [], 
		  "reference": { 
		  "jobId": "job-e241f6be", 
		  "projectId": "gcp_projectID" 
		   }, 
		  "labels": { 
            "goog-dataproc-workflow-instance-id": "44f2b59b-a303-4e57-82e5-e1838019a812", 
            "goog-dataproc-workflow-template-id": "template-d0a7c" 
           }, 
          "sparkJob": { 
            "mainClass": "org.apache.spark.examples.SparkPi", 
            "properties": {}, 
            "jarFileUris": [ 
               "file:///usr/lib/spark/examples/jars/spark-examples.jar" 
            ], 
            "args": [ 
               "1000" 
            ] 
          } 
       } 
   }
   "Verification Poll Interval (in seconds)": "20",
   "Tolerance": "2" 
} 

The GCP Dataproc job object uses the following parameters :

_{Back to top}

 Job:GCP BigQuery

The following example shows how to define a GCP BigQuery job. GCP BigQuery is a Google Cloud Platform computing service that you can use for data storage, processing, and analysis.

To deploy and run a GCP BigQuery job, ensure that you have installed the GCP BigQuery plug-in using the provision image command or the provision agent::update command.

The following example shows a job for a Query action in GCP BigQuery:

"GCP BigQuery_query": {
	"Type": "Job:GCP BigQuery",
	"ConnectionProfile": "BIGQSA",
	"Action": "Query",
	"Project Name": "proj",
	"Dataset Name": "Test",
	"Run Select Query and Copy to Table": "checked",
	"Table Name": "IFTEAM",
	"SQL Statement": "select user from IFTEAM2",
	"Query Parameters": {
		"name": "IFteam",
		"paramterType": { 
			"type": "STRING"
		},
		"parameterValue": {
			"value": "BMC"
		}
	},
	"Job Timeout": "30000",
	"Connection Timeout": "10",
	"Status Polling Frequency": "5"
}

The GCP BigQuery job object uses the following parameters:

{
	"name": "IFteam",
	"paramterType": { 
		"type": "STRING"
	},
	"parameterValue": {
		"value": "BMC"
	}
}

{ 
	{
		"datasetID": "Test1", 
		"projectID": "SomeProj1",
		"tableID": "IFteam1"
	}
	{
		"datasetID": "Test2", 
		"projectId": "SomepProj2", 
		"tableID": "IFteam2"
	}
}

{ 
  "datasetID": "Test3", 
  "projectID": "SomeProj3", 
  "tableID": "IFteam3" 
}

"schema": 
	{
		"fields": 
		[
			{
				"name": "name1",
				"type": "STRING1"
			}
			{
				"name": "name2",
				"type": "STRING2"
			}
			{
				"name": "name3",
				"type": "STRING3"
			}
		]
	}

Call new_r(‘value1’)

_{Back to top}

Job:GCP VM

The following example shows how to define a job that performs operations on a Google Virtual Machine (VM).

To deploy and run a Google VM job, ensure that you have installed the Google VM plug-in using the provision image command or the provision agent::update command.

"GCP VM_create": {
     "Type": "Job:GCP VM",
     "ConnectionProfile": "GCPVM",
     "Project ID": "applied-lattice",
     "Zone": "us-central1-f",     
     "Operation": "Create",
     "Parameters": "{ \"key\": \"value\"}",
     "Instance Name": "tb-mastercluster-m", 
     "Get Logs": "checked", 
     "Verification Poll Interval": "20",
     "Tolerance": "3"
}

The Google VM job object uses the following parameters :

_{Back to top}

Job:GCP Batch

The following example shows how to define a GCP Batchjob. Google Cloud Platform (GCP) Batch enables you to manage, schedule, and run batch computing workloads on a virtual machine that is provisioned to accommodate your resource and capacity needs.

To deploy and run a Google Batch job, ensure that you have installed the Google Batch plug-in using the provision image command or the provision agent::update command.

"GCP Batch_Job_2": {
   "Type": "Job:GCP Batch",
   "ConnectionProfile": "GCP_BATCH",
   "Project ID": "gcp_projectID",
   "Region": "us-central1",
   "Override Region": "Yes",
   "Allowed Locations": ["zones/us-central1-a", "zones/us-central1-c"],
   "Job Name": "unique",
   "Priority": "99",
   "Runnable Type": "Container",
   "Task Script Text": "echo hello world",
   "Override Commands": "Yes",
   "Commands": "\"echo\",\"hello world\"",
   "CPU": "1500",
   "Memory": "1500",
   "Instance Policy": "Machine Template",
   "Machine Type": "e2-medium",
   "Machine Template": "template-name",
   "Provisioning Model": "Spot",
   "Logs Policy": "Cloud Logging",
   "Use Advanced JSON Format": "unchecked",
   "Status Polling Frequency": "10"
}

The Google Batch job object uses the following parameters :

_{Back to top}

Job:GCP Functions

The following example shows how to define a GCP Functions job, which enables you to develop, test, and run applications in the cloud.

To deploy and run a Google Functions job, ensure that you have installed the Google Functions plug-in using the provision image command or the provision agent::update command.

"GCP Functions_Job": {
    "Type": "Job:GCP Functions",
    "ConnectionProfile": "GCPFUNCTIONS",
    "Project ID": "myProject",
    "Location": "us-central1",
    "Function Name": "myFunction",
    "Function Parameters": "Body",
    "Body": "{\\\"message\\\":\\\"controlm-body-%%ORDERID\\\"}",
    "Status Polling Frequency": "20",
    "Failure Tolerance": "2",
    "Get Logs": "unchecked",
}

The Google Functions job object uses the following parameters:

_{Back to top}

Job:GCP Dataprep

The following example shows how to define a GCP Dataprep job, which enables you to visualize, format, and prepare your data for analysis.

To deploy and run a Google Dataprep job, ensure that you have installed the Google Dataprep plug-in using the provision image command or the provision agent::update command.

"GCP Dataprep_Job": {
   "Type": "Job:GCP Dataprep",
   "ConnectionProfile": "GCP_DATAPREP",
   "Flow Name": "data_manipulation",
   "Parameters": "{schemaDriftOptions":{"schemaValidation": "true","stopJobOnErrorsFound": "true" }}",
   "Execute Job With Idempotency Token": "checked",
   "Idempotency Token": "Control-M-Token-%%ORDERID",
   "Status Polling Frequency": "10",
   "Failure Tolerance": "2"
}

The Google Dataprep job object uses the following parameters:

_{Back to top}

Job:GCP Deployment Manager

The following example shows how to define a GCP Deployment Manager job, which enables you to create, configure, test, and manage your GCP resources infrastructure.

To deploy and run a Google Deployment Manager job, ensure that you have installed the Google Deployment Manager plug-in using the provision image command or the provision agent::update command.

"GCP Deployment Manager_job": {
    "Type": "Job:GCP Deployment Manager",
    "ConnectionProfile": "DEPLOY_MANAGEMENT",
    "Project ID": "applied-lattice-333111",
    "Action": "Create Deployment",
    "Deployment Name": "demo_deployment",
    "Yaml Config Content": "{resources: [{type: compute.v1.instance, name: quickstart-deployment-vm, properties: {zone: us-central1-f, machineType: 'https://www.googleapis.com/compute/v1/projects/applied-lattice-333108/zones/us-central1-f/machineTypes/e2-micro', disks: [{deviceName: boot, type: PERSISTENT, boot: true, autoDelete: true, initializeParams: {sourceImage: 'https://www.googleapis.com/compute/v1/projects/debian-cloud/global/images/family/debian-11'}}], networkInterfaces: [{network: 'https://www.googleapis.com/compute/v1/projects/applied-lattice-333108/global/networks/default', accessConfigs: [{name: External NAT, type: ONE_TO_ONE_NAT}]}]}}]}",
    "Failure Tolerance": "2",
    "Status Polling Frequency": "10"
}

The Google Deployment Manager job object uses the following parameters:

resources:
- type: compute.v1.instance
  name: quickstart-deployment-vm
  properties:
    zone: us-central1-f
    machineType: https://www.googleapis.com/compute/v1/projects/applied-lattice-333108/zones/us-central1-f/
                 machineTypes/f1-micro
    disks:
    - deviceName: boot
      type: PERSISTENT
      boot: true
      autoDelete: true
      initializeParams:
        sourceImage: https://www.googleapis.com/compute/v1/projects/debian-cloud/global/images/family/debian-11
    networkInterfaces:
    - network: https://www.googleapis.com/compute/v1/projects/applied-lattice-333108/global/networks/default
      accessConfigs:
      - name: External NAT
        type: ONE_TO_ONE_NAT
- type: bigquery.v2.dataset
  name: big-query-dataset
  properties:
    datasetReference:
    datasetId:example_id

_{Back to top}

Job:Boomi

The following example shows how to define a Boomi job, which enables the integration of Boomi processes with your existing Control-M workflows.

To deploy and run a Boomi job, ensure that you have installed the Boomi plug-in using the provision image command or the provision agent::update command.

"Boomi_Job_2": {
  "Type": "Job:Boomi",
  "ConnectionProfile": "BOOMI_CCP",
  "Atom Name": "Atom1",
  "Process Name": "New Process",
  "Polling Intervals": "20",
  "Tolerance": "3"
}

The Boomi job object uses the following parameters:

_{Back to top}

Job:Databricks

The following example shows how to define a Databricksjob, which enables the integration of jobs created in the Databricks environment with your existing Control-M workflows.

To deploy and run a Databricks job, ensure that you have installed the Databricks plug-in using the provision image command or the provision agent::update command.

"Databricks_Job": {
  "Type": "Job:Databricks",
  "ConnectionProfile": "DATABRICKS",
  "Databricks Job ID": "91",
  "Parameters": "\"notebook_params\":{\"param1\":\"val1\", \"param2\":\"val2\"}",
  "Idempotency Token": "Control-M-Idem_%%ORDERID", 
  "Status Polling Frequency": "30"
}

The Databricks job object uses the following parameters:

_{Back to top}

Job:Microsoft Power BI

The following examples show how to define a Power BI job, which enables integration of Power BI workflows with your existing Control-M workflows.

To deploy and run a Power BI job, ensure that you have installed the Power BI plug-in using the provision image command or the provision agent::update command.

The following example shows a job for refreshing a dataset in Power BI:

"Microsoft Power BI_Job_2": { 
  "Type": "Job:Microsoft Power BI", 
  "ConnectionProfile": "POWERBI",
  "Dataset Refresh/ Pipeline Deployment": "Dataset Refresh",
  "Workspace Name": "Demo", 
  "Workspace ID": "a7989345-8cfe-44e7-851d-81560e67973f", 
  "Dataset ID": "9976ce6c-e21a-4c33-9b8c-37c8303231cf",
  "Parameters": "{\"type\":\"Full\",\"commitMode\":\"transactional\",\"maxParallelism\":20,\"retryCount\":2}",
  "Connection Timeout": "10", 
  "Status Polling Frequency": "10"
}

The following example shows a job for deploying a Power BI Pipeline from dev to test to production:

"Microsoft Power BI_Job_2": { 
  "Type": "Job:Microsoft Power BI", 
  "ConnectionProfile": "POWERBI",
  "Dataset Refresh/ Pipeline Deployment": "Pipeline Deployment",
  "Pipeline ID": "83f36385-4e38-43g4-8263-10aa12e3175c",
  "Connection Timeout": "10", 
  "Status Polling Frequency": "10"
}

The Power BI job object uses the following parameters:

{
  "type":"Defragment",
  "commitMode":"transactional",
  "maxParallelism":20,
  "retryCount":2,
  "objects":[
      {"table":"Contributions"},
	  {"table":"Traffic_Popular"}
	]
}

_{Back to top}

Job:Qlik Cloud

The following example shows how to define a Qlik Cloud job, which enables integration with Qlik Cloud Data Services for data visualization through Qlik Sense. 

To deploy and run a Qlik Cloud job , ensure that you have installed the Qlik Cloud plug-in using the provision image command or the provision agent::update command.

"Qlik Cloud_Job": {
  "Type": "Job:Qlik Cloud",
  "ConnectionProfile": "QLIK-TEST",
  "Reload Type": "Full",
  "App Name": "Demo1",
  "Print Log to Output": "Yes",
  "Status Polling Frequency": "10",
  "Tolerance": "2"
}

The Qlik Cloud job object uses the following parameters:

_{Back to top}

Job:Tableau

The following example shows how to define a Tableau job, which enables you to visualize, analyze, and share large workloads of data.

To deploy and run a Tableau job, ensure that you have installed the Tableau plug-in using the provision image command or the provision agent::update command.

"Tableau_Refresh_Datasource": {
    "Type": "Job:Tableau",
    "ConnectionProfile": "TABLEAU_CP",
    "Action": "Refresh Datasource",
    "Datasource Name": "BQ_Dataset",
    "Status Polling Frequency": "10",
    "Failure Tolerance": "2"
}

The Tableau job object uses the following parameters:

_{Back to top}

Job:Snowflake

The following example shows how to define a Snowflake job, which enables integration with Snowflake, a cloud computing platform that you can use for data storage, processing, and analysis. 

To deploy and run a Snowflake job, ensure that you have installed the Snowflake plug-in using the provision image command or the provision agent::update command.

The following example shows a job for a SQL Statement action in Snowflake:

"Snowflake_Job": { 
  "Type": "Job:Snowflake", 
  "ConnectionProfile": "SNOWFLAKE_CONNECTION_PROFILE", 
  "Database": "FactoryDB", 
  "Schema": "Public", 
  "Action": "SQL Statement", 
  "Snowflake SQL Statement": "Select * From Table1", 
  "Statement Timeout": "60", 
  "Show More Options": "unchecked",
  "Show Output": "unchecked",
  "Polling Interval": "20"
}

The Snowflake job object uses the following parameters: