def __init__(self, parmIdentifier=None, dbId=None, level=None): self.parmName = None self.parmLevel = None self.dbId = None self.compositeName = None self.shortParmId = None self.parmId = None if (parmIdentifier is not None) and (dbId is not None): self.parmName = parmIdentifier if type(dbId) is DatabaseID: self.dbId = dbId elif type(dbId) is str: self.dbId = DatabaseID(dbId) else: raise TypeError("Invalid database ID specified.") if level is None: self.parmLevel = self.defaultLevel() else: self.parmLevel = level self.__encodeIdentifier() elif parmIdentifier is not None: self.__decodeIdentifier(parmIdentifier) self.__encodeIdentifier()
def __decodeIdentifier(self, parmIdentifier): parts = parmIdentifier.split(":") nameLevel = parts[0].split("_") self.dbId = DatabaseID(parts[1]) if (len(nameLevel) == 2): self.parmName = nameLevel[0] self.parmLevel = nameLevel[1] else: self.parmName = nameLevel[0] self.parmLevel = self.defaultLevel()
def __call__(self, parser, namespace, values, option_string=None): did = DatabaseID(values) if did.isValid(): if (hasattr(namespace, self.dest)) and \ (getattr(namespace, self.dest) is not None): currentValues = getattr(namespace, self.dest) currentValues.append(did) setattr(namespace, self.dest, currentValues) else: setattr(namespace, self.dest, [did]) else: parser.error("DatabaseID [" + values + "] not valid identifier")
def validateArgs(): parser = UsageArgumentParser.UsageArgumentParser(prog='ifpBreakAllLocks', conflict_handler="resolve") parser.add_argument("-h", action="store", dest="host", help="The host the ifpServer is running on", metavar="host") parser.add_argument("-p", action="store", type=int, dest="port", help="The port number the server is using", metavar="port") parser.add_argument("-s", action="store", dest="siteID", help="Site ID", metavar="siteID") parser.add_argument("-a", action="store_true", dest="allLocks", help="Break locks on all databases") parser.add_argument("-d", action="append", dest="databaseIDs", default=[], help="Break locks on specified database identifier", metavar="databaseID") options = parser.parse_args() if options.host == None: if "CDSHOST" in os.environ: options.host = os.environ["CDSHOST"] else: parser.error("Error: host is not specified.") if options.port == None: if "CDSPORT" in os.environ: options.port = int(os.environ["CDSPORT"]) else: parser.error("Error: port is not specified.") if options.allLocks == False and not options.databaseIDs: parser.error("Error: either -a or -d are required.") invalidDbIds = [] if not options.allLocks: for db in options.databaseIDs: if not DatabaseID(dbIdentifier=db).isValid(): invalidDbIds.append(db) if invalidDbIds: parser.error("Invalid DatabaseIDs specified: {}".format(invalidDbIds)) return options
def __call__(self, parser, namespace, values, option_string=None): (isValid, dateTime) = DatabaseID.decodeDtg(values) if isValid: setattr(namespace, self.dest, dateTime) else: parser.error(str(self.dest) + " not in yyyymmdd_hhmm format")
def __call__(self, parser, namespace, values, option_string=None): did = DatabaseID(values) if did.isValid(): setattr(namespace, self.dest, did) else: parser.error("DatabaseID [" + values + "] not a valid identifier")
def deserialize(context): result = DatabaseID(context.readString()) return result
def __call__(self, parser, namespace, values, option_string=None): (isValid, dateTime) = DatabaseID.decodeDtg(values) if isValid: setattr(namespace, self.dest, dateTime) else: parser.error("Argument for option " + option_string + " not in yyyymmdd_hhmm format")
class ParmID(object): def __init__(self, parmIdentifier=None, dbId=None, level=None): self.parmName = None self.parmLevel = None self.dbId = None self.compositeName = None self.shortParmId = None self.parmId = None if (parmIdentifier is not None) and (dbId is not None): self.parmName = parmIdentifier if type(dbId) is DatabaseID: self.dbId = dbId elif type(dbId) is str: self.dbId = DatabaseID(dbId) else: raise TypeError("Invalid database ID specified.") if level is None: self.parmLevel = self.defaultLevel() else: self.parmLevel = level self.__encodeIdentifier() elif parmIdentifier is not None: self.__decodeIdentifier(parmIdentifier) self.__encodeIdentifier() def getParmName(self): return self.parmName def getParmLevel(self): return self.parmLevel def getDbId(self): return self.dbId def getCompositeName(self): return self.compositeName def getShortParmId(self): return self.shortParmId def getParmId(self): return self.parmId def __decodeIdentifier(self, parmIdentifier): parts = parmIdentifier.split(":") nameLevel = parts[0].split("_") self.dbId = DatabaseID(parts[1]) if (len(nameLevel) == 2): self.parmName = nameLevel[0] self.parmLevel = nameLevel[1] else: self.parmName = nameLevel[0] self.parmLevel = self.defaultLevel() def __encodeIdentifier(self): self.compositeName = self.parmName + "_" + self.parmLevel self.shortParmId = self.compositeName + ":" + self.dbId.getShortModelId( ) self.parmId = self.compositeName + ":" + self.dbId.getModelId() def isValid(self): if len(self.parmName) is None or len( self.parmLevel) is None or self.dbId is None: return False if len(self.parmName) < 1 or len( self.parmLevel) < 1 or not self.dbId.isValid(): return False if not self.parmName.isalnum(): return False if not self.parmLevel.isalnum(): return False return True @staticmethod def defaultLevel(): return "SFC" @staticmethod def parmNameAndLevel(composite): pos = composite.find('_') if pos != -1: return (composite[:pos], composite[pos + 1:]) else: return (composite, "SFC") def __str__(self): return self.__repr__() def __repr__(self): return self.parmName + '_' + self.parmLevel + ":" + str(self.dbId) def __hash__(self): return hash(self.parmId) def __cmp__(self, other): if isinstance(other, ParmID): nameComp = cmp(self.parmName, other.parmName) if nameComp != 0: return nameComp levelComp = cmp(self.parmLevel, other.parmLevel) if levelComp != 0: return levelComp return cmp(self.dbId, other.dbId) else: return NotImplemented def __eq__(self, other): if not isinstance(other, ParmID): return False if self.dbId != other.dbId: return False if self.parmLevel != other.parmLevel: return False if self.parmName != other.parmName: return False return True def __ne__(self, other): return (not self.__eq__(other))
class ParmID(object): def __init__(self, parmIdentifier=None, dbId=None, level=None): self.parmName = None self.parmLevel = None self.dbId = None self.compositeName = None self.shortParmId = None self.parmId = None if (parmIdentifier is not None) and (dbId is not None): self.parmName = parmIdentifier if type(dbId) is DatabaseID: self.dbId = dbId elif type(dbId) is str: self.dbId = DatabaseID(dbId) else: raise TypeError("Invalid database ID specified.") if level is None: self.parmLevel = self.defaultLevel() else: self.parmLevel = level self.__encodeIdentifier() elif parmIdentifier is not None: self.__decodeIdentifier(parmIdentifier) self.__encodeIdentifier() def getParmName(self): return self.parmName def getParmLevel(self): return self.parmLevel def getDbId(self): return self.dbId def getCompositeName(self): return self.compositeName def getShortParmId(self): return self.shortParmId def getParmId(self): return self.parmId def __decodeIdentifier(self, parmIdentifier): parts = parmIdentifier.split(":") nameLevel = parts[0].split("_") self.dbId = DatabaseID(parts[1]) if (len(nameLevel) == 2): self.parmName = nameLevel[0] self.parmLevel = nameLevel[1] else: self.parmName = nameLevel[0] self.parmLevel = self.defaultLevel() def __encodeIdentifier(self): self.compositeName = self.parmName + "_" + self.parmLevel self.shortParmId = self.compositeName + ":" + self.dbId.getShortModelId() self.parmId = self.compositeName + ":" + self.dbId.getModelId() def isValid(self): if len(self.parmName) is None or len(self.parmLevel) is None or self.dbId is None: return False if len(self.parmName) < 1 or len(self.parmLevel) < 1 or not self.dbId.isValid(): return False if not self.parmName.isalnum(): return False if not self.parmLevel.isalnum(): return False return True @staticmethod def defaultLevel(): return "SFC" @staticmethod def parmNameAndLevel(composite): pos = composite.find('_') if pos != -1: return (composite[:pos], composite[pos+1:]) else: return (composite, "SFC") def __str__(self): return self.__repr__() def __repr__(self): return self.parmName + '_' + self.parmLevel + ":" + str(self.dbId) def __hash__(self): return hash(self.parmId) def __cmp__(self, other): if isinstance(other, ParmID): nameComp = cmp(self.parmName, other.parmName) if nameComp != 0: return nameComp levelComp = cmp(self.parmLevel, other.parmLevel) if levelComp != 0: return levelComp return cmp(self.dbId, other.dbId) else: return NotImplemented def __eq__(self, other): if not isinstance(other, ParmID): return False if self.dbId != other.dbId: return False if self.parmLevel != other.parmLevel: return False if self.parmName != other.parmName: return False return True def __ne__(self, other): return (not self.__eq__(other))
def main(): __initLogger() logger.info("Publish Fcst Data to Official") args = validateArgs() logger.debug("Command-line arguments: " + str(args)) # build IFPClient object db = IFPClient.IFPClient(args.host, args.port, args.user, args.site, "publishGFE") # get site id siteID = args.site if siteID is None or len(siteID) == 0: sr = db.getSiteID() if not sr.isOkay(): logger.error("Unable to determine site id: " + sr.message()) sys.exit(1) siteID = sr.getPayload()[0] # calculate list of parms dbid = DatabaseID(siteID + "_GRID__Fcst_00000000_0000") sr = db.getParmList(dbid) if not sr.isOkay(): logger.error("Unable to determine parms: " + sr.message()) sys.exit(1) parmsInDb = sr.getPayload() commitParmList = [] if len(args.parmNamesAndLevels) == 0: commitParmList = parmsInDb else: for parm in args.parmNamesAndLevels: tx = ParmID.parmNameAndLevel(parm) found = False for dbParm in parmsInDb: if dbParm.getParmName() == tx[0] and dbParm.getParmLevel() == tx[1]: commitParmList.append(dbParm) found = True if not found: logger.warning("Unable to find parm [" + str(parm) + "] in database [" + str(dbid) + "]") # calculate time ranges tr = args.tr if len(args.definedTR) > 0: sr = db.getSelectTR(args.definedTR) if not sr.isOkay(): logger.error("Unable to find select tr definition: " + sr.message()) sys.exit(1) tr = sr.getPayload() # CommitGridRequest(parmid, commitTime) requests = [] for parm in commitParmList: inv = [] sr = db.getGridInventory(parm) if not sr.isOkay(): logger.error("Unable to get grid inventory: " + sr.message()) sys.exit(1) inv = sr.getPayload() expandTR = expandToParmInv(inv, tr) req = CommitGridRequest() req.setParmId(parm) req.setTimeRange(expandTR) requests.append(req) logger.debug(parm.getParmName() + ' ' + str(tr)) # commit grid sr = db.commitGrid(requests) if not sr.isOkay(): logger.error("Unable to publish grids: " + sr.message()) sys.exit(1) else: logger.info("Publish completed.")