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
optimization	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> 
</...>