Job types

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

Job:Command

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

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

_{Back to top}

Job:Script

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

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

_{Back to top}

Job:EmbeddedScript

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

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

_{Back to top}

Job:FileTransfer

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

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

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

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

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

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

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

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

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

The following parameters were used in the examples above:

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

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

This example contains the following additional optional parameters: 

_{Back to top}

Job:FileWatcher

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

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

This example contains the following parameters:

_{Back to top}

Job:Database

The following types of database jobs are available:

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

Job:Database:EmbeddedQuery

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

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

This example contains the following parameters:

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

Job:Database:SQLScript

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

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

This example contains the following parameters:

For additional optional parameters, see above.

Another example:

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

Job:Database:StoredProcedure

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

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

This example contains the following parameters:

For additional optional parameters, see above.

Job:Database:MSSQL:AgentJob

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

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

This example contains the following parameters:

For additional optional parameters, see above.

Job:Database:MSSQL:SSIS

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

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

This example contains the following parameters:

For additional optional parameters, see above.

_{Back to top}

Job:Hadoop

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

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

Job:Hadoop:Spark:Python

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

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

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

Optional parameters:

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

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

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

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

_{Back to top}

Job:Hadoop:Spark:ScalaJava

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

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

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

Optional parameters:

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

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

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

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

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

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

_{Back to top}

Job:Hadoop:Pig

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

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

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

Optional parameters:

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

_{Back to top}

Job:Hadoop:Sqoop

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

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

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

Optional parameters:

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

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

_{Back to top}

Job:Hadoop:Hive

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

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

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

Optional parameters:

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


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

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

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

_{Back to top}

Job:Hadoop:DistCp

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

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

Optional parameters:

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

_{Back to top}

Job:Hadoop:HDFSCommands

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

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

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

_{Back to top}

Job:Hadoop:HDFSFileWatcher

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

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

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

_{Back to top}

Job:Hadoop:Oozie

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

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


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

Optional parameters:

_{Back to top}

Job:Hadoop:MapReduce

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

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


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

Optional parameters:

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


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

_{Back to top}

Job:Hadoop:MapredStreaming

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

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


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

Optional parameters:

_{Back to top}

Job:SAP

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

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

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

Job:SAP:R3:CREATE

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

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

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

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

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

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

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

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

Job:SAP:R3:COPY

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

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

This SAP job object uses the following parameters:

Job:SAP:BW:ProcessChain

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

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

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

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

This SAP job object uses the following parameters:

  Job:SAP:BW:InfoPackage

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

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

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

This SAP job object uses the following parameters:

_{Back to top}

Job:PeopleSoft

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

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

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

This PeopleSoft job object uses the following parameters:

_{Back to top}

Job:Airflow

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

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

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

The Airflow job object uses the following parameters:

_{Back to top}

Job:ApplicationIntegrator

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

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

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

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

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

_{Back to top}

Job:Informatica

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

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

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

This Informatica job object uses the following parameters:

_{Back to top}

Job: Informatica CS

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

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

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

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

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

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

The Informatica CS job object uses the following parameters:

_{Back to top}

Job:AWS

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

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

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

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

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

• Job:AWS Data Pipeline

• Job:AWS EMR
• Job:AWSEC2
• Job:AWS Step Functions
• Job:AWS QuickSight
• Job:AWS Sagemaker

Job:AWS:Lambda

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

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

This AWS job object uses the following parameters:

Job:AWS:StepFunction

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

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

This AWS job object uses the following parameters :

Job:AWS:Batch

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

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

This AWS job object uses the following parameters :

Job:AWS Batch 

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

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

The following example defines a Batch job with basic parameters:

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

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

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

The AWS Batch job object uses the following parameters :

Job:AWS Glue

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

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

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

The AWS Glue job object uses the following parameters :

_{Back to top}

Job:AWS Glue DataBrew

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

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

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

The AWS Glue DataBrew job object uses the following parameters:

Job:AWS Data Pipeline

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

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

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

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

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

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

The AWS Data Pipeline job object uses the following parameters:

Job:AWS EMR

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

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

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

The AWS EMR job object uses the following parameters :

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

Job:AWSEC2

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

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

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

The AWS EC2 job object uses the following parameters :

Job:AWS Step Functions

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

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

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

The AWS Step Functions job object uses the following parameters:

Job:AWS QuickSight

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

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

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

The AWS QuickSight job object uses the following parameters:

Job:AWS Sagemaker

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

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

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

The AWS Sagemaker job object uses the following parameters:

_{Back to top}

Job:Azure

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

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

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

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

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

• Job:Azure Logic Apps

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

• Job:Azure VM

Job:Azure:Function

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

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

