Network Deployment (Distributed operating systems), v8.0 > Scripting the application serving environment (wsadmin) > Scripting concepts


Use wsadmin scripting with Jython

Jython is an alternate implementation of Python, and is written entirely in Java.

The wsadmin tool uses Jython V2.1. The following information is a basic summary of the Jython syntax. In all sample code, the => notation at the beginning of a line represents command or function output.

Limitation: On the Microsoft Windows 2003, Windows 2008, Windows Vista, and Windows 7 operating systems, the os.system() function in the Jython library fails. Jython interprets a Windows server to be like a UNIX server so it prepends "sh -c" to the beginning of every command. This issue is a known open source, Jython V2.1 limitation.


Basic function

The function is either the name of a built-in function or a Jython function. For example, the following functions return "Hello, World!" as the output:

print "Hello, World!"
=>Hello, World!

import sys
sys.stdout.write("Hello World!\n")
=>Hello, World!

In the example, print identifies the standard output stream. We can use the built-in module by running import statements such as the previous example. The statement import runs the code in a module as part of the importing and returns the module object. sys is a built-in module of the Python language. In the Python language, modules are name spaces which are places where names are created. Names that reside in modules are called attributes. Modules correspond to files and the Python language creates a module object to contain all the names defined in the file. In other words, modules are name spaces. When you issue a Jython command in a wsadmin script that invokes a WebSphere Application Server MBean operation, and the MBean method returns a string that includes some NLS translated characters such as the French accent character, Jython automatically converts the string to a python unicode string, and returns the converted string to wsadmin. If you include the Jython print output command in the script that invokes the MBean method, the NLS translated characters are included in the string that the MBean method returns to wsadmin instead of the python unicode values.

To avoid the displaying of NLS translated characters, use a variable for the MBean return (for example, output = AdminControl.invoke(mbean)) and then use print output. Use the Jython print command to convert strings that contain NLS translated characters correctly.


Variable

To assign objects to names, the target of an assignment goes on the left side of an equal sign (=) and the object that you are assigning on the right side. The target on the left side can be a name or object component, and the object on the right side can be an arbitrary expression that computes an object. The following rules exist for assigning objects to names:

Variable name rules are like the rules for the C language; for example, variable names can have an underscore character (_) or a letter plus any number of letters, digits, or underscores.

The following reserved words cannot be used for variable names:

For example:

a  = 5
print a => 5

b =  a print b
=> 5

text1, text2, text3, text4  = 'good', 'bad', 'pretty', 'ugly'
print text3
=> pretty

The second example assigns the value of variable a to variable b.


Types and operators

The following list contains a few of the built-in object types:

The following list contains a few of the operators:


Backslash substitution

If a statement must span multiple lines, you can also add a back slash (\) at the end of the previous line to indicate you are continuing on the next line. Do not use white space characters, specifically tabs or spaces, after the back slash character. For example:

text =  "This is a test of a long lines" \
" continuing lines here."
print text
=> This is a test of a long lines continuing lines here.


Functions and scope

Jython uses the def statement to define functions. Functions related statements include:

The basic syntax to define a function is the following:

def name (arg1, arg2, ... ArgN)
   statements
   return value 

where name is the name of the function being defined. It is followed by an open parenthesis, a close parenthesis, and a colon. The arguments inside parenthesis include a list of parameters to the procedures. The next line after the colon is the body of the function. A group of commands that form the body of the function. After you define a Jython function, it is used just like any of the built-in functions. For example:

def intersect(seq1, seq2):
   res = []
   try:
      for x in seq1:
         if x in seq2:
            res.append(x)
   except:
      pass
   return res

To call this function, use the following command:

s1 = "SPAM"
s2 = "SCAM"
intersect(s1, s2)
=> [S, A, M]

intersect([1,2,3], (1.4))
=> [1]


Comments

