def test_get_instances(self):
for f in os.listdir(os.path.dirname(os.path.abspath(__file__))+'/in/func'):
get_instances(os.path.dirname(os.path.abspath(__file__))+'/in/func/'+f)
with open(os.path.dirname(os.path.abspath(__file__))+'/gold/func/'+f+'cache') as af:
expected = yaml.load(af)
with open(os.path.dirname(os.path.abspath(__file__))+'/in/tmp/'+f+'cache') as af:
actual = yaml.load(af)
actual.pop('version')
self.assertEqual(actual, expected)
def load_all(self):
with open(self.filepath, 'r') as stream:
if not old_yaml:
conf_dict = yaml.load(stream, Loader=yaml.FullLoader)
else:
conf_dict = yaml.load(stream)
if isinstance(conf_dict, dict):
self.config = conf_dict
else:
raise ConfigError(
'Невозможно загрузить конфигурацию {0} - проверьте форматирование файла!'.format(
self.filepath,
),
)
def fetch_yaml():
'''fetches yaml file from mcmiddleearth,
loads, parses, and returns python object'''
response = requests.get(MCME_YAML_URL)
raw_yaml = response.content
response.close()
return yaml.load(raw_yaml)
def loads(self, a_string):
# The YAML parser does not expand tabs, let us
# expand tabs to 8 characters:
a_string = a_string.expandtabs(8)
return self.__reparse_instances(yaml.load(a_string))
def __init__(self):
self.masterpath = "/etc/meterd/"
self.server = ""
self.wdir = ""
self.fname = ""
self.user = ""
self.passw = ""
self.xmlpath = ""
try:
with open(self.masterpath + "main.yaml", 'r') as maincfg:
cfg = yaml.load(maincfg, Loader=Loader)
cfg_ftp = cfg["ftp"]
cfg_main = cfg["main"]
self.server = cfg_ftp["server"]
self.wdir = cfg_ftp["wdir"]
self.fname = cfg_ftp["fname"]
self.user = cfg_ftp["user"]
self.passw = cfg_ftp["pass"]
self.xmlpath = cfg_main["xmlpath"]
except FileNotFoundError:
logging.error("Main config file not found.")
exit(os.EX_CONFIG)
except KeyError:
logging.error("Invalid main config file.")
exit(os.EX_CONFIG)
def loads(self, a_string):
# The YAML parser does not expand tabs, let us
# expand tabs to 8 characters:
a_string = a_string.expandtabs(8)
return self.__reparse_instances(yaml.load(a_string))
def load(cls):
config_url = 'config/config.yaml'
stream = file(config_url, 'r')
mode = 'dev'
cls.data = yaml.load(stream)
logging.info("Loaded Configuration File("+config_url+") with contents:\n" + str(yaml.dump(cls.data)))
cls.data['base_url'] = cls.base_url()
cls.data['mode'] = mode
def load_config(dev):
fp = open(gloval.get_homedir() + '/config.yaml')
cfg = yaml.load(fp, Loader=yaml.FullLoader)
dev_cfg = cfg[dev]
if dev in ['MLB', '2BP', '12BP', 'PSU']:
know_dict = cfg['product']
dev_cfg[0].update({'product': cfg['product']})
dev_cfg[1].update({'product': cfg['product']})
return dev_cfg
def __init__(self, dbType):
dbConfig = yaml.load(open(DATABASE_FILE))
if not dbConfig.get(dbType):
raise TypeError("No such database type: %s" % dbType)
db = dbConfig[dbType]
self.host = db['host']
self.db = db['database']
self.user = db['username'] or ''
self.pw = db['password'] or ''
def load(file):
if not CACHE_LOAD:
return
file = cache_path(file)
y = None
try:
y = yaml.load(open(file))
except IOError as e:
logging.debug(e)
except Exception as e:
logging.warning(e)
try:
if shaOK(y) and versionOK(y):
return y
except IOError as e:
logging.debug(e)
def handle_data(notifName, notifParams, mymanager, networkID, timestamp):
print notifName, "recieved from network: " + str(networkID)
if notifName == "eventMoteJoin":
print "mote's macAddress: ", notifParams.macAddress
############# NotifHealthReport ###################
if notifName == "notifHealthReport":
global firstNotifHandled
global queueReady
mac = FormatUtils.formatMacString(notifParams.macAddress)
mac = mac.upper()
hrParser = HrParser.HrParser()
hr = hrParser.parseHr(notifParams.payload)
try:
res = mymanager.dn_getMoteConfig(notifParams.macAddress,False)
print "MoteID: ", res.moteId,", MAC: ",mac,", AP:", res.isAP,", State:", res.state, ", Routing:", res.isRouting
moteId = res.moteId
isAP = res.isAP
isRouting = res.isRouting
state = res.state
except:
print "error connecting to mote"
moteId = -1
isAP = "unknown"
isRouting = "unknown"
state = "unknown"
try:
settingsDict = moteDict[str(mac)]
except KeyError:
print "macAddress: " + str(mac) + " not found in settings"
'''
if 'settingsDict' not in locals():
try:
settingsDict = moteDict[str(moteId)]
except KeyError:
print "moteId: " + str(moteId) + " not found in settings"
if 'settingsDict' in locals():
if settingsDict['moteId'] != str(moteId):
print "warning: moteId (" + settingsDict['moteId'] + ") in settings does not match actual moteId: " + str(moteId)
x = settingsDict['x']
y = settingsDict['y']
z = settingsDict['z']
substrate = settingsDict['substrate']
antenna = settingsDict['antenna']
else:
'''
x = '0'
y = '0'
z = '0'
substrate = '0'
antenna = '0'
print "x ", x, "y ", x, "z ", z, "substrate: ", substrate, "antenna: ", antenna
dataBaseJsonString = ""
dataBaseJsonString += "{'Time': " + "'" + str(timestamp) + "' ,"
dataBaseJsonString += "'networkID' : " + str(networkID) + ","
dataBaseJsonString += "'MAC' : " + mac + ","
dataBaseJsonString += "'moteID' : " + str(moteId) + ","
dataBaseJsonString += "'isAP' : " + str(isAP) + ","
dataBaseJsonString += "'isRouting' : " + str(isRouting) + ","
dataBaseJsonString += "'state' : " + str(state) + ","
dataBaseJsonString += "'x' : " + str(x) + ","
dataBaseJsonString += "'y' : " + str(y) + ","
dataBaseJsonString += "'z' : " + str(z) + ","
dataBaseJsonString += "'substrate' : " + str(substrate) + ","
dataBaseJsonString += "'antenna' : " + str(antenna) + ","
dataBaseJsonString += "'hr' : " + str(hr) + ","
dataBaseJsonString += "'session_name': " + str(database_session['session_name']) + ","
dataBaseJsonString += "'start_time': " + "'" + str(database_session['start_time']) + "'"
dataBaseJsonString += '}'
dataBaseYaml = yaml.load(dataBaseJsonString)
dataBaseJson = json.dumps(dataBaseYaml)
with open('datafile', 'ab+') as datafile:
print timestamp
print "mac:" + mac
print "moteid: " + str(moteId)
print "payload: "
print hrParser.formatHr(hr)
#if a health notification is already in the datafile, remove the ']}' at the end of the file
#and write a ',' so the json in datafile is formatted properly
if firstNotifHandled:
datafile.seek(0, os.SEEK_END)
pos = datafile.tell() - 1
while pos > 0 and datafile.read(1) != "\n":
pos -= 1
datafile.seek(pos, os.SEEK_SET)
if pos > 0:
datafile.seek(pos, os.SEEK_SET)
datafile.truncate()
datafile.write(',\n')
#write the health report to the datafile
'''
datafile.write("\n{'Time':" + str(timestamp) + ",")
datafile.write('\n')
datafile.write("'networkID' : " + str(networkID) + ",")
datafile.write('\n')
datafile.write("'MAC' : " + mac + ",")
datafile.write('\n')
datafile.write("'moteID' : " + str(moteId) + ",")
datafile.write('\n')
datafile.write("'isAP' : " + str(isAP) + ",")
datafile.write('\n')
datafile.write("'isRouting' : " + str(isRouting) + ",")
datafile.write('\n')
datafile.write("'state' : " + str(state) + ",")
datafile.write('\n')
datafile.write(str(hr))
datafile.write('}')
datafile.write('\n')
datafile.write(']}')
datafile.write('\n')
'''
datafile.write('\n' + str(dataBaseJson))
datafile.write('\n')
datafile.write(']}')
datafile.write('\n')
print "health report handled successfully and added to datafile\n"
sendJSONtoServer(dataBaseJson)
firstNotifHandled = True
def __init__(self):
self.__exitcode = os.EX_OK
self.__interrupted = False
self.masterpath = "/etc/meterd/"
self.meters = []
self.xmlpath = ""
self.save_interval = 15
self.id = ""
self.sn = ""
self.ip = ""
signal.signal(signal.SIGINT, self.sig_handle)
try:
with open(self.masterpath + "main.yaml", 'r') as maincfg:
cfg = yaml.load(maincfg, Loader=Loader)
cfg_main = cfg["main"]
self.xmlpath = cfg_main["xmlpath"]
self.save_interval = cfg_main["save_interval"]
self.id = cfg_main["id"]
self.sn = cfg_main["sn"]
self.ip = cfg_main["ip"]
if not self.xmlpath or not self.save_interval or not self.id or not self.sn or not self.ip:
raise KeyError()
except FileNotFoundError:
logging.error("Main config file not found.")
exit(os.EX_CONFIG)
except (KeyError, ScannerError):
logging.error("Invalid main config file.")
exit(os.EX_CONFIG)
# Parse the config files
for r, d, f in os.walk(self.masterpath + "conf.d/", followlinks=False):
for file in f:
try:
with open(r + file, 'r') as metercfg:
cfg = yaml.load(metercfg, Loader=Loader)
cfg_basic = cfg["basic"]
# These settings are the same for both MBus and Modbus
protocol = cfg_basic["protocol"]
tpid = cfg_basic["tpid"]
unit = int(cfg_basic["unit"])
query_interval = int(cfg_basic["query_interval"])
query = None
if protocol == "modbus_tcp":
registers = Register.from_config(cfg["registers"])
address = cfg_basic["address"]
register_offset = int(cfg_basic["register_offset"])
query = ModbusTCPQuery(tpid, query_interval,
registers, unit, address,
register_offset)
elif protocol == "modbus_rtu":
registers = Register.from_config(cfg["registers"])
register_offset = int(cfg_basic["register_offset"])
device = cfg_basic["device"]
baudrate = int(cfg_basic["baudrate"])
parity = cfg_basic["parity"]
query = ModbusRTUQuery(tpid, query_interval,
registers, unit, device,
baudrate, parity,
register_offset)
elif protocol == "mbus":
datarecords = DataRecord.from_config(
cfg["records"])
device = cfg_basic["device"]
baudrate = int(cfg_basic["baudrate"])
parity = cfg_basic["parity"]
converter_echo = bool(cfg_basic["converter_echo"])
query = MBusQuery(tpid, query_interval,
datarecords, unit, device,
baudrate, parity, converter_echo)
else:
logging.error(
"Invalid protocol type \"{}\" in file {}. "
"Maybe this protocol will be supported in future versions."
.format(protocol, file))
exit(os.EX_CONFIG)
self.meters.append(query)
except InvalidDataTypeException as e:
logging.error(
"Invalid register data type \"{}\" in file {}.".format(
str(e), file))
exit(os.EX_CONFIG)
except InvalidEndianTypeException as e:
logging.error(
"Invalid endian type \"{}\" in file {}.".format(
str(e), file))
exit(os.EX_CONFIG)
except (KeyError, TypeError):
logging.error(
"Invalid configuration file {}.".format(file))
exit(os.EX_CONFIG)
except (IOError, PermissionError):
logging.error(
"Could not read config file {}.".format(file))
exit(os.EX_NOPERM)
if isinstance(d1[key], list):
d1[key].extend(d2_tmp)
elif isinstance(d1[key], dict):
merge(d1[key], d2_tmp)
d1.update(d2)
return d1
def load(module_name):
"""Looks for YAML settings for specific module.
Args:
module_name: the name of the module that was requested.
"""
config_path = os.path.join(settings.PROJECT_DIR, co.CONFIG_PATH,
module_name + co.CONFIG_FILE_ENDING)
config_settings = {}
try:
config_file = open(config_path, 'r').read()
except IOError, e:
print 'Could not read config file: %s' % (str(e), )
return {}
try:
config_settings = yaml.load(config_file)
except yaml.YAMLError, e:
print 'Yaml parse error: %s' % (str(e), )
return {}
return config_settings and config_settings or {}
def loadConfig(filename): global config configFile = file(filename) config = yaml.load(configFile) return config
def load_cache():
cache_file = os.path.join(gloval.get_homedir(), 'tmp/cache_image.yaml')
fp = open(cache_file)
cache = yaml.load(fp, Loader=yaml.FullLoader)
return cache
def handle_data(notifName, notifParams, mymanager, networkID, timestamp):
print notifName, "recieved from network: " + str(networkID)
if notifName == "eventMoteJoin":
print "mote's macAddress: ", notifParams.macAddress
############# NotifHealthReport ###################
if notifName == "notifHealthReport":
global firstNotifHandled
global queueReady
mac = FormatUtils.formatMacString(notifParams.macAddress)
mac = mac.upper()
hrParser = HrParser.HrParser()
hr = hrParser.parseHr(notifParams.payload)
try:
res = mymanager.dn_getMoteConfig(notifParams.macAddress, False)
print "MoteID: ", res.moteId, ", MAC: ", mac, ", AP:", res.isAP, ", State:", res.state, ", Routing:", res.isRouting
moteId = res.moteId
isAP = res.isAP
isRouting = res.isRouting
state = res.state
except:
print "error connecting to mote"
moteId = -1
isAP = "unknown"
isRouting = "unknown"
state = "unknown"
try:
settingsDict = moteDict[str(mac)]
except KeyError:
print "macAddress: " + str(mac) + " not found in settings"
'''
if 'settingsDict' not in locals():
try:
settingsDict = moteDict[str(moteId)]
except KeyError:
print "moteId: " + str(moteId) + " not found in settings"
if 'settingsDict' in locals():
if settingsDict['moteId'] != str(moteId):
print "warning: moteId (" + settingsDict['moteId'] + ") in settings does not match actual moteId: " + str(moteId)
x = settingsDict['x']
y = settingsDict['y']
z = settingsDict['z']
substrate = settingsDict['substrate']
antenna = settingsDict['antenna']
else:
'''
x = '0'
y = '0'
z = '0'
substrate = '0'
antenna = '0'
print "x ", x, "y ", x, "z ", z, "substrate: ", substrate, "antenna: ", antenna
dataBaseJsonString = ""
dataBaseJsonString += "{'Time': " + "'" + str(timestamp) + "' ,"
dataBaseJsonString += "'networkID' : " + str(networkID) + ","
dataBaseJsonString += "'MAC' : " + mac + ","
dataBaseJsonString += "'moteID' : " + str(moteId) + ","
dataBaseJsonString += "'isAP' : " + str(isAP) + ","
dataBaseJsonString += "'isRouting' : " + str(isRouting) + ","
dataBaseJsonString += "'state' : " + str(state) + ","
dataBaseJsonString += "'x' : " + str(x) + ","
dataBaseJsonString += "'y' : " + str(y) + ","
dataBaseJsonString += "'z' : " + str(z) + ","
dataBaseJsonString += "'substrate' : " + str(substrate) + ","
dataBaseJsonString += "'antenna' : " + str(antenna) + ","
dataBaseJsonString += "'hr' : " + str(hr) + ","
dataBaseJsonString += "'session_name': " + str(
database_session['session_name']) + ","
dataBaseJsonString += "'start_time': " + "'" + str(
database_session['start_time']) + "'"
dataBaseJsonString += '}'
dataBaseYaml = yaml.load(dataBaseJsonString)
dataBaseJson = json.dumps(dataBaseYaml)
with open('datafile', 'ab+') as datafile:
print timestamp
print "mac:" + mac
print "moteid: " + str(moteId)
print "payload: "
print hrParser.formatHr(hr)
#if a health notification is already in the datafile, remove the ']}' at the end of the file
#and write a ',' so the json in datafile is formatted properly
if firstNotifHandled:
datafile.seek(0, os.SEEK_END)
pos = datafile.tell() - 1
while pos > 0 and datafile.read(1) != "\n":
pos -= 1
datafile.seek(pos, os.SEEK_SET)
if pos > 0:
datafile.seek(pos, os.SEEK_SET)
datafile.truncate()
datafile.write(',\n')
#write the health report to the datafile
'''
datafile.write("\n{'Time':" + str(timestamp) + ",")
datafile.write('\n')
datafile.write("'networkID' : " + str(networkID) + ",")
datafile.write('\n')
datafile.write("'MAC' : " + mac + ",")
datafile.write('\n')
datafile.write("'moteID' : " + str(moteId) + ",")
datafile.write('\n')
datafile.write("'isAP' : " + str(isAP) + ",")
datafile.write('\n')
datafile.write("'isRouting' : " + str(isRouting) + ",")
datafile.write('\n')
datafile.write("'state' : " + str(state) + ",")
datafile.write('\n')
datafile.write(str(hr))
datafile.write('}')
datafile.write('\n')
datafile.write(']}')
datafile.write('\n')
'''
datafile.write('\n' + str(dataBaseJson))
datafile.write('\n')
datafile.write(']}')
datafile.write('\n')
print "health report handled successfully and added to datafile\n"
sendJSONtoServer(dataBaseJson)
firstNotifHandled = True
def load():
path = os.path.join(os.path.dirname(__file__), 'data', 'pkg_info.yaml')
with open(path, 'r') as f:
content = yaml.load(f)
return content