This Azure job object uses the following parameters :

Job:Azure:LogicApps

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

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

This Azure job object uses the following parameters :

Job:Azure:BatchAccount

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

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

This Azure job object uses the following parameters :

  Job:ADF

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

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

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

The ADF job object uses the following parameters :

Job:Azure Databricks

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

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

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

The Azure Databricks job object uses the following parameters :

Job:AzureFunctions

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

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

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

The Azure Functions job object uses the following parameters :

Job:Azure Batch Accounts

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

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

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

The Azure Batch Accounts job object uses the following parameters :

Job:Azure Logic Apps

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

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

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

This Azure job object uses the following parameters :

Job:Azure Machine Learning

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

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

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

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

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

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

The Azure Machine Learning job object uses the following parameters :

Job:Azure Synapse

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

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

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

The Azure Synapse job object uses the following parameters :

Job:Azure HDInsight 

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

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

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

The Azure HDInsight job object uses the following parameters:

Job:Azure VM

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

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

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

The Azure VM job object uses the following parameters :

_{Back to top}

Job:SLAManagement

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

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

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

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

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

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

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

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

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

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

Service Actions

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

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

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

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

_{Back to top}

Job:UI Path

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

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

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

The UiPath job object uses the following parameters :

_{Back to top}

Job:Automation Anywhere

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

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

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

The Automation Anywhere job object uses the following parameters :

_{Back to top}

Job:GCP DataFlow

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

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

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

The GCP Dataflow job object uses the following parameters :

_{Back to top}

Job:GCP Dataproc

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

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

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

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

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

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

The GCP Dataproc job object uses the following parameters :

_{Back to top}

Job:GCP BigQuery

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

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

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

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

The GCP BigQuery job object uses the following parameters:

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

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

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

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

Call new_r(‘value1’)

_{Back to top}

Job:GCP VM

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

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

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

The Google VM job object uses the following parameters :

_{Back to top}

Job:GCP Batch

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

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

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

The Google Batch job object uses the following parameters :

_{Back to top}

Job:Boomi

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

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

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

The Boomi job object uses the following parameters:

_{Back to top}

Job:Databricks

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

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

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

The Databricks job object uses the following parameters:

_{Back to top}

Job:Microsoft Power BI

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

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

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

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

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

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

The Power BI job object uses the following parameters:

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

_{Back to top}

Job:Qlik Cloud

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

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

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

The Qlik Cloud job object uses the following parameters:

_{Back to top}

Job:Snowflake

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

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

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

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

The Snowflake job object uses the following parameters:

"1": { 
      "type": "FIXED", 
      "value": "123" 
    } 
"2": { 
      "type": "TEXT", 
      "value": "String" 
    }

_{Back to top}

Job:Talend Data Management

The following examples show how to define a Talend Data Management job, which enables the integration of data management and data integration tasks or plans from Talend with your existing Control-M workflows.

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

The following example shows a job for a Talend task:

"Talend Data Management": {
  "Type": "Job: Talend Data Management",
  "ConnectionProfile": "TALENDDATAM",
  "Task/Plan Execution": "Execute Task",
  "Task Name": "GetWeather job",
  "Parameters": "{"parameter_city":"London","parameter_appid":"43be3fea88g092d9226eb7ca"}"
  "Log Level": "Information",
  "Bring logs to output": "checked",
  "Task Polling Intervals" : "10"
}

The following example shows a job for a Talend plan:

"Talend Data Management": {
  "Type": "Job: Talend Data Management",
  "ConnectionProfile": "TALENDDATAM",
  "Task/Plan Execution": "Execute Plan",
  "Plan Name": "Sales Operation Plan",
  "Plan Polling Intervals" : "10"
}

The Talend Data Management job object uses the following parameters:

_{Back to top}

Job:Trifacta

The following example shows how to define a Trifacta job. Trifacta is  a data-wrangling platform that allows you to discover, organize, edit, add to, and publish data in different formats and to multiple clouds, including AWS, Azure, Google, Snowflake, and Databricks. 

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

"Trifacta_Job_2": {
	"Type": "Job:Trifacta",
	"ConnectionProfile": "TRIFACTA",
	"Flow Name": "Flow",
	"Rerun with New Idempotency Token": "checked",
	"Idempotent Token": "Control-M-Idem_%%ORDERID'",
	"Retrack Job Status": "checked",
	"Run ID": "Run_ID",
	"Status Polling Frequency": "15"
}

The Trifacta job object uses the following parameters:

_{Back to top}

Job:Micro Focus Windows and Job:Micro Focus Linux

The following example shows how to define a Micro Focus job, which enables you to run Job Control Language (JCL) files on mainframe environments.

