Utilisation des scripts de wsadmin avec Jython

Fonction de base

La fonction correspond soit au nom d'une fonction intégrée, soit au nom d'une fonction Jython. Par exemple, les fonctions suivantes renvoient "Hello, World !" en tant que sortie:

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

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

Dans l'exemple, print identifie le flux de sortie standard. Vous pouvez utiliser le module intégré en exécutant des instructions d'importation comme dans l'exemple précédent. L'importation de l'instruction exécute le code dans un module qui fait partie de l'importation et renvoie l'objet du module. sys est un module intégré du langage Python. Dans le langage Python, les modules sont des espaces de nom dans lesquels les noms sont créés. Les noms qui se trouvent dans les modules sont des attributs. Les modules correspondent aux fichiers. Le langage Python crée un objet de module destiné à contenir tous les noms définis dans le fichier. En d'autres termes, les modules sont des espaces de nom.

Variables

Pour affecter des objets à des noms, la cible d'une affectation va à gauche du signe égal (=) et l'objet que vous affectez à droite. La cible à gauche peut être un nom ou un composant d'objet. L'objet à droite peut être une expression arbitraire qui calcule un objet. Il existe des règles pour affecter des objets à des noms :

• Les affectations créent des références d'objet.
• Les noms sont créés lorsque vous les affectez.
• Vous devez affecter un nom avant de le référencer.

Les règles de nom de variable sont identiques aux règles du langage C. Par exemple, les noms de variable peuvent contenir le caractère de soulignement (_) ou une lettre plus n'importe quel nombre de lettres, de chiffres ou de caractères de soulignement.

Par exemple :

a  = 5
print a
=> 5

b =  a
print b
=> 5

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

Le second exemple affecte la valeur d'une variable a à une variable b.

Types et opérateurs

La liste ci-dessous contient des exemples de types d'objet intégré :

• Numéros. Par exemple :

  8, 3.133,  999L,  3+4j
  
  num1 = int(10)
  print num1
  => 10

• Chaînes. Par exemple :

  'name',  "name's", ''
  
  print str(12345)
  => '12345'

• Listes. Par exemple :

  x = [1, [2,  'free'], 5]
  y = [0, 1, 2, 3]
  y.append(5)
  print y
  => [0, 1, 2, 3, 5]
  
  y.reverse()
  print y
  => [5, 3, 2, 1, 0]
  
  y.sort()
  print y
  => [0, 1, 2, 3, 5]
  
  print list("apple")
  => ['a', 'p', 'p', 'l', 'e']
  
  print list((1,2,3,4,5))
  => [1, 2, 3, 4, 5]
  
  test = "This is a test"
  test.index("test")
  => 10
  
  test.index('s')
  => 3

La liste ci-dessous contient des exemples d'opérateurs :

• x or y

  y est évalué uniquement si x est faux. Par exemple :

  print 0 or 1
  => 1

• x and y

  y est évalué uniquement si x est vrai. Par exemple :

  print 0 and 1
  =>  0

• x +y , x - y

  Addition et concaténation, soustraction. Par exemple :

  print  6 + 7
  => 13
  
  text1 = 'Something'
  text2 = ' else'
  print text1 + text2
  => Something else
  
  list1 = [0, 1, 2, 3]
  list2 = [4, 5, 6, 7]
  print list1 + list2
  => [0, 1, 2, 3, 4, 5, 6, 7]
  
  print  10 - 5
  => 5

• x * y, x / y, x % y

  Multiplication et répétition, division, reste et format. Par exemple :

  print 5 * 6
  => 30
  
  print 'test' * 3
  => test test test
  
  print 30 / 6
  => 5
  
  print 32 % 6
  => 2

• x[i], x[i:j], x(...)

  Indexation, découpage, appels de fonction. Par exemple :

  test = "This is a test"
  print  test[3]
  => s 
  
  print test[3:10]
  => s is a
  
  print test[5:]
  => is a test
  
  print test[:-4]
  => This is a 
  
  print len(test)
  => 14
  

• <, <=, >, >=, ==, <>, !=, is is not

  Opérateurs de comparaison, tests d'identité. Par exemple :

  L1 = [1, ('a', 3)]
  L2 = [1, ('a', 2)]
  L1 < L2, L1 == L2, L1 > L2, L1 <> L2, L1 != L2, L1 is L2, L1 is not L2
  => (0, 0, 1, 1, 1, 0, 1)

Remplacement de barre oblique inversée

Si une instruction doit s'étendre sur plusieurs lignes, vous pouvez également ajouter une barre oblique inversée (\) à la fin de la ligne précédente pour indiquer que vous continuez sur la ligne suivante. N'utilisez aucun espace (ni tabulation ou espace) après la barre oblique inversée. Par exemple :

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.

Fonctions et portée

La syntaxe de base permettant de définir une fonction est la suivante :

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

où nom est le nom de la fonction définie. Elle est suivie d'une parenthèse ouvrante, d'une parenthèse fermante et des deux-points (:). Les arguments entre parenthèses incluent une liste de paramètres dans les procédures. La ligne suivante après les deux points est le corps de la fonction. Un groupe de commandes qui forme la partie de la fonction. Une fois une fonction Jython définie, elle est utilisée comme n'importe quelle autre fonction intégrée. Par exemple :

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

Pour appeler cette fonction, utilisez la commande suivante :

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

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

Commentaires

Utilisez le caractère # pour insérer des commentaires en langage Jython.

Arguments de ligne de commande

