def main():
wsOpts = WSOpts()
parser = wsOpts.get_common_opts()
parser.add_option("--check", dest="action", action="store_const", const="check", \
help="Check server commit status")
parser.add_option("--start", dest="action", action="store_const", const="start", \
help="Start accepting commits if turned off")
parser.add_option("--stop", dest="action", action="store_const", const="stop", \
help="Stop new commits, wait till they finish")
parser.add_option("--stop-now", dest="action", action="store_const", const="stop-now", \
help="Stop new commits, don't wait till they finish")
(options, args) = parser.parse_args()
wsOpts.setLogging(options.debug)
if wsOpts.checkRequiredMissing(options, ('action', )):
parser.print_help()
sys.exit(-1)
wsOpts.setLogging(options.debug)
configServiceClient = ConfigServiceClient(options)
configServiceClient.new_commits(options.action)
def main():
wsOpts = WSOpts()
parser = wsOpts.get_common_opts()
parser.add_option("--username",
dest="username",
help="User to add to group")
parser.add_option("--email",
dest="email",
help="New email to replace existing")
parser.add_option("--role", dest="role", help="New role to add")
(options, args) = parser.parse_args()
if wsOpts.checkRequiredMissing(options, ('username', 'email'),
('username', 'role')):
logging.error("Must specify username and either new email or new role")
sys.exit(-1)
configServiceClient = ConfigServiceClient(options)
configServiceClient.update_user(options.username, options.email,
options.role)
def main():
wsOpts = WSOpts()
parser = wsOpts.get_common_opts()
parser.add_option("--username", dest="username", help="Username")
parser.add_option("--first", dest="first", help="First name")
parser.add_option("--last", dest="last", help="Last Name")
parser.add_option("--email", dest="email", help="Email")
parser.add_option("--group", dest="group", help="Local Groups to add to")
parser.add_option("--role", dest="role", help="Role")
parser.add_option("--ldap", default=False, dest="ldap", action="store_true", help="LDAP or local account, specify for LDAP, default is local")
(options, args) = parser.parse_args()
wsOpts.setLogging(options.debug)
if wsOpts.checkRequiredMissing(options, ('username',)):
parser.print_help()
sys.exit(-1)
configServiceClient = ConfigServiceClient(options);
if options.ldap:
logging.debug("Creating ldap account " + options.username)
configServiceClient.create_user(options.username, ldap=True,role=options.role,groups=options.group)
else:
logging.debug("Creating local account " + options.username)
configServiceClient.create_user(options.username,options.first,options.last,options.email,options.group,'coverity',role=options.role)
def main():
wsOpts = WSOpts()
parser = wsOpts.get_common_opts()
parser.add_option("--username",
dest="username",
help="User to print details")
(options, args) = parser.parse_args()
wsOpts.setLogging(options.debug)
if wsOpts.checkRequiredMissing(options, ('username', )):
parser.print_help()
sys.exit(-1)
configServiceClient = ConfigServiceClient(options)
u = configServiceClient.user_details(options.username)
logging.debug(u)
for attr in u.__dict__.keys():
if attr[0:2] == '__':
continue
if type(getattr(u, attr, None)) == type([]):
logging.debug("Skipping attribute " + attr)
# could add special handling for groups and roles
continue
if getattr(u, attr, None):
print attr, " \tis \t", getattr(u, attr)
def main():
wsOpts = WSOpts()
parser = wsOpts.get_common_opts()
parser.add_option("--file",
dest="filename",
help="Limit defects to those in file <filename>")
(options, args) = parser.parse_args()
wsOpts.setLogging(options.debug)
if wsOpts.checkRequiredMissing(options, ()):
parser.print_help()
sys.exit(-1)
configServiceClient = ConfigServiceClient(options)
defectServiceClient = DefectServiceClient(options)
streamIdDO = configServiceClient.get_streams(options.project,
options.stream)
if not streamIdDO:
logging.error("Not a valid stream")
sys.exit(1)
mergedDefectDOs = defectServiceClient.get_merged_defects(
streamIdDO, statusFilter='New', filename=options.filename)
total = mergedDefectDOs.totalNumberOfRecords
if total < 1:
sys.exit(1)
mdDOs = mergedDefectDOs.mergedDefects
for md in sorted(mdDOs):
defectServiceClient.print_stream_defect_brief(md.cid, streamIdDO[0],
options.project)
def main():
wsOpts = WSOpts()
parser = wsOpts.get_common_opts()
parser.add_option("--check", dest="action", action="store_const", const="check", \
help="Check server commit status")
parser.add_option("--start", dest="action", action="store_const", const="start", \
help="Start accepting commits if turned off")
parser.add_option("--stop", dest="action", action="store_const", const="stop", \
help="Stop new commits, wait till they finish")
parser.add_option("--stop-now", dest="action", action="store_const", const="stop-now", \
help="Stop new commits, don't wait till they finish")
(options, args) = parser.parse_args()
wsOpts.setLogging(options.debug)
if wsOpts.checkRequiredMissing(options, ('action',)):
parser.print_help()
sys.exit(-1)
wsOpts.setLogging(options.debug)
configServiceClient = ConfigServiceClient(options)
configServiceClient.new_commits(options.action)
def main():
wsOpts = WSOpts()
parser = wsOpts.get_common_opts()
parser.add_option("--username",dest="username",help="User to print details")
(options, args) = parser.parse_args()
wsOpts.setLogging(options.debug)
if wsOpts.checkRequiredMissing(options, ('username',)):
parser.print_help()
sys.exit(-1)
configServiceClient = ConfigServiceClient(options)
u=configServiceClient.user_details(options.username)
logging.debug(u)
for attr in u.__dict__.keys():
if attr[0:2] == '__':
continue
if type(getattr(u, attr, None)) == type([]):
logging.debug("Skipping attribute " + attr)
# could add special handling for groups and roles
continue
if getattr(u, attr, None):
print attr," \tis \t", getattr(u, attr)
def main():
wsOpts = WSOpts()
parser = wsOpts.get_common_opts()
parser.add_option("--file", dest="filename", help="Limit defects to those in file <filename>")
(options, args) = parser.parse_args()
wsOpts.setLogging(options.debug)
if wsOpts.checkRequiredMissing(options, ()):
parser.print_help()
sys.exit(-1)
configServiceClient = ConfigServiceClient(options)
defectServiceClient = DefectServiceClient(options)
streamIdDO = configServiceClient.get_streams(options.project, options.stream)
if not streamIdDO:
logging.error("Not a valid stream")
sys.exit(1)
mergedDefectDOs = defectServiceClient.get_merged_defects(streamIdDO, statusFilter="New", filename=options.filename)
total = mergedDefectDOs.totalNumberOfRecords
if total < 1:
sys.exit(1)
mdDOs = mergedDefectDOs.mergedDefects
for md in sorted(mdDOs):
defectServiceClient.print_stream_defect_brief(md.cid, streamIdDO[0], options.project)
def main():
wsOpts = WSOpts()
parser = wsOpts.get_common_opts()
parser.add_option("--file",
dest="filename",
help="Limit defects to those in file <filename>")
(options, args) = parser.parse_args()
wsOpts.setLogging(options.debug)
if wsOpts.checkRequiredMissing(options, ()):
parser.print_help()
sys.exit(-1)
configServiceClient = ConfigServiceClient(options)
defectServiceClient = DefectServiceClient(options)
streamIdDO = configServiceClient.get_streams(options.project,
options.stream)
if not streamIdDO:
print "Not a valid stream"
sys.exit(1)
mergedDefectDOs = defectServiceClient.get_merged_defects(
streamIdDO, filename=options.filename)
#Y mergedDefectDOs = defectServiceClient.get_merged_defects(streamIdDO, statusFilter='New', filename=options.filename)
total = mergedDefectDOs.totalNumberOfRecords
if total < 1:
logging.warning("No new defects")
sys.exit(1)
mdDOs = mergedDefectDOs.mergedDefects
logging.debug("Got " + str(len(mdDOs)) + " defects")
for md in sorted(mdDOs):
if md.severity in ['Major']:
logging.debug(md)
logging.debug(md.checkerName)
logging.debug(md.checkerSubcategory)
logging.debug(md.domain)
cat = configServiceClient.get_checker_properties(
md.checkerName, md.checkerSubcategory, md.domain)
if cat:
print cat.categoryDescription
print cat.subcategoryLocalEffect
print cat.subcategoryLongDescription
defectServiceClient.print_stream_defect_occurrences(
md.cid, streamIdDO[0], options.project)
c = getattr(md, 'comment', None)
if c:
print "Last comment [asya]: ", c
print ""
print ""
def main():
wsOpts = WSOpts()
parser = wsOpts.get_common_opts()
parser.add_option("--from_stream",
dest="fromStream",
help="get states from from this stream")
parser.add_option(
"--to_stream",
dest="toStream",
help=
"update triage in this stream\n\t\tSpecial stream name Every_stream reserved for all stream update"
)
(options, args) = parser.parse_args()
wsOpts.setLogging(options.debug)
if wsOpts.checkRequiredMissing(options, ('fromStream', 'toStream')):
parser.print_help()
sys.exit(-1)
configServiceClient = ConfigServiceClient(options)
streamFromDO = configServiceClient.get_stream(options.fromStream)
streamToDO = configServiceClient.get_stream(options.toStream)
defectServiceClient = DefectServiceClient(options)
defects_done = 0
batch = 200
matching_cids = []
# Fetch the set of defects to copy triage from
mergedDefectDOs = defectServiceClient.get_merged_defects(
streamFromDO, statusFilter='all')
TotalCids = mergedDefectDOs.totalNumberOfRecords
if TotalCids < 0:
logging.error("Error! Failed to get Merged Defects to copy from!")
sys.exit(-1)
matching_cids = [d.cid for d in mergedDefectDOs.mergedDefects]
if TotalCids != len(matching_cids):
logging.error(
"Should not happen: length of matching_cids isn't same as TotalCids"
)
while defects_done < TotalCids:
logging.debug("Got %d of %d total MDs" % (defects_done, TotalCids))
defectServiceClient.copy_triage(matching_cids[defects_done::batch],
streamFromDO, streamToDO)
defects_done += batch
logging.debug("Got %d of %d total MDs" %
(min(defects_done, TotalCids), TotalCids))
logging.info("Copied triage for %d defects" % (TotalCids))
def main():
wsOpts = WSOpts()
parser = wsOpts.get_common_opts()
(options, args) = parser.parse_args()
if wsOpts.checkRequiredMissing(options, ('stream', )):
parser.print_help()
sys.exit(-1)
wsOpts.setLogging(options.debug)
configServiceClient = ConfigServiceClient(options)
defectServiceClient = DefectServiceClient(options)
streamIdDO = configServiceClient.get_stream(options.stream)
mergedDefectDOs = defectServiceClient.get_merged_defects(
streamIdDO, statusFilter='all')
total = mergedDefectDOs.totalNumberOfRecords
logging.debug(total)
if total < 1:
logging.warning("No defects")
sys.exit(1)
mdDOs = mergedDefectDOs.mergedDefects
got = len(mergedDefectDOs.mergedDefects)
attrlist = [
'mergeKey', 'classification', 'severity', 'action', 'comment',
'filePathname', 'functionDisplayName'
]
cidlist = []
logging.debug("Got " + str(len(mdDOs)) + " out of " + str(total) +
" defects")
for md in mdDOs:
ciddict = {}
logging.debug("Cid %d, status %s, %s mergeKey" %
(md.cid, md.status, md.mergeKey))
for attr in attrlist:
ciddict[attr] = getattr(md, attr, None)
logging.debug(ciddict[attr])
cidlist.append(ciddict)
logging.debug("Exporting " + str(len(cidlist)) + " defects")
Writer = csv.DictWriter(open("keysTriage.csv", 'wb'), attrlist)
Writer.writerow(dict((fn, fn) for fn in attrlist))
for z in cidlist:
logging.debug("CID " + str(z['mergeKey']) + ": " +
str(z['classification']))
Writer.writerow(z)
def main():
wsOpts = WSOpts()
parser = wsOpts.get_common_opts()
(options, args) = parser.parse_args()
if wsOpts.checkRequiredMissing(options, ('stream', )):
parser.print_help()
sys.exit(-1)
wsOpts.setLogging(options.debug)
configServiceClient = ConfigServiceClient(options)
defectServiceClient = DefectServiceClient(options)
streamIdDO = configServiceClient.get_stream(options.stream)
mergedDefectDOs = defectServiceClient.get_merged_defects(
streamIdDO, statusFilter='all')
logging.debug(mergedDefectDOs.totalNumberOfRecords)
total = mergedDefectDOs.totalNumberOfRecords
if total < 1:
logging.warning("No defects")
sys.exit(1)
mdDOs = mergedDefectDOs.mergedDefects
got = len(mergedDefectDOs.mergedDefects)
cidlist = []
ciddict = {}
logging.debug("Got " + str(len(mdDOs)) + " out of " + str(total) +
" defects")
for md in mdDOs:
occurrences = defectServiceClient.get_num_stream_defect_occurrences(
md.cid, options.stream)
logging.debug("Cid %d, status %s, %d occurrences" %
(md.cid, md.status, occurrences))
cidlist.append((md.cid, md.classification, max(1, occurrences)))
totals = sum(x[2] for x in cidlist)
print "Total occurrences:", totals
ones = len(set(y[0] for y in cidlist if y[2] == 1))
moreThanOne = ((y[0], y[2]) for y in cidlist if y[2] > 1)
logging.debug(str(ones) + " defects have one occurrence")
if ones < totals:
logging.debug("The following " + str(len(set(moreThanOne))) +
" defects have more than one occurrence")
for z in sorted(moreThanOne):
logging.debug("CID " + str(z[0]) + ": " + str(z[1]))
def main():
wsOpts = WSOpts()
parser = wsOpts.get_common_opts()
parser.add_option("--file", dest="filename", help="Limit defects to those in file <filename>")
(options, args) = parser.parse_args()
wsOpts.setLogging(options.debug)
if wsOpts.checkRequiredMissing(options, ()):
parser.print_help()
sys.exit(-1)
configServiceClient = ConfigServiceClient(options)
defectServiceClient = DefectServiceClient(options)
streamIdDO = configServiceClient.get_streams(options.project,options.stream)
if not streamIdDO:
print "Not a valid stream"
sys.exit(1)
mergedDefectDOs = defectServiceClient.get_merged_defects(streamIdDO, filename=options.filename)
#Y mergedDefectDOs = defectServiceClient.get_merged_defects(streamIdDO, statusFilter='New', filename=options.filename)
total = mergedDefectDOs.totalNumberOfRecords
if total < 1:
logging.warning("No new defects")
sys.exit(1)
mdDOs = mergedDefectDOs.mergedDefects
logging.debug("Got "+str(len(mdDOs))+" defects")
for md in sorted(mdDOs):
if md.severity in ['Major']:
logging.debug(md)
logging.debug(md.checkerName)
logging.debug(md.checkerSubcategory)
logging.debug(md.domain)
cat = configServiceClient.get_checker_properties(md.checkerName, md.checkerSubcategory, md.domain)
if cat:
print cat.categoryDescription
print cat.subcategoryLocalEffect
print cat.subcategoryLongDescription
defectServiceClient.print_stream_defect_occurrences(md.cid, streamIdDO[0], options.project)
c = getattr(md, 'comment',None)
if c:
print "Last comment [asya]: ", c
print ""
print ""
def main():
wsOpts = WSOpts()
parser = wsOpts.get_common_opts()
(options, args) = parser.parse_args()
wsOpts.setLogging(options.debug)
if wsOpts.checkRequiredMissing(options, ()):
parser.print_help()
sys.exit(-1)
wsOpts.setLogging(options.debug)
configServiceClient = ConfigServiceClient(options)
configServiceClient.print_system_config()
def main():
wsOpts = WSOpts()
parser = wsOpts.get_common_opts()
(options, args) = parser.parse_args()
wsOpts.setLogging(options.debug)
if wsOpts.checkRequiredMissing(options, ()):
parser.print_help()
sys.exit(-1)
wsOpts.setLogging(options.debug)
configServiceClient = ConfigServiceClient(options)
configServiceClient.print_system_config()
def main():
wsOpts = WSOpts()
parser = wsOpts.get_common_opts()
parser.add_option("--filepath",dest="filepath",help="path of file to map")
(options, args) = parser.parse_args()
wsOpts.setLogging(options.debug)
if wsOpts.checkRequiredMissing(options, ('stream','filepath')):
parser.print_help()
sys.exit(-1)
if not options.stream or not options.filepath:
optionParser.error("Must specify both stream and filepath")
configServiceClient = ConfigServiceClient(options)
print configServiceClient.fileToComponent(options.filepath, options.stream)
def main():
wsOpts = WSOpts()
parser = wsOpts.get_common_opts()
(options, args) = parser.parse_args()
wsOpts.setLogging(options.debug)
if wsOpts.checkRequiredMissing(options, ('snapshot',)):
parser.print_help()
sys.exit(-1)
configServiceClient = ConfigServiceClient(options)
defectServiceClient = DefectServiceClient(options)
snapshotIdDO = configServiceClient.get_snapshot(options.snapshot)
if not snapshotIdDO:
logging.error("No valid snapshot found")
parser.print_help()
sys.exit(-1)
streamname = configServiceClient.get_stream_by_snapshot(options.snapshot)
streamIdDOs = configServiceClient.get_stream(streamname)
if not streamIdDOs:
logging.error("No valid stream for this snapshot found")
sys.exit(-1)
if len(streamIdDOs) != 1:
logging.error("Found more than one stream for this snapshot!!!")
sys.exit(-1)
streamIdDO = streamIdDOs[0]
try:
md = defectServiceClient.get_merged_defects_by_snapshot(snapshotIdDO,streamIdDO)
except:
logging.warning("No merged defects for snapshot found")
sys.exit(-1)
try:
cids = [d.cid for d in md.mergedDefects]
except:
logging.error("Error getting cids for snapshot")
sys.exit(-1)
totalFetched = len(cids)
if totalFetched < 1:
print "No defects in snapshot", snapshotIdDO.id.snapshotId.id
sys.exit(1)
else:
print "Fetched "+ str(totalFetched) + " cids in snapshot", options.snapshot
def main():
wsOpts = WSOpts()
parser = wsOpts.get_common_opts()
parser.add_option("--file",
dest="filename",
help="Limit defects to those in file <filename>")
(options, args) = parser.parse_args()
wsOpts.setLogging(options.debug)
if wsOpts.checkRequiredMissing(options, ('stream', )):
parser.print_help()
sys.exit(-1)
configServiceClient = ConfigServiceClient(options)
defectServiceClient = DefectServiceClient(options)
streamIdDO = configServiceClient.get_stream(options.stream)
mergedDefectDOs = defectServiceClient.get_merged_defects(
streamIdDO, statusFilter='New', filename=options.filename)
total = mergedDefectDOs.totalNumberOfRecords
if total < 1:
logging.warning("No new defects")
sys.exit(1)
mdDOs = mergedDefectDOs.mergedDefects
cidlist = []
for md in mdDOs:
occurrences = defectServiceClient.get_stream_defect_occurrences(
md.cid, options.stream)
logging.debug("CID %d, status %s, %d occurrences" %
(md.cid, md.status, len(occurrences)))
cidlist.append((md.cid, md.classification, max(1, len(occurrences))))
totals = sum(x[2] for x in cidlist)
print "Total occurrences:", totals
ones = len(set(y[0] for y in cidlist if y[2] == 1))
moreThanOne = ((y[0], y[2]) for y in cidlist if y[2] > 1)
print ones, " defects have one occurrence"
if ones < totals:
print "The following defects have more than one occurrence"
for z in sorted(moreThanOne):
print "CID ", z[0], ": ", z[1]
def make_url(self, options, oldurl=None, cid=None, project=None):
defectServiceClient = DefectServiceClient(options)
configServiceClient = ConfigServiceClient(options)
if oldurl:
logging.debug("Parsing old DM URL")
# parse URL into server, port and CID, expected format:
# http://pop.sf.coverity.com:5467/cov.cgi?cid=18103
o = urlparse(oldurl)
server = o.hostname
port = str(o.port)
cidq = o.query.find("cid=")
if cidq == -1:
logging.error("No cid found in URL")
return None
oldcid = int(o.query[cidq + 4:])
logging.debug("Server is %s, port is %s, cid is %d" %
(server, port, oldcid))
# gotta assume label is port:server - can be changed to any mapping
cid = defectServiceClient.get_cid_from_dm(oldcid,
server + ":" + port)
logging.debug("CIM CID is %d" % (cid))
# if not given a project, this _could_ return the wrong project URL
# if the CID appears in more than one migrated DB
# only way to check is by checking if snapshot IDs are in the range
# which is not available through WS
projectDOs = configServiceClient.get_projects(project)
project_id = defectServiceClient.get_project_for_CID(
projectDOs, cid)
elif project and cid:
project_id = configServiceClient.get_project_id(project)
else:
projectDOs = configServiceClient.get_projects(project)
project_id = defectServiceClient.get_project_for_CID(
projectDOs, cid)
if not cid:
return None
if not project_id:
return None
logging.debug("Host %s, port %s, projectId %d, CID %s" %
(options.host, options.port, project_id, cid))
return defectServiceClient.create_url(cid, project_id)
def main():
wsOpts = WSOpts()
parser = wsOpts.get_common_opts()
(options, args) = parser.parse_args()
if wsOpts.checkRequiredMissing(options, ('stream',)):
parser.print_help()
sys.exit(-1)
wsOpts.setLogging(options.debug)
configServiceClient = ConfigServiceClient(options)
defectServiceClient = DefectServiceClient(options)
streamIdDO = configServiceClient.get_stream(options.stream)
mergedDefectDOs = defectServiceClient.get_merged_defects(streamIdDO, statusFilter='all')
logging.debug(mergedDefectDOs.totalNumberOfRecords)
total = mergedDefectDOs.totalNumberOfRecords
if total < 1:
logging.warning("No defects")
sys.exit(1)
mdDOs = mergedDefectDOs.mergedDefects
got = len(mergedDefectDOs.mergedDefects)
cidlist = []
ciddict = {}
logging.debug("Got "+str(len(mdDOs))+" out of "+str(total)+" defects")
for md in mdDOs:
occurrences = defectServiceClient.get_num_stream_defect_occurrences(md.cid, options.stream)
logging.debug("Cid %d, status %s, %d occurrences" % (md.cid, md.status, occurrences))
cidlist.append((md.cid, md.classification, max(1,occurrences)))
totals = sum(x[2] for x in cidlist)
print "Total occurrences:", totals
ones = len(set(y[0] for y in cidlist if y[2] == 1))
moreThanOne = ( (y[0],y[2]) for y in cidlist if y[2] > 1)
logging.debug( str(ones) + " defects have one occurrence")
if ones < totals:
logging.debug("The following " + str(len(set(moreThanOne))) + " defects have more than one occurrence")
for z in sorted(moreThanOne):
logging.debug("CID " + str(z[0]) + ": " + str(z[1]))
def main():
wsOpts = WSOpts()
parser = wsOpts.get_common_opts()
(options, args) = parser.parse_args()
if wsOpts.checkRequiredMissing(options, ()):
parser.print_help()
sys.exit(-1)
wsOpts.setLogging(options.debug)
configServiceClient = ConfigServiceClient(options)
defectServiceClient = DefectServiceClient(options)
streamIdDO = configServiceClient.get_streams()
mergedDefectDOs = defectServiceClient.get_merged_defects(
streamIdDO, statusFilter='all')
total = mergedDefectDOs.totalNumberOfRecords
logging.debug(total)
if total < 1:
logging.warning("No defects")
sys.exit(1)
mdDOs = mergedDefectDOs.mergedDefects
got = len(mergedDefectDOs.mergedDefects)
mkeys = [m.mergeKey for m in mdDOs]
Reader = csv.DictReader(open("keysTriage.csv"))
for r in Reader:
#mergeKey,classification,severity,action,comment
if r['mergeKey'] in mkeys:
cid = cid_for_mkey(r['mergeKey'], mdDOs)
if r['action'] == 'Modeling Required':
defectServiceClient.update_merged_defect(
[cid], '*/*', r['classification'], r['severity'],
'Analysis Tuning Required', r['comment'])
else:
defectServiceClient.update_merged_defect([cid], '*/*',
r['classification'],
r['severity'],
r['action'],
r['comment'])
def main():
wsOpts = WSOpts()
parser = wsOpts.get_common_opts()
parser.add_option("--username", dest="username", help="User to add to group")
parser.add_option("--group", dest="group", help="Group name")
(options, args) = parser.parse_args()
wsOpts.setLogging(options.debug)
if wsOpts.checkRequiredMissing(options, ('username','group')):
parser.print_help()
sys.exit(-1)
configServiceClient = ConfigServiceClient(options)
configServiceClient.add_user_to_group(options.username, options.group)
def main():
wsOpts = WSOpts()
parser = wsOpts.get_common_opts()
parser.add_option("--username", dest="username", help="Username")
(options, args) = parser.parse_args()
wsOpts.setLogging(options.debug)
if wsOpts.checkRequiredMissing(options, ('username', )):
parser.print_help()
sys.exit(-1)
configServiceClient = ConfigServiceClient(options)
print configServiceClient.user_details(options.username)
def main():
wsOpts = WSOpts()
parser = wsOpts.get_common_opts()
parser.add_option("--group", dest="group", help="Group name")
(options, args) = parser.parse_args()
wsOpts.setLogging(options.debug)
if wsOpts.checkRequiredMissing(options, ('group', )):
parser.print_help()
sys.exit(-1)
configServiceClient = ConfigServiceClient(options)
print configServiceClient.get_users_for_group(options.group)
def main():
wsOpts = WSOpts()
parser = wsOpts.get_common_opts()
parser.add_option("--group", dest="group", help="Group name")
(options, args) = parser.parse_args()
wsOpts.setLogging(options.debug)
if wsOpts.checkRequiredMissing(options, ('group',)):
parser.print_help()
sys.exit(-1)
configServiceClient = ConfigServiceClient(options);
print configServiceClient.get_users_for_group(options.group)
def main():
wsOpts = WSOpts()
parser = wsOpts.get_common_opts()
parser.add_option("--group", dest="group", help="Group Name")
parser.add_option("--newname", dest="newname", help="New name")
(options, args) = parser.parse_args()
wsOpts.setLogging(options.debug)
if wsOpts.checkRequiredMissing(options, ('group','newname')):
parser.print_help()
sys.exit(-1)
configServiceClient = ConfigServiceClient(options);
configServiceClient.rename_group(options.group,options.newname)
def main():
wsOpts = WSOpts()
parser = wsOpts.get_common_opts()
parser.add_option("--group", dest="group", help="Group Name")
parser.add_option("--newname", dest="newname", help="New name")
(options, args) = parser.parse_args()
wsOpts.setLogging(options.debug)
if wsOpts.checkRequiredMissing(options, ('group', 'newname')):
parser.print_help()
sys.exit(-1)
configServiceClient = ConfigServiceClient(options)
configServiceClient.rename_group(options.group, options.newname)
def main():
wsOpts = WSOpts()
parser = wsOpts.get_common_opts()
parser.add_option("--filepath",
dest="filepath",
help="path of file to map")
(options, args) = parser.parse_args()
wsOpts.setLogging(options.debug)
if wsOpts.checkRequiredMissing(options, ('stream', 'filepath')):
parser.print_help()
sys.exit(-1)
if not options.stream or not options.filepath:
optionParser.error("Must specify both stream and filepath")
configServiceClient = ConfigServiceClient(options)
print configServiceClient.fileToComponent(options.filepath, options.stream)
def main():
wsOpts = WSOpts()
parser = wsOpts.get_common_opts()
parser.add_option("--username", dest="username", help="Username")
(options, args) = parser.parse_args()
wsOpts.setLogging(options.debug)
if wsOpts.checkRequiredMissing(options, ('username',)):
parser.print_help()
sys.exit(-1)
configServiceClient = ConfigServiceClient(options);
print configServiceClient.user_details(options.username)
def main():
wsOpts = WSOpts()
parser = wsOpts.get_common_opts()
(options, args) = parser.parse_args()
if wsOpts.checkRequiredMissing(options, ('stream',)):
parser.print_help()
sys.exit(-1)
wsOpts.setLogging(options.debug)
configServiceClient = ConfigServiceClient(options)
defectServiceClient = DefectServiceClient(options)
streamIdDO = configServiceClient.get_stream(options.stream)
mergedDefectDOs = defectServiceClient.get_merged_defects(streamIdDO, statusFilter='all')
total = mergedDefectDOs.totalNumberOfRecords
logging.debug(total)
if total < 1:
logging.warning("No defects")
sys.exit(1)
mdDOs = mergedDefectDOs.mergedDefects
got = len(mergedDefectDOs.mergedDefects)
attrlist = ['mergeKey','classification','severity','action','comment','filePathname','functionDisplayName']
cidlist = []
logging.debug("Got "+str(len(mdDOs))+" out of "+str(total)+" defects")
for md in mdDOs:
ciddict = {}
logging.debug("Cid %d, status %s, %s mergeKey" % (md.cid, md.status, md.mergeKey))
for attr in attrlist:
ciddict[attr]=getattr(md,attr,None)
logging.debug(ciddict[attr])
cidlist.append(ciddict)
logging.debug("Exporting " + str(len(cidlist)) + " defects")
Writer = csv.DictWriter(open("keysTriage.csv",'wb'), attrlist)
Writer.writerow(dict((fn,fn) for fn in attrlist))
for z in cidlist:
logging.debug("CID " + str(z['mergeKey']) + ": " + str(z['classification']))
Writer.writerow(z)
def main():
wsOpts = WSOpts()
parser = wsOpts.get_common_opts()
parser.add_option("--group", dest="group", help="Group Name")
parser.add_option("--ldap", default=False, dest="ldap", action="store_true", help="Ldap")
parser.add_option("--role", dest="role", help="Role to add to group")
(options, args) = parser.parse_args()
wsOpts.setLogging(options.debug)
if wsOpts.checkRequiredMissing(options, ('group',)):
parser.print_help()
sys.exit(-1)
configServiceClient = ConfigServiceClient(options);
configServiceClient.create_group(options.group,options.ldap,options.role)
def main():
wsOpts = WSOpts()
parser = wsOpts.get_common_opts()
parser.add_option("--username", dest="username", help="User to add to group")
parser.add_option("--email", dest="email", help="New email to replace existing")
parser.add_option("--role", dest="role", help="New role to add")
(options, args) = parser.parse_args()
if wsOpts.checkRequiredMissing(options, ("username", "email"), ("username", "role")):
logging.error("Must specify username and either new email or new role")
sys.exit(-1)
configServiceClient = ConfigServiceClient(options)
configServiceClient.update_user(options.username, options.email, options.role)
def main():
wsOpts = WSOpts()
parser = wsOpts.get_common_opts()
# parser.add_option("--reverse", action="store_true", dest="reverse", default=False, help="Reverse order of groups if Users is on the wrong end");
(options, args) = parser.parse_args()
if not options.password:
parser.print_help()
sys.exit(-1)
wsOpts.setLogging(options.debug)
if wsOpts.checkRequiredMissing(options, ()):
parser.print_help()
sys.exit(-1)
configServiceClient = ConfigServiceClient(options)
componentMaps = configServiceClient.get_component_maps()
if len(componentMaps) == 0:
# if they are no maps, something is wrong where is Default?
logging.error("Where is default component map?")
sys.exit(-1)
for cm in componentMaps:
print("Checking component map" + cm.componentMapId.name + ":")
print(str(len(cm.components)) + " components found")
for c in cm.components:
name = c.componentId.name
print("Component " + name)
numGroups = len(getattr(c, 'groupPermissions', []))
if numGroups == 0:
logging.error(" ERROR: component ", name,
" has no group permissions!!!")
else:
gPerms = c.groupPermissions
gPermsNum = len(gPerms)
for g in gPerms:
permission = g.groupRole
print(g.groupId.name + " \t/\t" + permission)
def main():
wsOpts = WSOpts()
parser = wsOpts.get_common_opts()
parser.add_option("--attr", dest="attr", help="attribute to filter on")
parser.add_option("--pattern", dest="pattern", help="pattern (glob)")
(options, args) = parser.parse_args()
wsOpts.setLogging(options.debug)
if wsOpts.checkRequiredMissing(options, ()):
parser.print_help()
sys.exit(-1)
configServiceClient = ConfigServiceClient(options)
streamIdDO = configServiceClient.get_streams(options.project,
options.stream)
if len(streamIdDO) == 0:
logging.error("No matching streams")
sys.exit(-1)
else:
logging.debug("Getting snapshots for " + str(len(streamIdDO)) +
" streams")
#streamSnapshots = configServiceClient.get_snapshots(streamIdDO, options.attr, options.pattern)
#for (streamname, snapshotDOs) in streamSnapshots:
for stream in streamIdDO:
print "Stream " + stream.name + ":"
snapshots = configServiceClient.get_snapshots_by_stream(stream)
for s in snapshots:
if len(s) != 1:
print "Error!!!"
continue
print "Stream " + stream.name,
print '\t',
print s[0].snapshotId.id,
print s[0].dateCreated,
print s[0].analysisVersion,
#print s[0].enabledCheckers
print str(len(getattr(s[0], 'enabledCheckers',
[]))) + " checkers enabled"
def main():
wsOpts = WSOpts()
parser = wsOpts.get_common_opts()
parser.add_option("--olduser", dest="olduser", help="Username")
parser.add_option("--newuser", dest="newuser", help="Username")
(options, args) = parser.parse_args()
if wsOpts.checkRequiredMissing(options, ('newuser','olduser')):
parser.print_help()
sys.exit(-1)
wsOpts.setLogging(options.debug)
configServiceClient = ConfigServiceClient(options);
logging.info("Creating new account "+ options.newuser +" from "+ options.olduser)
configServiceClient.copy_user(options.newuser,options.olduser)
def main():
wsOpts = WSOpts()
parser = wsOpts.get_common_opts()
parser.add_option("--username",
dest="username",
help="User to add to group")
parser.add_option("--group", dest="group", help="Group name")
(options, args) = parser.parse_args()
wsOpts.setLogging(options.debug)
if wsOpts.checkRequiredMissing(options, ('username', 'group')):
parser.print_help()
sys.exit(-1)
configServiceClient = ConfigServiceClient(options)
configServiceClient.add_user_to_group(options.username, options.group)
def main():
wsOpts = WSOpts()
parser = wsOpts.get_common_opts()
parser.add_option("--file", dest="filename", help="Limit defects to those in file <filename>")
(options, args) = parser.parse_args()
wsOpts.setLogging(options.debug)
if wsOpts.checkRequiredMissing(options, ('stream',)):
parser.print_help()
sys.exit(-1)
configServiceClient = ConfigServiceClient(options)
defectServiceClient = DefectServiceClient(options)
streamIdDO = configServiceClient.get_stream(options.stream)
mergedDefectDOs = defectServiceClient.get_merged_defects(streamIdDO, statusFilter='New', filename=options.filename)
total = mergedDefectDOs.totalNumberOfRecords
if total < 1:
logging.warning("No new defects")
sys.exit(1)
mdDOs = mergedDefectDOs.mergedDefects
cidlist = []
for md in mdDOs:
occurrences = defectServiceClient.get_stream_defect_occurrences(md.cid, options.stream)
logging.debug("CID %d, status %s, %d occurrences" % (md.cid, md.status, len(occurrences)))
cidlist.append((md.cid, md.classification, max(1,len(occurrences))))
totals = sum(x[2] for x in cidlist)
print "Total occurrences:", totals
ones = len(set(y[0] for y in cidlist if y[2] == 1))
moreThanOne = ( (y[0],y[2]) for y in cidlist if y[2] > 1)
print ones, " defects have one occurrence"
if ones < totals:
print "The following defects have more than one occurrence"
for z in sorted(moreThanOne):
print "CID ", z[0], ": ", z[1]
def main():
wsOpts = WSOpts()
parser = wsOpts.get_common_opts()
# parser.add_option("--reverse", action="store_true", dest="reverse", default=False, help="Reverse order of groups if Users is on the wrong end");
(options, args) = parser.parse_args()
if not options.password:
parser.print_help()
sys.exit(-1)
wsOpts.setLogging(options.debug)
if wsOpts.checkRequiredMissing(options, ()):
parser.print_help()
sys.exit(-1)
configServiceClient = ConfigServiceClient(options)
componentMaps = configServiceClient.get_component_maps()
if len(componentMaps) == 0:
# if they are no maps, something is wrong where is Default?
logging.error( "Where is default component map?")
sys.exit(-1)
for cm in componentMaps:
print ("Checking component map" + cm.componentMapId.name + ":")
print ( str(len(cm.components)) + " components found")
for c in cm.components:
name = c.componentId.name
print ("Component " + name)
numGroups = len(getattr(c,'groupPermissions',[]))
if numGroups == 0:
logging.error(" ERROR: component ",name," has no group permissions!!!")
else:
gPerms = c.groupPermissions
gPermsNum = len(gPerms)
for g in gPerms:
permission= g.groupRole
print (g.groupId.name + " \t/\t" + permission)
def main():
wsOpts = WSOpts()
parser = wsOpts.get_common_opts()
(options, args) = parser.parse_args()
wsOpts.setLogging(options.debug)
if wsOpts.checkRequiredMissing(options, ()):
parser.print_help()
sys.exit(-1)
configServiceClient = ConfigServiceClient(options)
defectServiceClient = DefectServiceClient(options)
a = configServiceClient.client.service.getAttribute({'name':'custom'})
attrDefSpec = configServiceClient.client.factory.create('attributeDefinitionSpecDataObj')
attrDefSpec.attributeName='custom'
attrDefSpec.attributeType=a.attributeType
attrDefSpec.showInTriage=a.showInTriage
attrDefSpec.description='attempt to get something to change'
changeSpec = configServiceClient.client.factory.create('attributeValueChangeSpecDataObj')
changeSpec.attributeValueIds=[]
changeSpec.attributeValues=[]
attribValId = configServiceClient.client.factory.create('attributeValueId')
attribVal = configServiceClient.client.factory.create('attributeValueSpecDataObj')
attribValId.name = 'four'
attribVal.name = 'five'
changeSpec.attributeValueIds.append(attribValId)
changeSpec.attributeValues.append(attribVal)
attribValId = configServiceClient.client.factory.create('attributeValueId')
attribVal = configServiceClient.client.factory.create('attributeValueSpecDataObj')
attribValId = null()
attribVal.name = 'one'
changeSpec.attributeValueIds.append(attribValId)
changeSpec.attributeValues.append(attribVal)
attribValId = configServiceClient.client.factory.create('attributeValueId')
attribVal = configServiceClient.client.factory.create('attributeValueSpecDataObj')
attribValId = null()
attribVal.name = 'two'
changeSpec.attributeValueIds.append(attribValId)
changeSpec.attributeValues.append(attribVal)
attribValId = configServiceClient.client.factory.create('attributeValueId')
attribVal = configServiceClient.client.factory.create('attributeValueSpecDataObj')
attribValId = null()
attribVal.name = 'three'
changeSpec.attributeValueIds.append(attribValId)
changeSpec.attributeValues.append(attribVal)
print changeSpec
attrDefSpec.attributeValueChangeSpec=changeSpec
print a.attributeDefinitionId
print attrDefSpec
configServiceClient.client.service.updateAttribute(a.attributeDefinitionId, attrDefSpec)
print configServiceClient.client.service.getAttribute({'name':'custom'})
def make_url(self, options, oldurl=None, cid=None, project=None):
defectServiceClient = DefectServiceClient(options)
configServiceClient = ConfigServiceClient(options)
if oldurl:
logging.debug("Parsing old DM URL")
# parse URL into server, port and CID, expected format:
# http://pop.sf.coverity.com:5467/cov.cgi?cid=18103
o = urlparse(oldurl)
server = o.hostname
port = str(o.port)
cidq = o.query.find("cid=")
if cidq == -1:
logging.error("No cid found in URL")
return None
oldcid = int(o.query[cidq+4:])
logging.debug("Server is %s, port is %s, cid is %d" % (server, port, oldcid))
# gotta assume label is port:server - can be changed to any mapping
cid = defectServiceClient.get_cid_from_dm(oldcid, server+":"+port)
logging.debug("CIM CID is %d" % (cid))
# if not given a project, this _could_ return the wrong project URL
# if the CID appears in more than one migrated DB
# only way to check is by checking if snapshot IDs are in the range
# which is not available through WS
projectDOs = configServiceClient.get_projects(project)
project_id =defectServiceClient.get_project_for_CID(projectDOs,cid)
elif project and cid:
project_id = configServiceClient.get_project_id(project)
else:
projectDOs = configServiceClient.get_projects(project)
project_id = defectServiceClient.get_project_for_CID(projectDOs,cid)
if not cid:
return None
if not project_id:
return None
logging.debug("Host %s, port %s, projectId %d, CID %s" % (options.host, options.port, project_id, cid))
return defectServiceClient.create_url(cid, project_id)
def main():
wsOpts = WSOpts()
parser = wsOpts.get_common_opts()
parser.add_option("--user1", dest="user1", help="Owner of defects")
parser.add_option("--user2", dest="user2", help="New owner to assign defects to")
(options, args) = parser.parse_args()
wsOpts.setLogging(options.debug)
if wsOpts.checkRequiredMissing(options, ('user1','user2')):
parser.print_help()
sys.exit(-1)
if options.user1 == options.user2:
logging.warning("Users are the same. Nothing to do")
sys.exit(0)
configServiceClient = ConfigServiceClient(options)
defectServiceClient = DefectServiceClient(options)
streamIdDO = configServiceClient.get_stream(options.stream)
mergedDefectDOs = defectServiceClient.get_merged_defects(streamIdDO, users=options.user1,statusFilter='all')
logging.debug(mergedDefectDOs.totalNumberOfRecords)
total = mergedDefectDOs.totalNumberOfRecords
if total < 1:
logging.warning("No defects returned")
sys.exit(1)
mdDOs = mergedDefectDOs.mergedDefects
got = len(mergedDefectDOs.mergedDefects)
logging.debug("Length of list %d %d" % (got, total))
cidlist = []
for md in mdDOs:
cidlist.append(md.cid)
scope = defectServiceClient.set_scope(options.project, options.stream)
logging.debug("Setting %d defects to owner=%s in scope %s" % (len(cidlist), options.user2, scope))
defectServiceClient.update_merged_defect(cidlist, scope, owner=options.user2)
def main():
wsOpts = WSOpts()
parser = wsOpts.get_common_opts()
parser.add_option("--from_stream", dest="fromStream", help="get states from from this stream")
parser.add_option("--to_stream", dest="toStream", help="update triage in this stream\n\t\tSpecial stream name Every_stream reserved for all stream update")
(options, args) = parser.parse_args()
wsOpts.setLogging(options.debug)
if wsOpts.checkRequiredMissing(options, ('fromStream','toStream')):
parser.print_help()
sys.exit(-1)
configServiceClient = ConfigServiceClient(options)
streamFromDO = configServiceClient.get_stream(options.fromStream)
streamToDO = configServiceClient.get_stream(options.toStream)
defectServiceClient = DefectServiceClient(options)
defects_done = 0
batch = 200
matching_cids = []
# Fetch the set of defects to copy triage from
mergedDefectDOs = defectServiceClient.get_merged_defects(streamFromDO, statusFilter='all')
TotalCids = mergedDefectDOs.totalNumberOfRecords
if TotalCids < 0:
logging.error("Error! Failed to get Merged Defects to copy from!")
sys.exit(-1)
matching_cids = [d.cid for d in mergedDefectDOs.mergedDefects]
if TotalCids != len(matching_cids):
logging.error("Should not happen: length of matching_cids isn't same as TotalCids")
while defects_done < TotalCids:
logging.debug("Got %d of %d total MDs" % (defects_done, TotalCids))
defectServiceClient.copy_triage(matching_cids[defects_done::batch], streamFromDO, streamToDO)
defects_done += batch
logging.debug("Got %d of %d total MDs" % (min(defects_done,TotalCids), TotalCids))
logging.info("Copied triage for %d defects" % (TotalCids))
def main():
wsOpts = WSOpts()
parser = wsOpts.get_common_opts()
parser.add_option("--attr", dest="attr", help="attribute to filter on");
parser.add_option("--pattern", dest="pattern", help="pattern (glob)");
(options, args) = parser.parse_args()
wsOpts.setLogging(options.debug)
if wsOpts.checkRequiredMissing(options, ()):
parser.print_help()
sys.exit(-1)
configServiceClient = ConfigServiceClient(options)
streamIdDO = configServiceClient.get_streams(options.project,options.stream)
if len(streamIdDO) == 0:
logging.error("No matching streams")
sys.exit(-1)
else:
logging.debug("Getting snapshots for "+str(len(streamIdDO))+" streams")
#streamSnapshots = configServiceClient.get_snapshots(streamIdDO, options.attr, options.pattern)
#for (streamname, snapshotDOs) in streamSnapshots:
for stream in streamIdDO:
print "Stream " + stream.name + ":"
snapshots = configServiceClient.get_snapshots_by_stream(stream)
for s in snapshots:
if len(s) != 1:
print "Error!!!"
continue
print "Stream " + stream.name,
print '\t',
print s[0].snapshotId.id,
print s[0].dateCreated,
print s[0].analysisVersion,
#print s[0].enabledCheckers
print str(len(getattr(s[0],'enabledCheckers',[]))) + " checkers enabled"
def main():
wsOpts = WSOpts()
parser = wsOpts.get_common_opts()
parser.add_option("--username", dest="username", help="Username")
(options, args) = parser.parse_args()
wsOpts.setLogging(options.debug)
if wsOpts.checkRequiredMissing(options, ('username', )):
parser.print_help()
sys.exit(-1)
configServiceClient = ConfigServiceClient(options)
logging.debug("Creating LDAP account " + options.username)
success = configServiceClient.create_user(options.username,
role=None,
ldap=True)
successConvert = False
if not success:
# assume the user exists as local user and switch to LDAP
successConvert = configServiceClient.convert_to_ldap_user(
options.username)
if not successConvert:
print "Couldn't create and couldn't convert, sorry!"
sys.exit(1)
subject = "Your Coverity account has been created"
userDO = configServiceClient.get_user(options.username)
url = "http://coverity.mongodb.com"
if successConvert:
subject = "Your Coverity account has been converted to Crowd/Jira"
text = """
<html><pre>
Dear %s,
\n
An account has been created for you at MongoDB Coverity Instance.
Your username is %s, same as your Crowd/Jira username.
You can go to <a href=%s>%s</a> to securely log in using your Crowd/Jira password.
\n
Your Coverity Admin Team
\n
</pre></html>
"""
name = str(options.username)
body = text % (name, options.username, url, url)
try:
configServiceClient.send_notifications(options.username, subject, body)
except Exception, err:
print "Error sending user notification", str(err)
sys.exit(1)
def main():
wsOpts = WSOpts()
parser = wsOpts.get_common_opts()
(options, args) = parser.parse_args()
if wsOpts.checkRequiredMissing(options, ()):
parser.print_help()
sys.exit(-1)
wsOpts.setLogging(options.debug)
configServiceClient = ConfigServiceClient(options)
highs = configServiceClient.get_checkers_by_impact('High')
#domains = ['STATIC_C', 'STATIC_JAVA', 'STATIC_CS']
domains = ['STATIC_C']
for d in domains:
dh = [h for h in highs if h.domain == d]
for c in sorted(dh):
print c.checkerName
meds = configServiceClient.get_checkers_by_impact('Medium')
for d in domains:
print '\tMedium impact for domain ', d
dh = [h for h in meds if h.domain == d]
for c in sorted(dh):
print c.checkerName
sys.exit(0)
print "----------------------******--------------------"
print "----------------------******--------------------"
print "How to get all Low Impact Checkers"
lows = configServiceClient.get_checkers_by_impact('Low')
for d in domains:
print '\tLow impact for domain ', d
dh = [h for h in lows if h.domain == d]
for c in sorted(dh):
print "\t\t", c.checkerName, c.subcategory
def main():
wsOpts = WSOpts()
parser = wsOpts.get_common_opts()
(options, args) = parser.parse_args()
if wsOpts.checkRequiredMissing(options,()):
parser.print_help()
sys.exit(-1)
wsOpts.setLogging(options.debug)
configServiceClient = ConfigServiceClient(options)
defectServiceClient = DefectServiceClient(options)
streamIdDO = configServiceClient.get_streams()
mergedDefectDOs = defectServiceClient.get_merged_defects(streamIdDO, statusFilter='all')
total = mergedDefectDOs.totalNumberOfRecords
logging.debug(total)
if total < 1:
logging.warning("No defects")
sys.exit(1)
mdDOs = mergedDefectDOs.mergedDefects
got = len(mergedDefectDOs.mergedDefects)
mkeys = [m.mergeKey for m in mdDOs]
Reader = csv.DictReader(open("keysTriage.csv"))
for r in Reader:
#mergeKey,classification,severity,action,comment
if r['mergeKey'] in mkeys:
cid = cid_for_mkey(r['mergeKey'], mdDOs)
if r['action'] == 'Modeling Required':
defectServiceClient.update_merged_defect([cid], '*/*',r['classification'],r['severity'],'Analysis Tuning Required',r['comment'])
else:
defectServiceClient.update_merged_defect([cid], '*/*',r['classification'],r['severity'],r['action'],r['comment'])
def main():
wsOpts = WSOpts()
parser = wsOpts.get_common_opts()
(options, args) = parser.parse_args()
if wsOpts.checkRequiredMissing(options, ()):
parser.print_help()
sys.exit(-1)
wsOpts.setLogging(options.debug)
configServiceClient = ConfigServiceClient(options)
highs = configServiceClient.get_checkers_by_impact('High')
#domains = ['STATIC_C', 'STATIC_JAVA', 'STATIC_CS']
domains = ['STATIC_C']
for d in domains:
dh = [h for h in highs if h.domain==d]
for c in sorted(dh):
print c.checkerName
meds = configServiceClient.get_checkers_by_impact('Medium')
for d in domains:
print '\tMedium impact for domain ',d
dh = [h for h in meds if h.domain==d]
for c in sorted(dh):
print c.checkerName
sys.exit(0)
print "----------------------******--------------------"
print "----------------------******--------------------"
print "How to get all Low Impact Checkers"
lows = configServiceClient.get_checkers_by_impact('Low')
for d in domains:
print '\tLow impact for domain ',d
dh = [h for h in lows if h.domain==d]
for c in sorted(dh):
print "\t\t", c.checkerName, c.subcategory
def main():
wsOpts = WSOpts()
parser = wsOpts.get_common_opts()
parser.add_option("--group", dest="group", help="Group Name")
parser.add_option("--ldap",
default=False,
dest="ldap",
action="store_true",
help="Ldap")
parser.add_option("--role", dest="role", help="Role to add to group")
(options, args) = parser.parse_args()
wsOpts.setLogging(options.debug)
if wsOpts.checkRequiredMissing(options, ('group', )):
parser.print_help()
sys.exit(-1)
configServiceClient = ConfigServiceClient(options)
configServiceClient.create_group(options.group, options.ldap, options.role)
def main():
wsOpts = WSOpts()
parser = wsOpts.get_common_opts()
parser.add_option("--username", dest="username", help="Username")
parser.add_option("--first", dest="first", help="First name")
parser.add_option("--last", dest="last", help="Last Name")
parser.add_option("--email", dest="email", help="Email")
parser.add_option("--group", dest="group", help="Existing Group to add user to")
(options, args) = parser.parse_args()
wsOpts.setLogging(options.debug)
if wsOpts.checkRequiredMissing(options, ('username','email','group')):
parser.print_help()
sys.exit(-1)
configServiceClient = ConfigServiceClient(options);
logging.debug("Creating local account " + options.username)
success = configServiceClient.create_user(options.username,options.first,options.last,options.email,'Administrators','xxxxxx',role=None, locked=True)
if not success:
print "Error!"
sys.exit(1)
subject = "Your Coverity account has been created"
text = """
<html><pre>
Dear %s,
\n
An account has been created for you at MongoDB Coverity Instance.
Your username is %s
You have been added to %s group
Please go to %s
and click on "Forgot Password?" link - this will allow you to set your password.
\n
Your Coverity Admin Team
\n
</pre></html>
"""
name = str(options.username)
if options.first:
name = str(options.first)
url = configServiceClient.create_url()
body = text % (name, options.username, options.group, url)
try:
configServiceClient.send_notifications(options.username, subject, body)
except Exception, err:
print "Error sending user notification", str(err)
sys.exit(1)
def main():
wsOpts = WSOpts()
parser = wsOpts.get_common_opts()
parser.add_option("--motd", dest="motd", \
help="Message of the Day to set")
(options, args) = parser.parse_args()
wsOpts.setLogging(options.debug)
if wsOpts.checkRequiredMissing(options, ('motd',)):
parser.print_help()
sys.exit(-1)
wsOpts.setLogging(options.debug)
configServiceClient = ConfigServiceClient(options)
configServiceClient.client.service.setMessageOfTheDay(options.motd)
def main():
wsOpts = WSOpts()
parser = wsOpts.get_common_opts()
parser.add_option("--username", dest="username", help="Username")
(options, args) = parser.parse_args()
wsOpts.setLogging(options.debug)
if wsOpts.checkRequiredMissing(options, ('username',)):
parser.print_help()
sys.exit(-1)
configServiceClient = ConfigServiceClient(options);
logging.debug("Creating LDAP account " + options.username)
success = configServiceClient.create_user(options.username,role=None, ldap=True)
successConvert=False
if not success:
# assume the user exists as local user and switch to LDAP
successConvert=configServiceClient.convert_to_ldap_user(options.username)
if not successConvert:
print "Couldn't create and couldn't convert, sorry!"
sys.exit(1)
subject = "Your Coverity account has been created"
userDO = configServiceClient.get_user(options.username)
url = "http://coverity.mongodb.com"
if successConvert: subject = "Your Coverity account has been converted to Crowd/Jira"
text = """
<html><pre>
Dear %s,
\n
An account has been created for you at MongoDB Coverity Instance.
Your username is %s, same as your Crowd/Jira username.
You can go to <a href=%s>%s</a> to securely log in using your Crowd/Jira password.
\n
Your Coverity Admin Team
\n
</pre></html>
"""
name = str(options.username)
body = text % (name, options.username, url, url)
try:
configServiceClient.send_notifications(options.username, subject, body)
except Exception, err:
print "Error sending user notification", str(err)
sys.exit(1)
def main():
wsOpts = WSOpts()
parser = wsOpts.get_common_opts()
parser.add_option("--username", dest="username", help="Username")
parser.add_option("--first", dest="first", help="First name")
parser.add_option("--last", dest="last", help="Last Name")
parser.add_option("--email", dest="email", help="Email")
parser.add_option("--group", dest="group", help="Local Groups to add to")
parser.add_option("--role", dest="role", help="Role")
parser.add_option(
"--ldap",
default=False,
dest="ldap",
action="store_true",
help="LDAP or local account, specify for LDAP, default is local")
(options, args) = parser.parse_args()
wsOpts.setLogging(options.debug)
if wsOpts.checkRequiredMissing(options, ('username', )):
parser.print_help()
sys.exit(-1)
configServiceClient = ConfigServiceClient(options)
if options.ldap:
logging.debug("Creating ldap account " + options.username)
configServiceClient.create_user(options.username,
ldap=True,
role=options.role,
groups=options.group)
else:
logging.debug("Creating local account " + options.username)
configServiceClient.create_user(options.username,
options.first,
options.last,
options.email,
options.group,
'coverity',
role=options.role)
def main():
"""
create and send notifications to all users who were assigned
any new defects in the past N days (N=1 or specified)
"""
wsOpts = WSOpts()
parser = wsOpts.get_common_opts()
# use --test flag to avoid sending e-mail while debugging this script
parser.set_defaults(testing="False")
parser.add_option("--test", action="store_true", dest="testing", default="False", help="Testing flag: no mail just echo to stdout");
parser.add_option("--days", dest="days", type=int, default=1, help="Days to check to notify about (default last 24 hours)");
(options, args) = parser.parse_args()
wsOpts.setLogging(options.debug)
if wsOpts.checkRequiredMissing(options, ()):
parser.print_help()
sys.exit(-1)
configServiceClient = ConfigServiceClient(options)
defectServiceClient = DefectServiceClient(options)
# calculate when the action would have to be since to get reported
cutoff = datetime.datetime.today()-datetime.timedelta(options.days)
# all assignable users - no disabled users, since they should not be notified
users = configServiceClient.get_all_users()
# get the streams for relevant project or get all if none
streamIdDO = configServiceClient.get_streams(options.project,options.stream)
mergedDefectDOs = defectServiceClient.get_merged_defects(streamIdDO,users=users)
email_cid = {}
totalFetched = mergedDefectDOs.totalNumberOfRecords
if totalFetched < 1:
logging.info("No defects")
sys.exit(totalFetched)
logging.info("Total fetched "+ repr(totalFetched))
for md in mergedDefectDOs.mergedDefects:
defectChangeDataObj = defectServiceClient.get_md_history(md.cid,streamIdDO)
i = len(defectChangeDataObj)-1
while i >= 0:
if defectChangeDataObj[i].dateModified > cutoff and len(set(defectChangeDataObj[i].affectedStreams).difference(set(streamIdDO))) > 0:
for fieldChangeDO in defectChangeDataObj[i].attributeChanges:
if fieldChangeDO != None and fieldChangeDO.fieldName=='Owner':
logging.debug("defectChangeDataObj with new owner is "+ repr(defectChangeDataObj[i]))
new_owner = fieldChangeDO.newValue
if new_owner not in email_cid:
email_cid[new_owner] = []
if md.cid not in email_cid[new_owner]:
email_cid[new_owner].append(md.cid)
break
i = i - 1
if len(email_cid) == 0:
logging.info("Nothing to notify about")
sys.exit(0)
if options.project:
subject = "New defects assigned to you in Coverity Project "+options.project
else:
subject = "New defects assigned to you in Coverity Projects"
project_id = None
url = None
if options.project and '*' not in options.project:
project_id =configServiceClient.get_project_id(options.project)
else:
if options.project:
projectDOs = configServiceClient.get_projects(options.project)
else:
projectDOs = configServiceClient.get_projects()
logging.debug("Got Project DOs " + str(len(projectDOs)))
if options.days == 1:
leadin = "<html>\n<br>The following defects were assigned to you in the past 24 hours<br>\n"
else:
leadin = "<html>\n<br>The following defects were assigned to you in the past " + str(options.days) + " days<br>\n"
if project_id:
projId=str(project_id)
for u in email_cid.keys():
body = leadin
for cid in email_cid[u]:
if not project_id:
(projId,streamDefectId) = defectServiceClient.get_project_for_CID_and_user(projectDOs, cid, u)
url = defectServiceClient.create_url(cid, projId,streamDefectId)
else:
url = defectServiceClient.create_url(cid, projId)
body = body + "CID " + str(cid) + ": <a href=" + url + ">" + url + "</a><br>\n"
body = body + "</html>"
if options.testing == True:
logging.warning("Testing: no actual e-mail will be sent")
print "Username: "******"Subject: " + subject
print body
else:
logging.debug("Users:" + str(u))
logging.debug("Subject:" + str(subject))
logging.debug("Body:" + str(body))
try:
resp = configServiceClient.send_notifications(u, subject, body)
logging.debug("Mail sent to %d recepient" % (len(resp)))
except Exception, err:
logging.error(str(err))
logging.error("Mail not sent to " + u)
def main():
"""
create and send notifications to all users who were assigned
any new defects in the past N days (N=1 or specified)
"""
wsOpts = WSOpts()
parser = wsOpts.get_common_opts()
# use --test flag to avoid sending e-mail while debugging this script
parser.set_defaults(testing="False")
parser.add_option("--test",
action="store_true",
dest="testing",
default="False",
help="Testing flag: no mail just echo to stdout")
parser.add_option(
"--days",
dest="days",
type=int,
default=1,
help="Days to check to notify about (default last 24 hours)")
(options, args) = parser.parse_args()
wsOpts.setLogging(options.debug)
if wsOpts.checkRequiredMissing(options, ()):
parser.print_help()
sys.exit(-1)
configServiceClient = ConfigServiceClient(options)
defectServiceClient = DefectServiceClient(options)
# calculate when the action would have to be since to get reported
cutoff = datetime.datetime.today() - datetime.timedelta(options.days)
# all assignable users - no disabled users, since they should not be notified
users = configServiceClient.get_all_users()
# get the streams for relevant project or get all if none
streamIdDO = configServiceClient.get_streams(options.project,
options.stream)
mergedDefectDOs = defectServiceClient.get_merged_defects(streamIdDO,
users=users)
email_cid = {}
totalFetched = mergedDefectDOs.totalNumberOfRecords
if totalFetched < 1:
logging.info("No defects")
sys.exit(totalFetched)
for md in mergedDefectDOs.mergedDefects:
defectChangeDataObj = defectServiceClient.get_md_history(
md.cid, options.project, options.stream)
i = len(defectChangeDataObj) - 1
while i >= 0:
if defectChangeDataObj[i].dateModified > cutoff and len(
set(defectChangeDataObj[i].affectedStreams).difference(
set(streamIdDO))) > 0:
if getattr(defectChangeDataObj[i], 'ownerChange', None):
new_owner = defectChangeDataObj[i].ownerChange.newValue
if new_owner not in email_cid:
email_cid[new_owner] = []
if md.cid not in email_cid[new_owner]:
email_cid[new_owner].append(md.cid)
break
i = i - 1
if len(email_cid) == 0:
logging.info("Nothing to notify about")
sys.exit(0)
if options.project:
subject = "New defects assigned to you in Coverity Project " + options.project
else:
subject = "New defects assigned to you in Coverity Projects"
project_id = None
url = None
if options.project and '*' not in options.project:
project_id = configServiceClient.get_project_id(options.project)
else:
if options.project:
projectDOs = configServiceClient.get_projects(options.project)
else:
projectDOs = configServiceClient.get_projects()
logging.debug("Got Project DOs " + str(len(projectDOs)))
if options.days == 1:
leadin = "<html>\n<br>The following defects were assigned to you in the past 24 hours<br>\n"
else:
leadin = "<html>\n<br>The following defects were assigned to you in the past " + str(
options.days) + " days<br>\n"
if project_id:
projId = str(project_id)
for u in email_cid.keys():
body = leadin
for cid in email_cid[u]:
if not project_id:
(projId, streamDefectId
) = defectServiceClient.get_project_for_CID_and_user(
projectDOs, cid, u)
url = defectServiceClient.create_url(cid, projId,
streamDefectId)
else:
url = defectServiceClient.create_url(cid, projId)
body = body + "CID " + str(
cid) + ": <a href=" + url + ">" + url + "</a><br>\n"
body = body + "</html>"
if options.testing == True:
logging.warning("Testing: no actual e-mail will be sent")
print "Username: "******"Subject: " + subject
print body
else:
logging.debug("Users:" + str(u))
logging.debug("Subject:" + str(subject))
logging.debug("Body:" + str(body))
try:
resp = configServiceClient.send_notifications(u, subject, body)
logging.debug("Mail sent to %d recepient" % (len(resp)))
except Exception, err:
logging.error(str(err))
logging.error("Mail not sent to " + u)
def main():
wsOpts = WSOpts()
parser = wsOpts.get_common_opts()
(options, args) = parser.parse_args()
wsOpts.setLogging(options.debug)
if wsOpts.checkRequiredMissing(options, ('snapshot', )):
parser.print_help()
sys.exit(-1)
configServiceClient = ConfigServiceClient(options)
defectServiceClient = DefectServiceClient(options)
snapshotIdDO = configServiceClient.get_snapshot(options.snapshot)
snapshotInfoDO = configServiceClient.get_snapshot_info(options.snapshot)
if not snapshotInfoDO:
logging.warning("No valid snapshot found")
parser.print_help()
sys.exit(-1)
streamname = configServiceClient.get_stream_by_snapshot(options.snapshot)
streamIdDOs = configServiceClient.get_stream(streamname)
if not streamIdDOs:
logging.error("No valid stream for this snapshot found")
parser.print_help()
sys.exit(-1)
if len(streamIdDOs) != 1:
logging.error("Found more than one stream for this snapshot!!!")
parser.print_help()
sys.exit(-1)
streamIdDO = streamIdDOs[0]
lastSnapshotIdDO = configServiceClient.get_snapshot_by_date(
datetime.datetime.now(), streamIdDO)
logging.debug("Last snapshot in stream %s is " % (streamIdDO.name))
logging.debug(lastSnapshotIdDO.id.snapshotId.id)
mergedDefectDOs = defectServiceClient.get_merged_defects_by_snapshot(
snapshotIdDO, streamIdDO)
logging.debug("Last snapshot in this stream is " +
str(lastSnapshotIdDO.id.snapshotId.id))
totalFetched = mergedDefectDOs.totalNumberOfRecords
if totalFetched < 1:
logging.warning("No defects")
sys.exit(1)
else:
logging.debug(
str(totalFetched) + " merged defects fetched for snapshot " +
str(snapshotIdDO.id) + " " + streamIdDO.name)
pass
currentMDDOs = defectServiceClient.get_merged_defects(streamIdDOs, 'all')
if currentMDDOs.totalNumberOfRecords < 1:
logging.warning("Something is wrong: no current defects")
sys.exit(1)
cids = [md.cid for md in currentMDDOs.mergedDefects]
logging.debug(len(cids))
badcids = ([
md.cid for md in mergedDefectDOs.mergedDefects if md.cid not in cids
])
goodcids = ([
md.cid for md in mergedDefectDOs.mergedDefects if md.cid in cids
])
allcids = [md.cid for md in mergedDefectDOs.mergedDefects]
logging.debug(len(allcids))
logging.debug(len(set(cids).difference(set(allcids))))
logging.debug(len(set(allcids).difference(set(cids))))
mds = ([md for md in mergedDefectDOs.mergedDefects if md.cid in cids])
logging.info(str(len(cids)) + " cids were committed - " + str(len(mds)))
# things to add
# get previous snapshot CIDs, compare
# get next snapshot CIDs, compare
# give breakdown of CIDs in that snapshot by current status
print "Number of CIDs committed to stream %s in snapshot %s: %d " % (
streamname, options.snapshot, len(cids))
print " of which:"
Fixed = [md.cid for md in mds if md.status == 'Fixed']
Dismissed = [md.cid for md in mds if md.status == 'Dismissed']
Triaged = [md.cid for md in mds if md.status == 'Triaged']
New = [md.cid for md in mds if md.status == 'New']
print len(Fixed), " were fixed"
print len(Dismissed), " are dismissed"
print len(Triaged), " were triaged but still outstanding"
print len(New), " are still New and untriaged"
def main():
"""
create and send notifications to all users who currently have assigned
any defects that are outstanding (maybe flagging those that are new)
"""
wsOpts = WSOpts()
parser = wsOpts.get_common_opts()
# use --test flag to avoid sending e-mail while debugging this script
parser.set_defaults(testing="False")
parser.add_option("--test", action="store_true", dest="testing", default="False", help="Testing flag: no mail just echo to stdout");
parser.add_option("--detail", action="store_true", dest="detail", default="False", help="Detail flag: add a bunch of details about the bugs");
parser.add_option("--days", dest="days", type=int, default=1, help="Days to check for new to notify about (default last 24 hours)");
(options, args) = parser.parse_args()
wsOpts.setLogging(options.debug)
if wsOpts.checkRequiredMissing(options, ()):
parser.print_help()
sys.exit(-1)
configServiceClient = ConfigServiceClient(options)
defectServiceClient = DefectServiceClient(options)
# calculate when the action would have to be since to get reported
cutoff = datetime.datetime.today()-datetime.timedelta(options.days)
# all assignable users - no disabled users, since they should not be notified
users = configServiceClient.get_all_users()
# get the streams for relevant project or get all if none
streamIdDO = configServiceClient.get_streams(options.project,options.stream)
mergedDefectDOs = defectServiceClient.get_merged_defects(streamIdDO,users=users)
email_cid = {}
totalFetched = mergedDefectDOs.totalNumberOfRecords
if totalFetched < 1:
logging.info("No defects")
sys.exit(totalFetched)
logging.debug("Total fetched "+ repr(totalFetched))
for md in mergedDefectDOs.mergedDefects:
for attr in md.defectStateAttributeValues:
logging.debug("Attribute is " + repr(attr) + "\n")
if attr.attributeDefinitionId.name=="Owner":
owner = attr.attributeValueId.name
logging.debug("\n\n*********** Found owner " + owner)
if owner not in email_cid:
email_cid[owner] = []
if md.cid not in email_cid[owner]:
email_cid[owner].append(md)
break
logging.debug(repr(md))
if len(email_cid) == 0:
logging.info("Nothing to notify about")
sys.exit(0)
if options.project:
subject = "Outstanding defects assigned to you in Coverity Project "+options.project
else:
subject = "Outstanding defects assigned to you in Coverity Projects"
project_id = None
url = None
if options.project and '*' not in options.project:
project_id =configServiceClient.get_project_id(options.project)
logging.debug("Project id is " + repr(project_id))
else:
if options.project:
projectDOs = configServiceClient.get_projects(options.project)
else:
projectDOs = configServiceClient.get_projects()
logging.debug("Got Project DOs " + str(len(projectDOs)))
if options.days == 1:
leadin = "<html>\n<br>\n<br>The following defects were newly detected in the past 24 hours<br>\n"
else:
leadin = "<html>\n<br>\n<br>The following defects were newly detected in the past " + str(options.days) + " days<br>\n"
leadinOthers = "\n<br>\n<br>In addition the following existing unresolved defects are assigned to you:<br>\n"
if project_id:
projId=str(project_id)
for u in email_cid.keys():
body = leadin
restOfBody = leadinOthers
for md in email_cid[u]:
if not project_id:
(projId,streamDefectId) = defectServiceClient.get_project_for_CID_and_user(projectDOs, md.cid, u)
url = defectServiceClient.create_url(md.cid, projId,streamDefectId)
else:
url = defectServiceClient.create_url(md.cid, projId)
logging.debug("First detected " + md.firstDetected.strftime('%Y/%m/%d'))
if md.firstDetected > cutoff:
body = body + "New CID " + str(md.cid) + ":\n<br> Issue " + md.checkerName + " in file " + md.filePathname + " was detected on " + md.firstDetected.strftime('%Y/%m/%d') + ". \n<br> <a href=" + url + ">" + url + "</a>\n<br>\n"
else:
restOfBody = restOfBody + "CID " + str(md.cid) + ": " + md.checkerName + ". <a href=" + url + ">" + url + "</a><br>\n"
body = body + restOfBody + "</html>"
#server = smtplib.SMTP('smtp.gmail.com',587)
server = 'localhost'
fromaddr = "*****@*****.**"
if options.testing == True:
logging.warning("Testing: no actual e-mail will be sent")
print "Username: "******"Subject: " + subject
print body
else:
logging.debug("Users:" + str(u))
logging.debug("Subject:" + str(subject))
logging.debug("Body:" + str(body))
try:
sent = False
resp = configServiceClient.send_notifications(u+"@local", subject, body)
logging.info("Mail sent to %d recepient" % (len(resp)))
if len(resp) > 0: sent=True
except Exception, err:
logging.error(str(err))
logging.error("Mail not sent to " + u)
sent=False
# now fall back on doing a regular email send...
if sent == False:
logging.info("Sending e-mail the regular way since notify failed")
udo = configServiceClient.user_details(u)
toaddr = udo.email
msg = ("Subject: %s\nFrom: %s\nTo: %s\n\n" % (subject, fromaddr, toaddr)) + body
server.sendmail(fromaddr, toaddr, msg)
server.quit()
def main():
wsOpts = WSOpts()
parser = wsOpts.get_common_opts()
# use --test flag to avoid sending e-mail while debugging this script
parser.add_option("--test", action="store_true", dest="testing", default="False", help="Testing flag: no mail just echo to stdout");
parser.add_option("--last", action="store_true", dest="last", help="Notify about last commit: project or stream MUST be specified");
(options, args) = parser.parse_args()
wsOpts.setLogging(options.debug)
if wsOpts.checkRequiredMissing(options, ('last','stream'),('last','project')):
logging.error("Must specify --last with either --stream or --project")
sys.exit(-1)
configServiceClient = ConfigServiceClient(options)
defectServiceClient = DefectServiceClient(options)
streamIdDOs = configServiceClient.get_streams(options.project,options.stream)
if not streamIdDOs:
logging.error("No valid streams found")
sys.exit(-1)
cws = configServiceClient.get_components_with_subscribers(options.project,options.stream)
if len(cws) == 0:
logging.warning("No subscribers for specified streams/projects")
sys.exit(-1)
logging.debug([(c.componentId.name, c.subscribers) for c in cws])
comps = [c.componentId.name for c in cws]
total = 0
mds = []
for streamIdDO in streamIdDOs:
lastSnapshotIdDO = configServiceClient.get_last_snapshot(streamIdDO)
nextToLastSnapshotIdDO = configServiceClient.get_next_to_last_snapshot(streamIdDO)
logging.debug(lastSnapshotIdDO)
logging.debug(nextToLastSnapshotIdDO)
mergedDefectsDOs = defectServiceClient.get_merged_defects_by_snapshot(lastSnapshotIdDO, streamIdDO, nextToLastSnapshotIdDO)
logging.debug(mergedDefectsDOs.totalNumberOfRecords)
if mergedDefectsDOs.totalNumberOfRecords > 0:
total += mergedDefectsDOs.totalNumberOfRecords
mds.extend(mergedDefectsDOs.mergedDefects)
if total == 0:
print "No records new in latest snapshots"
sys.exit(0)
md = [m for m in mds if m.componentName in comps]
if len(md) == 0:
print "No records found for notification"
sys.exit(0)
# iterate over merged defects
email_cid = {}
for mergedDefectDO in md:
# if the component the defect belongs to has subscribers
cName = mergedDefectDO.componentName
componentDO = configServiceClient.get_component(cName)
try:
subscribers = componentDO.subscribers
except:
# shouldn't be here as we filtered out the defects without subscribers
logging.debug("no subscribers for "+cName)
continue
else:
# store user and defects in a dictionary
for user in subscribers:
if user not in email_cid:
email_cid[user] = {}
if cName not in email_cid[user]:
email_cid[user][cName] = []
if mergedDefectDO.cid not in email_cid[user]:
email_cid[user][cName].append(mergedDefectDO.cid)
if len(email_cid) == 0:
print "Nothing to notify about"
sys.exit(0)
logging.debug("Will notify %d users about %d defects" % (len(email_cid), len(mds)))
if options.project:
subject = "New defects found in your subscribed components of Coverity project "+options.project
elif options.stream:
subject = "New defects in your subscribed components of Coverity stream "+options.stream
else:
logging.warning("Not yet implemented")
project_id = None
url = None
if options.project:
project_id = configServiceClient.get_project_id(options.project)
elif options.stream:
pDO = configServiceClient.get_projects(None, options.stream)
if len(pDO) == 0:
logging.error("Stream %s doesn't have a primary parent owner" % (options.stream))
project_id = configServiceClient.get_project_id(pDO[0].id.name)
else:
logging.warning("Not yet implemented")
leadin = "<html>\n<br>The following new defects were found in your subscribed components in the latest snapshot:<br>\n"
if project_id:
projId=str(project_id)
url = "http://"+options.host+":"+options.port+"/sourcebrowser.htm?projectId="+projId+"#mergedDefectId="
for u in email_cid.keys():
body = leadin
for c in email_cid[u].keys():
body = body + "Component " + c + ":<br>\n"
for cid in email_cid[u][c]:
U = url+str(cid)
body = body + " CID " + str(cid) + ": <a href " + U + ">" + U + "</a><br>\n"
body = body + "</html>"
if options.testing == True:
logging.info("just testing")
print u
print subject
print body
else:
logging.debug(u)
logging.debug(subject)
logging.debug(body)
configServiceClient.send_notifications(u, subject, body)