Micro Focus jobs are supported on UNIX/Linux (Job:Micro Focus Linux) and on Windows (Job:Micro Focus Windows).

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

"MicroFocusJob": {
    "Type": "Job:Micro Focus Windows",
    "ConnectionProfile": "MICROFWINDOWS",
    "JCL Filename": "JCL14",
    "PDS": "PDSLIBRARY",
    "Enable JCL Variables": "checked",
    "Additional Variables": [
        {
          "UCM-exports-N001-element": "MYVAR1=MYVAL1"
        },
        {
          "UCM-exports-N002-element": "MYVAR2=MYVAL2"
        }
    ], 
    "Restart on Rerun": "checked",
    "Rerun Job ID": "J0002571",
    "From Step/Proc": "/jrestart:1006#fSTEP2(3):PSTEP(1)",
    "To Step/Proc": "#tSTEP4(1):PSTEP(2)",
    "Recapture ABEND Codes": "Ignore",
    "Recapture COND Codes": "Ignore",
    "Auto Adjust Restart": "Ignore",
    "Set MF_UCC11": "Ignore",
    "Restart With Modified JCL": "No"
}

The Micro Focus job object uses the following parameters:

_{Back to top}

Job:Communication Suite

The following examples show how to define Communication Suite jobs, which enable you to automate business messaging and communication over Microsoft Teams, Slack, Telegram, and WhatsApp.

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

"Communication Suite_Job_Teams": {
   "Type": "Job:Communication Suite",
   "ConnectionProfile": "COMM_SUITE",
   "Application Name": "Microsoft Teams",
      "Teams Parameters":"{ "type":"message", "attachments":[ {"contentType":"application/vnd.microsoft.card.adaptive",
      "contentUrl":null, "content":{ "$schema":"http://adaptivecards.io/schemas/adaptive-card.json","type":"AdaptiveCard","version":"1.2",
   "body":[{"type": "TextBlock","text": "For Samples and Templates, see [https://adaptivecards.io/samples](https://adaptivecards.io/samples)" } ] } }]}",
   "Silent Message": "unchecked",
   "Protect Content": "unchecked"
}

"Communication Suite_Job_Slack": {
   "Type": "Job:Communication Suite",
   "ConnectionProfile": "COMM_SUITE",
   "Application Name": "Slack",
   "Slack Parameters":"{"blocks": [{"type": "section","text": {"type": "mrkdwn","text": "The job finished successfully orderid: %%ORDERID, and <https://google.com|this is a link>"}}]}",
   "Silent Message": "unchecked",
   "Protect Content": "unchecked"
}

"Communication Suite_Job_Telegram": {
   "Type": "Job:Communication Suite",
   "ConnectionProfile": "COMM_SUITE",
   "Application Name": "Telegram",
   "Telegram Parameters":"The job finished successfully orderid: %%ORDERID",
   "Silent Message": "unchecked",
   "Protect Content": "unchecked"
}

"Communication Suite_Job_WhatsApp": {
   "Type": "Job:Communication Suite",
   "ConnectionProfile": "COMM_SUITE",
   "Application Name": "WhatsApp",
   "WhatsApp Parameters":" { "messaging_product": "whatsapp", "to": "17181231234", "type": "template", "template": { "name": "control_m", "language": { "code": "en" } }}",
   "Silent Message": "unchecked",
   "Protect Content": "unchecked"
}

Communication Suite jobs use the following parameters:

_{Back to top}

Job:Dummy

The following example shows how to use Job:Dummy to define a job that always ends successfully without running any commands. 

"DummyJob" : {
   "Type" : "Job:Dummy"
}

Job:zOS:Member

The following example shows how to use Job:zOS:Member to run jobs on a z/OS system:

