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

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

9.0.21.030The following example provides more definitions for the parameters and return value. This format enables you to use the connection profile to deploy stored procedures without accessing the database during deployment.

{
	"storeFolder": {
		"Type": "Folder",
		"jobStoredProcedure": {
			"Type": "Job:Database:StoredProcedure",
			"Host": "myhost.mycomp.com",
			"StoredProcedure": "myProcedure",
			"Parameters" : [ {
			  "Name" : "table_name",
			  "ParameterType" : "text",
			  "Direction" : "In",
			  "Value": "TestTable"
			}, {
			  "Name" : "chunksize",
			  "ParameterType" : "int4",
			  "Direction" : "Out",
			  "Value": "4"
			}, {
			  "Name" : "rows_deleted",
			  "ParameterType" : "int4",
			  "Direction" : "InOut",
			  "ValueIn" : "1",
			  "ValueOut" : "2"
			} ],
        	"ReturnValue": {
          		"Name" : "returnValue",
          		"ValueType" : "int4",
          		"Value" : "RV"
        	},
			"Schema": "public",
			"ConnectionProfile": "DB-PG-CON"
		}
	}
}

These examples contain the following parameters:

For additional optional parameters, see above.

Job:Database:MSSQL:AgentJob

9.0.19.210 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": "LocalControlM",
        "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

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

