def main(self): """ Main method for bootstrap and parsing the options. It invokes the appropriate method and """ self.log = logging.getLogger() opts = self.options args = self.args if opts.debug: self.log.setLevel(logging.DEBUG) else: self.log.setLevel(logging.WARNING) known_tags = ["prod"] # Connect to the ConfDB to update the platform self.mConfDB = SoftConfDB() allvers = {} for tag in known_tags: tmplist = [] for p in sorted(self.mConfDB.listTag(tag.upper())): tmplist.append(p) allvers[tag] = tmplist import json print json.dumps(allvers, indent=2)
class LbSdbDeleteVersion(Script): """ Delete information about a project / version """ def defineOpts(self): """ Script specific options """ parser = self.parser parser.add_option("-d", dest="debug", action="store_true", help="Display debug output") def main(self): """ Main method for bootstrap and parsing the options. It invokes the appropriate method and """ self.log = logging.getLogger() opts = self.options args = self.args if opts.debug: self.log.setLevel(logging.DEBUG) else: self.log.setLevel(logging.WARNING) if len(args) < 2: self.log.error("Not enough arguments") sys.exit(1) else: project = args[0].upper() version = args[1] # Connect to the ConfDB to update the platform self.mConfDB = SoftConfDB() self.mConfDB.deletePV(project, version)
def main(self): """ Main method for bootstrap and parsing the options. It invokes the appropriate method and """ self.log = logging.getLogger() opts = self.options args = self.args if opts.debug: self.log.setLevel(logging.DEBUG) else: self.log.setLevel(logging.WARNING) if len(args) < 2: self.log.error("Not enough arguments") sys.exit(1) else: project = args[0].upper() version = args[1] # Connect to the ConfDB to update the platform self.mConfDB = SoftConfDB() if self.options.remove: self.mConfDB.unsetReleaseFlag(project, version) else: self.mConfDB.setReleaseFlag(project, version)
class LbSdbClear(Script): """ Clears the Active or Used flags """ def defineOpts(self): """ Script specific options """ parser = self.parser parser.add_option("-d", dest="debug", action="store_true", help="Display debug output") parser.add_option("-s", dest="action", action="store", default="a", help="Set the action to be done: a: active, u: used") def main(self): """ Main method for bootstrap and parsing the options. It invokes the appropriate method and """ self.log = logging.getLogger() # Connect to the ConfDB to update the platform self.mConfDB = SoftConfDB() if self.options.action.lower() == "a": self.mConfDB.deleteActiveLinks() elif self.options.action.lower() == "u": self.mConfDB.deleteUsedLinks() else: self.log.error("Unknown action %s " % self.options.action)
def main(self): """ Main method for bootstrap and parsing the options. It invokes the appropriate method and """ self.log = logging.getLogger() opts = self.options args = self.args if opts.debug: self.log.setLevel(logging.DEBUG) else: self.log.setLevel(logging.WARNING) if len(args) < 2 : self.log.error("Not enough arguments") sys.exit(1) else : project = args[0].upper() version = args[1] # Connect to the ConfDB to update the platform self.mConfDB = SoftConfDB() buildtool = "cmake" if self.options.usecmt: if self.options.usecmake: raise Exception("Please specify one build system only") buildtool = "cmt" if self.options.remove: self.mConfDB.unsetBuildTool(project, version) else: self.mConfDB.setBuildTool(project, version, buildtool)
class LbSdbBuildTool(Script): """ Update information about a project / version to say whether it was built with CMake or CMT""" def defineOpts(self): """ Script specific options """ parser = self.parser parser.add_option("-d", dest = "debug", action = "store_true", help = "Display debug output") parser.add_option("-r", "--remove", dest = "remove", action = "store_true", default = False, help = "Remove the link to the CMake node") parser.add_option("--cmt", dest = "usecmt", action = "store_true", default = False, help = "Set the build tool to be CMT") parser.add_option("--cmake", dest = "usecmake", action = "store_true", default = False, help = "Set the build tool to be CMT") def main(self): """ Main method for bootstrap and parsing the options. It invokes the appropriate method and """ self.log = logging.getLogger() opts = self.options args = self.args if opts.debug: self.log.setLevel(logging.DEBUG) else: self.log.setLevel(logging.WARNING) if len(args) < 2 : self.log.error("Not enough arguments") sys.exit(1) else : project = args[0].upper() version = args[1] # Connect to the ConfDB to update the platform self.mConfDB = SoftConfDB() buildtool = "cmake" if self.options.usecmt: if self.options.usecmake: raise Exception("Please specify one build system only") buildtool = "cmt" if self.options.remove: self.mConfDB.unsetBuildTool(project, version) else: self.mConfDB.setBuildTool(project, version, buildtool)
def main(self): """ Main method for bootstrap and parsing the options. It invokes the appropriate method and """ self.log = logging.getLogger() # Connect to the ConfDB to update the platform self.mConfDB = SoftConfDB() if self.options.action.lower() == "a": self.mConfDB.deleteActiveLinks() elif self.options.action.lower() == "u": self.mConfDB.deleteUsedLinks() else: self.log.error("Unknown action %s " % self.options.action)
class LbSdbTag(Script): """ Update information about a project / version to say whether it was built with CMake or CMT""" def defineOpts(self): """ Script specific options """ parser = self.parser parser.add_option("-d", dest="debug", action="store_true", help="Display debug output") parser.add_option("-r", "--remove", dest="remove", action="store_true", default=False, help="Remove the link to the CMake node") parser.add_option("-p", "--platform", dest="platform", action="store", default=None, help="Set the tag to the project/version/platform") def main(self): """ Main method for bootstrap and parsing the options. It invokes the appropriate method and """ self.log = logging.getLogger() opts = self.options args = self.args if opts.debug: self.log.setLevel(logging.DEBUG) else: self.log.setLevel(logging.WARNING) if len(args) < 3: self.log.error("Not enough arguments") sys.exit(1) else: project = args[0].upper() version = args[1] tag = args[2].upper() # Connect to the ConfDB to update the platform self.mConfDB = SoftConfDB() if self.options.remove: if self.options.platform != None: self.mConfDB.unsetPlatformTag(project, version, self.options.platform, tag) else: self.mConfDB.unsetTag(project, version, tag) else: if self.options.platform != None: self.mConfDB.setPlatformTag(project, version, self.options.platform, tag) else: self.mConfDB.setTag(project, version, tag)
def main(self): """ Main method for bootstrap and parsing the options. It invokes the appropriate method and """ self.log = logging.getLogger() opts = self.options args = self.args if opts.debug: self.log.setLevel(logging.DEBUG) else: self.log.setLevel(logging.WARNING) if len(args) < 2: self.log.error("Not enough arguments") sys.exit(1) else: project = args[0].upper() version = args[1] # Connect to the ConfDB to update the platform self.mConfDB = SoftConfDB() n = self.mConfDB.mNeoDB.get_indexed_node("ProjectVersion", "ProjectVersion", project + "_" + version) dbRev = n['Rev'] svnRev = getProjectLastRev(project, version) status = "ERROR" if dbRev == svnRev: status = "OK" print "%5s %s %s" % (status, dbRev, svnRev) sys.exit(dbRev != svnRev)
class LbSdbUpdateVersion(Script): """ Update information about a project / version """ def defineOpts(self): """ Script specific options """ parser = self.parser parser.add_option("-d", dest="debug", action="store_true", help="Display debug output") parser.add_option( "-s", dest="action", action="store", default="a", help= "Set the action to be done: a: clear active flags, u: clear used flags" ) def main(self): """ Main method for bootstrap and parsing the options. It invokes the appropriate method and """ self.log = logging.getLogger() opts = self.options args = self.args if opts.debug: self.log.setLevel(logging.DEBUG) else: self.log.setLevel(logging.WARNING) if len(args) < 2: self.log.error("Not enough arguments") sys.exit(1) else: project = args[0].upper() version = args[1] # Connect to the ConfDB to update the platform self.mConfDB = SoftConfDB() if self.options.action.lower() == "a": self.mConfDB.setPVActive(project, version) elif self.options.action.lower() == "u": self.mConfDB.setPVUsed(project, version) else: self.log.error("Unknown action %s " % self.options.action)
class LbSdbAddPlatform(Script): """ Script to add platforms to a project in the Software Configuration DB. Use: LbSdbAddPlatform project version platform """ def defineOpts(self): """ Script specific options """ parser = self.parser parser.add_option("-d", dest = "debug", action = "store_true", help = "Display debug output") parser.add_option("-r", dest = "remove", action = "store_true", default=False, help = "Remove platform instead of adding") def main(self): """ Main method for bootstrap and parsing the options. It invokes the appropriate method and """ self.log = logging.getLogger() opts = self.options args = self.args if opts.debug: self.log.setLevel(logging.DEBUG) else: self.log.setLevel(logging.WARNING) if len(args) < 3 : self.log.error("Not enough arguments") sys.exit(1) else : project = args[0].upper() version = args[1] platform = args[2] # Connect to the ConfDB to update the platform self.mConfDB = SoftConfDB() if opts.remove: self.mConfDB.delPVPlatform(project, version, platform) else: self.mConfDB.addPVPlatform(project, version, platform)
class LbSdbSetApp(Script): """ Update information about a project / version """ def defineOpts(self): """ Script specific options """ parser = self.parser parser.add_option("-d", dest = "debug", action = "store_true", help = "Display debug output") parser.add_option("-r", dest = "remove", action = "store_true", default = False, help = "Remove the link to the application node") def main(self): """ Main method for bootstrap and parsing the options. It invokes the appropriate method and """ self.log = logging.getLogger() opts = self.options args = self.args if opts.debug: self.log.setLevel(logging.DEBUG) else: self.log.setLevel(logging.WARNING) if len(args) < 1 : self.log.error("Not enough arguments") sys.exit(1) else : project = args[0].upper() # Connect to the ConfDB to update the platform self.mConfDB = SoftConfDB() if self.options.remove: self.mConfDB.unsetApplication(project) else: self.mConfDB.setApplication(project)
class LbSdbGenerateVersionJSON(Script): """ Update information about a project / version to say whether it was built with CMake or CMT""" def defineOpts(self): """ Script specific options """ parser = self.parser parser.add_option("-d", dest="debug", action="store_true", help="Display debug output") def main(self): """ Main method for bootstrap and parsing the options. It invokes the appropriate method and """ self.log = logging.getLogger() opts = self.options args = self.args if opts.debug: self.log.setLevel(logging.DEBUG) else: self.log.setLevel(logging.WARNING) known_tags = ["prod"] # Connect to the ConfDB to update the platform self.mConfDB = SoftConfDB() allvers = {} for tag in known_tags: tmplist = [] for p in sorted(self.mConfDB.listTag(tag.upper())): tmplist.append(p) allvers[tag] = tmplist import json print json.dumps(allvers, indent=2)
class AppImporter: """ Main scripts class for looking up dependencies. It inherits from """ def __init__(self, autorelease=True): # Creating the SoftConfDB Object self.mConfDB = SoftConfDB() self.log = logging.getLogger() self.installArea = None self.mAutorelease = autorelease def processProjectVersion(self, p, v, alreadyDone=[], recreate=False): """ Get the dependencies for a single project """ # Cleanup the project name and version and get the SVN URL (proj, ver) = importerTranslateProject(p, v) tagpath = "" # Getting the project.cmt file with dependencies if proj.upper() == "GANGA": projcmt = self.getGangaProjectCMT(ver) else: if proj.upper() == "GAUDI": tagpath = gaudisvn.url(proj, ver, isProject=True) elif proj.upper() == "LHCBDIRAC" or proj.upper() == "DIRAC": tagpath = diracsvn.url(proj, ver, isProject=True) else: tagpath = lbsvn.url(proj, ver, isProject=True) self.log.debug("SVN PATH:" + tagpath) # Get the project.cmt file and parse it to retrieve the dependencies #if not tagpath.endswith("cmt"): # tagpath += "/cmt" projcmt = getProjectCmt(tagpath).strip() self.log.debug("Project tag SVN path:" + tagpath) deps = [] # Formatting the project name/version corver = ver if proj in ver: corver = ver.replace(proj + "_", "") proj = proj.upper() # Looking for the project version in the DB tmp = self.mConfDB.findVersion(proj, ver) rev = getPathLastRev(tagpath) createNode = False node_parent = None # First checking if the node is there with the correct revision if len(tmp) != 0: node = tmp[0][0] node_parent = node noderev = node["Rev"] if noderev != None: self.log.warning( "Project %s %s already exists with revision %s (path rev: %s)" % (proj, ver, noderev, rev)) if rev != noderev and recreate: self.log.warning( "Mismatch in revisions for %s %s, recreating" % (proj, ver)) self.log.warning( "WARNING was a retag of %s %s done? you may need to call " " lb-sdb-deletepv <proj> <ver> and reimport if " " it is the case " % (proj, ver)) try: self.mConfDB.deletePV(proj, corver) except Exception, e: self.log.error(e) createNode = True else: self.log.warning( "Project %s %s already exists without revision" % (proj, ver)) #If the node does not exist just create it... else:
def __init__(self): # Creating the SoftConfDB Object self.mConfDB = SoftConfDB() self.log = logging.getLogger() self.installArea = None self.doSvnCheck = True
class DatapkgImporter: """ Main script to look up package """ def __init__(self): # Creating the SoftConfDB Object self.mConfDB = SoftConfDB() self.log = logging.getLogger() self.installArea = None self.doSvnCheck = True def setSvnCheck(self, svncheck): """ Set the flag indicating whether the SVN check should be done """ self.doSvnCheck = svncheck def importpkg(self, project, datapkg, version, hat=None): """ Import a datapackage version """ project = project.upper() tmp = datapkg if hat != None: tmp = "/".join([hat, datapkg]) self.log.info("Checking %s %s %s" % (project, tmp, version)) # Loading the package from LbScripts pack = getPackage(datapkg) if pack.hat() != hat: raise Exception("Error importing: hat does not match conf data!") if pack.project().upper() != project: raise Exception( "Error importing: project does not match conf data!") # Check if the package actually exist if self.doSvnCheck: found = lbsvn.hasVersion(tmp, version) if not found: raise Exception("Could not find package %s %s %s in SVN" % (project, tmp, version)) # Now creating the package if it does not exist self.log.warning("Adding to DB %s %s %s" % (project, tmp, version)) self.mConfDB.getOrCreateDatapkgVersion(project, hat, datapkg, version) def importProjectDir(self, dirname, hat=None, nbdays=-1): """ Import all projects in a directory """ import os # Checking existence if not os.path.exists(dirname): raise Exception("Directory %s does not exist" % dirname) # Getting the absolute path dirabspath = os.path.realpath(os.path.abspath(dirname)) # Now iterating on the subdirs, we try and see if they are data packages # That's how we separate datapackages from hats... for entry in os.listdir(dirabspath): path = os.path.join(dirabspath, entry) # We ignores files, just processing directories... if not os.path.isdir(path): continue pack = None try: pack = getPackage(entry) except PackageConfException: # This is not a package, it maybe a hat for other packages... # but only if we're not trying to process a hat already... # CAREFUL: only handle one level hats... if hat == None: self.log.warning("Processing subdirectory %s" % entry) # Checking the date verpath = os.path.join(dirname, entry) self.importProjectDir(verpath, entry, nbdays) if pack != None: # Now performing the import self.log.info("Processing package: %s" % entry) self._importPackage(os.path.join(dirname, entry), hat, pack, nbdays) def _importPackage(self, datapkgdir, hat, pack, nbdays): """ Import all the versions of a package from a specific directory """ # First some checks... project = pack.project() datapkg = pack.Name() if hat != pack.hat(): raise Exception("Mismatch in hats: %s vs %s" % (hat, pack.hat())) if hat == None: har = "" # Now adding all the versions from the directory # Using LbCOnfigurations tool for that for ver in getVersionsFromDir(datapkgdir): self.log.info("Adding package %s %s %s %s" % (project, hat, datapkg, ver.name())) verpath = os.path.join(datapkgdir, ver.name()) processdir = True if nbdays > 0: now = datetime.now() delta = timedelta(days=nbdays) then = datetime.fromtimestamp(os.path.getctime(verpath)) if (now - then) > delta: self.log.info("Too old %s" % verpath) processdir = False if processdir == True: self.importpkg(project, datapkg, ver.name(), hat)
def __init__(self, autorelease=True): # Creating the SoftConfDB Object self.mConfDB = SoftConfDB() self.log = logging.getLogger() self.installArea = None self.mAutorelease = autorelease