{
  "ZF_DOCS" : {
    "Type" : "Folder",
    "ControlmServer" : "M2MTROLM",
    "FolderLibrary" : "IOAA.CCIDM2.CTM.OPR.SCHEDULE",
    "RunAs" : "emuser",
    "CreatedBy" : "emuser",
    "When" : {
      "RuleBasedCalendars" : {
        "Included" : [ "EVERYDAY" ],
        "EVERYDAY" : {
          "Type" : "Calendar:RuleBased",
          "When" : {
            "DaysRelation" : "OR",
            "WeekDays" : [ "NONE" ],
            "MonthDays" : [ "ALL" ]
          }
        }
      }
    },
    "ZJ_DATA" : {
      "Type" : "Job:zOS:Member",
      "SystemAffinity" : "ABCD",
      "SchedulingEnvironment" : "PLEX8ALL",
      "ControlDCategory" : "SEQL_FILE",
      "PreventNCT2" : "Yes",
      "MemberLibrary" : "IOA.WORK.JCL",
      "SAC" : "Prev",
      "CreatedBy" : "emuser",
      "RequestNJENode" : "NODE3",
      "RunAs" : "emuser",
	  "StatisticsCalendar": "CALPERIO",
      "TaskInformation" : {
        "EmergencyJob" : true,
		"RunAsStartedTask" : true,
      },
      "OutputHandling" : {
	    "Operation" : "Copy"
        "FromClass" : "X",
        "Destination" : "NODE3",
      },
      "History" : {
		"RetentionDays": "05",
        "RetentionGenerations" : "07"
      },
      "Archiving" : {
        "JobRunsToRetainData" : "4",
        "DaysToRetainData" : "1",
        "ArchiveSysData" : true
      },
      "Scheduling" : {
        "MinimumNumberOfTracks" : "5",
        "PartitionDataSet" : "fgf"
      },
      "RerunLimit" : {
        "RerunMember" : "JOBRETRY",
        "Units" : "Minutes",
        "Every" : "7"
      },
	  "MustEnd" : {
  		"Minutes" : "16",
  		"Hours" : "17",
  		"Days" : "0"
	  },
      "When" : {
        "WeekDays" : [ "NONE" ],
        "Months" : [ "NONE" ],
        "MonthDays" : [ "NONE" ],
        "DaysRelation" : "OR"
      },
      "CRS" : {
        "Type" : "Resource:Lock",
        "IfFail" : "Keep",
        "LockType" : "Shared"
      },
      "QRS" : {
        "Type" : "Resource:Pool",
        "IfFail" : "Keep",
        "IfOk" : "Discard",
        "Quantity" : "1"
      },
      "Demo" : {
        "Type" : "StepRange",
        "FromProgram" : "STEP1",
        "FromProcedure" : "SMPIOA",
        "ToProgram" : "STEP8",
        "ToProcedure" : "CTBTROLB"
      },
      "IfCollection:zOS_0" : {
        "Type" : "IfCollection:zOS",
        "Ifs" : [ {
          "Type" : "If:zOS:AnyProgramStep",
          "ReturnCodes" : [ "OK" ],
          "Procedure" : "SMPIOA"
        }, "OR", {
          "Type" : "If:zOS:EveryProgramStep",
          "ReturnCodes" : [ "*$EJ", ">S002" ],
          "Procedure" : "SMPIOA"
        } ],
        "CtbRuleData_2" : {
          "Type" : "Action:ControlMAnalyzerRule",
          "Name" : "RULEDEMO",
          "Arg" : "3"
        }
      },
      "IfCollection:zOS_1" : {
        "Type" : "IfCollection:zOS",
        "Ifs" : [ {
          "Type" : "If:zOS:SpecificProgramStep",
          "Program" : "Demo",
          "ReturnCodes" : [ "*****" ],
          "Procedure" : "SMPIOA"
        }, "OR", {
          "Type" : "If:zOS:SpecificProgramStep",
          "Program" : "STEP5",
          "ReturnCodes" : [ ">U0002" ],
          "Procedure" : "SMPIOA"
        } ],
        "IfRerun_2" : {
          "Type" : "Action:Restart",
          "FromProgram" : "STEP1",
          "FromProcedure" : "SMPIOA",
		  "ToProgram" : "STEP5",
	      "ToProcedure" : "CTBTROLB"
	      "Confirm" : false,           
        }
      }
    }
  }
}

Job:zOS:InStreamJCL

The following example shows how to create an in-stream JCL job which runs an embedded script on a z/OS system:

{
  "ZF_ROBOT" : {
    "Type" : "SimpleFolder",
    "ControlmServer" : "R2MTROLM",
    "FolderLibrary" : "CTMP.V900.SCHEDULE",
    "OrderMethod" : "Manual",
    "Z_R1" : {
      "Type" : "Job:zOS:InStreamJCL", 
	  "JCL" : "0036//ROASMCL JOB ,ASM,CLASS=A,REGION=0M0033// JCLLIB ORDER=IOAP.V900.PROCLIB0024// INCLUDE MEMBER=IOASET0035//S1 EXEC IOATEST,PARM='TERM=C0000'0035//S2 EXEC IOATEST,PARM='TERM=C0000'",
      "CreatedBy" : "emuser",
      "RunAs" : "emuser",
      "When" : {
        "WeekDays" : [ "NONE" ],
        "MonthDays" : [ "ALL" ],
        "DaysRelation" : "OR"
      },
      "Archiving" : {
        "ArchiveSysData" : true
      }
    }
  }
}

_{Back to top}