{
   "MSSQLFolder": {
       "Type": "Folder",
       "ControlmServer": "LocalControlM",
       "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
• Tajo Input File
• Tajo Query

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:Hadoop:Tajo:InputFile

The following example shows how to execute a Hadoop Tajo job based on an input file.

    "HadoopTajo_InputFile_Job" :
    {
        "Type" : "Job:Hadoop:Tajo:InputFile",
        "ConnectionProfile" : "TAJO_CONNECTION_PROFILE",
        "Host" : "edgenode",
        "FullFilePath" : "/home/user/tajo_command.sh",
        "Parameters" : [
            {"amount":"1000"},
            {"volume":"120"}
        ]
    } 

Additional optional parameters:

_{Back to top}

Job:Hadoop:Tajo:Query

The following example shows how to execute a Hadoop Tajo job based on a query.

    "HadoopTajo_Query_Job" :
    {
        "Type" : "Job:Hadoop:Tajo:Query",
        "ConnectionProfile" : "TAJO_CONNECTION_PROFILE",
        "Host" : "edgenode",
        "OpenQuery" : "SELECT %%firstParamName AS VAR1 \\n FROM DUMMY \\n ORDER BY \\t VAR1 DESC",
    } 

Additional 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 Control-M for SAP plug-in installed in your Control-M environment.

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 in your Control-M environment.

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 Application Integrator.

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 Control-M 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 Control-M for Informatica plug-in installed in your Control-M environment.

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 Control-M Application Integrator plug-in and the Informatica CS plug-in. To install the Informatica CS plug-in, use the provision image command (version 9.0.21 or later) or the deploy jobtype command (versions lower than 9.0.21).

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 Control-M for AWS plug-in installed in your Control-M environment.

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 Control-M Application Integrator plug-in. You must also have installed the relevant AWS plug-in using the provision image command (version 9.0.21 or later) or the deploy jobtype command (versions lower than 9.0.21).

• 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: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 Control-M Application Integrator plug-in and the AWS Batch plug-in. To install the AWS Batch plug-in, use the provision image command (version 9.0.21 or later) or the deploy jobtype command (versions lower than 9.0.21).

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 Control-M Application Integrator plug-in and the AWS Glue plug-in. To install the AWS Glue plug-in, use the provision image command (version 9.0.21 or later) or the deploy jobtype command (versions lower than 9.0.21).

"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 :

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 Control-M Application Integrator plug-in and the AWS Glue DataBrew plug-in. To install the AWS Glue DataBrew plug-in, use the provision image command (version 9.0.21 or later) or the deploy jobtype command (versions lower than 9.0.21).

"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 Control-M Application Integrator plug-in and the AWS Data Pipeline plug-in. To install the AWS Data Pipeline plug-in, use the provision image command (version 9.0.21 or later) or the deploy jobtype command (versions lower than 9.0.21).

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 Control-M Application Integrator plug-in and the AWS EMR plug-in. To install the AWS EMR plug-in, use the provision image command (version 9.0.21 or later) or the deploy jobtype command (versions lower than 9.0.21).

"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 Control-M Application Integrator plug-in and the AWS EC2 plug-in. To install the AWS EC2 plug-in, use the provision image command (version 9.0.21 or later) or the deploy jobtype command (versions lower than 9.0.21).

}
"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 Control-M Application Integrator plug-in and the AWS ECS plug-in. To install the AWS ECS plug-in, use the provision image command (version 9.0.21 or later) or the deploy jobtype command (versions lower than 9.0.21).

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 Control-M Application Integrator plug-in and the AWS Step Functions plug-in. To install the AWS Step Functions plug-in, use the provision image command (version 9.0.21 or later) or the deploy jobtype command (versions lower than 9.0.21).

"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 Control-M Application Integrator plug-in and the AWS QuickSight plug-in. To install the AWS QuickSight plug-in, use the provision image command (version 9.0.21 or later) or the deploy jobtype command (versions lower than 9.0.21).

"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 Control-M Application Integrator plug-in and the AWS SageMaker plug-in. To install the AWS SageMaker plug-in, use the provision image command (version 9.0.21 or later) or the deploy jobtype command (versions lower than 9.0.21).

"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 Control-M Application Integrator plug-in and the AWS Athena plug-in. To install the AWS Athena plug-in, use the provision image command (version 9.0.21 or later) or the deploy jobtype command (versions lower than 9.0.21).

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:

_{Back to top}

Job:Azure

9.0.19.220 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 Control-M for Azure plug-in installed in your Control-M environment.

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 Control-M Application Integrator plug-in. You must also have installed the relevant Azure plug-in using the provision image command (version 9.0.21 or later) or the deploy jobtype command (versions lower than 9.0.21).

• 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: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 Accounts 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 Control-M Application Integrator plug-in and the ADF plug-in. To install the ADF plug-in, use the provision image command (version 9.0.21 or later) or the deploy jobtype command (versions lower than 9.0.21).

"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 Control-M Application Integrator plug-in and the Azure Databricks plug-in. To install the Azure Databricks plug-in, use the provision image command (version 9.0.21 or later) or the deploy jobtype command (versions lower than 9.0.21).

"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 Control-M Application Integrator plug-in and the Azure Functions plug-in. To install the Azure Functions plug-in, use the provision image command (version 9.0.21 or later) or the deploy jobtype command (versions lower than 9.0.21).

"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 Control-M Application Integrator plug-in and the Azure Batch Accounts plug-in. To install the Azure Batch Accounts plug-in, use the provision image command (version 9.0.21 or later) or the deploy jobtype command (versions lower than 9.0.21).

"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 Control-M Application Integrator plug-in and the Azure Logic Apps plug-in. To install the Azure Logic Apps plug-in, use the provision image command (version 9.0.21 or later) or the deploy jobtype command (versions lower than 9.0.21).

"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 Control-M Application Integrator plug-in and the Azure Machine Learning plug-in. To install the Azure Machine Learning plug-in, use the provision image command (version 9.0.21 or later) or the deploy jobtype command (versions lower than 9.0.21).

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 Control-M Application Integrator plug-in and the Azure Synapse plug-in. To install the Azure Synapse plug-in, use the provision image command (version 9.0.21 or later) or the deploy jobtype command (versions lower than 9.0.21).

"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 Control-M Application Integrator plug-in and the Azure HDInsight plug-in. To install the Azure HDInsight plug-in, use the provision image command (version 9.0.21 or later) or the deploy jobtype command (versions lower than 9.0.21).

"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 Control-M Application Integrator plug-in and the Azure VM plug-in. To install the Azure VM plug-in, use the provision image command (version 9.0.21 or later) or the deploy jobtype command (versions lower than 9.0.21).

"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 Control-M Application Integrator plug-in and the Azure Backup plug-in. To install the Azure Backup plug-in, use the provision image command (version 9.0.21 or later) or the deploy jobtype command (versions lower than 9.0.21).

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 :

_{Back to top}

Job:WebServices

9.0.20.220The following examples shows how to define a Web Services job for execution of standard web services, servlets, or RESTful web services. To manage Web Services jobs, you must have the Control-M for Web Services, Java, and Messaging (Control-M for WJM) plug-in installed in your Control-M environment.

The following example presents a Web Services job that receives input for a calculator service and outputs the result of a simple calculation:

"WebServices_Job": {
  "Type": "Job:WebServices",
  "Location": http://www.dneonline.com/calculator.asmx?WSDL,
  "SoapHeaderFile": "c:\\myheader.txt",
  "Service": "Calculator(Port:CalculatorSoap)",
  "Operation": "Add",
  "RequestType": "Parameter",
  "OverrideUrlEndpoint": http://myoverridehost.com,
  "OverrideContentType": "*/*",
  "HttpConnectionTimeout": "2345",
  "PreemptiveHttpAuthentication": abc@bmc.com,
  "IncludeTitleInOutput": true,
  "ExcludeJobOutput": false,
  "ConnectionProfile": "CALCULATOR",
  "Host": "host1",
  "OutputParameters": [
	{
	  "Element": "AddResponse.AddResult",
	  "HttpCode": "*",
	  "Destination": "testResultAdd",
	  "Type": "string"
	}
  ],
  "InputParameters": [
	{
	  "Name": "Add.intA",
	  "Value": "97",
	  "Type": "string"
	},
	{
	  "Name": "Add.intB",
	  "Value": "345",
	  "Type": "string"
	}
  ],
}

The following example presents a Web Services job that receives all input through a SOAP request to a calculator service and outputs the result of a simple calculation:

"WSSoapRequest": {
  "Type": "Job:WebServices",
  "SoapHeaderFile": "c:\\myheader.txt",
  "Location": http://www.dneonline.com/calculator.asmx?WSDL,
  "Service": "Calculator(Port:CalculatorSoap)",
  "Operation": "Add",
  "RequestType": "FreeText",
  "OverrideUrlEndpoint": http://myoverridehost.com,
  "OverrideContentType": "*/*",
  "HttpConnectionTimeout": "2345",
  "PreemptiveHttpAuthentication": abc@bmc.com,
  "IncludeTitleInOutput": true,
  "ExcludeJobOutput": false,
  "ConnectionProfile": "CALCULATOR",
  "Host": "host1",
  "OutputParameters": [
	{
	  "Element": "AddResponse.AddResult",
	  "HttpCode": "*",
	  "Destination": "testResultAdd",
	  "Type": "string"
	}
  ],
  "Request": [
	"<soapenv:Envelope xmlns:soapenv=http://schemas.xmlsoap.org/soap/envelope/ xmlns:tem=http://tempuri.org/>
	   <soapenv:Header/>
	   <soapenv:Body>
		  <tem:Add>
			 <tem:intA>98978</tem:intA>
			 <tem:intB>75675</tem:intB>
		  </tem:Add>
	   </soapenv:Body>
	</soapenv:Envelope>"
  ],
}

The following example presents a Web Services job that receives a SOAP request thorugh an input file. It then uses the input file to submit a SOAP request to a calculator service, and outputs the result of a simple calculation:

"WSSoapRequest_InputFile": {
  "Type": "Job:WebServices",
  "SoapHeaderFile": "c:\\myheader.txt",
  "Location": http://www.dneonline.com/calculator.asmx?WSDL,
  "Service": "Calculator(Port:CalculatorSoap)",
  "Operation": "Add",
  "RequestType": "InputFile",
  "OverrideUrlEndpoint": http://myoverridehost.com,
  "OverrideContentType": "*/*",
  "HttpConnectionTimeout": "2345",
  "PreemptiveHttpAuthentication": abc@bmc.com,
  "IncludeTitleInOutput": true,
  "ExcludeJobOutput": false,
  "ConnectionProfile": "CALCULATOR",
  "Host": "host1",
  "OutputParameters": [
	{
	  "Element": "AddResponse.AddResult",
	  "HttpCode": "*",
	  "Destination": "testResultAdd",
	  "Type": "string"
	}
  ],
  "InputFile": "/home/usr/soap.xml"
}

The following example presents a job that receives input for a calculator REST service and outputs the result of a simple calculation:

"REST_Service_Job": {
  "Type": "Job:WebServices",
  "Location": "http://www.dneonline.com",
  "Service": "/restAPI/calculator.asmx",
  "Operation": "PUT",
  "RequestType": "Parameter",
  "OverrideContentType": "*/*",
  "HttpConnectionTimeout": "2345",
  "PreemptiveHttpAuthentication": abc@bmc.com,
  "IncludeTitleInOutput": true,
  "ExcludeJobOutput": false,
  "ConnectionProfile": "CALCULATOR_REST",
  "Host": "host1",
  "OutputParameters": [
	{
	  "Element": "$AddResponse.AddResult",
	  "HttpCode": "*",
	  "Destination": "testResultAdd",
	  "Type": "string"
	}
  ],
  "InputParameters": [
	{
	  "Name": "intA",
	  "Value": "97",
	  "Type": "string"
	},
	{
	  "Name": "intB",
	  "Value": "345",
	  "Type": "string"
	},
	{
	  "Name": "accept-encoding",
	  "Value": "*/*",
	  "Type": "header"
	}
  ],
}

The Web Services 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 a Web Services REST job, ensure that you have installed the Control-M Application Integrator plug-in and the Web Services REST plug-in. To install the Web Services REST plug-in, use the provision image command (version 9.0.21 or later) or the deploy jobtype command (versions lower than 9.0.21).

"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 a Web Services SOAP job, ensure that you have installed the Control-M Application Integrator plug-in and the Web Services SOAP plug-in. To install the Web Services SOAP plug-in, use the provision image command (version 9.0.21 or later) or the deploy jobtype command (versions lower than 9.0.21).

"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": "LocalControlM",
    "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": "LocalControlM",        
            "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": "LocalControlM",        
            "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 Control-M Application Integrator plug-in and the UiPath plug-in. To install the UiPath plug-in, use the provision image command (version 9.0.21 or later) or the deploy jobtype command (versions lower than 9.0.21).

"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 Control-M Application Integrator plug-in and the Automation Anywhere plug-in. To install the Automation Anywhere plug-in, use the provision image command (version 9.0.21 or later) or the deploy jobtype command (versions lower than 9.0.21).

"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 Control-M Application Integrator plug-in and the DBT plug-in. To install the DBT plug-in, use the provision image command (version 9.0.21 or later) or the deploy jobtype command (versions lower than 9.0.21).

"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 Control-M Application Integrator plug-in and the GCP Dataflow plug-in. To install the GCP Dataflow plug-in, use the provision image command (version 9.0.21 or later) or the deploy jobtype command (versions lower than 9.0.21).

"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 Control-M Application Integrator plug-in and the GCP Dataproc plug-in. To install the GCP Dataproc plug-in, use the provision image command (version 9.0.21 or later) or the deploy jobtype command (versions lower than 9.0.21).

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 Control-M Application Integrator plug-in and the GCP BigQuery plug-in. To install the GCP BigQuery plug-in, use the provision image command (version 9.0.21 or later) or the deploy jobtype command (versions lower than 9.0.21).

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 Control-M Application Integrator plug-in and the Google VM plug-in. To install the Google VM plug-in, use the provision image command (version 9.0.21 or later) or the deploy jobtype command (versions lower than 9.0.21).

"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 Batch job. 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 Control-M Application Integrator plug-in and the Google Batch plug-in. To install the Google Batch plug-in, use the provision image command (version 9.0.21 or later) or the deploy jobtype command (versions lower than 9.0.21).

"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 Control-M Application Integrator plug-in and the Google Functions plug-in. To install the Google Functions plug-in, use the provision image command (version 9.0.21 or later) or the deploy jobtype command (versions lower than 9.0.21).

"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 Control-M Application Integrator plug-in and the Google Dataprep plug-in. To install the Google Dataprep plug-in, use the provision image command (version 9.0.21 or later) or the deploy jobtype command (versions lower than 9.0.21).

"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: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 Control-M Application Integrator plug-in and the Boomi plug-in. To install the Boomi plug-in, use the provision image command (version 9.0.21 or later) or the deploy jobtype command (versions lower than 9.0.21).

"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 Control-M Application Integrator plug-in and the Databricks plug-in. To install the Databricks plug-in, use the provision image command (version 9.0.21 or later) or the deploy jobtype command (versions lower than 9.0.21).

"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 Control-M Application Integrator plug-in and the Power BI plug-in. To install the Power BI plug-in, use the provision image command (version 9.0.21 or later) or the deploy jobtype command (versions lower than 9.0.21).

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 Control-M Application Integrator plug-in and the Qlik Cloud plug-in. To install the Qlik Cloud plug-in, use the provision image command (version 9.0.21 or later) or the deploy jobtype command (versions lower than 9.0.21).

"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 Control-M Application Integrator plug-in and the Tableau plug-in. To install the Tableau plug-in, use the provision image command (version 9.0.21 or later) or the deploy jobtype command (versions lower than 9.0.21).

"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 Control-M Application Integrator plug-in and the Snowflake plug-in. To install the Snowflake plug-in, use the provision image command (version 9.0.21 or later) or the deploy jobtype command (versions lower than 9.0.21).

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: