| #!/usr/bin/env python2.6 |
| |
| ''' |
| 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 multiprocessing |
| import platform |
| import AmbariConfig |
| import os.path |
| import shell |
| import logging |
| import subprocess |
| import pprint |
| import traceback |
| |
| logger = logging.getLogger() |
| |
| class Hardware: |
| def __init__(self): |
| self.hardware = {} |
| osdisks = self.osdisks() |
| self.hardware['mounts'] = osdisks |
| otherInfo = self.facterInfo() |
| self.hardware.update(otherInfo) |
| pass |
| |
| def osdisks(self): |
| """ Run df to find out the disks on the host. Only works on linux |
| platforms. Note that this parser ignores any filesystems with spaces |
| and any mounts with spaces. """ |
| mounts = [] |
| df = subprocess.Popen(["df", "-kPT"], stdout=subprocess.PIPE) |
| dfdata = df.communicate()[0] |
| lines = dfdata.splitlines() |
| for l in lines: |
| split = l.split() |
| """ this ignores any spaces in the filesystemname and mounts """ |
| if (len(split)) == 7: |
| device, type, size, used, available, percent, mountpoint = split |
| mountinfo = { |
| 'size' : size, |
| 'used' : used, |
| 'available' : available, |
| 'percent' : percent, |
| 'mountpoint' : mountpoint, |
| 'type': type, |
| 'device' : device } |
| if os.access(mountpoint, os.W_OK): |
| mounts.append(mountinfo) |
| pass |
| pass |
| return mounts |
| |
| def facterBin(self, facterHome): |
| facterBin = facterHome + "/bin/facter" |
| if (os.path.exists(facterBin)): |
| return facterBin |
| else: |
| return "facter" |
| pass |
| |
| def facterLib(self, facterHome): |
| return facterHome + "/lib/" |
| pass |
| |
| def configureEnviron(self, environ): |
| if not AmbariConfig.config.has_option("puppet", "ruby_home"): |
| return environ |
| ruby_home = AmbariConfig.config.get("puppet", "ruby_home") |
| if os.path.exists(ruby_home): |
| """Only update ruby home if the config is configured""" |
| path = os.environ["PATH"] |
| if not ruby_home in path: |
| environ["PATH"] = ruby_home + os.path.sep + "bin" + ":"+environ["PATH"] |
| environ["MY_RUBY_HOME"] = ruby_home |
| return environ |
| |
| def parseFacterOutput(self, facterOutput): |
| retDict = {} |
| allLines = facterOutput.splitlines() |
| for line in allLines: |
| keyValue = line.split("=>") |
| if (len(keyValue) == 2): |
| """Ignoring values that are just spaces or do not confirm to the |
| format""" |
| strippedKey = keyValue[0].strip() |
| logger.info("Stripped key is " + strippedKey) |
| if strippedKey in ["memoryfree", "memorysize", "memorytotal"]: |
| value = keyValue[1].strip() |
| """Convert to KB""" |
| parts = value.split() |
| if len(parts) == 2: |
| mem_size = parts[1].upper() |
| if mem_size in ["GB", "G"]: |
| mem_in_kb = long(float(parts[0]) * 1024 * 1024) |
| elif mem_size in ["MB", "M"]: |
| mem_in_kb = long(float(parts[0]) * 1024) |
| elif mem_size in ["KB", "K"]: |
| mem_in_kb = long(float(parts[0])) |
| else: |
| mem_in_kb = long(float(parts[0]) / 1024) |
| else: |
| mem_in_kb = long(float(parts[0]) / 1024) |
| retDict[strippedKey] = mem_in_kb |
| pass |
| else: |
| retDict[strippedKey] = keyValue[1].strip() |
| pass |
| pass |
| pass |
| """ Convert the needed types to the true values """ |
| if 'physicalprocessorcount' in retDict.keys(): |
| retDict['physicalprocessorcount'] = int(retDict['physicalprocessorcount']) |
| pass |
| if 'is_virtual' in retDict.keys(): |
| retDict['is_virtual'] = ("true" == retDict['is_virtual']) |
| pass |
| |
| logger.info("Facter info : \n" + pprint.pformat(retDict)) |
| return retDict |
| |
| def facterInfo(self): |
| facterHome = AmbariConfig.config.get("puppet", "facter_home") |
| facterEnv = os.environ |
| logger.info("Using facter home as: " + facterHome) |
| facterInfo = {} |
| try: |
| if os.path.exists(facterHome): |
| rubyLib = "" |
| if os.environ.has_key("RUBYLIB"): |
| rubyLib = os.environ["RUBYLIB"] |
| logger.info("RUBYLIB from Env " + rubyLib) |
| if not (self.facterLib(facterHome) in rubyLib): |
| rubyLib = rubyLib + ":" + self.facterLib(facterHome) |
| |
| facterEnv["RUBYLIB"] = rubyLib |
| facterEnv = self.configureEnviron(facterEnv) |
| logger.info("Setting RUBYLIB as: " + rubyLib) |
| facter = subprocess.Popen([self.facterBin(facterHome)], |
| stdout=subprocess.PIPE, |
| stderr=subprocess.PIPE, |
| env=facterEnv) |
| stderr_out = facter.communicate() |
| if facter.returncode != 0: |
| logging.error("Error getting facter info: " + stderr_out[1]) |
| pass |
| facterOutput = stderr_out[0] |
| infoDict = self.parseFacterOutput(facterOutput) |
| facterInfo = infoDict |
| pass |
| else: |
| logger.error("Facter home at " + facterHome + " does not exist") |
| except: |
| logger.info("Traceback " + traceback.format_exc()) |
| pass |
| return facterInfo |
| |
| def get(self): |
| return self.hardware |
| |
| def main(argv=None): |
| hardware = Hardware() |
| print hardware.get() |
| |
| if __name__ == '__main__': |
| main() |
