| #!/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. |
| |
| ''' |
| USAGE: gpcheck_hostdump [--appliance] [--linux] [--solaris] --hadoop hadoop_home_path --sysctl comma_separated_sysctl_options |
| where --appliance will do a dump of appliance server |
| where --linux will do a dump of a generic linux server |
| where --solaris will do a dump of a generic solaris server |
| ''' |
| |
| import os, sys, re, tempfile, subprocess, pickle, glob, stat, time, getpass |
| from xml.dom import minidom |
| |
| try: |
| from optparse import Option, OptionParser |
| from gppylib.gpparseopts import OptParser, OptChecker |
| from gppylib.gpcheckutil import ApplianceOutputData, GenericLinuxOutputData, GenericSolarisOutputData |
| from gppylib.gpcheckutil import chkconfig, omreport, grubconf, mounts, GpMount, GpMount, inittab, ntp |
| from gppylib.gpcheckutil import securetty, ioschedulers, blockdev, bcu, rclocal, sysctl, limitsconf, limitsconf_entry, uname, connectemc, diskusage, diskusage_entry, hdfs, hawq, machine |
| from gppylib.gpcheckutil import solaris_etc_system, solaris_etc_project, solaris_etc_user_attr |
| except ImportError, e: |
| sys.exit('Cannot import modules. Please check that you have sourced greenplum_path.sh. Detail: ' + str(e)) |
| |
| |
| # Global Variables |
| output = None |
| options = None |
| |
| |
| def removeComments(line): |
| words = line.split("#") |
| if len(words) < 2: |
| return line |
| return words[0] |
| |
| |
| def collectChkconfigData(): |
| |
| data = chkconfig() |
| |
| p = subprocess.Popen("/sbin/chkconfig --list", shell = True, stdout = subprocess.PIPE, stderr = subprocess.PIPE) |
| |
| result = p.communicate() |
| |
| data.errormsg = result[1].strip() |
| |
| if p.returncode: |
| return data |
| |
| startxInet = False |
| for line in result[0].splitlines(): |
| if not startxInet: |
| if re.search("xinetd based services", line): |
| startxInet = True |
| else: |
| words = line.split() |
| if len(words) != 8: |
| continue |
| levels = dict() |
| for i in range(1,8): |
| state = words[i].split(":") |
| if state[1] == 'on': |
| levels[state[0]] = True |
| else: |
| levels[state[0]] = False |
| data.services[words[0]] = levels |
| else: |
| words = line.split() |
| if len(words) != 2: |
| continue |
| name = words[0].split(":") |
| if words[1] == 'on': |
| data.xinetd[name[0]] = True |
| else: |
| data.xinetd[name[0]] = False |
| |
| |
| return data |
| |
| # argument is a reference to instantiated omreport object |
| def omReportOmVersion(data): |
| |
| # Obtain Dell OpenManage software version |
| |
| p = subprocess.Popen("omreport system version", shell = True, stdout = subprocess.PIPE, stderr = subprocess.PIPE) |
| |
| result = p.communicate() |
| |
| data.omversion_errormsg = result[1].strip() |
| |
| if p.returncode: |
| return |
| |
| nextLineisOurs = False |
| for line in result[0].splitlines(): |
| |
| words = line.split(":") |
| if len(words) != 2: |
| continue |
| |
| if nextLineisOurs: |
| data.omversion = words[1].strip() |
| break |
| |
| label = words[1].strip() |
| if label == 'Dell Server Administrator': |
| nextLineisOurs = True |
| |
| |
| |
| # argument is a reference to instantiated omreport object |
| def omReportStorageController(data): |
| |
| p = subprocess.Popen("omreport storage controller", shell = True, stdout = subprocess.PIPE, stderr = subprocess.PIPE) |
| |
| result = p.communicate() |
| |
| data.controller_errormsg = result[1].strip() |
| |
| if p.returncode: |
| return |
| |
| for line in result[0].splitlines(): |
| |
| words = line.split(":") |
| if len(words) != 2: |
| continue |
| |
| data.controller[words[0].strip()] = words[1].strip() |
| |
| |
| # argument is a reference to instantiated omreport object |
| def omReportStorageVdisk(data): |
| |
| p = subprocess.Popen("omreport storage vdisk controller=0", shell = True, stdout = subprocess.PIPE, stderr = subprocess.PIPE) |
| |
| result = p.communicate() |
| |
| data.vdisks_errormsg = result[1].strip() |
| |
| if p.returncode: |
| return |
| |
| counter = -1 |
| for line in result[0].splitlines(): |
| if re.search("ID\s*:", line): |
| counter += 1 |
| data.vdisks.append(dict()) |
| words = line.split(":") |
| if len(words) < 2: |
| continue |
| data.vdisks[counter][words[0].strip()] = ":".join(words[1:]).strip() |
| |
| |
| # argument is a reference to instantiated omreport object |
| def omReportChassisRemoteaccess(data): |
| |
| p = subprocess.Popen("omreport chassis remoteaccess", shell = True, stdout = subprocess.PIPE, stderr = subprocess.PIPE) |
| result = p.communicate() |
| |
| if p.returncode: |
| # the remote access command on omreport is flaky... retry it once |
| p = subprocess.Popen("omreport chassis remoteaccess", shell = True, stdout = subprocess.PIPE, stderr = subprocess.PIPE) |
| result = p.communicate() |
| data.remoteaccess_errormsg = result[1].strip() |
| |
| if p.returncode: |
| data.remoteaccess_errormsg = "%s\nreturn code from omreport %d" % (data.remoteaccess_errormsg, p.returncode) |
| return |
| |
| attribute = None |
| for line in result[0].splitlines(): |
| |
| if not attribute: |
| if re.search("Attribute :", line): |
| words = line.strip().split("Attribute :") |
| attribute = words[1].strip() |
| else: |
| if re.search("Value :", line): |
| words = line.strip().split("Value :") |
| data.remoteaccess[attribute] = words[1].strip() |
| |
| attribute = None |
| |
| # argument is a reference to instantiated omreport object |
| def omReportChassisBios(data): |
| |
| p = subprocess.Popen("omreport chassis bios", shell = True, stdout = subprocess.PIPE, stderr = subprocess.PIPE) |
| |
| result = p.communicate() |
| |
| data.bios_errormsg = result[1].strip() |
| |
| if p.returncode: |
| return |
| |
| for line in result[0].splitlines(): |
| |
| words = line.split(":") |
| |
| if len(words) != 2: |
| continue |
| |
| data.bios[words[0].strip()] = words[1].strip() |
| |
| # argument is a reference to instantiated omreport object |
| def omReportChassisBiossetup(data): |
| |
| p = subprocess.Popen("omreport chassis biossetup", shell = True, stdout = subprocess.PIPE, stderr = subprocess.PIPE) |
| |
| result = p.communicate() |
| |
| data.biossetup_errormsg = result[1].strip() |
| |
| if p.returncode: |
| return |
| |
| attribute = None |
| for line in result[0].splitlines(): |
| |
| if not attribute: |
| if re.search("Attribute :", line): |
| words = line.strip().split("Attribute :") |
| attribute = words[1].strip() |
| else: |
| if re.search("Setting :", line): |
| words = line.strip().split("Setting :") |
| data.biossetup[attribute] = words[1].strip() |
| |
| attribute = None |
| |
| # argument is a reference to instantiated omreport object |
| def omReportSystemAlertlog(data): |
| |
| p = subprocess.Popen("omreport system alertlog", shell = True, stdout = subprocess.PIPE, stderr = subprocess.PIPE) |
| |
| result = p.communicate() |
| |
| data.alerts_errormsg = result[1].strip() |
| |
| if p.returncode: |
| return |
| |
| openAlert = False |
| |
| for line in result[0].splitlines(): |
| |
| words = line.split(":") |
| if len(words) < 2: |
| openAlert = False |
| continue |
| |
| if len(words) != 2 and len(words) != 4: |
| continue |
| |
| key = words[0].strip() |
| |
| if len(words) == 4: |
| if words[0].strip() != 'Date and Time': |
| continue |
| |
| value = ":".join(words[1:]) |
| else: |
| value = words[1].strip() |
| |
| if key == 'Severity': |
| |
| openAlert = False |
| |
| # this is not an OK alert ... add it to the list and start adding attributes |
| if value != 'Ok': |
| workingDictionary = dict() |
| data.alerts.append(workingDictionary) |
| openAlert = True |
| |
| if openAlert: |
| # add kvp to last element in list of alerts |
| data.alerts[-1][key] = value |
| |
| |
| # argument is a reference to instantiated omreport object |
| def omReportChassisBiossetupBootorder(data): |
| |
| p = subprocess.Popen("omreport chassis biossetup attribute=bootorder", shell = True, stdout = subprocess.PIPE, stderr = subprocess.PIPE) |
| |
| result = p.communicate() |
| |
| data.bootorder_errormsg = result[1].strip() |
| |
| if p.returncode: |
| return |
| |
| for line in result[0].splitlines(): |
| if re.search("BIOS Hard Disk Sequence", line): |
| break |
| |
| if re.search("Device Name :", line): |
| words = line.strip().split("Device Name :") |
| data.bootorder.append(words[1].strip()) |
| |
| # returns populated omreport object |
| def collectOmReports(): |
| |
| data = omreport() |
| |
| omReportOmVersion(data) |
| omReportChassisBios(data) |
| omReportChassisBiossetup(data) |
| omReportChassisBiossetupBootorder(data) |
| omReportChassisRemoteaccess(data) |
| omReportStorageVdisk(data) |
| omReportStorageController(data) |
| omReportSystemAlertlog(data) |
| |
| return data |
| |
| def collectBcu(): |
| |
| data = bcu() |
| p = subprocess.Popen("bcu adapter --query 1", shell = True, stdout = subprocess.PIPE, stderr = subprocess.PIPE) |
| |
| result = p.communicate() |
| |
| data.errormsg = result[1].strip() |
| |
| if p.returncode: |
| return data |
| |
| for line in result[0].splitlines(): |
| if re.search("bios version:", line): |
| words = line.strip().split("bios version:") |
| if len(words) == 2: |
| data.biosversion = words[1].strip() |
| if re.search("fw version:", line): |
| words = line.strip().split("fw version:") |
| if len(words) == 2: |
| data.firmware = words[1].strip() |
| |
| return data |
| |
| |
| # returns populated grubconf object |
| def collectGrubConf(): |
| data = grubconf() |
| |
| try: |
| for line in open("/boot/grub/grub.conf", "r"): |
| line = removeComments(line) |
| if re.search("^serial ", line): |
| data.serial_declaration = True |
| if re.search("^terminal ", line): |
| data.terminal_declaration = True |
| if re.search("kernel", line): |
| if re.search(" console=ttyS1,", line): |
| data.ttyS1_declaration = True |
| |
| except Exception, e: |
| data.errormsg = e.__str__() |
| |
| return data |
| |
| |
| def collectUname(): |
| data = uname() |
| p = subprocess.Popen("uname -r", shell = True, |
| stdout = subprocess.PIPE, stderr = subprocess.PIPE) |
| result = p.communicate() |
| |
| if p.returncode: |
| data.errormsg = result[1].strip() |
| else: |
| data.output = result[0].strip() |
| return data |
| |
| |
| def collectCPUandMemoryInfo(): |
| data = machine() |
| |
| # cpu cores number |
| p = subprocess.Popen('grep "^processor" /proc/cpuinfo | wc -l', shell = True, |
| stdout = subprocess.PIPE, stderr = subprocess.PIPE) |
| result = p.communicate() |
| if p.returncode: |
| data.errormsg = result[1].strip() |
| else: |
| data.total_cpucores = int(result[0].strip()) |
| |
| # total memory |
| p = subprocess.Popen("head -n 1 /proc/meminfo | awk '{print $2}'", shell = True, |
| stdout = subprocess.PIPE, stderr = subprocess.PIPE) |
| result = p.communicate() |
| if p.returncode: |
| data.errormsg = result[1].strip() |
| else: |
| memory_in_KB = int(result[0].strip()) |
| data.memory_in_MB = memory_in_KB / 1024 |
| |
| return data |
| |
| |
| def collectHAWQ(): |
| if not options.hawq: |
| return None |
| data = hawq() |
| hawq_config_dir = os.environ.get('GPHOME') |
| if hawq_config_dir is None: |
| print "Please export GPHOME first, exit" |
| sys.exit(1) |
| hdfs_client_file = os.path.join(hawq_config_dir, "etc/hdfs-client.xml") |
| yarn_client_file = os.path.join(hawq_config_dir, "etc/yarn-client.xml") |
| hawq_site_file = os.path.join(hawq_config_dir, "etc/hawq-site.xml") |
| |
| # collect HDFS site config |
| getPropName = lambda node: node.getElementsByTagName('name')[0].childNodes[0].data |
| getPropValue = lambda node: node.getElementsByTagName('value')[0].childNodes[0].data |
| hawq_config_file_list = [hdfs_client_file, hawq_site_file] |
| if options.yarn: |
| hawq_config_file_list.append(yarn_client_file) |
| for filename in hawq_config_file_list: |
| try: |
| with open(filename) as f: |
| xmldoc = minidom.parse(f) |
| for node in xmldoc.getElementsByTagName('property'): |
| try: |
| data.site_config[getPropName(node)] = getPropValue(node).strip() |
| except IndexError: |
| pass # the <value> tag may be empty, which causes IndexError in getPropValue |
| |
| except Exception, e: |
| data.errormsg = "Failed to read HAWQ config file '%s': %s" % (filename, e) |
| |
| return data |
| |
| |
| def collectHDFS(): |
| if not options.hadoop: |
| return None |
| data = hdfs() |
| hawq_config_dir = os.environ.get('GPHOME') |
| if hawq_config_dir is None: |
| print "Please export GPHOME first, exit" |
| sys.exit(1) |
| hadoop_config_file = os.path.join(options.hadoop, "libexec/hadoop-config.sh") |
| hadoop_env_file = os.path.join(options.hadoop, "etc/hadoop/hadoop-env.sh") |
| hdfs_site_file = os.path.join(options.hadoop, "etc/hadoop/hdfs-site.xml") |
| yarn_site_file = os.path.join(options.hadoop, "etc/hadoop/yarn-site.xml") |
| core_site_file = os.path.join(options.hadoop, "etc/hadoop/core-site.xml") |
| |
| # collect java heap size config |
| p = subprocess.Popen(". %s; echo $JAVA_HEAP_MAX" % hadoop_config_file, shell = True, |
| stdout = subprocess.PIPE, stderr = subprocess.PIPE) |
| result = p.communicate() |
| |
| if p.returncode: |
| data.errormsg = result[1].strip() |
| return data |
| else: |
| data.max_heap_size = int(re.sub(r'[^\d]+', '', result[0])) |
| |
| # collect possible namenode/datanode heap size config |
| p = subprocess.Popen(". %s && echo $HADOOP_NAMENODE_OPTS | tr ' ' '\\n' | grep Xmx | tail -n 1" % hadoop_env_file, shell = True, |
| stdout = subprocess.PIPE, stderr = subprocess.PIPE) |
| result = p.communicate() |
| |
| if p.returncode or result[0] == '': |
| data.namenode_heap_size = data.max_heap_size |
| else: |
| data.namenode_heap_size = int(re.sub(r'[^\d]+', '', result[0])) |
| |
| # collect possible namenode/datanode heap size config |
| p = subprocess.Popen(". %s && echo $HADOOP_DATANODE_OPTS | tr ' ' '\\n' | grep Xmx | tail -n 1" % hadoop_env_file, shell = True, |
| stdout = subprocess.PIPE, stderr = subprocess.PIPE) |
| result = p.communicate() |
| |
| if p.returncode or result[0] == '': |
| data.datanode_heap_size = data.max_heap_size |
| else: |
| data.datanode_heap_size = int(re.sub(r'[^\d]+', '', result[0])) |
| |
| # collect HDFS site config |
| getPropName = lambda node: node.getElementsByTagName('name')[0].childNodes[0].data |
| getPropValue = lambda node: node.getElementsByTagName('value')[0].childNodes[0].data |
| hdfs_config_file_list = [hdfs_site_file, core_site_file] |
| if options.yarn: |
| hdfs_config_file_list.append(yarn_site_file) |
| for filename in hdfs_config_file_list: |
| try: |
| with open(filename) as f: |
| xmldoc = minidom.parse(f) |
| for node in xmldoc.getElementsByTagName('property'): |
| try: |
| data.site_config[getPropName(node)] = getPropValue(node).strip() |
| except IndexError: |
| pass # the <value> tag may be empty, which causes IndexError in getPropValue |
| |
| except Exception, e: |
| data.errormsg = "Failed to read HDFS config file '%s': %s" % (filename, e) |
| |
| return data |
| |
| |
| def collectDiskUsage(): |
| data = diskusage() |
| p = subprocess.Popen("df -Ph", shell = True, |
| stdout = subprocess.PIPE, stderr = subprocess.PIPE) |
| result = p.communicate() |
| |
| if p.returncode: |
| data.errormsg = result[1].strip() |
| else: |
| for line in result[0].splitlines()[1:]: |
| words = line.split() # [Filesystem, Size, Used, Avail, Use%, Mounted on] |
| data.lines.append(diskusage_entry(*words)) |
| return data |
| |
| |
| def collectSysctl(): |
| data = sysctl() |
| |
| for param in options.sysctl.split(","): |
| p = subprocess.Popen("/sbin/sysctl -n " + param, shell = True, |
| stdout = subprocess.PIPE, stderr = subprocess.PIPE) |
| result = p.communicate() |
| |
| if p.returncode: |
| data.errormsg = result[1].strip() |
| else: |
| # replace TAB to space, for param like 'kernel.sem' can be compare with |
| # value in gpcheck.cnf as a whole |
| data.variables[param] = result[0].strip().replace('\t', ' ') |
| |
| return data |
| |
| |
| def collectLimits(): |
| data = limitsconf() |
| try: |
| lines = [] |
| results = [open("/etc/security/limits.conf")] + [open(f) for f in glob.glob("/etc/security/limits.d/*.conf")] |
| for f in results: |
| lines += map(removeComments, f.readlines()) |
| |
| for line in lines: |
| words = line.split() |
| if len(words) == 4: |
| domain = words[0].strip() |
| type = words[1].strip() |
| item = words[2].strip() |
| value = words[3].strip() |
| data.lines.append(limitsconf_entry(domain, type, item, value)) |
| except Exception, e: |
| data.errormsg = str(e) |
| return data |
| |
| |
| def collectMounts(): |
| data = mounts() |
| |
| p = subprocess.Popen("mount", shell = True, |
| stdout = subprocess.PIPE, stderr = subprocess.PIPE) |
| result = p.communicate() |
| |
| if p.returncode: |
| data.errormsg = result[1].strip() |
| else: |
| for line in result[0].splitlines(): |
| mdata = GpMount() |
| words = line.strip().split() |
| mdata.partition = words[0] |
| mdata.dir = words[2] |
| mdata.type = words[4] |
| mdata.options = set(words[5].strip("()").split(",")) |
| data.entries[mdata.partition] = mdata |
| |
| return data |
| |
| |
| def collectIOschedulers(): |
| data = ioschedulers() |
| devices = set() |
| |
| try: |
| for f in glob.glob("/sys/block/*/queue/scheduler"): |
| words = f.split("/") |
| if len(words) == 6: |
| devices.add(words[3].strip()) |
| except Exception, e: |
| data.errormsg = str(e) |
| |
| for d in devices: |
| try: |
| fd = open("/sys/block/%s/queue/scheduler" % d, 'r') |
| scheduler = fd.read() |
| words = scheduler.split("[") |
| if len(words) != 2: |
| continue |
| words = words[1].split("]") |
| if len(words) != 2: |
| continue |
| data.devices[d] = words[0].strip() |
| |
| except Exception, e: |
| data.errormsg += str(e) |
| |
| return data |
| |
| |
| def collectBlockdev(): |
| data = blockdev() |
| try: |
| devices = glob.glob("/dev/sd*") |
| except Exception, e: |
| data.errormsg = str(e) |
| return data |
| |
| for d in devices: |
| # need "sudo" |
| p = subprocess.Popen("/sbin/blockdev --getra %s" % d, shell = True, |
| stdout = subprocess.PIPE, stderr = subprocess.PIPE) |
| result = p.communicate() |
| if p.returncode: |
| data.errormsg = result[1].strip() |
| else: |
| data.ra[d] = result[0].strip() |
| |
| return data |
| |
| |
| def collectNtpd(): |
| data = ntp() |
| |
| p = subprocess.Popen("/usr/sbin/ntpq -p", shell = True, |
| stdout = subprocess.PIPE, stderr = subprocess.PIPE) |
| result = p.communicate() |
| data.errormsg = result[1].strip() |
| |
| if not p.returncode: |
| startHosts = False |
| for line in result[0].splitlines(): |
| |
| if startHosts: |
| words = line.split() |
| if len(words) < 2: # there are actually 10 fields but we only care about the first field |
| continue |
| host = words[0].strip() |
| if host.startswith("*"): |
| host = host.lstrip("*") |
| data.hosts.add(host) |
| else: |
| if re.search("======", line): |
| startHosts = True |
| |
| p = subprocess.Popen("pgrep ntpd", shell = True, |
| stdout = subprocess.PIPE, stderr = subprocess.PIPE) |
| result = p.communicate() |
| |
| if data.errormsg: |
| data.errormsg = "%s\n%s" % (data.errormsg, result[1].strip()) |
| else: |
| data.errormsg = result[1].strip() |
| |
| if not p.returncode: |
| for line in result[0].splitlines(): |
| try: |
| pid = int(line.strip()) |
| data.running = True |
| except: |
| pass |
| |
| data.currenttime = time.time() |
| return data |
| |
| |
| def collectRclocal(): |
| |
| data = rclocal() |
| data.isexecutable = False |
| |
| try: |
| bits = os.stat('/etc/rc.d/rc.local')[stat.ST_MODE] |
| if bits & 0100: |
| data.isexecutable = True |
| |
| except Exception, e: |
| pass |
| |
| return data |
| |
| # returns populated inittab object |
| def collectInittab(): |
| data = inittab() |
| |
| try: |
| for line in open("/etc/inittab", "r"): |
| if re.search("^id:", line): |
| words = line.split(":") |
| if len(words) > 2: |
| data.defaultRunLevel = words[1] |
| |
| if re.search("^S1", line): |
| data.s1 = True |
| |
| except Exception, e: |
| data.errormsg = e.__str__() |
| |
| return data |
| |
| |
| def collectConnectemc(): |
| |
| data = connectemc() |
| |
| p = subprocess.Popen("/etc/init.d/connectemc status", shell = True, stdout = subprocess.PIPE, stderr = subprocess.PIPE) |
| |
| result = p.communicate() |
| |
| data.errormsg = result[1].strip() |
| |
| if p.returncode: |
| return data |
| |
| data.output = result[0].strip() |
| |
| return data |
| |
| |
| # returns populated securetty object |
| def collectSecuretty(): |
| data = securetty() |
| |
| try: |
| for line in open("/etc/securetty", "r"): |
| |
| val = line.strip() |
| data.data.add(val) |
| |
| except Exception, e: |
| data.errormsg = e.__str__() |
| |
| return data |
| |
| # returns poulated object of type: solaris_etc_system |
| def collectSolarisEtcSystem(): |
| |
| # create dictionary |
| data = solaris_etc_system() |
| |
| # comments begin with either a * or # |
| # lines we care about look like: set rlim_fd_max=262144 |
| |
| try: |
| for line in open("/etc/system", "r"): |
| |
| line = line.strip() |
| if line.startswith("#"): |
| continue |
| if line.startswith("*"): |
| continue |
| words = line.split("set ") |
| if len(words) != 2: |
| continue |
| words = words[1].split("=") |
| if len(words) != 2: |
| continue |
| key = words[0].strip() |
| value = words[1].strip() |
| data.parameters[key] = value |
| |
| except Exception, e: |
| data.errormsg = e.__str__() |
| |
| return data |
| |
| # returns poulated object of type: solaris_etc_project |
| def collectSolarisEtcProject(): |
| |
| # store list of lines |
| # ignore lines that start with # or do not contain : |
| data = solaris_etc_project() |
| |
| try: |
| for line in open("/etc/project", "r"): |
| |
| val = line.strip() |
| if val.startswith("#"): |
| continue |
| if not re.search(":", val): |
| continue |
| data.lines.append(val) |
| |
| except Exception, e: |
| data.errormsg = e.__str__() |
| |
| return data |
| |
| # returns poulated object of type: solaris_etc_user_attr |
| def collectSolarisEtcUserAttr(): |
| |
| # store list of lines |
| # ignore lines that start with # or do not contain : |
| data = solaris_etc_user_attr() |
| |
| try: |
| for line in open("/etc/user_attr", "r"): |
| |
| val = line.strip() |
| if val.startswith("#"): |
| continue |
| if not re.search(":", val): |
| continue |
| data.lines.append(val) |
| |
| except Exception, e: |
| data.errormsg = e.__str__() |
| |
| return data |
| |
| |
| def processGenericSolarisServer(): |
| global output |
| output = GenericSolarisOutputData() |
| output.etc_system = collectSolarisEtcSystem() |
| output.etc_project = collectSolarisEtcProject() |
| output.etc_user_attr = collectSolarisEtcUserAttr() |
| output.uname = collectUname() |
| |
| |
| def processGenericLinuxServer(): |
| global output |
| output = GenericLinuxOutputData() |
| |
| output.hdfs = collectHDFS() |
| output.hawq = collectHAWQ() |
| output.uname = collectUname() |
| output.machine = collectCPUandMemoryInfo() |
| output.diskusage = collectDiskUsage() |
| output.sysctl = collectSysctl() |
| output.limitsconf = collectLimits() |
| output.mounts = collectMounts() |
| output.ioschedulers = collectIOschedulers() |
| output.ntp = collectNtpd() |
| if getpass.getuser() == "root": |
| output.blockdev = collectBlockdev() |
| |
| |
| |
| def processApplianceServer(): |
| global output |
| output = ApplianceOutputData() |
| output.chkconfig = collectChkconfigData() |
| output.omreport = collectOmReports() |
| output.grubconf = collectGrubConf() |
| output.mounts = collectMounts() |
| output.inittab = collectInittab() |
| output.uname = collectUname() |
| output.securetty = collectSecuretty() |
| output.ioschedulers = collectIOschedulers() |
| output.blockdev = collectBlockdev() |
| output.bcu = collectBcu() |
| output.rclocal = collectRclocal() |
| output.sysctl = collectSysctl() |
| output.limitsconf = collectLimits() |
| output.connectemc = collectConnectemc() |
| output.ntp = collectNtpd() |
| |
| |
| def parseargs(): |
| global options |
| |
| parser = OptParser(option_class=OptChecker) |
| parser.remove_option('-h') |
| parser.add_option('-h', '-?', '--help', action='store_true') |
| parser.add_option('--hadoop', type='string') |
| parser.add_option('--hawq', action='store_true') |
| parser.add_option('--yarn', action='store_true') |
| parser.add_option('--sysctl', type='string') |
| parser.add_option('--appliance', action='store_true') |
| parser.add_option('--linux', action='store_true') |
| parser.add_option('--solaris', action='store_true') |
| (options, args) = parser.parse_args() |
| |
| if options.help: |
| print __doc__ |
| sys.exit(1) |
| |
| |
| if __name__ == "__main__": |
| parseargs() |
| |
| if options.solaris: |
| processGenericSolarisServer() |
| |
| elif options.linux: |
| processGenericLinuxServer() |
| |
| elif options.appliance: |
| processApplianceServer() |
| |
| else: |
| sys.stderr.write("host type not specified on command line\n") |
| sys.exit(1) |
| |
| (fd, filename) = tempfile.mkstemp(dir='/tmp', prefix='gpcheck_dump', text=True) |
| with open(filename, 'wb') as f: |
| pickle.dump(output, f) |
| |
| print filename # `gpcheck` will get the pickled filename from stdout |