Make comments in the Jython language with the pound character (#).


Command-line arguments

The Jython shells pass the command-line arguments to the script as the value of the sys.argv. In wsadmin Jython, the name of the program, or script, is not part of sys.argv. Unlike wsadmin Jython, Jython stand-alone takes the script file as the first argument to the script. Since sys.argv is an array, use the index command to extract items from the argument list. For example, test.py takes three arguments a, b, and c.

wsadmin -f test.py  a  b  c

test.py content:

import sys
first  =  sys.argv[0]
second = sys.argv[1]
third = sys.argv[2]
arglen = len(sys.argv)


Basic statements

There are two looping statements: while and for. The conditional statement is if. The error handling statement is try. Finally, there are some statements to fine-tune control flow: break, continue, and pass.

if

The if statement selects actions to perform. The if statement might contain other statements, including other if statements. The if statement can be followed by one or more optional elif statements and ends with an optional else block.

The general format of an if looks like the following:

if test1
   statements1
elif test2
   statements2
else
   statements3

For example:

weather = 'sunny'
if weather == 'sunny':
   print "Nice weather"
elif weather == 'raining':
   print "Bad weather"
else:
   print "Uncertain, don't plan anything"

while

The while statement consists of a header line with a test expression, a body of one or more indented statements, and an optional else statement that runs if control exits the loop without running into a break statement. The while statement repeatedly runs a block of indented statements as long as a test at the top keeps evaluating a true value. The general format of a while looks like the following:

while test1
   statements1
else
   statements2

For example:

a = 0; b = 10
while a
< b:
   print a    a = a + 1

for

The for statement begins with a header line that specifies an assignment target or targets, along with an object to step through. The header is followed by a block of indented statements which to repeat.

The general format of a for statement looks like the following:

for target in object:
   statements
else:
   statements

It assigns items in the sequence object to the target, one by one, and runs the loop body for each. The loop body typically uses the assignment target to refer to the current item in the sequence as if it were a cursor stepping through the sequence. For example:

sum = 0
for x in [1, 2, 3, 4]:
   sum = sum + x

break, continue, and pass

We can control loops with the break, continue and pass statements. The break statement jumps out of the closest enclosing loop (past the entire loop statement). The continue statements jumps to the top of the closest enclosing loop (to the header line of the loop), and the pass statement is an empty statement placeholder.

try

A statement will raise an error if it is called with the wrong number of arguments, or if it detects some error condition particular to its implementation. An uncaught error stops the running of a script. The try statement is used to trap such errors. Python try statements come in two flavors, one that handles exceptions and one that runs finalization code whether exceptions occur or not. The try, except, else statement starts with a try header line followed by a block of indented statements, then one or more optional except clauses that name exceptions to be caught, and an optional else clause at the end. The try, finally statements starts with a try header line followed by a block of indented statements, then the finally clause that always runs on the way out whether an exception occurred while the try block was running or not.

The general format of the try, except, else function looks like the following:

try:
   statements
except name:
   statements
except name, data:
   statements
else
   statements

For example:

try: myfunction() except: import sys print 'uncaught exception', sys.exc_info() try: myfilereader() except EOFError: break else: process next line here

The general format of a try and finally looks like the following:

try
   statements
finally
   statements

For example:

def divide(x, y):
   return x / y

def tester(y):
   try:
      print divide(8, y)
   finally:
      print 'on the way out...'

The following is a list of syntax rules in Python:


Call scripts using another script

Use the execfile command to call a Jython script from another Jython script. For example:

Create a script called test1.py that contains the following:

execfile('c:/temp/script/testFunctions.py')
print printName('Cathy', 'Smith')

Create a script called testFunctions.py that contains the following:

def printName(first, last):
   name = first + ' ' + last
   return name 

Then pass the following path as a script argument:

wsadmin -lang jython -f 'c:/temp/script/test1.py'

We must use forward slashes (/) as your path separator. Backward slashes (\) do not work.


Jython usage with Microsoft Windows directories

Jython treats the following list of characters or conditions as special. Do not use the characters, if possible, when using Jython.

When specifying Microsoft Windows file paths in Jython you must be aware of these special conditions. When use any of these character strings, you can counteract the Jython interpretation of these special character strings by using either "two backslashes" instead of one backslash or by substituting a forward slash for the single backslash. The following examples illustrate how to make these adjustments.

Jython file path specifications. Use \\ or / for directory separators in Windows file paths.

Erroneous Path Corrected Double Backslash Path Corrected Forward Slash Path
c:\aadirectory\myfile.txt c:\\aadirectory\\myfile.txt c:/aadirectory/myfile.txt
c:\myfiles\number1.txt c:\\myfiles\\number1.txt c:/myfiles/number1.txt
c:\zebra7\stripe.txt c:\zebra7\\stripe.txt c:/zebra7/stripe.txt
c:\5mod\Net33\residue.log c:\\fivemod\\Net33\\residue.log c:/fivemod/Net33/residue.log
In general, try to use the forward slash where possible in specifying directory paths in Jython. The forward slash avoids many of the problems associated with using the backslash.
Use wsadmin scripting with Jacl
Get started with wsadmin scripting
IBM Jacl to Jython Conversion Assistant
WAS Administration Using Jython

+

Search Tips   |   Advanced Search