def run(self):
try:
sc3wrap.dbQuery = self.query()
DataModel.Notifier.Enable()
DataModel.Notifier.SetCheckEnabled(False)
if not self.routingMode:
self.inv = SC3Inventory(self.query().loadInventory())
self.inv.load_stations("*")
self.inv.load_stations("*", "*")
self.inv.load_stations("*", "*", "*")
self.inv.load_stations("*", "*", "*", "*")
self.inv.load_instruments()
for f in self.input_files:
self.inv.load_xml(f)
self.inv.flush()
self.send_notifiers("INVENTORY")
else:
self.rtn = SC3Routing(self.query().loadRouting())
self.rtn.load_routes("*", "*")
for f in self.input_files:
self.rtn.load_xml(f)
self.rtn.flush()
self.send_notifiers("ROUTING")
except Exception:
logs.print_exc()
return False
return True
def run(self):
try:
sc3wrap.dbQuery = self.query()
DataModel.Notifier.Enable()
DataModel.Notifier.SetCheckEnabled(False)
if not self.routingMode:
self.inv = SC3Inventory(self.query().loadInventory())
self.inv.load_stations("*")
self.inv.load_stations("*", "*")
self.inv.load_stations("*", "*", "*")
self.inv.load_stations("*", "*", "*", "*")
self.inv.load_instruments()
self.inv.save_xml(self.output_file, instr=2)
else:
self.rtn = SC3Routing(self.query().loadRouting())
self.rtn.load_routes("*", "*")
if self.addAccess:
self.rtn.load_access()
self.rtn.save_xml(self.output_file, self.addAccess)
except Exception:
logs.print_exc()
return False
return True
def run(self):
try:
sc3wrap.dbQuery = self.query()
DataModel.Notifier.Enable()
DataModel.Notifier.SetCheckEnabled(False)
if not self.routingMode:
self.inv = SC3Inventory(self.query().loadInventory())
self.inv.load_stations("*")
self.inv.load_stations("*", "*")
self.inv.load_stations("*", "*", "*")
self.inv.load_stations("*", "*", "*", "*")
self.inv.load_instruments()
self.inv.save_xml(self.output_file, instr=2)
else:
self.rtn = SC3Routing(self.query().loadRouting())
self.rtn.load_routes("*", "*")
if self.addAccess:
self.rtn.load_access()
self.rtn.save_xml(self.output_file, self.addAccess)
except Exception:
logs.print_exc()
return False
return True
def run(self):
try:
if self.dcid is None:
print("Please specify datacenter/archive ID", file=sys.stderr)
return False
nettab = Nettab(self.dcid)
instdb = Instruments(self.dcid)
try:
self.__load_file(instdb.load_db, self.inst_db_file)
self.__load_file(nettab.load_statmap, self.stat_map_file)
self.__load_file(nettab.load_access_net, self.access_net_file)
self.__load_file(nettab.load_access_stat,
self.access_stat_file)
self.__load_file(instdb.load_sensor_attr,
self.sensor_attr_file)
self.__load_file(instdb.load_datalogger_attr,
self.datalogger_attr_file)
self.__load_file(nettab.load_network_attr,
self.network_attr_file)
self.__load_file(nettab.load_station_attr,
self.station_attr_file)
inv = SC3Inventory(seiscomp.datamodel.Inventory())
idx = 1
for tab in sorted(self.tab_files):
print("Loading %s (%d/%d)" %
(tab, idx, len(self.tab_files)),
file=sys.stderr)
self.__load_file(nettab.load_tab, tab)
print("Generating data structures", file=sys.stderr)
nettab.update_inventory(instdb, inv)
idx = idx + 1
if self.isExitRequested():
print("Exit requested, abort", file=sys.stderr)
return False
print("Generating output", file=sys.stderr)
ar = seiscomp.io.XMLArchive()
ar.setFormattedOutput(
self.commandline().hasOption("formatted"))
ar.create(self.out_file)
ar.writeObject(inv.obj)
ar.close()
print("Finished", file=sys.stderr)
except (IOError, NettabError) as e:
logs.error("fatal error: " + str(e))
return False
except Exception:
logs.print_exc()
return False
return True
def run(self):
try:
logs.info("ArcLink request handler v" + VERSION + " started")
logs.info("Configuration: ")
logs.info("Request handler for %s (organization) at %s (Datacenter Id)" % (self.organization, self.dcid))
logs.info("Request Dir: %s" % self.reqdir)
logs.info("Max request size: %s" % self.maxsize)
logs.info("Archive Dir: %s" % self.archdir)
logs.info("ISO Dir: %s" % self.isodir)
logs.info("NRT Dir: %s" % self.nrtdir)
logs.info("Trackdb is %s @ %s" % (self.trackdb, self.trackdir))
logs.info("Subnodelist: %s" % self.subnodelist)
logs.info("File Database: %s" % self.filedb)
subnode_addr = {}
dcid_override = {}
if self.subnodelist is not None:
fd = open(self.subnodelist)
line = fd.readline()
while line:
try:
(dcid, addr) = line.split()
subnode_addr[dcid] = addr
except ValueError:
(dcid, addr, net, sta) = line.split()
subnode_addr[dcid] = addr
dcid_override[(net,sta)] = dcid
line = fd.readline()
fd.close()
sc3wrap.dbQuery = self.query()
handler.sc3App = self
inv = Inventory(self.query().loadInventory())
rtn = Routing(self.query().loadRouting())
wf = WiggleFetcher(self.nrtdir, self.archdir, self.isodir, self.filedb,
1024*1024*self.maxsize, self.dcid, subnode_addr, dcid_override)
rh = RequestHandler(inv, rtn, wf, self.reqdir, (self.trackdir, self.trackdb),
5, self.organization, DEFAULT_LABEL)
mt = MessageThread(self.connection(), rh)
mt.start()
rh.start()
except Exception:
logs.print_exc()
return False
return True
def run(self):
try:
if self.dcid is None:
print >>sys.stderr, "Please specify datacenter/archive ID"
return False
nettab = Nettab(self.dcid)
instdb = Instruments(self.dcid)
try:
self.__load_file(instdb.load_db, self.inst_db_file)
self.__load_file(nettab.load_statmap, self.stat_map_file)
self.__load_file(nettab.load_access_net, self.access_net_file)
self.__load_file(nettab.load_access_stat, self.access_stat_file)
self.__load_file(instdb.load_sensor_attr, self.sensor_attr_file)
self.__load_file(instdb.load_datalogger_attr, self.datalogger_attr_file)
self.__load_file(nettab.load_network_attr, self.network_attr_file)
self.__load_file(nettab.load_station_attr, self.station_attr_file)
inv = SC3Inventory(DataModel.Inventory())
idx = 1
for tab in sorted(self.tab_files):
print >>sys.stderr, "Loading %s (%d/%d)" % (tab, idx, len(self.tab_files))
self.__load_file(nettab.load_tab, tab)
print >>sys.stderr, "Generating data structures"
nettab.update_inventory(instdb, inv)
idx = idx + 1
if self.isExitRequested():
print >>sys.stderr, "Exit requested, abort"
return False
print >>sys.stderr, "Generating output"
ar = IO.XMLArchive()
ar.setFormattedOutput(self.commandline().hasOption("formatted"))
ar.create(self.out_file)
ar.writeObject(inv.obj)
ar.close()
print >>sys.stderr, "Finished"
except (IOError, NettabError), e:
logs.error("fatal error: " + str(e))
return False
except Exception:
logs.print_exc()
return False
return True
def __load_module(self, path):
modname = os.path.splitext(os.path.basename(path))[0].replace('.', '_')
if modname in self.__modules:
logs.error("'%s' is already loaded!" % modname)
return
try:
mod = imp.load_source('__wi_' + modname, path)
except:
logs.error("Error loading '%s'" % modname)
logs.print_exc()
return
self.__modules[modname] = mod.WI_Module(self)
def __load_module(self, path):
modname = os.path.splitext(os.path.basename(path))[0].replace('.', '_')
if modname in self.__modules:
logs.error("'%s' is already loaded!" % modname)
return
try:
mod = imp.load_source('__wi_' + modname, path)
except:
logs.error("Error loading '%s'" % modname)
logs.print_exc()
return
self.__modules[modname] = mod.WI_Module(self)
def validateParameters(self):
try:
if self.commandline().hasOption("routing"):
self.routingMode = True
args = self.commandline().unrecognizedOptions()
if len(args) < 1:
print >>sys.stderr, "Usage: fill_db [options] files..."
return False
self.input_files = args
except Exception:
logs.print_exc()
return False
return True
def validateParameters(self):
try:
if self.commandline().hasOption("routing"):
self.routingMode = True
if self.commandline().hasOption("with-access"):
self.addAccess = True
args = self.commandline().unrecognizedOptions()
if len(args) != 1:
print >> sys.stderr, "Usage: dump_db [options] file"
return False
self.output_file = args[0]
except Exception:
logs.print_exc()
return False
return True
def validateParameters(self):
try:
if self.commandline().hasOption("routing"):
self.routingMode = True
if self.commandline().hasOption("with-access"):
self.addAccess = True
args = self.commandline().unrecognizedOptions()
if len(args) != 1:
print >>sys.stderr, "Usage: dump_db [options] file"
return False
self.output_file = args[0]
except Exception:
logs.print_exc()
return False
return True
ar = seiscomp3.IO.XMLArchive()
if not self.output:
sys.stderr.write("Writing output to stdout\n")
if not ar.create("-"):
sys.stderr.write("Cannot open open stdout\n")
return False
else:
sys.stderr.write("Writing output to %s\n" % self.output)
if not ar.create(self.output):
sys.stderr.write("Cannot open open %s\n" % self.output)
return False
ar.setFormattedOutput(self.commandline().hasOption("formatted"))
ar.writeObject(sc3Inv)
except Exception:
logs.print_exc()
return True
if __name__ == "__main__":
logs.debug = seiscomp3.Logging.debug
logs.info = seiscomp3.Logging.info
logs.notice = seiscomp3.Logging.notice
logs.warning = seiscomp3.Logging.warning
logs.error = seiscomp3.Logging.error
app = Key2DB(len(sys.argv), sys.argv)
sys.exit(app())
def run(self):
try:
seiscompRoot = self.commandline().unrecognizedOptions()[0]
sys.stderr.write("root directory: %s\n" % seiscompRoot)
try:
DCID = self.configGetString("datacenterID")
except:
logs.error("datacenterID not found in global.cfg")
return False
networkRestricted = {}
incompleteResponse = {}
global instdb
instdb = Instruments(DCID)
self.__load_file(loadGains,
os.path.join(seiscompRoot, "config", "gain.dlsv"))
# for backwards compatibility
self.__load_file(
loadGains, os.path.join(seiscompRoot, "config",
"gain.tab.out"))
self.__load_file(loadGains,
os.path.join(seiscompRoot, "config", "gain.tab"))
try:
self.__load_file(instdb.load_db,
os.path.join(seiscompRoot, "resp", "inst.db"))
self.__load_file(
instdb.load_sensor_attr,
os.path.join(seiscompRoot, "resp", "sensor_attr.csv"))
self.__load_file(
instdb.load_datalogger_attr,
os.path.join(seiscompRoot, "resp", "datalogger_attr.csv"))
except (IOError, NettabError) as e:
logs.error("fatal error: " + str(e))
return False
sc3Inv = seiscomp3.DataModel.Inventory()
inventory = InventoryWrapper(sc3Inv, DCID)
existingNetworks = set()
existingStations = set()
for f in glob.glob(os.path.join(seiscompRoot, "key", "network_*")):
try:
logs.debug("processing " + f)
netCode = f.split("/network_")[-1]
try:
kf = Keyfile(f)
except IOError as e:
logs.error(str(e))
continue
existingNetworks.add(netCode)
networkRestricted[netCode] = False
inventory.updateNetwork(netCode, kf)
except ValueError as e:
logs.error("%s: %s" % (f, str(e)))
for f in glob.glob(os.path.join(seiscompRoot, "key", "station_*")):
try:
logs.debug("processing " + f)
(netCode, staCode) = f.split("/station_")[-1].split('_', 1)
try:
kf = Keyfile(f)
except IOError as e:
logs.error(str(e))
continue
existingStations.add((netCode, staCode))
if netCode not in existingNetworks:
logs.warning(
"network %s does not exist, ignoring station %s" %
(netCode, staCode))
continue
if not hasattr(kf, "latitude") or not kf.latitude:
logs.warning("missing latitude for %s %s" %
(netCode, staCode))
continue
if not hasattr(kf, "longitude") or not kf.longitude:
logs.warning("missing longitude for %s %s" %
(netCode, staCode))
continue
if not hasattr(kf, "elevation") or not kf.elevation:
logs.warning("missing elevation for %s %s" %
(netCode, staCode))
continue
if not hasattr(kf, "depth1") or not kf.depth1:
logs.warning(
"missing depth of primary sensor for %s %s" %
(netCode, staCode))
continue
if decimal.Decimal(kf.latitude) == decimal.Decimal("0.0") and \
decimal.Decimal(kf.longitude) == decimal.Decimal("0.0"):
logs.warning("missing coordinates for %s %s" %
(netCode, staCode))
continue
if not hasattr(kf, "orientation1") or not kf.orientation1:
logs.warning(
"missing orientation of primary sensor for %s %s, using default"
% (netCode, staCode))
kf.orientation1 = "Z 0.0 -90.0; N 0.0 0.0; E 90.0 0.0"
if not hasattr(kf, "orientation2"):
kf.orientation2 = ""
if not hasattr(kf, "unit1") or not kf.unit1:
logs.warning(
"missing unit of primary sensor for %s %s, using M/S"
% (netCode, staCode))
kf.unit1 = "M/S"
if not hasattr(kf, "unit2"):
logs.warning(
"missing unit of secondary sensor for %s %s, using M/S**2"
% (netCode, staCode))
kf.unit2 = "M/S**2"
if not hasattr(kf, "type"):
kf.type = ""
restricted = False
# TODO: Make restricted part of the key file
if not inventory.updateStation(netCode, staCode,
restricted, kf):
try:
incNet = incompleteResponse[netCode]
except KeyError:
incNet = set()
incompleteResponse[netCode] = incNet
incNet.add(staCode)
except ValueError as e:
logs.error("%s: %s" % (f, str(e)))
for (netCode, restricted) in networkRestricted.items():
inventory.setNetworkRestricted(netCode, restricted)
for (netCode, network) in inventory.networks.items():
if netCode not in existingNetworks:
logs.notice("deleting network %s from inventory" %
(netCode, ))
inventory.obj.remove(network.obj)
for ((netCode, staCode), station) in inventory.stations.items():
if netCode in existingNetworks and (
netCode, staCode) not in existingStations:
logs.notice("deleting station %s_%s from inventory" %
(netCode, staCode))
inventory.networks[netCode].obj.remove(station.obj)
if incompleteResponse:
logs.info(
"The following stations are missing full response data")
logs.info("Use dlsv2inv if needed")
# for netCode in sorted(incompleteResponse.keys()):
# logs.info("%s: %s" % (netCode, " ".join(sorted(list(incompleteResponse[netCode])))))
tmpDict = sortDictionary(incompleteResponse)
for netCode in list(tmpDict.keys()):
tmpSortedList = list(tmpDict[netCode])
tmpSortedList.sort()
logs.info("%s: %s" % (netCode, " ".join(tmpSortedList)))
ar = seiscomp3.IO.XMLArchive()
if not self.output:
sys.stderr.write("Writing output to stdout\n")
if not ar.create("-"):
sys.stderr.write("Cannot open open stdout\n")
return False
else:
sys.stderr.write("Writing output to %s\n" % self.output)
if not ar.create(self.output):
sys.stderr.write("Cannot open open %s\n" % self.output)
return False
ar.setFormattedOutput(self.commandline().hasOption("formatted"))
ar.writeObject(sc3Inv)
except Exception:
logs.print_exc()
return True
if not self.output:
sys.stderr.write("Writing output to stdout\n")
if not ar.create("-"):
sys.stderr.write("Cannot open open stdout\n")
return False
else:
sys.stderr.write("Writing output to %s\n" % self.output)
if not ar.create(self.output):
sys.stderr.write("Cannot open open %s\n" % self.output)
return False
ar.setFormattedOutput(self.commandline().hasOption("formatted"))
ar.writeObject(sc3Inv)
except Exception:
logs.print_exc()
return True
if __name__ == "__main__":
logs.debug = seiscomp3.Logging.debug
logs.info = seiscomp3.Logging.info
logs.notice = seiscomp3.Logging.notice
logs.warning = seiscomp3.Logging.warning
logs.error = seiscomp3.Logging.error
app = Key2DB(len(sys.argv), sys.argv)
sys.exit(app())
def validateParameters(self):
try:
opts = self.commandline().unrecognizedOptions()
if len(opts) < 1:
self.input_dir = os.path.join(
seiscomp.system.Environment.Instance().appConfigDir(),
"nettab")
else:
self.input_dir = opts[0]
if len(opts) < 2:
self.out_file = "-"
else:
self.out_file = opts[1]
if self.commandline().hasOption("dcid"):
self.dcid = self.commandline().optionString("dcid")
if self.commandline().hasOption("stat-map"):
self.stat_map_file = self.commandline().optionString(
"stat-map")
else:
self.stat_map_file = os.path.join(self.input_dir,
"stat_map.lst")
if self.commandline().hasOption("access-net"):
self.access_net_file = self.commandline().optionString(
"access-net")
else:
self.access_net_file = os.path.join(self.input_dir,
"access.net")
if self.commandline().hasOption("access-stat"):
self.access_stat_file = self.commandline().optionString(
"access-stat")
else:
self.access_stat_file = os.path.join(self.input_dir,
"access.stat")
if self.commandline().hasOption("sensor-attr"):
self.sensor_attr_file = self.commandline().optionString(
"sensor-attr")
else:
self.sensor_attr_file = os.path.join(self.input_dir,
"sensor_attr.csv")
if self.commandline().hasOption("datalogger-attr"):
self.datalogger_attr_file = self.commandline().optionString(
"datalogger-attr")
else:
self.datalogger_attr_file = os.path.join(
self.input_dir, "datalogger_attr.csv")
if self.commandline().hasOption("network-attr"):
self.network_attr_file = self.commandline().optionString(
"network-attr")
else:
self.network_attr_file = os.path.join(self.input_dir,
"network_attr.csv")
if self.commandline().hasOption("station-attr"):
self.station_attr_file = self.commandline().optionString(
"station-attr")
else:
self.station_attr_file = os.path.join(self.input_dir,
"station_attr.csv")
if self.commandline().hasOption("inst-db"):
self.inst_db_file = self.commandline().optionString("inst-db")
else:
self.inst_db_file = os.path.join(self.input_dir, "inst.db")
except Exception:
logs.print_exc()
return False
self.tab_files = glob.glob(os.path.join(self.input_dir, "*.tab"))
return True
def validateParameters(self):
try:
opts = self.commandline().unrecognizedOptions()
if len(opts) < 1:
self.input_dir = os.path.join(System.Environment.Instance().appConfigDir(), "nettab")
else:
self.input_dir = opts[0]
if len(opts) < 2:
self.out_file = "-"
else:
self.out_file = opts[1]
if self.commandline().hasOption("dcid"):
self.dcid = self.commandline().optionString("dcid")
if self.commandline().hasOption("stat-map"):
self.stat_map_file = self.commandline().optionString("stat-map")
else:
self.stat_map_file = os.path.join(self.input_dir, "stat_map.lst")
if self.commandline().hasOption("access-net"):
self.access_net_file = self.commandline().optionString("access-net")
else:
self.access_net_file = os.path.join(self.input_dir, "access.net")
if self.commandline().hasOption("access-stat"):
self.access_stat_file = self.commandline().optionString("access-stat")
else:
self.access_stat_file = os.path.join(self.input_dir, "access.stat")
if self.commandline().hasOption("sensor-attr"):
self.sensor_attr_file = self.commandline().optionString("sensor-attr")
else:
self.sensor_attr_file = os.path.join(self.input_dir, "sensor_attr.csv")
if self.commandline().hasOption("datalogger-attr"):
self.datalogger_attr_file = self.commandline().optionString("datalogger-attr")
else:
self.datalogger_attr_file = os.path.join(self.input_dir, "datalogger_attr.csv")
if self.commandline().hasOption("network-attr"):
self.network_attr_file = self.commandline().optionString("network-attr")
else:
self.network_attr_file = os.path.join(self.input_dir, "network_attr.csv")
if self.commandline().hasOption("station-attr"):
self.station_attr_file = self.commandline().optionString("station-attr")
else:
self.station_attr_file = os.path.join(self.input_dir, "station_attr.csv")
if self.commandline().hasOption("inst-db"):
self.inst_db_file = self.commandline().optionString("inst-db")
else:
self.inst_db_file = os.path.join(self.input_dir, "inst.db")
except Exception:
logs.print_exc()
return False
self.tab_files = glob.glob(os.path.join(self.input_dir, "*.tab"))
return True