Les shells Jython transmettent les arguments de ligne de commande au script en tant que valeur de sys.argv. Dans Jython wsadmin, le nom du programme, ou le script, ne font pas partie de sys.argv. A la différence de Jython wsadmin, Jython autonome accepte le fichier de script comme l'argument initial du script. sys.argv étant un tableau, utilisez la commande index pour extraire des arguments de la liste. Par exemple, test.py accepte trois arguments, a, b et c.

wsadmin -f test.py  a  b  c

test.pyContenu :

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

Instructions de base

Il existe deux instructions en boucle : while et for. L'instruction conditionnelle est if. L'instruction de traitement des erreurs est try. Enfin, il existe des instructions pour ajuster le flux de contrôle : break, continue et pass.

if

L'instruction if sélectionne les actions à réaliser. L'instruction if peut contenir d'autres instructions, notamment d'autres instructions if. L'instruction if peut être suivie d'une ou de plusieurs instructions elif facultatives et se termine par un bloc else facultatif.

Le format général d'une instruction if est le suivant :

if test1
   statements1
elif test2
   statements2
else
   statements3

Par exemple :

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

while

L'instruction while comprend une ligne d'en-tête avec une expression de test, une partie contenant une ou plusieurs instructions en retrait et une instruction facultative else exécutée si le contrôle quitte la boucle sans s'exécuter dans une instruction break. L'instruction while exécute de manière répétée un bloc d'instructions en retrait tant qu'un test au début évalue si une valeur est vraie. Voici un exemple d'utilisation de while :

while test1
   statements1
else
   statements2

Par exemple :

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

pour

L'instruction for commence par une ligne d'en-tête qui spécifie une ou plusieurs cibles d'affectation, ainsi qu'un objet à parcourir. L'en-tête est suivi d'un bloc d'instructions en retrait à répéter.

Voici un exemple d'utilisation de l'instruction for :

for target in object:
   statements
else:
   statements

Les éléments sont affectés dans l'objet de séquence pour la cible, un par un, et sont exécutés dans la partie de boucle pour chacun. La partie de boucle utilise généralement la cible d'affectation pour faire référence à l'élément en cours dans la séquence comme s'il s'agissait d'un curseur parcourant la séquence. Par exemple :

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

break, continue et pass

Vous pouvez contrôler les boucles à l'aide des instructions break, continue et pass. L'instruction break passe à la boucle la plus proche (au-delà de l'instruction de boucle entière). L'instruction continue passe au début de la boucle la plus proche (ligne d'en-tête de la boucle) et l'instruction pass est un espace réservé d'instruction vide.

try

Une instruction génère une erreur si elle est appelée avec un nombre d'arguments incorrect ou si une condition d'erreur particulière est détectée dans son implémentation. Une erreur non interceptée arrête l'exécution d'un script. L'instruction try permet d'intercepter ces erreurs. Les instructions Python try ont deux variantes, une qui gère les exceptions et une autre qui exécute le code de finalisation, que des exceptions se produisent ou non. Les instructions try, except, else commencent par une ligne d'en-tête try suivie d'un bloc d'instructions en retrait, puis d'une ou de plusieurs clauses d'exception facultatives désignant les exceptions à intercepter et une clause else facultative à la fin. Les instructions try, finally commencent par une ligne d'en-tête try suivie d'un bloc d'instructions en retrait, puis d'une clause finally qui s'exécute toujours, que des exceptions se soient produites ou non et que le bloc try était en cours d'exécution ou non.

Voici un exemple d'utilisation des fonctions try, except et else :

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

Par exemple :

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

Le format général des instructions try et finally est le suivant :

try
   statements
finally
   statements

Par exemple :

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

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

Appel de scripts à l'aide d'un autre script

Utilisez la commande execfile pour appeler un script Jython à partir d'un autre. Par exemple :

Créez le script test1.py contenant ce qui suit :

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

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

Créez le script testFunctions.py contenant ce qui suit :

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

Passez ensuite le chemin d'accès comme argument de script :

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

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

Vous devez utiliser des barres obliques (/) comme séparateur de chemin. Les barres obliques inversées (\) ne fonctionnent pas.

Exécution de scripts Jython qui utilisent des packages

Si vous exécutez des scripts qui utilisent des packages, vous devez fournir à l'outil wsadmin le chemin de recherche des scripts Jython qui utilisent ces packages.

Pour fournir ces informations à l'outil wsadmin, incluez l'option suivante lorsque vous lancez l'outil :

-Dwsadmin.script.libraries.packages=path1;path2;...

où path1 et path2 représentent les chemins de recherche de répertoire des bibliothèques contenant les packages Jython.

Utilisation de Jython avec les répertoires Microsoft Windows

Pour Jython, les conditions et les caractères suivants sont spéciaux. Dans la mesure du possible, évitez d'utiliser ces caractères avec Jython.

• \a
• \b
• \f
• \n
• \N
• \r
• \t
• \u
• \U
• \v
• \x
• Une barre oblique inversée suivie d'une séquence de chiffres compris entre 0 et 7

Lorsque de la spécification de chemins d'accès Microsoft Windows dans Jython, vous devez connaître ces conditions particulières. Lorsque vous devez utiliser l'une de ces chaînes de caractères, vous pouvez neutraliser l'interprétation par Jython de ces chaînes de caractères spéciales en utilisant "deux barres obliques inversées" au lieu d'une seule ou en remplaçant une barre oblique inversée par une barre oblique. Les exemples suivants illustrent ces réglages.