| #!/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. |
| ''' |
| gpsys.py -- print system properties |
| |
| Usage: gpsys.py [-p] [-t] |
| |
| -p : print system properties in Python pickled format |
| -t : print system properties in Text (default). |
| ''' |
| |
| import os, platform, sys, getopt, pickle |
| from datetime import datetime |
| |
| opt = {} |
| opt['-p'] = False |
| GPHOME=os.getenv('__GPHOME') |
| if not GPHOME: |
| GPHOME = os.getenv('GPHOME') |
| |
| def makeCommand(cmd): |
| return ('__GPHOME=%s && GPHOME=$__GPHOME && export GPHOME ' |
| '&& PATH=$GPHOME/bin:$PATH && export PATH ' |
| '&& LD_LIBRARY_PATH=$GPHOME/lib:$LD_LIBRARY_PATH && export LD_LIBRARY_PATH ' |
| '&& %s' |
| % (GPHOME, cmd)) |
| |
| ################ |
| def usage(exitarg): |
| print __doc__ |
| sys.exit(exitarg) |
| |
| |
| def parseCommandLine(): |
| global opt |
| try: |
| (options, args) = getopt.getopt(sys.argv[1:], 'pt') |
| except Exception, e: |
| usage('Error: ' + str(e)) |
| |
| for (switch, val) in options: |
| if switch == '-p': opt['-p'] = True |
| elif switch == '-t': opt['-p'] = False |
| |
| def run(cmd): |
| f = None |
| ok = False |
| out = [] |
| try: |
| f = os.popen(cmd) |
| for line in f: |
| out.append(line) |
| ok = not f.close() |
| finally: |
| if f: f.close() |
| |
| return (ok, out) |
| |
| def add(res, prefix, lines): |
| for line in lines: |
| x = line.split(' ', 1) |
| if len(x) == 2: |
| x[0] = x[0].strip() |
| x[1] = x[1].strip() |
| if (x[0] and x[1]): |
| if x[0][-1] == ':': |
| x[0] = x[0][:-1] |
| elif x[1][0] == ':': |
| x[1] = x[1][1:] |
| elif x[0][-1] == '=': |
| x[0] = x[0][:-1] |
| elif x[1][0] == '=': |
| x[1] = x[1][1:] |
| |
| if x[0]: |
| res[prefix + x[0].lower().strip()] = x[1].strip() |
| return res |
| |
| |
| def do_gppath(res): |
| out = os.getenv("GPHOME") |
| if out is None: |
| out = '' |
| res['env.GPHOME'] = out.strip() |
| out = os.getenv('__GPHOME') |
| if out is None: |
| out = '' |
| res['env.__GPHOME'] = out.strip() |
| return True |
| |
| |
| def do_postgres_md5(res): |
| cmd = makeCommand("cat $__GPHOME/bin/postgres | " |
| "python -c 'import md5, sys; m = md5.new(); m.update(sys.stdin.read()); print m.hexdigest()'") |
| (ok, out) = run(cmd) |
| if ok: |
| for line in out: |
| if len(line) == 33: |
| res['postgres.md5'] = line.lower().strip() |
| return True |
| return False |
| |
| |
| def do_postgres_version(res): |
| cmd = makeCommand("$__GPHOME/bin/postgres --version") |
| (ok, out) = run(cmd) |
| if ok and len(out) == 1: |
| res['postgres.version'] = out[0].strip() |
| return True |
| return False |
| |
| |
| |
| def do_sysctl(res): |
| (ok, out) = run('export PATH="/sbin:/usr/sbin:$PATH" && sysctl -a 2> /dev/null') |
| if ok: |
| add(res, 'sysctl.', out) |
| return ok |
| |
| |
| def do_ulimit(res): |
| (ok, out) = run('ulimit -u && ulimit -n') |
| if ok: |
| res['ulimit.nproc'] = out[0].strip() |
| res['ulimit.nofile'] = out[1].strip() |
| return ok |
| |
| |
| def do_sync(res): |
| res['sync.time'] = datetime.today() |
| |
| def do_platform(res): |
| res['platform.platform'] = platform.platform() |
| uname = platform.uname() |
| res['platform.system'] = uname[0].lower() |
| res['platform.node'] = uname[1] |
| res['platform.release'] = uname[2] |
| res['platform.version'] = uname[3] |
| res['platform.machine'] = uname[4] |
| res['platform.processor'] = uname[5] |
| s = res['platform.system'] |
| mem = 0 |
| if (s.find('sunos') >= 0): |
| (ok, out) = run('''sh -c "/usr/sbin/prtconf | awk '/^Memory/{print}'"''') |
| if ok: |
| list = out[0].strip().split(' ') |
| val = int(list[2]) |
| factor = list[3] |
| if factor == 'Megabytes': |
| mem = val * 1024 * 1024 |
| elif (s.find('linux') >= 0): |
| ok, out = run("sh -c 'cat /proc/meminfo | grep MemTotal'") |
| if ok: |
| list = out[0].strip().split(' ') |
| val = int(list[len(list) - 2]) |
| factor = list[len(list) - 1] |
| if factor == 'kB': |
| mem = val * 1024 |
| elif (s.find('darwin') >= 0): |
| (ok, out) = run("/usr/sbin/sysctl hw.physmem") |
| if ok: |
| list = out[0].strip().split(' ') |
| mem = int(list[1]) |
| |
| res['platform.memory'] = mem |
| return True |
| |
| def do_python(res): |
| version = sys.version_info |
| res['python.version'] = '%s.%s.%s' % version[0:3] |
| |
| def do_system(res): |
| SYSTEM_KEYS = ('rlim_fd_max', 'rlim_fd_cur', 'shmsys:shminfo_shmmax', 'semsys:seminfo_semmni') |
| f = open('/etc/system', 'r') |
| content = f.read() |
| f.close() |
| |
| p = [] |
| lines = content.splitlines() |
| for line in lines: |
| line = line.strip() |
| if line.startswith('set'): |
| for key in SYSTEM_KEYS: |
| if line.find(key) != -1: |
| res['system.%s' % key] = line[3:].split('=')[-1].strip() |
| break |
| |
| return True |
| |
| def do_meminfo(res): |
| if not os.path.exists('/proc/meminfo'): |
| return False |
| |
| f = None |
| try: |
| f = open('/proc/meminfo', 'r') |
| list = [] |
| for line in f: |
| list.append(line) |
| add(res, '/proc/meminfo', list) |
| return True |
| finally: |
| if f: f.close() |
| |
| def do_ndd(res): |
| if not os.path.exists('/usr/sbin/ndd'): |
| return False |
| |
| list = ('tcp_conn_req_max_q', 'tcp_conn_req_max_q0', 'tcp_largest_anon_port', \ |
| 'tcp_smallest_anon_port', 'tcp_time_wait_interval') |
| for key in list: |
| (ok, out) = run('/usr/sbin/ndd /dev/tcp ' + key) |
| if ok and len(out) == 1: |
| res['ndd.' + key] = out[0].strip() |
| |
| def do_solaris(res): |
| if not os.path.exists('/etc/release'): |
| return False |
| f = open('/etc/release') |
| lines = f.readlines(); |
| f.close(); |
| for i in lines: |
| i = i.strip() |
| if i.startswith('Solaris 10'): |
| res['solaris.release'] = i |
| f = os.popen("ls -1 /var/sadm/patch ", "r") |
| files = f.readlines() |
| f.close() |
| res['solaris.patch_file'] = ' '.join(files) |
| f = os.popen("/bin/showrev -p", "r") |
| lines = f.readlines(); |
| f.close() |
| patch = [] |
| for i in lines: |
| i = i.strip() |
| i = i.split() |
| if len(i) > 2: |
| patch.append(i[1]); |
| res['solaris.patch'] = ' '.join(patch) |
| |
| def do_zfs(res): |
| (ok, out) = run('/sbin/zpool list -H') |
| if ok and len(out) == 1: |
| r = out[0].split() |
| if len(r) == 7: |
| res['zfs.health'] = r[5].strip() |
| (ok, out) = run('/sbin/zfs get -H checksum %s' % r[0]) |
| if ok and len(out) == 1: |
| r = out[0].split() |
| if len(r) == 4: |
| res['zfs.checksum'] = r[2].strip() |
| |
| |
| parseCommandLine() |
| res = {} |
| |
| do_gppath(res) |
| do_postgres_md5(res) |
| do_postgres_version(res) |
| do_python(res) |
| do_platform(res) |
| do_sync(res) |
| system = res['platform.system'] |
| if system == 'sunos': |
| do_zfs(res) |
| do_system(res) |
| do_ndd(res) |
| do_solaris(res) |
| elif system == 'linux': |
| do_sysctl(res) |
| do_ulimit(res) |
| do_meminfo(res) |
| elif system == 'darwin': |
| do_sysctl(res) |
| do_ulimit(res) |
| |
| |
| if opt['-p']: |
| print "BEGINDUMP" |
| print pickle.dumps(res) |
| print "ENDDUMP" |
| else: |
| for i in res: |
| print i, ' | ', res[i] |
| |
