Job Submission Description Language schema reference

This reference section specifies the semantics and structure of the Job Submission Description Language (JSDL) that apply specifically for use with dynamic workload broker. The JSDL schema is used to describe the job requirements for submission to resources. dynamic workload broker analyzes the IT environment and assigns the best available resource to run the job, based on the requirements you specify.

Introduction

The Job Submission Description Language (JSDL) is a language for describing the job requirements for submission to resources. The JSDL language contains a vocabulary and normative XML schema that facilitate the expression of those requirements as a set of XML elements.

JSDL files adhere to the XML syntax and semantics as defined in the JSDL schema.

Job Submission Description Language document structure

A JSDL file is described using the XML syntax and adheres to the XML syntax and semantics. The XML syntax is an industry standard and is not explained in this manual. The JSDL file also adheres to specific JSDL syntax rules, as explained in Job Submission Description Language element types and in JSDL elements.

The JSDL file consists of elements (either complex or simple) and types. Complex elements contain other elements while simple elements do not contain any other elements. A type specification performs a syntax check on the value specified for the element it refers to. For example, the physicalMemory element adheres to the jsdl:NumericRangeType type. The jsdl:NumericRangeType type specifies that you can assign to this element either a specific numeric value or a numeric range value. No other value types are supported for the physicalMemory element.

The JSDL file is arranged in a hierarchical structure where the jobDefinition element is the root element. The jobDefinition element contains all the elements that describe the job and their attributes.

The pseudo schema definition looks like this:

	 <jobDefinition  >
			<annotation ... />?
			<category>... />*
			<variables ... />?
			<application ... />
			<resources ... />?
			<relatedResources ... />*
			<optimization ... >?
			<scheduling ...>?
	</jobDefinition>
Hierarchical structure of the JSDL file provides a table view of the JSDL file indicating the hierarchical relationships between the elements contained in the jobDefinition element.
Table 1. Hierarchical structure of the JSDL file
First level Second level Third level Fourth level
annotation
category
variables stringVariable
uintVariable
doubleVariable
application script
arguments value
environment variable name
credential username
groupname
password
j2ee invoker type
jms connFactory
destination
message
ejb jndiHome
credential userName
password
JAASalias
resources candidateHosts hostName
candidateCPUs cpu speed
physicalMemory
virtualMemory
candidateOperatingSystems operatingsystems
fileSystem
logicalResource
group
properties and and
or
requirement
or and
or
requirement
requirement and
or
requirement
allocation
relationship
candidateResources (reserved for internal use) endpointReference (reserved for internal use)
relatedResources logicalResource
group
properties and and
or
requirement
or and
or
requirement
requirement and
or
requirement
allocation
relationship
candidateResources (reserved for internal use) endpointReference (reserved for internal use)
optimization objective
ewlm
scheduling maximumResourceWaitingTime
estimatedDuration
priority
recoveryActions action parameters
credential
tpmaddress
workflow
The JSDL syntax uses the BNF-style conventions for elements and attributes:
?
Indicates that the element or attribute is optional and can be specified once.
*
Indicates that the element or attribute is optional and can be specified zero or more times.
+
Indicates that the element or attribute is required and can be specified one or more times.
[...]
Indicate that the elements or attributes contained within the brackets form a group.
|
Indicates that two or more elements or attributes are mutually exclusive.

Job Submission Description Language element types

The JSDL specification uses a number of standard XML Schema types. It also uses a number of types specific to the description of job requirements.

Both types perform a syntax check on the value that can be assigned to each element in the JSDL file. For example, the physicalMemory element adheres to the jsdl:NumericRangeType type. The jsdl:NumericRangeType type specifies that you can assign to this element either a specific numeric value or a numeric range value. No other value types are supported for the physicalMemory element.

Normative XML schema types

The JSDL specification adopts the normative XML schema (xsd) types listed below. The XML syntax is an industry standard and is not explained in this manual.
  • xsd:any
  • xsd:anyURI
  • xsd:boolean
  • xsd:double
  • xsd:DoubleVariableType
  • xsd:duration
  • xsd:IDREF
  • xsd:NCName
  • xsd:PriorityType
  • xsd:QName
  • xsd:string
  • xsd:unsignedInt
  • xsd:UnsignedIntVariableType

JSDL types

