1 files changed, 137 insertions, 0 deletions
diff --git a/validator/src/validation_tool/src/test/probe.py b/validator/src/validation_tool/src/test/probe.py
new file mode 100644
index 0000000..daeccbc
--- /dev/null
+++ b/validator/src/validation_tool/src/test/probe.py
@@ -0,0 +1,137 @@
+##############################################################################
+# Copyright (c) 2015 Todd Gaunt and others.
+#
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Apache License, Version 2.0
+# which accompanies this distribution, and is available at
+# http://www.apache.org/licenses/LICENSE-2.0
+##############################################################################
+
+import os
+import re
+import sys
+import platform
+import subprocess
+import netifaces
+import logging
+
+from pharosvalidator.util import cd # Contains the pharos specification values
+
+# Static vars
+mempath="/proc/meminfo"
+cpuinfopath="/proc/cpuinfo"
+cpupath="/sys/devices/system/cpu/"
+diskpath="/sys/block/"
+
+def readproc(path):
+    """Reads and parses /proc from [path] argument files
+    and returns a hashmap of values"""
+    logger = logging.getLogger(__name__)
+    # Fail if path does not exist
+    try:
+        hashmap = {}
+        with open(path) as fd:
+            logger.debug("Reading {}".format(path))
+            for line in fd:
+                data = line.split(":")
+                if len(data) == 2:
+                    # Strip trailing characters from hashmap names and entries
+                    # for less junk
+                    hashmap[data[0].strip()] = data[1].strip()
+        return hashmap
+    except IOError:
+        logger.error("Path to file does not exist: {}".format(path))
+        quit(1)
+
+def cpu():
+    logger = logging.getLogger(__name__)
+    cpudata = {}
+    cpuinfo = readproc(cpuinfopath)
+    cpudata["bitsize"] = sys.maxsize.bit_length()
+    cpudata["architecture"] = platform.architecture()[0]
+    cpudata["cores"] = int(cpuinfo["cpu cores"])
+    cpudata["frequency"] = []
+    for i in range(cpudata["cores"]):
+        freqpath = "{0}/cpu{1}/cpufreq/cpuinfo_max_freq".format(cpupath, \
+                                                                str(i))
+        try:
+            with open(freqpath) as fd:
+                logger.debug("Opening {}".format(freqpath))
+                cpufreq = (float(fd.read(-1)))/1000
+        except IOError:
+            # Less accurate way of getting cpu information as
+            # this frequency may change during operation,
+            # if dynamic frequency scaling is enabled,
+            # however it is better than nothing.
+            logger.error("Path to file does not exist: {}".format(freqpath))
+            logger.error("Reading cpu frequency from {} instead".format(freqpath))
+            cpufreq = float(cpuinfo["cpu MHz"])
+
+        if cpufreq < 0:
+            cpudata["frequency"].append(0)
+        else:
+            cpudata["frequency"].append(cpufreq)
+
+    return cpudata
+
+def memory():
+    logger = logging.getLogger(__name__)
+    meminfo=readproc(mempath)
+    # Create the memory object to store memory information
+    memdata = {}
+    memdata["size"] = (int(meminfo["MemTotal"].split(' ')[0]))/1000000
+    return memdata
+
+def storage():
+    """Gather's disk information"""
+    logger = logging.getLogger(__name__)
+    diskdata = {"names":[],"rotational":{},"sizes":{}}
+    for disk in os.listdir(diskpath):
+        #sdX is the naming schema for IDE/SATA interfaces in Linux
+        if re.match(r"sd\w",disk):
+            logger.debug("Found disk {}".format(disk))
+            diskdata["names"].append(disk)
+            sizepath = "{0}/{1}/size".format(diskpath, disk)
+            try:
+                with open(sizepath) as fd:
+                    size = int(fd.read(-1))
+            except IOError:
+                size = -1
+            # If the read was successful
+            if size != -1:
+                # Converts the value to Gb
+                diskdata["sizes"][disk] = (size * 512)/1000000000
+
+            rotationalpath = "{0}/{1}/queue/rotational".format(diskpath, disk)
+            try:
+                with open(rotationalpath) as fd:
+                    rotational = int(fd.read(-1))
+            except IOError:
+                rotational = -1
+            if rotational == 0:
+                diskdata["rotational"][disk] = False
+            else:
+                diskdata["rotational"][disk] = True
+
+    return diskdata
+
+def netinterfaces(nodeinfo):
+    """Uses netifaces to probe the system for network interface information"""
+    netfaces = []
+    for interface in netifaces.interfaces():
+        netface = netdata()
+        netface.name = interface
+        tmp = netifaces.ifaddresses(interface)
+        # If the interface is up and has at least one ip address
+        if netifaces.AF_INET in tmp:
+            netface.status = 1 # 1 stands for "up"
+            netface.addrs = tmp[netifaces.AF_INET]
+        # If the interface is down
+        else:
+            netface.status = 0 # 0 stands for "down"
+        # The file /proc/net/arp may also be used to read MAC addresses
+        if netifaces.AF_LINK in tmp:
+            netface.MAC = tmp[netifaces.AF_LINK]
+        netfaces.append(netface)
+
+    return netfaces