| #!/usr/bin/env python |
| |
| # ----------------------------------------------------------------------- |
| # Licensed to the Apache Software Foundation (ASF) under one |
| # or more contributor license agreements. See the NOTICE file |
| # distributed with this work for additional information |
| # regarding copyright ownership. The ASF licenses this file |
| # to you under the Apache License, Version 2.0 (the |
| # "License"); you may not use this file except in compliance |
| # with the License. You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, |
| # software distributed under the License is distributed on an |
| # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| # KIND, either express or implied. See the License for the |
| # specific language governing permissions and limitations |
| # under the License. |
| # ----------------------------------------------------------------------- |
| |
| import re |
| import os |
| import sys |
| import time |
| import getopt |
| import subprocess |
| |
| import string |
| # Must be self-contained using only the DUCC_HOME runtime |
| # |
| # Python-based CLI equivalent of the API tests |
| # |
| |
| class DuccPropertiesException(Exception): |
| def __init__(self, msg): |
| self.msg = msg |
| |
| def __str__(self): |
| return repr(self.msg) |
| |
| |
| class DuccProperties: |
| # copied in from ducc_base to read ducc.properties. maybe should make into its own file some day |
| def __init__(self): |
| self.props = {} |
| self.builtin = {} |
| |
| # |
| # Expand all ${} values from env or from this properties file itself |
| # The search order is: |
| # 1 look in this properties file |
| # 2 look in the environment |
| # |
| def do_subst(self, st): |
| key = None |
| p = re.compile("\\$\\{[a-zA-Z0-9_\\.\\-]+\\}") |
| ndx = 0 |
| response = st.strip() |
| m = p.search(response, ndx) |
| while ( m != None ): |
| key = m.group()[2:-1] |
| |
| val = None |
| if ( self.has_key(key) ): |
| val = self.get(key) |
| elif (self.builtin.has_key(key) ): |
| val = self.builtin[key] |
| |
| if ( val != None ): |
| response = string.replace(response, m.group() , val) |
| ndx = m.start()+1 |
| m = p.search(response, ndx) |
| |
| return response |
| |
| def mkitem(self, line): |
| ndx = line.find('#') # remove comments - like the java DuccProperties |
| if ( ndx >= 0 ): |
| line = line[0:ndx] # strip the comment |
| ndx = line.find('//') # remove comments - like the java DuccProperties |
| if ( ndx >= 0 ): |
| line = line[0:ndx] # strip the comment |
| line = line.strip() # clear leading and trailing whitespace |
| if ( line == '' ): # empty line? |
| return |
| |
| mobj = re.search('[ =:]+', line) |
| if ( mobj ): |
| key = line[:mobj.start()].strip() |
| val = line[mobj.end():].strip() |
| #print 'NEXT', mobj.start(), 'END', mobj.end(), 'KEY', key, 'VAL', val |
| # val = self.do_subst(val) # we'll do lazy subst on get instead |
| self.props[key] = val |
| else: |
| self.props[line] = None |
| |
| # |
| # Load reads a properties file and adds it contents to the |
| # hash. It may be called several times; each call updates |
| # the internal has, thus building it up. The input file is |
| # in the form of a java-like properties file. |
| # |
| def load(self, propsfile, ducchome=None): |
| if ( not os.path.exists(propsfile) ): |
| raise DuccPropertiesException(propsfile + ' does not exist and cannot be loaded.') |
| |
| if (ducchome != None): |
| self.props['DUCC_HOME'] = ducchome |
| f = open(propsfile); |
| for line in f: |
| self.mkitem(line.strip()) |
| f.close() |
| |
| def load_from_manifest(self, jarfile): |
| z = zipfile.ZipFile(jarfile) |
| items = z.read('META-INF/MANIFEST.MF').split('\n') |
| for item in items: |
| self.mkitem(item) |
| |
| # |
| # Try to load a properties file. Just be silent if it doesn't exist. |
| # |
| def load_if_exists(self, propsfile): |
| if ( os.path.exists(propsfile) ): |
| return self.load(propsfile) |
| |
| # |
| # Put something into the hash. |
| # |
| def put(self, key, value): |
| self.props[key] = value |
| |
| # |
| # Get something from the hash. |
| # |
| def get(self, key): |
| if ( self.props.has_key(key) ): |
| return self.do_subst(self.props[key]) # we'll do lazy subst on get instead |
| return None |
| |
| # |
| # Remove an item if it exists |
| # |
| def delete(self, key): |
| if ( self.props.has_key(key) ): |
| del self.props[key] |
| # |
| # Write the has as a Java-like properties file |
| # |
| def write(self, propsfile): |
| f = open(propsfile, 'w') |
| items = self.props.items() |
| for (k, v) in items: |
| #print 'WRITING', k, '=', v |
| f.write(k + ' = ' + str(v) + '\n') |
| f.close() |
| |
| # |
| # return a shallow copy of the dictionary |
| # |
| def copy_dictionary(self): |
| return self.props.copy() |
| |
| # |
| # return the entries in the dictionary |
| # |
| def items(self): |
| return self.props.items() |
| |
| # |
| # check to see if the key exists in the dictionary |
| # |
| def has_key(self, key): |
| return self.props.has_key(key) |
| |
| # |
| # Return the length of the dictionary |
| # |
| def __len__(self): |
| return len(self.props) |
| |
| def usage(msg): |
| if ( msg != None ): |
| print msg |
| print "Usage: reserve.py -d <DUCC_HOMe>" |
| print " DUCC_HOME is the full path to your installed, working, and running ducc installation." |
| sys.exit(1); |
| |
| def mkcmd(CMD, props): |
| CMD = os.environ['DUCC_HOME'] + '/bin/' + CMD |
| for k in props.keys(): |
| v = props[k] |
| if ( v == None ): |
| CMD = CMD + ' --' + k |
| else: |
| CMD = CMD + ' --' + k + ' ' + "'" + props[k] + "'" |
| return CMD |
| |
| def mkBrokerUrl(ducc_home): |
| props = DuccProperties() |
| props.load(ducc_home + '/resources/ducc.properties') |
| protocol = props.get('ducc.broker.protocol') |
| host = props.get('ducc.broker.hostname') |
| port = props.get('ducc.broker.port') |
| return protocol + '://' + host + ':' + port |
| |
| |
| def waitForState(state, sid): |
| print 'Waiting for state', state |
| while True: |
| CMD = mkcmd('ducc_services', {'query':sid}) |
| proc = subprocess.Popen(CMD, bufsize=0, stdout=subprocess.PIPE, shell=True, stderr=subprocess.STDOUT) |
| stdout = proc.stdout |
| for line in stdout: |
| line = line.strip() |
| if ( 'Service State' in line ): |
| if ( state in line ): |
| return |
| else: |
| print ' ...', line |
| time.sleep(5) |
| |
| |
| def waitForEnable(sid): |
| print 'Waiting for service to be Enabled' |
| while True: |
| CMD = mkcmd('ducc_services', {'query':sid}) |
| proc = subprocess.Popen(CMD, bufsize=0, stdout=subprocess.PIPE, shell=True, stderr=subprocess.STDOUT) |
| stdout = proc.stdout |
| for line in stdout: |
| line = line.strip() |
| if ( 'Start Mode' in line ): |
| if ( 'Enabled' in line ): |
| return |
| else: |
| print line |
| time.sleep(5) |
| |
| def waitForDisable(sid): |
| print 'Waiting for service to be Disabled' |
| while True: |
| CMD = mkcmd('ducc_services', {'query':sid}) |
| proc = subprocess.Popen(CMD, bufsize=0, stdout=subprocess.PIPE, shell=True, stderr=subprocess.STDOUT) |
| stdout = proc.stdout |
| for line in stdout: |
| line = line.strip() |
| if ( 'Start Mode' in line ): |
| if ( 'Disabled' in line ): |
| return |
| else: |
| print line |
| time.sleep(5) |
| |
| def waitForStartState(state, sid): |
| print 'Waiting for service start state', state |
| while True: |
| CMD = mkcmd('ducc_services', {'query':sid}) |
| proc = subprocess.Popen(CMD, bufsize=0, stdout=subprocess.PIPE, shell=True, stderr=subprocess.STDOUT) |
| stdout = proc.stdout |
| for line in stdout: |
| line = line.strip() |
| if ( 'Start Mode' in line ): |
| if ( state in line ): |
| return |
| else: |
| print ' ...', line |
| time.sleep(5) |
| |
| |
| def main(argv): |
| |
| ducc_home = None |
| testno = 0 |
| |
| try: |
| opts, args = getopt.getopt(argv, 'd:', ['ducc=']) |
| except: |
| usage("Invalid arguments " + ' '.join(argv)) |
| |
| for ( o, a ) in opts: |
| if o in ('-d', '--ducc'): |
| ducc_home = a |
| else: |
| usage("Illegal arguments") |
| |
| |
| if ( ducc_home == None ): |
| usage('No ducc home') |
| |
| os.environ['DUCC_HOME'] = ducc_home |
| print 'Starting test' |
| |
| broker = mkBrokerUrl(ducc_home) |
| print broker |
| |
| props = { |
| "process_jvm_args" : "-Xmx100M -DdefaultBrokerURL=" + broker, |
| "classpath" : "${DUCC_HOME}/lib/uima-ducc/examples/*:${DUCC_HOME}/apache-uima/lib/*:${DUCC_HOME}/apache-uima/apache-activemq/lib/*:${DUCC_HOME}/examples/simple/resources/service", |
| "service_ping_arguments": "broker-jmx-port=1099", |
| "environment" : "AE_INIT_TIME=5000 AE_INIT_RANGE=1000 INIT_ERROR=0 LD_LIBRARY_PATH=/yet/a/nother/dumb/path", |
| "process_memory_size" : "15", |
| "process_DD" : "${DUCC_HOME}/examples/simple/resources/service/Service_FixedSleep_1.xml", |
| "scheduling_class" : "fixed", |
| "working_directory" : "${HOME}", |
| "service_linger" : "30000", |
| } |
| |
| testno = testno + 1 |
| print '------------------------------ Test', testno, 'Clear services at start ------------------------------' |
| CMD = mkcmd('ducc_services', {'query':None}) |
| proc = subprocess.Popen(CMD, bufsize=0, stdout=subprocess.PIPE, shell=True, stderr=subprocess.STDOUT) |
| stdout = proc.stdout |
| for line in stdout: |
| line = line.strip() |
| print line |
| if ( 'Service Class' in line ): |
| toks = line.split() |
| sid = toks[6] |
| user = re.split('[\[\]]', toks[7] )[1] |
| if ( user == os.environ['LOGNAME'] ): |
| print 'Unregister service', user, sid, line |
| os.system(mkcmd('ducc_services', {'unregister':sid})) |
| |
| testno = testno + 1 |
| print '------------------------------ Test', testno, 'Register ------------------------------' |
| props['description'] = 'Service test ' + str(testno) |
| props['register'] = None |
| CMD = mkcmd('ducc_services', props) |
| proc = subprocess.Popen(CMD, bufsize=0, stdout=subprocess.PIPE, shell=True, stderr=subprocess.STDOUT) |
| stdout = proc.stdout |
| for line in stdout: |
| line = line.strip() |
| print line |
| if ( 'succeeded' in line ): |
| toks = line.split() |
| sid = re.split('[\[\]]', toks[7] )[1] |
| print '======= service id', sid |
| |
| time.sleep(3) |
| os.system(mkcmd('ducc_services', {'query':None})) |
| |
| testno = testno + 1 |
| print '------------------------------ Test', testno, 'Start ------------------------------' |
| os.system(mkcmd('ducc_services', {'start':sid})) |
| waitForState("Available", sid) |
| print "Service is started:" |
| os.system(mkcmd('ducc_services', {'query':sid})) |
| |
| testno = testno + 1 |
| print '------------------------------ Test', testno, 'Stop ------------------------------' |
| os.system(mkcmd('ducc_services', {'stop':sid})) |
| waitForState("Stopped", sid) |
| print "Service is stopped:" |
| os.system(mkcmd('ducc_services', {'query':sid})) |
| |
| testno = testno + 1 |
| print '------------------------------ Test', testno, 'Enable ------------------------------' |
| os.system(mkcmd('ducc_services', {'enable':sid})) |
| waitForEnable(sid) |
| os.system(mkcmd('ducc_services', {'query':sid})) |
| |
| testno = testno + 1 |
| print '------------------------------ Test', testno, 'Disable ------------------------------' |
| os.system(mkcmd('ducc_services', {'disable':sid})) |
| waitForDisable(sid) |
| os.system(mkcmd('ducc_services', {'query':sid})) |
| |
| testno = testno + 1 |
| print '------------------------------ Test', testno, 'Modify ------------------------------' |
| os.system(mkcmd('ducc_services', {'enable':sid})) # first enable it |
| waitForEnable(sid) |
| os.system(mkcmd('ducc_services', {'query':sid})) |
| os.system(mkcmd('ducc_services', {'modify':sid, 'autostart':'true'})) |
| |
| print 'Waiting for service to start' |
| waitForState("Available", sid) |
| os.system(mkcmd('ducc_services', {'query':sid})) |
| |
| testno = testno + 1 |
| print '------------------------------ Test', testno, 'Switch to reference start 1 ------------------------------' |
| os.system(mkcmd('ducc_services', {'modify':sid, 'autostart':'false'})) |
| waitForStartState('manual', sid) # this can take a few moments |
| os.system(mkcmd('ducc_services', {'observe_references':sid})) # first enable it |
| waitForStartState('reference', sid) |
| print 'Waiting for service to linger stop' |
| waitForState("Stopped", sid) |
| os.system(mkcmd('ducc_services', {'query':sid})) |
| |
| testno = testno + 1 |
| print '------------------------------ Test', testno, 'Switch to reference start 2 ------------------------------' |
| print 'Start service in manual mode then switch to reference' |
| os.system(mkcmd('ducc_services', {'start':sid} )) |
| waitForState("Available", sid) |
| os.system(mkcmd('ducc_services', {'query':sid})) |
| os.system(mkcmd('ducc_services', {'observe_references':sid})) # first enable it |
| waitForStartState('reference', sid) |
| os.system(mkcmd('ducc_services', {'query':sid})) |
| |
| print 'Waiting for service to linger stop' |
| waitForState("Stopped", sid) |
| os.system(mkcmd('ducc_services', {'query':sid})) |
| |
| |
| testno = testno + 1 |
| print '------------------------------ Test', testno, 'Switch to reference start 3 ------------------------------' |
| print 'Start service in manual mode then switch to reference, then back before it stops' |
| os.system(mkcmd('ducc_services', {'start':sid} )) # start in manual |
| waitForState("Available", sid) |
| os.system(mkcmd('ducc_services', {'query':sid})) |
| |
| os.system(mkcmd('ducc_services', {'observe_references':sid})) # swith to reference |
| waitForStartState('reference', sid) |
| os.system(mkcmd('ducc_services', {'query':sid})) |
| |
| os.system(mkcmd('ducc_services', {'ignore_references':sid})) # switch back to manual |
| waitForStartState('manual', sid) |
| os.system(mkcmd('ducc_services', {'query':sid})) |
| |
| os.system(mkcmd('ducc_services', {'stop':sid} )) # done, stop |
| print 'Waiting for service to linger stop' |
| waitForState("Stopped", sid) |
| os.system(mkcmd('ducc_services', {'query':sid})) |
| |
| testno = testno + 1 |
| print '------------------------------ Test', testno, 'Unregister ------------------------------' |
| print 'Unregisteres the service before completion of the test.' |
| os.system(mkcmd('ducc_services', {'unregister':sid} )) # start in manual |
| |
| print '------------------------------ Service Testing Complete ------------------------------' |
| |
| main(sys.argv[1:]) |