The following types are specific to the JSDL syntax:
StringVariableExpressionType
A string variable expression type is a simple type in which you can specify a variable expression that might contain one or more variable references, such as ${var}, any character, and any string. The following is the syntax schema for this type:
<...>
<xsd:simpleType name="StringVariableExpressionType">
		<xsd:union>
			<xsd:simpleType>
				<xsd:restriction base='xsd:string' />
			</xsd:simpleType>
			<xsd:simpleType>
				<xsd:restriction base='xsd:string'>
					<xsd:pattern
						value=".*\t*\r*\n*((\$\{[a-zA-Z_]+
									 [0-9a-zA-Z_\.\-]*\})+[^\{]*[.\n]*)+" />
				</xsd:restriction>
			</xsd:simpleType>
		</xsd:union>
	</xsd:simpleType>
</...>
DoubleVariableExpressionType
A double variable expression type is a simple type in which you can specify a variable expression that might contain one variable reference, such as ${var}, or a double value. The following is the syntax schema for this type:
<...>
	<xsd:simpleType name="DoubleVariableExpressionType">
		<xsd:union>
			<xsd:simpleType>
				<xsd:restriction base='xsd:double' />
			</xsd:simpleType>
			<xsd:simpleType>
				<xsd:restriction base='xsd:string'>
					xsd:pattern value="[\n\r\t ]*($\{[a-zA-Z_]+
															[0-9a-zA-Z_\.\-]*\})[\n\r\t ]*" />
				</xsd:restriction>
			</xsd:simpleType>
		</xsd:union>
	</xsd:simpleType>

</...>
UnsignedIntVariableExpressionType
An unsigned variable expression type is a simple type in which you can specify a variable expression that might contain one variable reference, such as ${var}, or an unsigned integer value. The following is the syntax schema for this type:
<...>
<xsd:simpleType name="UnsignedIntVariableExpressionType">
		<xsd:union>
			<xsd:simpleType>
				<xsd:restriction base='xsd:unsignedInt' />
			</xsd:simpleType>
			<xsd:simpleType>
				<xsd:restriction base='xsd:string'>
					xsd:pattern value="[\n\r\t ]*($\{[a-zA-Z_]+
															[0-9a-zA-Z_\.\-]*\})[\n\r\t ]*" />
				</xsd:restriction>
			</xsd:simpleType>
		</xsd:union>
	</xsd:simpleType>

</...>
NotEmptyStringVariableExpressionType
A string variable expression type is a simple type that allows the specification of a variable expression that might contain one or more variable references such as ${var}, optionally in association with any character or with a simple string. This variable expression cannot be empty. The following is the syntax schema for this type:
<xsd:simpleType name="NotEmptyStringVariableExpressionType">
		<xsd:union>
			<xsd:simpleType>
				<xsd:restriction base='xsd:string'>
					<xsd:minLength value="1"/>
				</xsd:restriction>
			</xsd:simpleType>
			<xsd:simpleType>
				<xsd:restriction base='xsd:string'>
					<xsd:pattern
						value=".*\t*\r*\n*((\$\{[a-zA-Z_]+
                      [0-9a-zA-Z_\.\-]*\})+[^\{]*[.\n]*)+" />
				</xsd:restriction>
			</xsd:simpleType>
		</xsd:union>
	</xsd:simpleType>
NumericRangeOnlyType
A numeric range value is a complex type that allows the definition of intervals and ranges higher than, smaller than, or contained within the specified value. All numbers given are double variable expressions. The following is the syntax schema for this type:
<...>
	<minimum>jsdl:DoubleVariableExpressionType/minimum> ?
	<maximum> jsdl:DoubleVariableExpressionType/maximum> ?
</...>
NumericRangeType
A numeric range value is a complex type that allows the definition of exact values or ranges. All numbers given are double variable expressions. The following is the syntax schema for this type:
<...>
	<exact>jsdl:DoubleVariableExpressionType/exact> |
	<range>jsdl:NumericRangeOnlyType/range> 
</...>
StringRangeOnlyType
A string range value is a complex type that allows the definition of intervals and ranges higher than, smaller than, or contained within the specified value. All numbers and strings given are string variable expressions. The following is the syntax schema for this type:
<...>
	<minimum>jsdl:StringVariableExpressionType</minimum> ?
	<maximum>jsdl:StringVariableExpressionType</maximum> ?
</...>
StringRangeType
A string range value is a complex type that allows the definition of exact values as string variable expressions or ranges that can be applied to integer or string types. The following is the syntax schema for this type:
<...>
	<exact>jsdl:StringVariableExpressionType</exact> |
	<range>jsdl:StringRangeOnlyType</range> 
</...>