The offline mode can be used to create domains from a template shipped with WebLogic Server or by using your own created template. It's in fact the configuration wizard in command or scripted mode. In this mode, you need not connect to a running WebLogic Server, which sounds plausible. When you want to create a domain, there is no running server instance yet. During offline mode, one cannot view runtime performance or modify security data.

The offline mode is not recommended to do configuration changes because they can be overwritten by JMX clients, such as WLST online or the Administration Console. Also, you need to be running WLST locally for offline mode. You need filesystem access to the domain''s config folder.

The following script is a very simple example of an offline script to create a domain:

wl_home='/app/oracle/Middleware/wlserver_10.3'
# Open a domain template.
readTemplate (wl_home + '/common/templates/domains/wls.jar')
cd('Servers/AdminServer')
set('ListenPort', 7001 )
set('ListenAddress','10.0.0.12')
create('AdminServer','SSL')
cd('SSL/AdminServer')
set('Enabled', 'True')
set('ListenPort', 7002)
cd('/')
cd('Security/base_domain/User/WebLogic')
cmo.setName('WebLogic')
cmo.setPassword('webl0gic ')
setOption('OverwriteDomain', 'true')
setOption('ServerStartMode', 'prod')
writeDomain(domaintarget)
closeTemplate()

When connecting WLST to a running Administration Server, you can manage the configuration of an active WebLogic domain and view performance data about resources in the domain. You can also use WLST to connect to Managed Servers, but you cannot modify configuration data from Managed Servers; because this should only be done by the Administration Server since it is responsible for maintaining, updating, and storing the configuration data. During online mode, one cannot create a domain.

Example of an online mode:

WLST online: Connecting to a domain

In the interactive mode, you can enter a command and view the response at the command-line prompt; it is useful for learning the tool, command syntax, and verifying configuration options before creating a script. When using WLST interactively, you will get immediate feedback after making a critical configuration change. The WLST shell keeps a connection with an instance of the WebLogic Server.

With the interactive mode you can browse through the complete MBean structure, navigating with certain commands.

WebLogic Server runtime MBeans are arranged in a hierarchical data structure. When connected to an Administration Server, you access the runtime MBean hierarchy by entering the serverRuntime or the domainRuntime command. The serverRuntime command places WLST at the root of the server runtime management object, ServerRuntimeMBean; the domainRuntime command places WLST at the root of the domain-wide runtime management objects called the DomainRuntimeMBean. When connected to a Managed Server, the root of the runtime MBeans is ServerRuntimeMBean. The domain runtime MBean hierarchy exists on the Administration Server only; you cannot use the domainRuntime command when connected to a Managed Server.

Using the cd command, you can navigate to any of the runtime child MBeans. The navigation model for runtime MBeans is the same as the navigation model for configuration MBeans. However, runtime MBeans exist only on the same server instance as their underlying managed resources (except for the domain-wide runtime MBeans on the Administration Server). Also, they are all uneditable.

Browsing with the WLST command-line needs a specific syntax such as:

When you use the easeSyntax() command, all quotes and brackets can be left out. Beware, this is only when you don't have to change a configuration. So this is not recommended for scripted mode and especially when using loop constructs. You can also use the regular Jython syntax with parentheses after you enabled the easy syntax. To leave the easy syntax mode, just execute the easeSyntax() command again.

When you become an expert in WLST, you'll be able to write your own scripts for administering your WebLogic Server and automate manual tasks. To run in scripted mode, you must invoke the script with the WLST command. This can be done in two ways:

Because you always have to start with a connection to a domain , you should embed the connect-string to your WebLogic domain in the following way:

connect('<weblogic username>','<weblogic password>','<weblogic admin url>')

To use weblogic.WLST, you should run the setWLSEnv or the setDomainEnv script.

The setWLSEnv script is in the WebLogic Server Home, that is under the wlserver_10.3/server/bin directory.

The setDomainEnv script is in your Domain Home, that is in the bin directory. You can execute this by running the following code:

. ./setDomainEnv.sh

The same counts for the setWLSEnv.sh script.

Finally, WebLogic Server is shipped with some preconfigured shell-scripts, located in the<WebLogic Server Home> /common/bin/wlst.sh.

To include WLST in Java programs, you can embed the code. This makes it possible to call the WLST interpreter from within your Java code.

For an administrator, the embedded mode is difficult to maintain, but the following is a small example:

package wlst;
import java.util.*;
import weblogic.management.scripting.utils.WLSTInterpreter;
import org.python.util.InteractiveInterpreter;
public class EmbeddedWLST
{
static InteractiveInterpreter interpreter = null;
EmbeddedWLST() { interpreter = new WLSTInterpreter(); }
private static void connect() { StringBuffer buffer = new StringBuffer(); buffer.append("connect('weblogic','weblogic')"); interpreter.exec(buffer.toString()); }
private static void createServers() { StringBuffer buf = new StringBuffer(); buf.append(startTransaction()); buf.append("man1=create('msEmbedded1','Server')
"); buf.append("man2=create('msEmbedded2','Server')
"); buf.append("clus=create('clusterEmbedded','Cluster')
"); buf.append("man1.setListenPort(8001)
"); buf.append("man2.setListenPort(9001)
"); buf.append("man1.setCluster(clus)
"); buf.append("man2.setCluster(clus)
"); buf.append(endTransaction()); buf.append("print 'Script ran successfully ...' 
"); interpreter.exec(buf.toString()); }
private static String startTransaction() { StringBuffer buf = new StringBuffer(); buf.append("edit()
"); buf.append("startEdit()
"); return buf.toString(); }
private static String endTransaction() { StringBuffer buf = new StringBuffer(); buf.append("save()
"); buf.append("activate(block='true')
"); return buf.toString(); }
public static void main(String[] args) { new EmbeddedWLST(); connect(); createServers(); } }

You can use WLST to start, stop, suspend, or manage the lifecycle of your Server instances. This can be accomplished in two ways:

Starting with the Node Manager

The following diagram explains that you can connect to the Node Manager using WLST, and from there you can stop or start your WebLogic Server instances:

1. First, of course you will have to start up WLST, using:

   java weblogic.WLST
   

2. In the WLST console, notice the 'Offline' in the prompt. Next type the following command to connect the Administration Server:

   connect('weblogic','Welkom123','t3://localhost:7001')
   

   When ready, notice the change in the prompt.

3. First, if it's necessary, start the Node Manager:

   startNodeManager(verbose='true',
   NodeManagerHome='<Node Manager Directory>', ListenPort='5556')
   

4. In the WLST shell, execute the following command to connect to the Node Manager:

   nmConnect('weblogic', '<weblogic password>','<weblogic host>','<nodemanager port>','<name of domain>,'<domain dir>','plain')
   

   The 'plain' stands for whether the connection is SSL or not. In this case, it's not.

   Tip

   Type the command help('nmConnect') for detailed information on the void in the function nmConnect(void). If you get syntax errors, review the paths and names in the void; a typo is to be expected.

5. In the WLST shell, type the following command to view the status of the Managed Server ms_trn_1:

   nmServerStatus('<WebLogic Server Instance>')
   

6. If the status is running use the following command to stop the Managed Server:

   nmKill('<WebLogic Server Instance>')
   

   Verify that the server is SHUTDOWN using the nmServerStatus command.

7. Use the following command to restart the Managed Server ms_trn_1 and review the feedback:

   nmStart('<WebLogic Server Instance>')
   

8. When the Node Manager is done, use the command nmServerStatus to review the current status.

startServer('AdminServer', '<name of domain>','<Admin URL>', 'weblogic','<password WebLogic>', '>,'<domain dir>','true')

# Connect WLST to the running server
connect('weblogic','<password WebLogic>','<Admin URL>'),
#The following command will print the state of the servers
print 'Status',state('AdminServer','Server'),
serverRuntime()
a = get('State')
if a == 'RUNNING'
print 'Status',state('<Managed Server Name 1>','Server'),
print 'Status',state('<Managed Server Name 2>','Server'),
startServer('AdminServer','mydomain','<Admin URL>',
'weblogic','<password weblogic>', >,'<domain dir>','true')
# Disconnect the WLST from Adminserver
disconnect();

CMO is the WLST inbuilt variable. These are like our Java keywords having a dedicated meaning and functionality. CMO stands for Current Management Object. While using or programming in WLST, you can use cmo to point the current MBean (object) instance you are navigating to. The cmo value changes when you navigate to a different hierarchy of MBeans under different MBean trees in WebLogic (except for the JNDI tree).

When WLST first connects to an instance of WebLogic Server, cmo is initialized to the root of all configuration management objects which are of the DomainMBean.MBean type, the value of cmo reflects the parent MBean. MBean name gives the name of the MBean object.

wls:/mydomain/edit> cmo.setAdministrationPort(9005)

If you log in using WLST, cmo gives you the root MBean:

wls:/forms11g_domain/serverConfig> cmo
[MBeanServerInvocationHandler]com.bea:Name=forms11g_domain,Type=Domain

It is possible to embed WLST commands into your ANT scripting, because Oracle WebLogic provides an ANT task for this, called wlst.

If you want to use the wlst task with your own ANT installation, include the following task definition in your build file:

<taskdef name="wlst"
classname="weblogic.ant.taskdefs.management.WLSTTask" />

To use the ANT command, you will have to run the setWLSEnv.sh script from the WebLogic Server Home or the setDomainEnv.sh script from the Domain Home to run it from command-line and set all environment settings correctly.

When invoking WLST from an ANT script, it is recommended that you fork a new JVM by specifying fork="true". This will ensure a clean environment and prevent the WLST Exit command which calls System.exit(0) from exiting the ANT script.

For deployment, you can use the wldeploy to add it to your ANT task. For this, you will have to include the following code into your build file:

<taskdef name="wldeploy" classname="weblogic.ant.taskdefs.management.WLDeploy"/>

Then you can start using the wldeploy tasks as shown in the following example. It shows a wldeploy target that deploys an application to a single WebLogic Server instance:

<target name="deploy"> <wldeploy action="deploy" verbose="true" debug="true" name="DeployExample" source="output/redeployEAR" user="weblogic" password="weblogic" adminurl="t3://localhost:7001" targets="myserver" /> </target>

If you want to explore the capabilities of WLST and how to build scripts, you could use the Recording feature for the Admin Console:

First log into the Admin Console:

You now have a parameterized WLST script that your administrator can use to add new SSL-enabled servers to 'MyCluster' as the load goes up.

Now you can run the script and the raw_input statement enables you to fill in your own parameters.