In that context, in the last few months I had inquiries from some users asking where they could find the original WLST that works with WebLogic 8.1 and 7.0, also WLST Script Generator and Console extension that work with WebLogic 9.x.

Now you can get these from the new google code project wlst-modules. WLST Script Generator 9.x can be downloaded from here. The zip contains a ReadMe.html that should walk you through the configurations steps. And for those unfortunate souls who are still using WebLogic 7.0 and 8.1, WLST jar can be downloaded from here.

Interview can be found here

For a brief description on what’s new with Jython 2.2 see my old post here.

E:\WebLogic11g\Oracle\Middleware\wlserver_10.3\common\bin>java org.python.util.jython
Jython 2.2.1 on java1.6.0_05
>>>

*sys-package-mgr*: can’t create package cache dir, ‘/tmp/cachedir/packages’
Traceback (innermost last):
File “<iostream>”, line 12, in ?
ImportError: no module named java

When Jython initializes it scans all the jar files it can find at startup to build the package and class structure available to the JVM. This information is written to files in a directory named ‘cachedir’, WLST chooses your ‘java.io.tmpdir’ to store these files. There is a problem with this approach especially on Unix machines.

Problem:

Most Unix machines are shared across a number of users. Say “user1″ first logs into the machine and fired up ‘java weblogic.WLST’, Jython will create the ‘cachedir’ under ‘/var/tmp/’ and this directory will be owned by ‘user1′. This user will have no problems using WLST. Now ‘user2′ logs in and fires up WLST, this process will try to write to the same directory, ‘/var/tmp/cachedir’ which is now owned by ‘user1′ and hence fails with the above error message.

Solution:

There is a pretty simple and straight forward solution to this problem. Jython supports a System property (python.cachedir) that you can set which will determine the directory where this ‘cachedir’ is created. So in our case to start WLST you will use,

java -Dpython.cachedir=/home/user1 weblogic.WLST

This will create the cachedir under /home/user1, and this way all users can have their own cachedir’s without running into each other. For a more elegant solution you can create a simple unix script that wraps the call to WLST and adding the right cachedir location per user. Sample is shown below,

#!/bin/sh

# Setup classpath, probably execute setDomainEnv.sh

java -Dpython.cachedir=~ weblogic.WLST

As long as the ‘~’ resolves properly to the home directory for the user executing WLST you will never have to worry about this ‘cachedir’ related error messages..

But once SSL is configured and you have dis-abled the non-ssl port, you should make sure that the DefaultProtocol your WebLogic Server uses is SSL (either t3s, https or iiops). If you haven’t done this, your WebLogic Server will try to use “t3″ (default) for any outbound connections and since the ListenPort is disabled it will fail.

Here’s a simple wlst script to change the default protocol to t3s for all the servers in the domain.

# After connecting to the Admin Server

edit()

startEdit()

servers = cmo.getServers()

for i in servers:

i.setDefaultProtocol(“t3s”)

save()

activate()

• New-style classes and their instances are Java serializable
• Java collections integration
• New and Improved socket module
• Support for JDK1.5 and 1.6
• telnetlib from CPython
• Lots of bug fixes

The complete changelog is posted at http://www.jython.org/NEWS.
I hope BEA will consider bundling Jython 2.2 in its next major release.

_uacct = “UA-2684269-2″;
urchinTracker();

import os
import shutil
# define the source control commands here
delete = “p4 delete “
add = “p4 add “
forceSync = “p4 sync -f “
revert = “p4 revert “

“”"
Usage:
java weblogic.WLST c:/scripts/p4files.py d:/myfiles .foo .bar
This will revert all files under myfiles directory from source control, force sync’s the files,
copy the file to the given extension, deletes the file from source control and add the new file
to source control
“”"
dirwalk(sys.argv[1])

As you can see Jython is not only useful to call into Java objects you can also use it to call into operating system for file manipulation and also use most of the python modules with utmost ease.
This is one of the many many uses of Jython.

_uacct = “UA-2684269-2″;
urchinTracker();

What is a Jython Module?
In simple words, a jython Module is more or less like a Java class/object that you can import into other Modules. Lets say, you wrote a script/module ‘A.py’ and you defined a function ‘myFunction’. Now you can import this A.py into a different script, say B.py’ and call the function ‘myFunction’. Here’s how you do it.

A.py
——-
def myFunction():
··print “Hello There!”

def printFirstName(myName):
··print “Hello “+myName

B.py
——
import A
A.myFunction()
A.printFirstName(“satya”)

WLST provides a convienient way for you to import it as a module into your scripts and use all the WLST commands that are supported. The advantage of doing this is you can write Jython Modules without any WebLogic dependency and import WLST module into these modules. For example, now you can have another module C.py where you will import wlstModule.py and A.py.

C.py
——
import A
import wlstModule.py as myWLST
# connect to the server
myWLST.connect(‘weblogic’,'weblogic’,'t3://sghattu:7001′)
# call a function from module A
A.printFirstName(“satya”)
#start and edit session and create a server
myWLST.edit()
myWLST.startEdit()
newSvr = myWLST.cmo.createServer(‘ms1′)
newSvr.setListenPort(8001)
myWLST.activate()
myWLST.disconnect()


What is the difference between WLST as a Module and invoking WLST?
If you invoke WLST via ‘java weblogic.WLST‘, WLST instantiates a Jython Interpreter, creates a WLST Namespace and installs all the WLST functions in it. You can import other modules, but you will not have access to WLST functions from these external modules because when you import other modules they will be imported into the Jython’s Default NameSpace not the WLST NameSpace. To use your modules in WLST namespace you will have to execute the module in wlst NameSpace using execfile(externalModule.py).

Where can I find WLST Module and are there any recommendations
WLST Module is under {WL_HOME}/common/wlst/modules/wlstModule.py. You can also generate one using the writeIniFile command.
If you are using WLST as a module, you should use java org.python.util.jython to invoke your scripts. Do not use java weblogic.WLST and import WLST as a module. This will import WLST Module into WLST NameSpace and if you mix the module calls with straight WLST calls, you will see some weird interactions. This is not recommended. Please use straight Jython if you are using WLST as a Module.

_uacct = “UA-2684269-2″;
urchinTracker();