""")
if leaderfound==0:
if cgimode:
out = []
out.append("""
""")
if len(masterlist)==0:
out.append(""" """)
out.append(""" """)
out.append(""" Can't find masters (resolve given name) !!!
""")
out.append(""" """)
out.append(""" | """)
out.append("""
""")
elif electfound:
out.append(""" """)
out.append(""" """)
out.append(""" Leader master server not found, but there is an elect, so make sure that all chunkservers are running - elect should become a leader soon
""")
out.append(""" | """)
out.append("""
""")
else:
out.append(""" """)
out.append(""" """)
out.append(""" Can't find working masters !!!
""")
out.append(""" """)
out.append(""" | """)
out.append("""
""")
out.append("""
""")
print("\n".join(out))
else:
if len(masterlist)==0:
print("""Can't find masters (resolve '%s') !!!""" % (masterhost))
elif electfound:
print("Leader master server not found, but there is an elect, so make sure that all chunkservers are running - elect should become a leader soon")
else:
print("Working master servers not found !!! - maybe you are using wrong port number or wrong dns name")
if not cgimode:
Tabble.Needseparator=1
if not cgimode:
if leaderfound:
if masterconn.version_less_than(1,7,0):
allowedsections = ["IN","CS","HD","EX","MS","MO","MC","CC"]
elif masterconn.version_less_than(2,1,0):
allowedsections = ["IN","CS","HD","EX","MS","MO","QU","MC","CC"]
else:
allowedsections = ["IN","CS","HD","EX","MS","MO","RS","QU","MC","CC"]
elif electfound:
allowedsections = ["IN","CS","HD","EX","QU","MC","CC"]
elif followerfound:
allowedsections = ["IN","MC"]
elif len(masterlist)>0:
allowedsections = ["IN"]
else:
sys.exit(1)
filtered_sectionset = []
for section in sectionset:
if section in allowedsections:
filtered_sectionset.append(section)
else:
print("""section '%s' not allowed""" % section)
sectionset = filtered_sectionset
# parse cgi parameters
if cgimode:
try:
INmatrix = int(fields.getvalue("INmatrix"))
except Exception:
INmatrix = 0
try:
IMorder = int(fields.getvalue("IMorder"))
except Exception:
IMorder = 0
try:
IMrev = int(fields.getvalue("IMrev"))
except Exception:
IMrev = 0
try:
MForder = int(fields.getvalue("MForder"))
except Exception:
MForder = 0
try:
MFrev = int(fields.getvalue("MFrev"))
except Exception:
MFrev = 0
try:
MFlimit = int(fields.getvalue("MFlimit"))
except Exception:
MFlimit = 100
try:
CSorder = int(fields.getvalue("CSorder"))
except Exception:
CSorder = 0
try:
CSrev = int(fields.getvalue("CSrev"))
except Exception:
CSrev = 0
try:
MBorder = int(fields.getvalue("MBorder"))
except Exception:
MBorder = 0
try:
MBrev = int(fields.getvalue("MBrev"))
except Exception:
MBrev = 0
try:
HDorder = int(fields.getvalue("HDorder"))
except Exception:
HDorder = 0
try:
HDrev = int(fields.getvalue("HDrev"))
except Exception:
HDrev = 0
try:
HDperiod = int(fields.getvalue("HDperiod"))
except Exception:
HDperiod = 0
try:
HDtime = int(fields.getvalue("HDtime"))
except Exception:
HDtime = 0
try:
HDaddrname = int(fields.getvalue("HDaddrname"))
except Exception:
HDaddrname = 0
try:
EXorder = int(fields.getvalue("EXorder"))
except Exception:
EXorder = 0
try:
EXrev = int(fields.getvalue("EXrev"))
except Exception:
EXrev = 0
try:
MSorder = int(fields.getvalue("MSorder"))
except Exception:
MSorder = 0
try:
MSrev = int(fields.getvalue("MSrev"))
except Exception:
MSrev = 0
try:
MOorder = int(fields.getvalue("MOorder"))
except Exception:
MOorder = 0
try:
MOrev = int(fields.getvalue("MOrev"))
except Exception:
MOrev = 0
try:
MOdata = int(fields.getvalue("MOdata"))
except Exception:
MOdata = 0
try:
SCorder = int(fields.getvalue("SCorder"))
except Exception:
SCorder = 0
try:
SCrev = int(fields.getvalue("SCrev"))
except Exception:
SCrev = 0
try:
OForder = int(fields.getvalue("OForder"))
except Exception:
OForder = 0
try:
OFrev = int(fields.getvalue("OFrev"))
except Exception:
OFrev = 0
try:
OFsessionid = int(fields.getvalue("OFsessionid"))
except Exception:
OFsessionid = 0
try:
ALorder = int(fields.getvalue("ALorder"))
except Exception:
ALorder = 0
try:
ALrev = int(fields.getvalue("ALrev"))
except Exception:
ALrev = 0
try:
ALinode = int(fields.getvalue("ALinode"))
except Exception:
ALinode = 0
try:
QUorder = int(fields.getvalue("QUorder"))
except Exception:
QUorder = 0
try:
QUrev = int(fields.getvalue("QUrev"))
except Exception:
QUrev = 0
try:
if "MCdata" in fields:
MCdata = fields.getvalue("MCdata")
else:
MCdata = ""
except Exception:
MCdata = ""
try:
if "CCdata" in fields:
CCdata = fields.getvalue("CCdata")
else:
CCdata = ""
except Exception:
CCdata = ""
else:
# fix order id's
if CSorder>=2:
CSorder+=1
if leaderfound and masterconn.version_less_than(1,7,25) and CSorder>=4:
CSorder+=1
if leaderfound and masterconn.version_less_than(1,6,28) and CSorder>=5:
CSorder+=1
if CSorder>=6 and CSorder<=9:
CSorder+=4
elif CSorder>=10 and CSorder<=13:
CSorder+=10
if MBorder>=2:
MBorder+=1
if HDorder>=13 and HDorder<=15:
HDorder+=7
if leaderfound and masterconn.version_less_than(1,7,0) and EXorder>=10:
EXorder+=1
if MSorder>=3:
MSorder+=1
if leaderfound and masterconn.version_less_than(1,7,0) and MSorder>=10:
MSorder+=1
if MSorder==0:
MSorder=2
if MOorder==2:
MOorder = 3
elif MOorder>=3 and MOorder<=18:
MOorder += 97
elif MOorder==19:
MOorder = 150
elif MOorder!=1:
MOorder = 0
if QUorder>=2 and QUorder<=6:
QUorder += 8
elif QUorder>=7 and QUorder<=10:
QUorder += 14
elif QUorder>=11 and QUorder<=22:
QUorder = (lambda x: x[0]+x[1]*10)(divmod(QUorder-11,3))+31
elif QUorder<1 or QUorder>22:
QUorder = 0
if "IN" in sectionset:
if cgimode and MFS_MESSAGE:
out = []
out.append("""
""")
out.append("""| Notice |
|---|
""")
out.append("""| You are currently using GPL version of MooseFS. If you want to find out what great features are available in MooseFS Pro go to https://moosefs.com/products/ |
""")
out.append("""
""")
print("\n".join(out))
if "IM" in sectionsubset and len(masterlistinfo)>0:
try:
if cgimode:
out = []
out.append("""
""")
out.append(""" | Metadata Servers (masters) |
|---|
""")
out.append(""" """)
out.append(""" | # | """)
out.append(""" ip | """)
out.append(""" version | """)
out.append(""" state | """)
out.append(""" local time | """)
out.append(""" metadata version | """)
out.append(""" metadata delay | """)
out.append(""" RAM used | """)
out.append(""" CPU used | """)
out.append(""" last successful metadata save | """)
out.append(""" last metadata save duration | """)
out.append(""" last metadata save status | """)
out.append(""" exports checksum | """)
out.append("""
""")
elif ttymode:
tab = Tabble("Metadata Servers",12,"r")
tab.header("ip","version","state","local time","metadata version","metadata delay","RAM used","CPU used","last meta save","last save duration","last save status","exports checksum")
else:
tab = Tabble("metadata servers",12)
masterstab = []
for sortip,strip,sortver,strver,statestr,statecolor,metaversion,memusage,syscpu,usercpu,lastsuccessfulstore,lastsaveseconds,lastsavestatus,exports_checksum,usectime,chlogtime in masterlistinfo:
if IMorder==1:
sf = sortip
elif IMorder==2:
sf = sortver
elif IMorder==3:
sf = statecolor
elif IMorder==4:
sf = usectime if usectime!=None else 0
elif IMorder==5:
sf = metaversion
elif IMorder==6:
sf = chlogtime if chlogtime!=None else 0
elif IMorder==7:
sf = memusage
elif IMorder==8:
sf = syscpu+usercpu
elif IMorder==9:
sf = lastsuccessfulstore
elif IMorder==10:
sf = lastsaveseconds
elif IMorder==11:
sf = lastsavestatus
elif IMorder==12:
sf = exports_checksum
else:
sf = 0
masterstab.append((sf,sortip,strip,sortver,strver,statestr,statecolor,metaversion,memusage,syscpu,usercpu,lastsuccessfulstore,lastsaveseconds,lastsavestatus,exports_checksum,usectime,chlogtime))
masterstab.sort()
if IMrev:
masterstab.reverse()
for sf,sortip,strip,sortver,strver,statestr,statecolor,metaversion,memusage,syscpu,usercpu,lastsuccessfulstore,lastsaveseconds,lastsavestatus,exports_checksum,usectime,chlogtime in masterstab:
if usectime==None or usectime==0:
secdelta = None
else:
secdelta = 0.0
if leader_usectime==None or leader_usectime==0:
if master_maxusectime!=None and master_minusectime!=None:
secdelta = (master_maxusectime - master_minusectime) / 1000000.0
else:
if leader_usectime > usectime:
secdelta = (leader_usectime - usectime) / 1000000.0
else:
secdelta = (usectime - leader_usectime) / 1000000.0
if chlogtime==None or chlogtime==0 or leader_usectime==None or leader_usectime==0:
metadelay = None
else:
metadelay = leader_usectime/1000000.0 - chlogtime
if metadelay>1.0:
metadelay-=1.0
else:
metadelay=0.0
if cgimode:
if masterconn!=None and masterconn.is_pro() and not strver.endswith(" PRO"):
verclass = "BADVERSION"
elif masterconn!=None and masterconn.sort_ver() > sortver:
verclass = "LOWERVERSION"
elif masterconn!=None and masterconn.sort_ver() < sortver:
verclass = "HIGHERVERSION"
else:
verclass = "OKVERSION"
out.append(""" """)
out.append(""" | %s %s | %s %s | """ % (sortip,strip,sortver,verclass,strver))
out.append(""" %s | """ % (statecolor,statestr))
if secdelta==None:
out.append(""" - | """)
else:
out.append(""" %s | """ % (("ERROR" if secdelta>2.0 else "WARNING" if secdelta>1.0 else "SUCCESS" if secdelta>0.0 else "DEFINED"),time.asctime(time.localtime(usectime//1000000))))
out.append(""" %s | """ % (decimal_number(metaversion)))
if metadelay==None:
out.append(""" - | """)
else:
out.append(""" %.0f s | """ % (("SUCCESS" if metadelay<1.0 else "WARNING" if metadelay<6.0 else "ERROR"),metadelay))
if memusage>0:
out.append(""" %s | """ % (decimal_number(memusage),humanize_number(memusage," ")))
else:
out.append(""" not available | """)
if syscpu>0 or usercpu>0:
out.append(""" all:%.2f%% sys:%.2f%% user:%.2f%% | """ % (syscpu+usercpu,syscpu,usercpu,syscpu+usercpu,syscpu,usercpu))
else:
out.append(""" not available | """)
if lastsuccessfulstore>0:
out.append(""" %s | """ % time.asctime(time.localtime(lastsuccessfulstore)))
out.append(""" %s | """ % (timeduration_to_fullstr(lastsaveseconds),timeduration_to_shortstr(lastsaveseconds)))
else:
out.append(""" - | - | """)
if lastsuccessfulstore>0 or lastsavestatus>0:
out.append(""" %s | """ % ("SUCCESS" if lastsavestatus==0 or lastsavestatus==1 else "WARNING" if lastsavestatus==2 else "ERROR","Saved in background" if lastsavestatus==0 else "Downloaded from other master" if lastsavestatus==1 else "Saved in foreground" if lastsavestatus==2 else "Unknown status: %u" % lastsavestatus))
else:
out.append(""" - | """)
if exports_checksum!=None:
out.append(""" %016X | """ % (("ERROR" if exports_checksum != master_exports_checksum else "SUCCESS"),exports_checksum))
else:
out.append(""" - | """)
out.append("""
""")
else:
clist = [strip,strver,(statestr,"c%u" % statecolor)]
if secdelta==None:
clist.append("not available")
else:
if ttymode:
clist.append((time.asctime(time.localtime(usectime//1000000)),("1" if secdelta>2.0 else "3" if secdelta>1.0 else "4" if secdelta>0.0 else "0")))
else:
clist.append("%.6lf" % (usectime/1000000.0))
clist.append(decimal_number(metaversion))
if metadelay==None:
clist.append("not available")
else:
if ttymode:
clist.append((("%.0f s" % metadelay),("4" if metadelay<1.0 else "3" if metadelay<6.0 else "1")))
else:
clist.append(int(metadelay))
if memusage>0:
if ttymode:
clist.append(humanize_number(memusage," "))
else:
clist.append(memusage)
else:
clist.append("not available")
if syscpu>0 or usercpu>0:
if ttymode:
clist.append("all:%.2f%% sys:%.2f%% user:%.2f%%" % (syscpu+usercpu,syscpu,usercpu))
else:
clist.append("all:%.7f%% sys:%.7f%% user:%.7f%%" % (syscpu+usercpu,syscpu,usercpu))
else:
clist.append("not available")
if lastsuccessfulstore>0:
if ttymode:
clist.append(time.asctime(time.localtime(lastsuccessfulstore)))
clist.append(timeduration_to_shortstr(lastsaveseconds))
else:
clist.append(lastsuccessfulstore)
clist.append("%.3f" % lastsaveseconds)
else:
clist.append("-")
clist.append("-")
if lastsuccessfulstore>0 or lastsavestatus>0:
clist.append(("Saved in background","4") if lastsavestatus==0 else ("Downloaded from other master","4") if lastsavestatus==1 else ("Saved in foreground","2") if lastsavestatus==2 else ("Unknown status: %u" % lastsavestatus,"1"))
else:
clist.append("-")
if exports_checksum!=None:
clist.append((("%016X" % exports_checksum),("1" if exports_checksum != master_exports_checksum else "4")))
else:
clist.append("-")
tab.append(*clist)
if len(masterstab)==0:
if cgimode:
out.append(""" | Servers not found !!! - check your DNS |
""")
else:
tab.append(("""Servers not found !!! - check your DNS""","c",9))
if cgimode:
out.append("""
""")
print("\n".join(out))
else:
print(myunicode(tab))
except Exception:
print_exception()
if "IG" in sectionsubset and masterconn!=None:
try:
length = len(masterinfo)
if length==68:
v1,v2,v3,total,avail,trspace,trfiles,respace,refiles,nodes,dirs,files,chunks,allcopies,tdcopies = struct.unpack(">HBBQQQLQLLLLLLL",masterinfo)
strver,sortver = version_str_and_sort((v1,v2,v3))
if cgimode:
out = []
out.append("""
""")
out.append(""" | Info |
|---|
""")
out.append(""" """)
out.append(""" | version | """)
out.append(""" total space | """)
out.append(""" avail space | """)
out.append(""" trash space | """)
out.append(""" trash files | """)
out.append(""" sustained space | """)
out.append(""" sustained files | """)
out.append(""" all fs objects | """)
out.append(""" directories | """)
out.append(""" files | """)
out.append(""" chunks | """)
out.append(""" all chunk copies | """)
out.append(""" regular chunk copies | """)
out.append("""
""")
out.append(""" """)
out.append(""" | %s | """ % strver)
out.append(""" %s | """ % (decimal_number(total),humanize_number(total," ")))
out.append(""" %s | """ % (decimal_number(avail),humanize_number(avail," ")))
out.append(""" %s | """ % (decimal_number(trspace),humanize_number(trspace," ")))
out.append(""" %u | """ % trfiles)
out.append(""" %s | """ % (decimal_number(respace),humanize_number(respace," ")))
out.append(""" %u | """ % refiles)
out.append(""" %u | """ % nodes)
out.append(""" %u | """ % dirs)
out.append(""" %u | """ % files)
out.append(""" %u | """ % chunks)
out.append(""" %u | """ % allcopies)
out.append(""" %u | """ % tdcopies)
out.append("""
""")
out.append("""
""")
print("\n".join(out))
else:
if ttymode:
tab = Tabble("Master Info",2)
else:
tab = Tabble("master info",2)
tab.defattr("l","r")
tab.append("master version",strver)
if ttymode:
tab.append("total space",humanize_number(total," "))
tab.append("avail space",humanize_number(avail," "))
tab.append("trash space",humanize_number(trspace," "))
else:
tab.append("total space",total)
tab.append("avail space",avail)
tab.append("trash space",trspace)
tab.append("trash files",trfiles)
if ttymode:
tab.append("sustained space",humanize_number(respace," "))
else:
tab.append("sustained space",respace)
tab.append("sustained files",refiles)
tab.append("all fs objects",nodes)
tab.append("directories",dirs)
tab.append("files",files)
tab.append("chunks",chunks)
tab.append("all chunk copies",allcopies)
tab.append("regular chunk copies",tdcopies)
print(myunicode(tab))
elif length==76:
v1,v2,v3,memusage,total,avail,trspace,trfiles,respace,refiles,nodes,dirs,files,chunks,allcopies,tdcopies = struct.unpack(">HBBQQQQLQLLLLLLL",masterinfo)
strver,sortver = version_str_and_sort((v1,v2,v3))
if cgimode:
out = []
out.append("""
""")
out.append(""" | Info |
|---|
""")
out.append(""" """)
out.append(""" | version | """)
out.append(""" RAM used | """)
out.append(""" total space | """)
out.append(""" avail space | """)
out.append(""" trash space | """)
out.append(""" trash files | """)
out.append(""" sustained space | """)
out.append(""" sustained files | """)
out.append(""" all fs objects | """)
out.append(""" directories | """)
out.append(""" files | """)
out.append(""" chunks | """)
out.append(""" all chunk copies | """)
out.append(""" regular chunk copies | """)
out.append("""
""")
out.append(""" """)
out.append(""" | %s | """ % strver)
if memusage>0:
out.append(""" %s | """ % (decimal_number(memusage),humanize_number(memusage," ")))
else:
out.append(""" not available | """)
out.append(""" %s | """ % (decimal_number(total),humanize_number(total," ")))
out.append(""" %s | """ % (decimal_number(avail),humanize_number(avail," ")))
out.append(""" %s | """ % (decimal_number(trspace),humanize_number(trspace," ")))
out.append(""" %u | """ % trfiles)
out.append(""" %s | """ % (decimal_number(respace),humanize_number(respace," ")))
out.append(""" %u | """ % refiles)
out.append(""" %u | """ % nodes)
out.append(""" %u | """ % dirs)
out.append(""" %u | """ % files)
out.append(""" %u | """ % chunks)
out.append(""" %u | """ % allcopies)
out.append(""" %u | """ % tdcopies)
out.append("""
""")
out.append("""
""")
print("\n".join(out))
else:
if ttymode:
tab = Tabble("Master Info",2)
else:
tab = Tabble("master info",2)
tab.defattr("l","r")
tab.append("master version",strver)
if memusage>0:
if ttymode:
tab.append("RAM used",humanize_number(memusage," "))
else:
tab.append("RAM used",memusage)
else:
tab.append("RAM used","not available")
if ttymode:
tab.append("total space",humanize_number(total," "))
tab.append("avail space",humanize_number(avail," "))
tab.append("trash space",humanize_number(trspace," "))
else:
tab.append("total space",total)
tab.append("avail space",avail)
tab.append("trash space",trspace)
tab.append("trash files",trfiles)
if ttymode:
tab.append("sustained space",humanize_number(respace," "))
else:
tab.append("sustained space",respace)
tab.append("sustained files",refiles)
tab.append("all fs objects",nodes)
tab.append("directories",dirs)
tab.append("files",files)
tab.append("chunks",chunks)
tab.append("all chunk copies",allcopies)
tab.append("regular chunk copies",tdcopies)
print(myunicode(tab))
elif length==101 or length==121 or length==129 or length==137 or length==149:
if length>=137:
v1,v2,v3,memusage,syscpu,usercpu,totalspace,availspace,freespace,trspace,trfiles,respace,refiles,nodes,dirs,files,chunks,allcopies,tdcopies,lastsuccessfulstore,lastsaveseconds,lastsavestatus = struct.unpack(">HBBQQQQQQQLQLLLLLLLLLB",masterinfo[:109])
else:
v1,v2,v3,memusage,syscpu,usercpu,totalspace,availspace,trspace,trfiles,respace,refiles,nodes,dirs,files,chunks,allcopies,tdcopies,lastsuccessfulstore,lastsaveseconds,lastsavestatus = struct.unpack(">HBBQQQQQQLQLLLLLLLLLB",masterinfo[:101])
freespace = None
strver,sortver = version_str_and_sort((v1,v2,v3))
syscpu/=10000000.0
usercpu/=10000000.0
if masterconn.version_at_least(2,0,14):
lastsaveseconds = lastsaveseconds / 1000.0
if cgimode:
out = []
if length==101:
out.append("""
""")
out.append(""" | General Info |
|---|
""")
out.append(""" """)
out.append(""" | version | """)
out.append(""" RAM used | """)
out.append(""" CPU used | """)
out.append(""" last successful metadata save | """)
out.append(""" last metadata save duration | """)
out.append(""" last metadata save status | """)
out.append("""
""")
out.append(""" """)
out.append(""" | %s | """ % strver)
if memusage>0:
out.append(""" %s | """ % (decimal_number(memusage),humanize_number(memusage," ")))
else:
out.append(""" not available | """)
if syscpu>0 or usercpu>0:
out.append(""" all:%.2f%% sys:%.2f%% user:%.2f%% | """ % (syscpu+usercpu,syscpu,usercpu,syscpu+usercpu,syscpu,usercpu))
else:
out.append(""" not available | """)
if lastsuccessfulstore>0:
out.append(""" %s | """ % time.asctime(time.localtime(lastsuccessfulstore)))
out.append(""" %s | """ % (timeduration_to_fullstr(lastsaveseconds),timeduration_to_shortstr(lastsaveseconds)))
else:
out.append(""" - | - | """)
if lastsuccessfulstore>0 or lastsavestatus>0:
out.append(""" %s | """ % ("SUCCESS" if lastsavestatus==0 else "ERROR","OK" if lastsavestatus==0 else "ERROR (%u)" % lastsavestatus))
else:
out.append(""" - | """)
out.append("""
""")
out.append("""
""")
out.append("""
""")
out.append(""" | Metadata Info |
|---|
""" % (12 if freespace==None else 13))
out.append(""" """)
out.append(""" | total space | """)
out.append(""" avail space | """)
if freespace!=None:
out.append(""" free space | """)
out.append(""" trash space | """)
out.append(""" trash files | """)
out.append(""" sustained space | """)
out.append(""" sustained files | """)
out.append(""" all fs objects | """)
out.append(""" directories | """)
out.append(""" files | """)
out.append(""" chunks | """)
out.append(""" all chunk copies | """)
out.append(""" regular chunk copies | """)
out.append("""
""")
out.append(""" """)
out.append(""" | %s | """ % (decimal_number(totalspace),humanize_number(totalspace," ")))
out.append(""" %s | """ % (decimal_number(availspace),humanize_number(availspace," ")))
if freespace!=None:
out.append(""" %s | """ % (decimal_number(freespace),humanize_number(freespace," ")))
out.append(""" %s | """ % (decimal_number(trspace),humanize_number(trspace," ")))
out.append(""" %u | """ % trfiles)
out.append(""" %s | """ % (decimal_number(respace),humanize_number(respace," ")))
out.append(""" %u | """ % refiles)
out.append(""" %u | """ % nodes)
out.append(""" %u | """ % dirs)
out.append(""" %u | """ % files)
out.append(""" %u | """ % chunks)
out.append(""" %u | """ % allcopies)
out.append(""" %u | """ % tdcopies)
out.append("""
""")
out.append("""
""")
print("\n".join(out))
else:
if ttymode:
tab = Tabble("Master Info",2)
else:
tab = Tabble("master info",2)
tab.defattr("l","r")
tab.append("master version",strver)
if memusage>0:
if ttymode:
tab.append("RAM used",humanize_number(memusage," "))
else:
tab.append("RAM used",memusage)
else:
tab.append("RAM used","not available")
if syscpu>0 or usercpu>0:
if ttymode:
tab.append("CPU used","%.2f%%" % (syscpu+usercpu))
tab.append("CPU used (system)","%.2f%%" % (syscpu))
tab.append("CPU used (user)","%.2f%%" % (usercpu))
else:
tab.append("CPU used (system)","%.9f" % (syscpu/100.0))
tab.append("CPU used (user)","%.9f" % (usercpu/100.0))
else:
tab.append("CPU used","not available")
if ttymode:
tab.append("total space",humanize_number(totalspace," "))
tab.append("avail space",humanize_number(availspace," "))
if freespace!=None:
tab.append("free space",humanize_number(freespace," "))
tab.append("trash space",humanize_number(trspace," "))
else:
tab.append("total space",totalspace)
tab.append("avail space",availspace)
if freespace!=None:
tab.append("free space",freespace)
tab.append("trash space",trspace)
tab.append("trash files",trfiles)
if ttymode:
tab.append("sustained space",humanize_number(respace," "))
else:
tab.append("sustained space",respace)
tab.append("sustained files",refiles)
tab.append("all fs objects",nodes)
tab.append("directories",dirs)
tab.append("files",files)
tab.append("chunks",chunks)
tab.append("all chunk copies",allcopies)
tab.append("regular chunk copies",tdcopies)
if lastsuccessfulstore>0:
if ttymode:
tab.append("last successful store",time.asctime(time.localtime(lastsuccessfulstore)))
tab.append("last save duration",timeduration_to_shortstr(lastsaveseconds))
else:
tab.append("last successful store",lastsuccessfulstore)
tab.append("last save duration","%.3f" % lastsaveseconds)
else:
tab.append("last successful store","-")
tab.append("last save duration","-")
if lastsuccessfulstore>0 or lastsavestatus>0:
tab.append("last save status",("Saved in background","4") if lastsavestatus==0 else ("Downloaded from another master","4") if lastsavestatus==1 else ("Saved in foreground","2") if lastsavestatus==2 else ("Unknown status: %u" % lastsavestatus,"1"))
else:
tab.append("last save status","-")
print(myunicode(tab))
else:
if cgimode:
out = []
out.append("""
""")
out.append(""" | unrecognized answer from MFSmaster |
""")
out.append("""
""")
print("\n".join(out))
else:
print("unrecognized answer from MFSmaster")
except Exception:
print_exception()
if "MU" in sectionsubset and masterconn!=None and masterconn.version_at_least(1,7,16):
try:
data,length = masterconn.command(CLTOMA_MEMORY_INFO,MATOCL_MEMORY_INFO)
if length>=176 and length%16==0:
memusage = struct.unpack(">QQQQQQQQQQQQQQQQQQQQQQ",data[:176])
memlabels = ["chunk hash","chunks","cs lists","edge hash","edges","node hash","nodes","deleted nodes","chunk tabs","symlinks","quota"]
abrlabels = ["c.h.","c.","c.l.","e.h.","e.","n.h.","n.","d.n.","c.t.","s.","q."]
totalused = 0
totalallocated = 0
for i in xrange(11):
totalused += memusage[1+i*2]
totalallocated += memusage[i*2]
if cgimode:
out = []
out.append("""
""")
out.append(""" | Memory usage detailed info |
|---|
""" % (len(memlabels)+2))
out.append(""" | """)
for i in xrange(11):
out.append(""" %s | """ % memlabels[i])
out.append(""" total |
|---|
""")
out.append(""" | used | """)
for i in xrange(11):
out.append(""" %s | """ % (decimal_number(memusage[1+i*2]),humanize_number(memusage[1+i*2]," ")))
out.append(""" %s |
|---|
""" % (decimal_number(totalused),humanize_number(totalused," ")))
out.append(""" | allocated | """)
for i in xrange(11):
out.append(""" %s | """ % (decimal_number(memusage[i*2]),humanize_number(memusage[i*2]," ")))
out.append(""" %s |
|---|
""" % (decimal_number(totalallocated),humanize_number(totalallocated," ")))
out.append(""" | utilization | """)
for i in xrange(11):
if memusage[i*2]:
percent = "%.2f %%" % (100.0 * memusage[1+i*2] / memusage[i*2])
else:
percent = "-"
out.append(""" %s | """ % percent)
if totalallocated:
percent = "%.2f %%" % (100.0 * totalused / totalallocated)
else:
percent = "-"
out.append(""" %s |
|---|
""" % percent)
if totalallocated>0:
out.append(""" | distribution | """)
for i in xrange(11):
tpercent = "%.2f %%" % (100.0 * memusage[i*2] / totalallocated)
out.append(""" %s | """ % tpercent)
out.append(""" - |
|---|
""")
out.append(""" | distribution bar | """)
out.append(""" """ % (len(memlabels)+1))
out.append(""" """)
memdistribution = []
other = 0.0
for i,(label,abr) in enumerate(zip(memlabels,abrlabels)):
tpercent = (100.0 * memusage[i*2] / totalallocated)
if tpercent>1.0:
memdistribution.append((tpercent,label,abr))
else:
other+=tpercent
memdistribution.sort()
memdistribution.reverse()
if other>0:
memdistribution.append((other,None,None))
cl = "FIRST"
labels = []
tooltips = []
for i,(percent,label,abr) in enumerate(memdistribution):
if label:
if percent>10.0:
out.append(""" | %s | """ % (percent,i,cl,label,percent,label))
elif percent>3.0:
out.append(""" %s | """ % (percent,i,cl,label,percent,abr))
else:
out.append(""" %s | """ % (percent,i,cl,label,percent,"#"))
labels.append(label)
tooltips.append("%s (%.2f %%)" % (label,percent))
else:
out.append(""" | """ % (percent,cl))
labels.append("others")
tooltips.append("other memory segments (%.2f %%)" % (percent))
cl = "MID"
out.append("""
""")
out.append("""""")
out.append("""""")
out.append(""" | """)
out.append("""
|---|
""")
out.append("""
""")
print("\n".join(out))
else:
if ttymode:
tab = Tabble("Memory Usage Detailed Info",5)
tab.defattr("l","r","r","r","r")
tab.header("object name","memory used","memory allocated","utilization percent","percent of total allocated memory")
else:
tab = Tabble("memory usage detailed info",3)
tab.defattr("l","r","r")
tab.header("object name","memory used","memory allocated")
for i in xrange(11):
if ttymode:
if memusage[i*2]>0:
upercent = "%.2f %%" % (100.0 * memusage[1+i*2] / memusage[i*2])
else:
upercent = "-"
if totalallocated:
tpercent = "%.2f %%" % (100.0 * memusage[i*2] / totalallocated)
else:
tpercent = "-"
tab.append(memlabels[i],humanize_number(memusage[1+i*2]," "),humanize_number(memusage[i*2]," "),upercent,tpercent)
else:
tab.append(memlabels[i],memusage[1+i*2],memusage[i*2])
if ttymode:
tab.append(("---","",5))
percent = 100.0 * totalused / totalallocated
tab.append("total",humanize_number(totalused," "),humanize_number(totalallocated," "),"%.2f %%" % percent,"-")
print(myunicode(tab))
except Exception:
print_exception()
if "IC" in sectionsubset and leaderfound:
try:
if masterconn.version_less_than(1,7,0):
data,length = masterconn.command(CLTOMA_CHUNKS_MATRIX,MATOCL_CHUNKS_MATRIX,struct.pack(">B",0))
if length==484:
matrix = []
matrix.append([])
for i in range(11):
matrix[0].append(list(struct.unpack(">LLLLLLLLLLL",data[i*44:i*44+44])))
data,length = masterconn.command(CLTOMA_CHUNKS_MATRIX,MATOCL_CHUNKS_MATRIX,struct.pack(">B",1))
if length==484:
matrix.append([])
for i in range(11):
matrix[1].append(list(struct.unpack(">LLLLLLLLLLL",data[i*44:i*44+44])))
progressstatus = 0
else:
data,length = masterconn.command(CLTOMA_CHUNKS_MATRIX,MATOCL_CHUNKS_MATRIX)
if length==969:
progressstatus = struct.unpack(">B",data[0:1])[0]
matrix = ([],[])
for x in range(2):
for i in range(11):
matrix[x].append(list(struct.unpack(">LLLLLLLLLLL",data[1+x*484+i*44:45+x*484+i*44])))
progressstr = "disconnections" if (progressstatus==1) else "connections" if (progressstatus==2) else "connections and disconnections"
if len(matrix)==2:
if cgimode:
out = []
out.append("""
""")
out.append(""" | """)
out.append(""" All chunks state matrix (counts 'regular' hdd space and 'marked for removal' hdd space : switch to 'regular')""")
out.append(""" Regular chunks state matrix (counts only 'regular' hdd space : switch to 'all')""")
out.append(""" |
|---|
""")
if progressstatus>0:
out.append("""| Warning: counters may not be valid - %s in progress |
|---|
""" % progressstr)
out.append(""" """)
out.append(""" | goal | """)
out.append(""" valid copies | """)
out.append("""
""")
out.append(""" """)
out.append(""" | 0 | """)
out.append(""" 1 | """)
out.append(""" 2 | """)
out.append(""" 3 | """)
out.append(""" 4 | """)
out.append(""" 5 | """)
out.append(""" 6 | """)
out.append(""" 7 | """)
out.append(""" 8 | """)
out.append(""" 9 | """)
out.append(""" 10+ | """)
out.append(""" all | """)
out.append("""
""")
elif ttymode:
if INmatrix==0:
tab = Tabble("All chunks state matrix",13,"r")
else:
tab = Tabble("Regular chunks state matrix",13,"r")
if progressstatus>0:
tab.header(("Warning: counters may not be valid - %s in progress" % progressstr,"1c",13))
tab.header(("---","",13))
tab.header("",("valid copies","",12))
tab.header("goal",("---","",12))
tab.header(""," 0 "," 1 "," 2 "," 3 "," 4 "," 5 "," 6 "," 7 "," 8 "," 9 "," 10+ "," all ")
else:
out = []
if INmatrix==0:
mtypeprefix=("all chunks matrix:%s" % plaintextseparator)
else:
mtypeprefix=("regular chunks matrix:%s" % plaintextseparator)
classsum = []
classsum.append(7*[0])
classsum.append(7*[0])
sumlist = []
sumlist.append(11*[0])
sumlist.append(11*[0])
for goal in range(11):
if cgimode:
out.append(""" """)
if goal==10:
out.append(""" | 10+ | """)
else:
out.append(""" %u | """ % goal)
else:
if goal==10:
clist = ["10+"]
else:
clist = [goal]
for vc in range(11):
if goal==0:
if vc==0:
cl = "DELETEREADY"
clidx = 6
else:
cl = "DELETEPENDING"
clidx = 5
elif vc==0:
cl = "MISSING"
clidx = 0
elif vc>goal:
cl = "OVERGOAL"
clidx = 4
elif vc""")
if matrix[0][goal][vc]>0:
out.append(""" %u""" % (cl,matrix[0][goal][vc]))
if matrix[1][goal][vc]>0:
out.append(""" %u""" % (cl,matrix[1][goal][vc]))
out.append(""" """)
elif ttymode:
if matrix[INmatrix][goal][vc]>0:
clist.append((matrix[INmatrix][goal][vc],"1234678"[clidx]))
else:
clist.append("-")
else:
if matrix[INmatrix][goal][vc]>0:
out.append("""%sgoal/copies/chunks:%s%u%s%u%s%u""" % (mtypeprefix,plaintextseparator,goal,plaintextseparator,vc,plaintextseparator,matrix[INmatrix][goal][vc]))
if cgimode:
if goal==0:
out.append(""" """)
out.append(""" %u""" % sum(matrix[0][goal]))
out.append(""" %u""" % sum(matrix[1][goal]))
out.append(""" | """)
else:
out.append(""" """)
out.append(""" %u""" % sum(matrix[0][goal]))
out.append(""" %u""" % sum(matrix[1][goal]))
out.append(""" | """)
out.append("""
""")
elif ttymode:
clist.append(sum(matrix[INmatrix][goal]))
tab.append(*clist)
if goal>0:
sumlist[0] = [ a + b for (a,b) in zip(sumlist[0],matrix[0][goal])]
sumlist[1] = [ a + b for (a,b) in zip(sumlist[1],matrix[1][goal])]
if cgimode:
out.append(""" """)
out.append(""" | all 1+ | """)
for vc in range(11):
out.append(""" %u%u | """ % (sumlist[0][vc],sumlist[1][vc]))
out.append(""" %u%u | """ % (sum(sumlist[0]),sum(sumlist[1])))
out.append("""
""")
out.append(""" | colors | """)
out.append(""" """+(" / ".join([""" - %s (%u)""" % (cl,desc,cl,classsum[0][clidx]) for clidx,cl,desc in [(0,"MISSING","missing"),(1,"ENDANGERED","endangered"),(2,"UNDERGOAL","undergoal"),(3,"NORMAL","stable"),(4,"OVERGOAL","overgoal"),(5,"DELETEPENDING","pending deletion"),(6,"DELETEREADY","ready to be removed")]]))+"")
out.append(""" """+(" / ".join([""" - %s (%u)""" % (cl,desc,cl,classsum[1][clidx]) for clidx,cl,desc in [(0,"MISSING","missing"),(1,"ENDANGERED","endangered"),(2,"UNDERGOAL","undergoal"),(3,"NORMAL","stable"),(4,"OVERGOAL","overgoal"),(5,"DELETEPENDING","pending deletion"),(6,"DELETEREADY","ready to be removed")]]))+"")
out.append(""" |
|---|
""")
out.append("""
""")
print("\n".join(out))
elif ttymode:
clist = ["all 1+"]
for vc in range(11):
clist.append(sumlist[INmatrix][vc])
clist.append(sum(sumlist[INmatrix]))
tab.append(*clist)
tab.append(("---","",13))
#tab.append(("missing: %s%u%s / endangered: %s%u%s / undergoal: %s%u%s / stable: %s%u%s / overgoal: %s%u%s / pending deletion: %s%u%s / to be removed: %s%u%s" % (colorcode[0],classsum[0],ttyreset,colorcode[1],classsum[1],ttyreset,colorcode[2],classsum[2],ttyreset,colorcode[3],classsum[3],ttyreset,colorcode[5],classsum[4],ttyreset,colorcode[6],classsum[5],ttyreset,colorcode[7],classsum[6],ttyreset),"c",13))
tab.append(("missing: %u / endangered: %u / undergoal: %u / stable: %u / overgoal: %u / pending deletion: %u / to be removed: %u" % (classsum[INmatrix][0],classsum[INmatrix][1],classsum[INmatrix][2],classsum[INmatrix][3],classsum[INmatrix][4],classsum[INmatrix][5],classsum[INmatrix][6]),"c",13))
# out.append("chunkclass missing: %s%u%s" % (colorcode[0],classsum[0],ttyreset))
# out.append("chunkclass endangered: %s%u%s" % (colorcode[1],classsum[1],ttyreset))
# out.append("chunkclass undergoal: %s%u%s" % (colorcode[2],classsum[2],ttyreset))
# out.append("chunkclass stable: %s%u%s" % (colorcode[3],classsum[3],ttyreset))
# out.append("chunkclass overgoal: %s%u%s" % (colorcode[4],classsum[4],ttyreset))
# out.append("chunkclass pending deletion: %s%u%s" % (colorcode[5],classsum[5],ttyreset))
# out.append("chunkclass to be removed: %s%u%s" % (colorcode[6],classsum[6],ttyreset))
print(myunicode(tab))
else:
out.append("%schunkclass missing:%s%u" % (mtypeprefix,plaintextseparator,classsum[INmatrix][0]))
out.append("%schunkclass endangered:%s%u" % (mtypeprefix,plaintextseparator,classsum[INmatrix][1]))
out.append("%schunkclass undergoal:%s%u" % (mtypeprefix,plaintextseparator,classsum[INmatrix][2]))
out.append("%schunkclass stable:%s%u" % (mtypeprefix,plaintextseparator,classsum[INmatrix][3]))
out.append("%schunkclass overgoal:%s%u" % (mtypeprefix,plaintextseparator,classsum[INmatrix][4]))
out.append("%schunkclass pending deletion:%s%u" % (mtypeprefix,plaintextseparator,classsum[INmatrix][5]))
out.append("%schunkclass to be removed:%s%u" % (mtypeprefix,plaintextseparator,classsum[INmatrix][6]))
print("\n".join(out))
except Exception:
print_exception()
if "IL" in sectionsubset and leaderfound:
try:
data,length = masterconn.command(CLTOMA_CHUNKSTEST_INFO,MATOCL_CHUNKSTEST_INFO)
if length==52:
loopstart,loopend,del_invalid,ndel_invalid,del_unused,ndel_unused,del_dclean,ndel_dclean,del_ogoal,ndel_ogoal,rep_ugoal,nrep_ugoal,rebalnce = struct.unpack(">LLLLLLLLLLLLL",data)
if cgimode:
out = []
out.append("""
""")
out.append(""" | Chunk operations info |
|---|
""")
out.append(""" """)
out.append(""" | loop time | """)
out.append(""" deletions | """)
out.append(""" replications | """)
out.append("""
""")
out.append(""" """)
out.append(""" | start | """)
out.append(""" end | """)
out.append(""" invalid | """)
out.append(""" unused | """)
out.append(""" disk clean | """)
out.append(""" over goal | """)
out.append(""" under goal | """)
out.append(""" rebalance | """)
out.append("""
""")
if loopstart>0:
out.append(""" """)
out.append(""" | %s | """ % (time.asctime(time.localtime(loopstart)),))
out.append(""" %s | """ % (time.asctime(time.localtime(loopend)),))
out.append(""" %u/%u | """ % (del_invalid,del_invalid+ndel_invalid))
out.append(""" %u/%u | """ % (del_unused,del_unused+ndel_unused))
out.append(""" %u/%u | """ % (del_dclean,del_dclean+ndel_dclean))
out.append(""" %u/%u | """ % (del_ogoal,del_ogoal+ndel_ogoal))
out.append(""" %u/%u | """ % (rep_ugoal,rep_ugoal+nrep_ugoal))
out.append(""" %u | """ % rebalnce)
out.append("""
""")
else:
out.append(""" """)
out.append(""" | no data | """)
out.append("""
""")
out.append("""
""")
print("\n".join(out))
elif ttymode:
tab = Tabble("Chunk operations info",8,"r")
tab.header(("loop time","",2),("deletions","",4),("replications","",2))
tab.header(("---","",8))
tab.header("start","end","invalid","unused","disk clean","over goal","under goal","rebalance")
if loopstart>0:
tab.append((time.asctime(time.localtime(loopstart)),"c"),(time.asctime(time.localtime(loopend)),"c"),"%u/%u" % (del_invalid,del_invalid+ndel_invalid),"%u/%u" % (del_unused,del_unused+ndel_unused),"%u/%u" % (del_dclean,del_dclean+ndel_dclean),"%u/%u" % (del_ogoal,del_ogoal+ndel_ogoal),"%u/%u" % (rep_ugoal,rep_ugoal+nrep_ugoal),rebalnce)
else:
tab.append(("no data","c",8))
print(myunicode(tab))
else:
out = []
if loopstart>0:
out.append("""chunk loop%sstart:%s%u""" % (plaintextseparator,plaintextseparator,loopstart))
out.append("""chunk loop%send:%s%u""" % (plaintextseparator,plaintextseparator,loopend))
out.append("""chunk loop%sdeletions%sinvalid:%s%u/%u""" % (plaintextseparator,plaintextseparator,plaintextseparator,del_invalid,del_invalid+ndel_invalid))
out.append("""chunk loop%sdeletions%sunused:%s%u/%u""" % (plaintextseparator,plaintextseparator,plaintextseparator,del_unused,del_unused+ndel_unused))
out.append("""chunk loop%sdeletions%sdisk clean:%s%u/%u""" % (plaintextseparator,plaintextseparator,plaintextseparator,del_dclean,del_dclean+ndel_dclean))
out.append("""chunk loop%sdeletions%sover goal:%s%u/%u""" % (plaintextseparator,plaintextseparator,plaintextseparator,del_ogoal,del_ogoal+ndel_ogoal))
out.append("""chunk loop%sreplications%sunder goal:%s%u/%u""" % (plaintextseparator,plaintextseparator,plaintextseparator,rep_ugoal,rep_ugoal+nrep_ugoal))
out.append("""chunk loop%sreplications%srebalance:%s%u""" % (plaintextseparator,plaintextseparator,plaintextseparator,rebalnce))
else:
out.append("""chunk loop%sno data""" % plaintextseparator)
print("\n".join(out))
elif length==60:
loopstart,loopend,del_invalid,ndel_invalid,del_unused,ndel_unused,del_dclean,ndel_dclean,del_ogoal,ndel_ogoal,rep_ugoal,nrep_ugoal,rebalnce,locked_unused,locked_used = struct.unpack(">LLLLLLLLLLLLLLL",data)
if cgimode:
out = []
out.append("""
""")
out.append(""" | Chunk operations info |
|---|
""")
out.append(""" """)
out.append(""" | loop time | """)
out.append(""" deletions | """)
out.append(""" replications | """)
out.append(""" locked | """)
out.append("""
""")
out.append(""" """)
out.append(""" | start | """)
out.append(""" end | """)
out.append(""" invalid | """)
out.append(""" unused | """)
out.append(""" disk clean | """)
out.append(""" over goal | """)
out.append(""" under goal | """)
out.append(""" rebalance | """)
out.append(""" unused | """)
out.append(""" used | """)
out.append("""
""")
if loopstart>0:
out.append(""" """)
out.append(""" | %s | """ % (time.asctime(time.localtime(loopstart)),))
out.append(""" %s | """ % (time.asctime(time.localtime(loopend)),))
out.append(""" %u/%u | """ % (del_invalid,del_invalid+ndel_invalid))
out.append(""" %u/%u | """ % (del_unused,del_unused+ndel_unused))
out.append(""" %u/%u | """ % (del_dclean,del_dclean+ndel_dclean))
out.append(""" %u/%u | """ % (del_ogoal,del_ogoal+ndel_ogoal))
out.append(""" %u/%u | """ % (rep_ugoal,rep_ugoal+nrep_ugoal))
out.append(""" %u | """ % rebalnce)
out.append(""" %u | """ % locked_unused)
out.append(""" %u | """ % locked_used)
out.append("""
""")
else:
out.append(""" """)
out.append(""" | no data | """)
out.append("""
""")
out.append("""
""")
print("\n".join(out))
elif ttymode:
tab = Tabble("Chunk operations info",10,"r")
tab.header(("loop time","",2),("deletions","",4),("replications","",2),("locked","",2))
tab.header(("---","",10))
tab.header("start","end","invalid","unused","disk clean","over goal","under goal","rebalance","unused","used")
if loopstart>0:
tab.append((time.asctime(time.localtime(loopstart)),"c"),(time.asctime(time.localtime(loopend)),"c"),"%u/%u" % (del_invalid,del_invalid+ndel_invalid),"%u/%u" % (del_unused,del_unused+ndel_unused),"%u/%u" % (del_dclean,del_dclean+ndel_dclean),"%u/%u" % (del_ogoal,del_ogoal+ndel_ogoal),"%u/%u" % (rep_ugoal,rep_ugoal+nrep_ugoal),rebalnce,locked_unused,locked_used)
else:
tab.append(("no data","c",10))
print(myunicode(tab))
else:
out = []
if loopstart>0:
out.append("""chunk loop%sstart:%s%u""" % (plaintextseparator,plaintextseparator,loopstart))
out.append("""chunk loop%send:%s%u""" % (plaintextseparator,plaintextseparator,loopend))
out.append("""chunk loop%sdeletions%sinvalid:%s%u/%u""" % (plaintextseparator,plaintextseparator,plaintextseparator,del_invalid,del_invalid+ndel_invalid))
out.append("""chunk loop%sdeletions%sunused:%s%u/%u""" % (plaintextseparator,plaintextseparator,plaintextseparator,del_unused,del_unused+ndel_unused))
out.append("""chunk loop%sdeletions%sdisk clean:%s%u/%u""" % (plaintextseparator,plaintextseparator,plaintextseparator,del_dclean,del_dclean+ndel_dclean))
out.append("""chunk loop%sdeletions%sover goal:%s%u/%u""" % (plaintextseparator,plaintextseparator,plaintextseparator,del_ogoal,del_ogoal+ndel_ogoal))
out.append("""chunk loop%sreplications%sunder goal:%s%u/%u""" % (plaintextseparator,plaintextseparator,plaintextseparator,rep_ugoal,rep_ugoal+nrep_ugoal))
out.append("""chunk loop%sreplications%srebalance:%s%u""" % (plaintextseparator,plaintextseparator,plaintextseparator,rebalnce))
out.append("""chunk loop%slocked%sunused:%s%u""" % (plaintextseparator,plaintextseparator,plaintextseparator,locked_unused))
out.append("""chunk loop%slocked%sused:%s%u""" % (plaintextseparator,plaintextseparator,plaintextseparator,locked_used))
else:
out.append("""chunk loop%sno data""" % plaintextseparator)
print("\n".join(out))
elif length==72:
loopstart,loopend,del_invalid,ndel_invalid,del_unused,ndel_unused,del_dclean,ndel_dclean,del_ogoal,ndel_ogoal,rep_ugoal,nrep_ugoal,rep_wlab,nrep_wlab,rebalnce,labels_dont_match,locked_unused,locked_used = struct.unpack(">LLLLLLLLLLLLLLLLLL",data)
if cgimode:
out = []
out.append("""
""")
out.append(""" | Chunk operations info |
|---|
""")
out.append(""" """)
out.append(""" | loop time | """)
out.append(""" deletions | """)
out.append(""" replications | """)
out.append(""" locked | """)
out.append("""
""")
out.append(""" """)
out.append(""" | start | """)
out.append(""" end | """)
out.append(""" invalid | """)
out.append(""" unused | """)
out.append(""" disk clean | """)
out.append(""" over goal | """)
out.append(""" under goal | """)
out.append(""" wrong labels | """)
out.append(""" rebalance | """)
out.append(""" unused | """)
out.append(""" used | """)
out.append("""
""")
if loopstart>0:
out.append(""" """)
out.append(""" | %s | """ % (time.asctime(time.localtime(loopstart)),))
out.append(""" %s | """ % (time.asctime(time.localtime(loopend)),))
out.append(""" %u/%u | """ % (del_invalid,del_invalid+ndel_invalid))
out.append(""" %u/%u | """ % (del_unused,del_unused+ndel_unused))
out.append(""" %u/%u | """ % (del_dclean,del_dclean+ndel_dclean))
out.append(""" %u/%u | """ % (del_ogoal,del_ogoal+ndel_ogoal))
out.append(""" %u/%u | """ % (rep_ugoal,rep_ugoal+nrep_ugoal))
out.append(""" %u/%u/%u | """ % (rep_wlab,labels_dont_match,rep_wlab+nrep_wlab+labels_dont_match))
out.append(""" %u | """ % rebalnce)
out.append(""" %u | """ % locked_unused)
out.append(""" %u | """ % locked_used)
out.append("""
""")
else:
out.append(""" """)
out.append(""" | no data | """)
out.append("""
""")
out.append("""
""")
print("\n".join(out))
elif ttymode:
tab = Tabble("Chunk operations info",11,"r")
tab.header(("loop time","",2),("deletions","",4),("replications","",3),("locked","",2))
tab.header(("---","",11))
tab.header("start","end","invalid","unused","disk clean","over goal","under goal","wrong labels","rebalance","unused","used")
if loopstart>0:
tab.append((time.asctime(time.localtime(loopstart)),"c"),(time.asctime(time.localtime(loopend)),"c"),"%u/%u" % (del_invalid,del_invalid+ndel_invalid),"%u/%u" % (del_unused,del_unused+ndel_unused),"%u/%u" % (del_dclean,del_dclean+ndel_dclean),"%u/%u" % (del_ogoal,del_ogoal+ndel_ogoal),"%u/%u" % (rep_ugoal,rep_ugoal+nrep_ugoal),"%u/%u/%u" % (rep_wlab,labels_dont_match,rep_wlab+nrep_wlab+labels_dont_match),rebalnce,locked_unused,locked_used)
else:
tab.append(("no data","c",11))
print(myunicode(tab))
else:
out = []
if loopstart>0:
out.append("""chunk loop%sstart:%s%u""" % (plaintextseparator,plaintextseparator,loopstart))
out.append("""chunk loop%send:%s%u""" % (plaintextseparator,plaintextseparator,loopend))
out.append("""chunk loop%sdeletions%sinvalid:%s%u/%u""" % (plaintextseparator,plaintextseparator,plaintextseparator,del_invalid,del_invalid+ndel_invalid))
out.append("""chunk loop%sdeletions%sunused:%s%u/%u""" % (plaintextseparator,plaintextseparator,plaintextseparator,del_unused,del_unused+ndel_unused))
out.append("""chunk loop%sdeletions%sdisk clean:%s%u/%u""" % (plaintextseparator,plaintextseparator,plaintextseparator,del_dclean,del_dclean+ndel_dclean))
out.append("""chunk loop%sdeletions%sover goal:%s%u/%u""" % (plaintextseparator,plaintextseparator,plaintextseparator,del_ogoal,del_ogoal+ndel_ogoal))
out.append("""chunk loop%sreplications%sunder goal:%s%u/%u""" % (plaintextseparator,plaintextseparator,plaintextseparator,rep_ugoal,rep_ugoal+nrep_ugoal))
out.append("""chunk loop%sreplications%swrong labels:%s%u/%u/%u""" % (plaintextseparator,plaintextseparator,plaintextseparator,rep_wlab,labels_dont_match,rep_wlab+nrep_wlab+labels_dont_match))
out.append("""chunk loop%sreplications%srebalance:%s%u""" % (plaintextseparator,plaintextseparator,plaintextseparator,rebalnce))
out.append("""chunk loop%slocked%sunused:%s%u""" % (plaintextseparator,plaintextseparator,plaintextseparator,locked_unused))
out.append("""chunk loop%slocked%sused:%s%u""" % (plaintextseparator,plaintextseparator,plaintextseparator,locked_used))
else:
out.append("""chunk loop%sno data""" % plaintextseparator)
print("\n".join(out))
except Exception:
print_exception()
try:
if (masterconn.version_at_least(2,0,66) and masterconn.version_less_than(3,0,0)) or masterconn.version_at_least(3,0,19):
data,length = masterconn.command(CLTOMA_FSTEST_INFO,MATOCL_FSTEST_INFO,struct.pack(">B",0))
pver = 1
else:
data,length = masterconn.command(CLTOMA_FSTEST_INFO,MATOCL_FSTEST_INFO)
pver = 0
if length>=(36 + pver*8):
if pver==1:
loopstart,loopend,files,ugfiles,mfiles,mtfiles,msfiles,chunks,ugchunks,mchunks,msgbuffleng = struct.unpack(">LLLLLLLLLLL",data[:44])
datastr = data[44:].decode('utf-8','replace')
else:
loopstart,loopend,files,ugfiles,mfiles,chunks,ugchunks,mchunks,msgbuffleng = struct.unpack(">LLLLLLLLL",data[:36])
datastr = data[36:].decode('utf-8','replace')
if cgimode:
out = []
out.append("""
""")
out.append(""" | Filesystem check info |
|---|
""" % (8 if pver==0 else 10))
out.append(""" """)
out.append(""" | check loop start time | """)
out.append(""" check loop end time | """)
out.append(""" files | """)
out.append(""" under-goal files | """)
out.append(""" missing files | """)
if pver==1:
out.append(""" missing trash files | """)
out.append(""" missing sustained files | """)
out.append(""" chunks | """)
out.append(""" under-goal chunks | """)
out.append(""" missing chunks | """)
out.append("""
""")
if loopstart>0:
out.append(""" """)
out.append(""" | %s | """ % (time.asctime(time.localtime(loopstart)),))
out.append(""" %s | """ % (time.asctime(time.localtime(loopend)),))
out.append(""" %u | """ % files)
out.append(""" %u | """ % ugfiles)
out.append(""" %u | """ % mfiles)
if pver==1:
out.append(""" %u | """ % mtfiles)
out.append(""" %u | """ % msfiles)
out.append(""" %u | """ % chunks)
out.append(""" %u | """ % ugchunks)
out.append(""" %u | """ % mchunks)
out.append("""
""")
if msgbuffleng>0:
if msgbuffleng==100000:
out.append(""" | Important messages (first 100k): |
|---|
""")
else:
out.append(""" | Important messages: |
|---|
""")
out.append(""" """)
out.append(""" %s | """ % (datastr.replace("&","&").replace(">",">").replace("<","<")))
out.append("""
""")
else:
out.append(""" """)
out.append(""" | no data | """ % (8 if pver==0 else 10))
out.append("""
""")
out.append("""
""")
print("\n".join(out))
elif ttymode:
if pver==1:
tab = Tabble("Filesystem check info",10,"r")
tabwidth = 10
tab.header("check loop start time","check loop end time","files","under-goal files","missing files","missing trash files","missing sustained files","chunks","under-goal chunks","missing chunks")
else:
tab = Tabble("Filesystem check info",8,"r")
tabwidth = 8
tab.header("check loop start time","check loop end time","files","under-goal files","missing files","chunks","under-goal chunks","missing chunks")
if loopstart>0:
if pver==1:
tab.append((time.asctime(time.localtime(loopstart)),"c"),(time.asctime(time.localtime(loopend)),"c"),files,ugfiles,mfiles,mtfiles,msfiles,chunks,ugchunks,mchunks)
else:
tab.append((time.asctime(time.localtime(loopstart)),"c"),(time.asctime(time.localtime(loopend)),"c"),files,ugfiles,mfiles,chunks,ugchunks,mchunks)
if msgbuffleng>0:
tab.append(("---","",tabwidth))
if msgbuffleng==100000:
tab.append(("Important messages (first 100k):","c",tabwidth))
else:
tab.append(("Important messages:","c",tabwidth))
tab.append(("---","",tabwidth))
for line in datastr.strip().split("\n"):
tab.append((line.strip(),"l",tabwidth))
else:
tab.append(("no data","c",tabwidth))
print(myunicode(tab))
else:
out = []
if loopstart>0:
out.append("""check loop%sstart:%s%u""" % (plaintextseparator,plaintextseparator,loopstart))
out.append("""check loop%send:%s%u""" % (plaintextseparator,plaintextseparator,loopend))
out.append("""check loop%sfiles:%s%u""" % (plaintextseparator,plaintextseparator,files))
out.append("""check loop%sunder-goal files:%s%u""" % (plaintextseparator,plaintextseparator,ugfiles))
out.append("""check loop%smissing files:%s%u""" % (plaintextseparator,plaintextseparator,mfiles))
if pver==1:
out.append("""check loop%smissing trash files:%s%u""" % (plaintextseparator,plaintextseparator,mtfiles))
out.append("""check loop%smissing sustained files:%s%u""" % (plaintextseparator,plaintextseparator,msfiles))
out.append("""check loop%schunks:%s%u""" % (plaintextseparator,plaintextseparator,chunks))
out.append("""check loop%sunder-goal chunks:%s%u""" % (plaintextseparator,plaintextseparator,ugchunks))
out.append("""check loop%smissing chunks:%s%u""" % (plaintextseparator,plaintextseparator,mchunks))
if msgbuffleng>0:
for line in datastr.strip().split("\n"):
out.append("check loop%simportant messages:%s%s" % (plaintextseparator,plaintextseparator,line.strip()))
else:
out.append("""check loop: no data""")
print("\n".join(out))
except Exception:
print_exception()
if "MF" in sectionsubset and leaderfound and ((masterconn.version_at_least(2,0,66) and masterconn.version_less_than(3,0,0)) or masterconn.version_at_least(3,0,19)):
try:
inodes = set()
missingchunks = []
if ((masterconn.version_at_least(2,0,71) and masterconn.version_less_than(3,0,0)) or masterconn.version_at_least(3,0,25)):
data,length = masterconn.command(CLTOMA_MISSING_CHUNKS,MATOCL_MISSING_CHUNKS,struct.pack(">B",1))
if length%17==0:
n = length//17
for x in xrange(n):
chunkid,inode,indx,mtype = struct.unpack(">QLLB",data[x*17:x*17+17])
inodes.add(inode)
missingchunks.append((chunkid,inode,indx,mtype))
mode = 1
else:
data,length = masterconn.command(CLTOMA_MISSING_CHUNKS,MATOCL_MISSING_CHUNKS)
if length%16==0:
n = length//16
for x in xrange(n):
chunkid,inode,indx = struct.unpack(">QLL",data[x*16:x*16+16])
inodes.add(inode)
missingchunks.append((chunkid,inode,indx,None))
mode = 0
inodepaths = resolve_inodes_paths(masterconn,inodes)
mcdata = []
mccnt = 0
for chunkid,inode,indx,mtype in missingchunks:
if inode in inodepaths:
paths = inodepaths[inode]
mccnt += len(paths)
else:
paths = []
mccnt += 1
sf = paths
if MForder==1:
sf = paths
elif MForder==2:
sf = inode
elif MForder==3:
sf = indx
elif MForder==4:
sf = chunkid
elif MForder==5:
sf = mtype
mcdata.append((sf,paths,inode,indx,chunkid,mtype))
mcdata.sort()
if MFrev:
mcdata.reverse()
if cgimode:
out = []
if mccnt>0:
out.append("""
""")
if MFlimit>0 and mccnt>MFlimit:
out.append(""" | Missing files (gathered by previous file-loop) - %u/%u entries - show more - show all |
|---|
""" % ((6 if mode==1 else 5),MFlimit,mccnt,createlink({"MFlimit":"%u" % (MFlimit + 100)}),createlink({"MFlimit":"0"})))
else:
out.append(""" | Missing files (gathered by previous file-loop) |
|---|
""" % (6 if mode==1 else 5))
out.append(""" """)
out.append(""" | # | """)
out.append(""" paths | """)
out.append(""" inode | """)
out.append(""" index | """)
out.append(""" chunk id | """)
if mode==1:
out.append(""" type of missing chunk | """)
out.append("""
""")
elif ttymode:
if mode==1:
tab = Tabble("Missing Files/Chunks (gathered by previous file-loop)",5)
tab.header("path","inode","index","chunk id","type of missing chunk")
tab.defattr("l","r","r","r","r")
else:
tab = Tabble("Missing Files/Chunks (gathered by previous file-loop)",4)
tab.header("path","inode","index","chunk id")
tab.defattr("l","r","r","r")
else:
tab = Tabble("missing files",(5 if mode==1 else 4))
missingcount = 0
for sf,paths,inode,indx,chunkid,mtype in mcdata:
if mtype==0:
mtypestr = "NO COPY"
elif mtype==1:
mtypestr = "INVALID COPIES"
elif mtype==2:
mtypestr = "WRONG VERSIONS"
else:
mtypestr = "OTHER"
if cgimode:
if mccnt>0:
if len(paths)==0:
if missingcount""")
out.append(""" | """)
out.append(""" * unknown path * (deleted file) | """)
out.append(""" %u | """ % inode)
out.append(""" %u | """ % indx)
out.append(""" %016X | """ % chunkid)
if mode==1:
out.append(""" %s | """ % mtypestr)
out.append(""" """)
missingcount += 1
else:
for path in paths:
if missingcount""")
out.append(""" | """)
out.append(""" %s | """ % path)
out.append(""" %u | """ % inode)
out.append(""" %u | """ % indx)
out.append(""" %016X | """ % chunkid)
if mode==1:
out.append(""" %s | """ % mtypestr)
out.append(""" """)
missingcount += 1
else:
if len(paths)==0:
dline = [" * unknown path * (deleted file)",inode,indx,"%016X" % chunkid]
if mode==1:
dline.append(mtypestr)
tab.append(*dline)
else:
for path in paths:
dline = [path,inode,indx,"%016X" % chunkid]
if mode==1:
dline.append(mtypestr)
tab.append(*dline)
if cgimode:
if mccnt>0:
out.append("""
""")
print("\n".join(out))
else:
print(myunicode(tab))
except Exception:
print_exception()
if "CS" in sectionset:
if "CS" in sectionsubset:
try:
if cgimode:
out = []
out.append("""
""")
if masterconn.version_at_least(3,0,38):
out.append(""" | Chunk Servers |
|---|
""")
elif masterconn.version_at_least(2,1,0):
out.append(""" | Chunk Servers |
|---|
""")
elif masterconn.version_at_least(2,0,11):
out.append(""" | Chunk Servers |
|---|
""")
elif masterconn.version_at_least(1,7,25):
out.append(""" | Chunk Servers |
|---|
""")
elif masterconn.version_at_least(1,6,28):
out.append(""" | Chunk Servers |
|---|
""")
else:
out.append(""" | Chunk Servers |
|---|
""")
out.append(""" """)
out.append(""" | # | """)
out.append(""" host | """)
out.append(""" ip | """)
out.append(""" port | """)
if masterconn.version_at_least(1,7,25):
out.append(""" id | """)
if masterconn.version_at_least(2,1,0):
out.append(""" labels | """)
out.append(""" version | """)
if masterconn.version_at_least(1,6,28):
out.append(""" load | """)
if masterconn.version_at_least(2,0,11):
out.append(""" maintenance | """)
out.append(""" 'regular' hdd space | """)
if masterconn.version_at_least(3,0,38):
out.append(""" 'marked for removal' hdd space | """)
else:
out.append(""" 'marked for removal' hdd space | """)
out.append("""
""")
out.append(""" """)
out.append(""" | chunks | """)
out.append(""" used | """)
out.append(""" total | """)
out.append(""" % used | """)
if masterconn.version_at_least(3,0,38):
out.append(""" status | """)
out.append(""" chunks | """)
out.append(""" used | """)
out.append(""" total | """)
out.append(""" % used | """)
out.append("""
""")
elif ttymode:
if masterconn.version_at_least(3,0,38):
tab = Tabble("Chunk Servers",16,"r")
tab.header("","","","","","","",("'regular' hdd space","",4),("'marked for removal' hdd space","",5))
tab.header("ip/host","port","id","labels","version","load","maintenance",("---","",9))
tab.header("","","","","","","","chunks","used","total","% used","status","chunks","used","total","% used")
elif masterconn.version_at_least(2,1,0):
tab = Tabble("Chunk Servers",15,"r")
tab.header("","","","","","","",("'regular' hdd space","",4),("'marked for removal' hdd space","",4))
tab.header("ip/host","port","id","labels","version","load","maintenance",("---","",8))
tab.header("","","","","","","","chunks","used","total","% used","chunks","used","total","% used")
elif masterconn.version_at_least(2,0,11):
tab = Tabble("Chunk Servers",14,"r")
tab.header("","","","","","",("'regular' hdd space","",4),("'marked for removal' hdd space","",4))
tab.header("ip/host","port","id","version","load","maintenance",("---","",8))
tab.header("","","","","","","chunks","used","total","% used","chunks","used","total","% used")
elif masterconn.version_at_least(1,7,25):
tab = Tabble("Chunk Servers",13,"r")
tab.header("","","","","",("'regular' hdd space","",4),("'marked for removal' hdd space","",4))
tab.header("ip/host","port","id","version","load",("---","",8))
tab.header("","","","","","chunks","used","total","% used","chunks","used","total","% used")
elif masterconn.version_at_least(1,6,28):
tab = Tabble("Chunk Servers",12,"r")
tab.header("","","","",("'regular' hdd space","",4),("'marked for removal' hdd space","",4))
tab.header("ip/host","port","version","load",("---","",8))
tab.header("","","","","chunks","used","total","% used","chunks","used","total","% used")
else:
tab = Tabble("Chunk Servers",11,"r")
tab.header("","","",("'regular' hdd space","",4),("'marked for removal' hdd space","",4))
tab.header("ip/host","port","version",("---","",8))
tab.header("","","","chunks","used","total","% used","chunks","used","total","% used")
else:
if masterconn.version_at_least(3,0,38):
tab = Tabble("chunk servers",14)
elif masterconn.version_at_least(2,1,0):
tab = Tabble("chunk servers",13)
elif masterconn.version_at_least(2,0,11):
tab = Tabble("chunk servers",12)
elif masterconn.version_at_least(1,7,25):
tab = Tabble("chunk servers",11)
elif masterconn.version_at_least(1,6,28):
tab = Tabble("chunk servers",10)
else:
tab = Tabble("chunk servers",9)
servers = []
dservers = []
usedsum = 0
totalsum = 0
for cs in dataprovider.get_chunkservers():
if cs.total>0:
usedsum+=cs.used
totalsum+=cs.total
if CSorder==1:
sf = cs.host
elif CSorder==2 or CSorder==0:
sf = cs.sortip
elif CSorder==3:
sf = cs.port
elif CSorder==4:
sf = cs.csid
elif CSorder==5:
sf = cs.sortver
elif CSorder==6:
sf = (cs.gracetime,cs.load)
elif CSorder==10:
sf = cs.chunks
elif CSorder==11:
sf = cs.used
elif CSorder==12:
sf = cs.total
elif CSorder==13:
if cs.total>0:
sf = (1.0*cs.used)/cs.total
else:
sf = 0
elif CSorder==20:
sf = cs.tdchunks
elif CSorder==21:
sf = cs.tdused
elif CSorder==22:
sf = cs.tdtotal
elif CSorder==23:
if cs.tdtotal>0:
sf = (1.0*cs.tdused)/cs.tdtotal
else:
sf = 0
else:
sf = 0
if (cs.flags&1)==0:
servers.append((sf,cs.host,cs.sortip,cs.strip,cs.port,cs.csid,cs.sortver,cs.strver,cs.flags,cs.used,cs.total,cs.chunks,cs.tdused,cs.tdtotal,cs.tdchunks,cs.errcnt,cs.load,cs.gracetime,cs.labels,cs.mfrstatus))
else:
dservers.append((sf,cs.host,cs.sortip,cs.strip,cs.port,cs.csid,cs.flags))
servers.sort()
dservers.sort()
if CSrev:
servers.reverse()
dservers.reverse()
if totalsum>0:
avgpercent = (usedsum*100.0)/totalsum
else:
avgpercent = 0
for sf,host,sortip,strip,port,csid,sortver,strver,flags,used,total,chunks,tdused,tdtotal,tdchunks,errcnt,load,gracetime,labels,mfrstatus in servers:
if cgimode:
if masterconn.is_pro() and not strver.endswith(" PRO"):
verclass = "BADVERSION"
elif masterconn.sort_ver() > sortver:
verclass = "LOWERVERSION"
elif masterconn.sort_ver() < sortver:
verclass = "HIGHERVERSION"
else:
verclass = "OKVERSION"
if masterconn.version_at_least(2,0,11) and leaderfound:
if (flags&2)==0:
mmstr = "OFF"
mm = "switch on"
mmurl = createlink({"CSmaintenanceon":("%s:%u" % (strip,port))})
cl = None
elif (flags&4)==0:
mmstr = "ON"
mm = "switch off"
mmurl = createlink({"CSmaintenanceoff":("%s:%u" % (strip,port))})
cl = "MAINTAINREADY"
else:
mmstr = "ON (TEMP)"
mm = "switch off"
mmurl = createlink({"CSmaintenanceoff":("%s:%u" % (strip,port))})
cl = "MAINTAINREADY"
else:
cl = None
out.append(""" """)
out.append(""" | """)
if cl:
out.append(""" %s | """ % (cl,host))
out.append(""" %s %s | """ % (sortip,cl,strip))
out.append(""" %u | """ % (cl,port))
if masterconn.version_at_least(1,7,25):
out.append(""" %u | """ % (cl,csid))
else:
out.append(""" %s | """ % (host))
out.append(""" %s %s | """ % (sortip,strip))
out.append(""" %u | """ % (port))
if masterconn.version_at_least(1,7,25):
out.append(""" %u | """ % (csid))
if masterconn.version_at_least(2,1,0):
if labels==0:
labelstr = "-"
else:
labelstab = []
for bit,char in enumerate(map(chr,range(ord('A'),ord('Z')+1))):
if labels & (1<%s""" % labelstr)
out.append(""" %s %s | """ % (sortver,verclass,strver))
if masterconn.version_at_least(1,6,28):
if gracetime>=0x80000000:
if gracetime>=0xC0000000:
out.append(""" <%u> | """ % (load))
else:
out.append(""" (%u) | """ % (load))
elif gracetime>0:
out.append(""" [%u] | """ % (gracetime,createlink({"CSbacktowork":("%s:%u" % (strip,port))}),load))
else:
out.append(""" %u | """ % (load))
if masterconn.version_at_least(2,0,11):
if leaderfound:
out.append(""" %s : %s | """ % (mmstr,mmurl,mm))
else:
out.append(""" not available | """)
out.append(""" %u | %u %s | %u %s | """ % (chunks,used,decimal_number(used),humanize_number(used," "),total,decimal_number(total),humanize_number(total," ")))
if (total>0):
usedpercent = (used*100.0)/total
if usedpercent%.10f """ % (usedpercent,100.0-usedpercent,avgpercent,usedpercent,diffstr,usedpercent))
else:
out.append(""" -1 | """)
if masterconn.version_at_least(3,0,38):
if tdchunks==0 or leaderfound==0:
out.append(""" - | """)
elif mfrstatus==1:
out.append(""" NOT READY | """)
elif mfrstatus==2:
out.append(""" READY | """)
else:
out.append(""" PENDING | """)
out.append(""" %u | %u %s | %u %s | """ % (tdchunks,tdused,decimal_number(tdused),humanize_number(tdused," "),tdtotal,decimal_number(tdtotal),humanize_number(tdtotal," ")))
if (tdtotal>0):
usedpercent = (tdused*100.0)/tdtotal
out.append(""" %.10f | """ % (usedpercent,100.0-usedpercent,usedpercent))
else:
out.append(""" -1 | """)
out.append("""
""")
elif ttymode:
if total>0:
regperc = "%.2f%%" % ((used*100.0)/total)
else:
regperc = "-"
if tdtotal>0:
tdperc = "%.2f%%" % ((tdused*100.0)/tdtotal)
else:
tdperc = "-"
data = [host,port]
if masterconn.version_at_least(1,7,25):
data.append(csid)
if masterconn.version_at_least(2,1,0):
if labels==0xFFFFFFFF or labels==0:
labelstr = "-"
else:
labelstab = []
for bit,char in enumerate(map(chr,range(ord('A'),ord('Z')+1))):
if labels & (1<=0x80000000:
if gracetime>=0xC0000000:
data.append("<%u>" % load)
else:
data.append("(%u)" % load)
elif gracetime>0:
data.append("[%u]" % load)
else:
data.append(load)
if masterconn.version_at_least(2,0,11):
if leaderfound==0:
data.append("not available")
elif (flags&2)==0:
data.append("off")
elif (flags&4)==0:
data.append("on")
else:
data.append("on (temp)")
data.extend([chunks,humanize_number(used," "),humanize_number(total," "),regperc])
if masterconn.version_at_least(3,0,38):
if tdchunks==0 or leaderfound==0:
data.append("-")
elif mfrstatus==1:
data.append(("NOT READY",'3'))
elif mfrstatus==2:
data.append(("READY",'4'))
else:
data.append("PENDING")
data.extend([tdchunks,humanize_number(tdused," "),humanize_number(tdtotal," "),tdperc])
tab.append(*data)
else:
data = [host,port]
if masterconn.version_at_least(1,7,25):
data.append(csid)
if masterconn.version_at_least(2,1,0):
if labels==0xFFFFFFFF or labels==0:
labelstr = "-"
else:
labelstab = []
for bit,char in enumerate(map(chr,range(ord('A'),ord('Z')+1))):
if labels & (1<=0x80000000:
if gracetime>=0xC0000000:
data.append("<%u>" % load)
else:
data.append("(%u)" % load)
elif gracetime>0:
data.append("[%u]" % load)
else:
data.append(load)
if masterconn.version_at_least(2,0,11):
if leaderfound==0:
data.append("-")
elif (flags&2)==0:
data.append("maintenance_off")
elif (flags&4)==0:
data.append("maintenance_on")
else:
data.append("maintenance_tmp_on")
data.extend([chunks,used,total])
if masterconn.version_at_least(3,0,38):
if tdchunks==0 or leaderfound==0:
data.append("-")
elif mfrstatus==1:
data.append("NOT READY")
elif mfrstatus==2:
data.append("READY")
else:
data.append("PENDING")
data.extend([tdchunks,tdused,tdtotal])
tab.append(*data)
if len(dservers)>0:
if cgimode:
out.append("""
""")
out.append("""
""")
if masterconn.version_at_least(2,0,11):
out.append(""" | Disconnected Chunk Servers |
|---|
""")
elif masterconn.version_at_least(1,7,25):
out.append(""" | Disconnected Chunk Servers |
|---|
""")
else:
out.append(""" | Disconnected Chunk Servers |
|---|
""")
out.append(""" """)
out.append(""" | # | """)
out.append(""" host | """)
out.append(""" ip | """)
out.append(""" port | """)
if masterconn.version_at_least(1,7,25):
out.append(""" id | """)
if masterconn.version_at_least(2,0,11):
out.append(""" maintenance | """)
if leaderfound:
out.append(""" remove | """)
else:
out.append(""" temporarily remove | """)
out.append("""
""")
elif ttymode:
if masterconn.version_at_least(3,0,38):
tab.append(("---","",16))
tab.append(("disconnected servers","1c",16))
tab.append(("---","",16))
tab.append(("ip/host","c"),("port","c"),("id","r"),("maintenance","c"),("change maintenance command","c",6),("remove command","c",6))
tab.append(("---","",16))
elif masterconn.version_at_least(2,1,0):
tab.append(("---","",15))
tab.append(("disconnected servers","1c",15))
tab.append(("---","",15))
tab.append(("ip/host","c"),("port","c"),("id","r"),("maintenance","c"),("change maintenance command","c",5),("remove command","c",6))
tab.append(("---","",15))
elif masterconn.version_at_least(2,0,11):
tab.append(("---","",14))
tab.append(("disconnected servers","1c",14))
tab.append(("---","",14))
tab.append(("ip/host","c"),("port","c"),("id","r"),("maintenance","c"),("change maintenance command","c",5),("remove command","c",5))
tab.append(("---","",14))
elif masterconn.version_at_least(1,7,25):
tab.append(("---","",13))
tab.append(("disconnected servers","1c",13))
tab.append(("---","",13))
tab.append(("ip/host","c"),("port","c"),("id","r"),("remove command","c",10))
tab.append(("---","",13))
elif masterconn.version_at_least(1,6,28):
tab.append(("---","",12))
tab.append(("disconnected servers","1c",12))
tab.append(("---","",12))
tab.append(("ip/host","c"),("port","c"),("remove command","c",10))
tab.append(("---","",12))
else:
tab.append(("---","",11))
tab.append(("disconnected servers","1c",11))
tab.append(("---","",11))
tab.append(("ip/host","c"),("port","c"),("remove command","c",9))
tab.append(("---","",11))
else:
print(myunicode(tab))
print("")
if masterconn.version_at_least(2,0,11):
tab = Tabble("Disconnected chunk servers",4)
elif masterconn.version_at_least(1,7,25):
tab = Tabble("Disconnected chunk servers",3)
else:
tab = Tabble("Disconnected chunk servers",2)
for sf,host,sortip,strip,port,csid,flags in dservers:
if cgimode:
out.append(""" """)
if masterconn.version_at_least(2,0,11):
if leaderfound==0:
cl = "DISCONNECTED"
elif (flags&2)==0:
mmstr = "OFF"
mm = "switch on"
mmurl = createlink({"CSmaintenanceon":("%s:%u" % (strip,port))})
cl = "DISCONNECTED"
elif (flags&4)==0:
mmstr = "ON"
mm = "switch off"
mmurl = createlink({"CSmaintenanceoff":("%s:%u" % (strip,port))})
cl = "MAINTAINED"
else:
mmstr = "ON (temp)"
mm = "switch off"
mmurl = createlink({"CSmaintenanceoff":("%s:%u" % (strip,port))})
cl = "TMPMAINTAINED"
out.append(""" | %s | """ % (cl,host))
out.append(""" %s %s | """ % (sortip,cl,strip))
out.append(""" %u | """ % (cl,port))
if masterconn.version_at_least(1,7,25):
out.append(""" %u | """ % (cl,csid))
if leaderfound:
out.append(""" %s : %s | """ % (cl,mmstr,mmurl,mm))
else:
out.append(""" not available | """ % cl)
if leaderfound:
out.append(""" click to remove | """ % (createlink({"CSremove":("%s:%u" % (strip,port))})))
elif masterconn.version_at_least(3,0,67):
out.append(""" click to temporarily remove | """ % (createlink({"CStmpremove":("%s:%u" % (strip,port))})))
else:
out.append(""" not available | """)
else:
out.append(""" | %s | """ % (host))
out.append(""" %s %s | """ % (sortip,strip))
out.append(""" %u | """ % (port))
if masterconn.version_at_least(1,7,25):
out.append(""" %u | """ % (csid))
if leaderfound:
out.append(""" click to remove | """ % (createlink({"CSremove":("%s:%u" % (strip,port))})))
else:
out.append(""" not available | """)
out.append("""
""")
elif ttymode:
data = [host,port]
if masterconn.version_at_least(1,7,25):
data.append(csid)
if masterconn.version_at_least(2,0,11):
if leaderfound==0:
mm = "-"
mmcmd = "not available"
elif (flags&2)==0:
mm = "off"
mmcmd = "%s -H %s -P %u -CM1/%s/%s" % (sys.argv[0],masterhost,masterport,strip,port)
elif (flags&4)==0:
mm = "on"
mmcmd = "%s -H %s -P %u -CM0/%s/%s" % (sys.argv[0],masterhost,masterport,strip,port)
else:
mm = "on (temp)"
mmcmd = "%s -H %s -P %u -CM0/%s/%s" % (sys.argv[0],masterhost,masterport,strip,port)
data.append(mm)
if masterconn.version_at_least(3,0,38):
data.append((mmcmd,"l",6))
else:
data.append((mmcmd,"l",5))
if leaderfound:
rmcmd = "%s -H %s -P %u -CRC/%s/%s" % (sys.argv[0],masterhost,masterport,strip,port)
elif masterconn.version_at_least(3,0,67):
rmcmd = "%s -H %s -P %u -CTR/%s/%s" % (sys.argv[0],masterhost,masterport,strip,port)
else:
rmcmd = "not available"
if masterconn.version_at_least(2,1,0):
data.append((rmcmd,"l",6))
else:
data.append((rmcmd,"l",5))
else:
if leaderfound:
rmcmd = "%s -H %s -P %u -CRC/%s/%s" % (sys.argv[0],masterhost,masterport,strip,port)
else:
rmcmd = "not available"
if masterconn.version_at_least(1,6,28):
data.append((rmcmd,"l",10))
else:
data.append((rmcmd,"l",9))
tab.append(*data)
else:
if masterconn.version_at_least(2,0,11):
if leaderfound==0:
mm = "-"
elif (flags&2)==0:
mm = "maintenance_off"
elif (flags&4)==0:
mm = "maintenance_on"
else:
mm = "maintenance_temp_on"
tab.append(host,port,csid,mm)
elif masterconn.version_at_least(1,7,25):
tab.append(host,port,csid)
else:
tab.append(host,port)
if cgimode:
out.append("""
""")
print("\n".join(out))
else:
print(myunicode(tab))
except Exception:
print_exception()
if "MB" in sectionsubset and leaderfound:
try:
if cgimode:
out = []
out.append("""
""")
out.append(""" | Metadata Backup Loggers |
|---|
""")
out.append(""" """)
out.append(""" | # | """)
out.append(""" host | """)
out.append(""" ip | """)
out.append(""" version | """)
out.append("""
""")
elif ttymode:
tab = Tabble("Metadata Backup Loggers",2,"r")
tab.header("ip/host","version")
else:
tab = Tabble("metadata backup loggers",2)
data,length = masterconn.command(CLTOMA_MLOG_LIST,MATOCL_MLOG_LIST)
if (length%8)==0:
n = length//8
servers = []
for i in range(n):
d = data[i*8:(i+1)*8]
v1,v2,v3,ip1,ip2,ip3,ip4 = struct.unpack(">HBBBBBB",d)
strip = "%u.%u.%u.%u" % (ip1,ip2,ip3,ip4)
host = resolve(strip)
sortip = "%03u_%03u_%03u_%03u" % (ip1,ip2,ip3,ip4)
strver,sortver = version_str_and_sort((v1,v2,v3))
sf = (ip1,ip2,ip3,ip4)
if MBorder==1:
sf = host
elif MBorder==2:
sf = sortip
elif MBorder==3:
sf = sortver
servers.append((sf,host,sortip,strip,sortver,strver))
servers.sort()
if MBrev:
servers.reverse()
for sf,host,sortip,strip,sortver,strver in servers:
if cgimode:
if masterconn.is_pro() and not strver.endswith(" PRO"):
verclass = "BADVERSION"
elif masterconn.sort_ver() > sortver:
verclass = "LOWERVERSION"
elif masterconn.sort_ver() < sortver:
verclass = "HIGHERVERSION"
else:
verclass = "OKVERSION"
out.append(""" """)
out.append(""" | %s | %s %s | %s %s | """ % (host,sortip,strip,sortver,verclass,strver))
out.append("""
""")
else:
tab.append(host,strver)
if cgimode:
out.append("""
""")
print("\n".join(out))
else:
print(myunicode(tab))
except Exception:
print_exception()
if "HD" in sectionset:
try:
# get cs list
hostlist = []
for cs in dataprovider.get_chunkservers():
if (cs.flags&1)==0:
hostlist.append((cs.ip,cs.port,cs.version,cs.mfrstatus))
# get hdd lists one by one
hdd = []
shdd = []
for (ip1,ip2,ip3,ip4),port,version,mfrstatus in hostlist:
# for v1,v2,v3,ip1,ip2,ip3,ip4,port in hostlist:
hostip = "%u.%u.%u.%u" % (ip1,ip2,ip3,ip4)
hostkey = "%s:%u" % (hostip,port)
hoststr = resolve(hostip)
if port>0:
if version<=(1,6,8):
hdd.append((None,hostkey,"0","version too old","version too old",0,0,0,0,0,0,[0,0,0],[0,0,0],[0,0,0],[0,0,0],[0,0,0],[0,0,0],[0,0,0],[0,0,0],[0,0,0],[0,0,0],[0,0,0],[0,0,0],[0,0,0]))
else:
conn = MFSConn(hostip,port)
data,length = conn.command(CLTOCS_HDD_LIST,CSTOCL_HDD_LIST)
while length>0:
entrysize = struct.unpack(">H",data[:2])[0]
entry = data[2:2+entrysize]
data = data[2+entrysize:]
length -= 2+entrysize
if sys.version_info[0]<3:
plen = ord(entry[0])
else:
plen = entry[0]
hddpath = entry[1:plen+1]
hddpath = hddpath.decode('utf-8','replace')
hostpath = "%s:%u:%s" % (hoststr,port,hddpath)
ippath = "%s:%u:%s" % (hostip,port,hddpath)
sortippath = "%03u.%03u.%03u.%03u:%05u:%s" % (ip1,ip2,ip3,ip4,port,hddpath)
flags,errchunkid,errtime,used,total,chunkscnt = struct.unpack(">BQLQQL",entry[plen+1:plen+34])
rbytes = [0,0,0]
wbytes = [0,0,0]
usecreadsum = [0,0,0]
usecwritesum = [0,0,0]
usecfsyncsum = [0,0,0]
rops = [0,0,0]
wops = [0,0,0]
fsyncops = [0,0,0]
usecreadmax = [0,0,0]
usecwritemax = [0,0,0]
usecfsyncmax = [0,0,0]
if entrysize==plen+34+144:
rbytes[0],wbytes[0],usecreadsum[0],usecwritesum[0],rops[0],wops[0],usecreadmax[0],usecwritemax[0] = struct.unpack(">QQQQLLLL",entry[plen+34:plen+34+48])
rbytes[1],wbytes[1],usecreadsum[1],usecwritesum[1],rops[1],wops[1],usecreadmax[1],usecwritemax[1] = struct.unpack(">QQQQLLLL",entry[plen+34+48:plen+34+96])
rbytes[2],wbytes[2],usecreadsum[2],usecwritesum[2],rops[2],wops[2],usecreadmax[2],usecwritemax[2] = struct.unpack(">QQQQLLLL",entry[plen+34+96:plen+34+144])
# if HDperiod==0:
# rbytes,wbytes,usecreadsum,usecwritesum,rops,wops,usecreadmax,usecwritemax = struct.unpack(">QQQQLLLL",entry[plen+34:plen+34+48])
# elif HDperiod==1:
# rbytes,wbytes,usecreadsum,usecwritesum,rops,wops,usecreadmax,usecwritemax = struct.unpack(">QQQQLLLL",entry[plen+34+48:plen+34+96])
# elif HDperiod==2:
# rbytes,wbytes,usecreadsum,usecwritesum,rops,wops,usecreadmax,usecwritemax = struct.unpack(">QQQQLLLL",entry[plen+34+96:plen+34+144])
elif entrysize==plen+34+192:
rbytes[0],wbytes[0],usecreadsum[0],usecwritesum[0],usecfsyncsum[0],rops[0],wops[0],fsyncops[0],usecreadmax[0],usecwritemax[0],usecfsyncmax[0] = struct.unpack(">QQQQQLLLLLL",entry[plen+34:plen+34+64])
rbytes[1],wbytes[1],usecreadsum[1],usecwritesum[1],usecfsyncsum[1],rops[1],wops[1],fsyncops[1],usecreadmax[1],usecwritemax[1],usecfsyncmax[1] = struct.unpack(">QQQQQLLLLLL",entry[plen+34+64:plen+34+128])
rbytes[2],wbytes[2],usecreadsum[2],usecwritesum[2],usecfsyncsum[2],rops[2],wops[2],fsyncops[2],usecreadmax[2],usecwritemax[2],usecfsyncmax[2] = struct.unpack(">QQQQQLLLLLL",entry[plen+34+128:plen+34+192])
# if HDperiod==0:
# rbytes,wbytes,usecreadsum,usecwritesum,usecfsyncsum,rops,wops,fsyncops,usecreadmax,usecwritemax,usecfsyncmax = struct.unpack(">QQQQQLLLLLL",entry[plen+34:plen+34+64])
# elif HDperiod==1:
# rbytes,wbytes,usecreadsum,usecwritesum,usecfsyncsum,rops,wops,fsyncops,usecreadmax,usecwritemax,usecfsyncmax = struct.unpack(">QQQQQLLLLLL",entry[plen+34+64:plen+34+128])
# elif HDperiod==2:
# rbytes,wbytes,usecreadsum,usecwritesum,usecfsyncsum,rops,wops,fsyncops,usecreadmax,usecwritemax,usecfsyncmax = struct.unpack(">QQQQQLLLLLL",entry[plen+34+128:plen+34+192])
rbw = [0,0,0]
wbw = [0,0,0]
usecreadavg = [0,0,0]
usecwriteavg = [0,0,0]
usecfsyncavg = [0,0,0]
for i in range(3):
if usecreadsum[i]>0:
rbw[i] = rbytes[i]*1000000//usecreadsum[i]
if usecwritesum[i]+usecfsyncsum[i]>0:
wbw[i] = wbytes[i]*1000000//(usecwritesum[i]+usecfsyncsum[i])
if rops[i]>0:
usecreadavg[i] = usecreadsum[i]//rops[i]
if wops[i]>0:
usecwriteavg[i] = usecwritesum[i]//wops[i]
if fsyncops[i]>0:
usecfsyncavg[i] = usecfsyncsum[i]//fsyncops[i]
sf = sortippath
if HDorder==1:
sf = sortippath
elif HDorder==2:
sf = chunkscnt
elif HDorder==3:
sf = errtime
elif HDorder==4:
sf = -flags
elif HDorder==5:
sf = rbw[HDperiod]
elif HDorder==6:
sf = wbw[HDperiod]
elif HDorder==7:
if HDtime==1:
sf = usecreadavg[HDperiod]
else:
sf = usecreadmax[HDperiod]
elif HDorder==8:
if HDtime==1:
sf = usecwriteavg[HDperiod]
else:
sf = usecwritemax[HDperiod]
elif HDorder==9:
if HDtime==1:
sf = usecfsyncavg[HDperiod]
else:
sf = usecfsyncmax[HDperiod]
elif HDorder==10:
sf = rops[HDperiod]
elif HDorder==11:
sf = wops[HDperiod]
elif HDorder==12:
sf = fsyncops[HDperiod]
elif HDorder==20:
if flags&4==0:
sf = used
else:
sf = 0
elif HDorder==21:
if flags&4==0:
sf = total
else:
sf = 0
elif HDorder==22:
if flags&4==0 and total>0:
sf = (1.0*used)/total
else:
sf = 0
if flags&4 and not cgimode and ttymode:
shdd.append((sf,hostkey,sortippath,ippath,hostpath,flags,errchunkid,errtime,used,total,chunkscnt,rbw,wbw,usecreadavg,usecwriteavg,usecfsyncavg,usecreadmax,usecwritemax,usecfsyncmax,rops,wops,fsyncops,rbytes,wbytes,mfrstatus))
else:
hdd.append((sf,hostkey,sortippath,ippath,hostpath,flags,errchunkid,errtime,used,total,chunkscnt,rbw,wbw,usecreadavg,usecwriteavg,usecfsyncavg,usecreadmax,usecwritemax,usecfsyncmax,rops,wops,fsyncops,rbytes,wbytes,mfrstatus))
if len(hdd)>0 or len(shdd)>0:
if cgimode:
out = []
out.append("""
""")
out.append(""" | Disks |
|---|
""")
out.append(""" """)
out.append(""" | # | """)
out.append(""" """)
out.append(""" info (switch IP to name)""")
out.append(""" info (switch name to IP)""")
out.append(""" | """)
out.append(""" """)
out.append(""" I/O stats last min (switch to hour,day)""")
out.append(""" I/O stats last hour (switch to min,day)""")
out.append(""" I/O stats last day (switch to min,hour)""")
out.append(""" | """)
# if HDperiod==2:
# out.append(""" I/O stats last day (switch to min,hour) | """ % (createlink({"HDperiod":"0"}),createlink({"HDperiod":"1"})))
# elif HDperiod==1:
# out.append(""" I/O stats last hour (switch to min,day) | """ % (createlink({"HDperiod":"0"}),createlink({"HDperiod":"2"})))
# else:
# out.append(""" I/O stats last min (switch to hour,day) | """ % (createlink({"HDperiod":"1"}),createlink({"HDperiod":"2"})))
out.append(""" space | """)
out.append("""
""")
out.append(""" """)
out.append(""" | transfer | """)
out.append(""" """)
out.append(""" max time (switch to avg)""")
out.append(""" avg time (switch to max)""")
out.append(""" | """)
# if HDtime==1:
# out.append(""" avg time (switch to max) | """ % (createlink({"HDtime":"0"})))
# else:
# out.append(""" max time (switch to avg) | """ % (createlink({"HDtime":"1"})))
out.append(""" # of ops | """)
out.append("""
""")
out.append(""" """)
out.append(""" | IPname path | """)
out.append(""" chunks | """)
out.append(""" last error | """)
out.append(""" status | """)
out.append(""" read | """)
out.append(""" write | """)
out.append(""" read | """)
out.append(""" write | """)
out.append(""" fsync | """)
out.append(""" read | """)
out.append(""" write | """)
out.append(""" fsync | """)
out.append(""" used | """)
out.append(""" total | """)
out.append(""" % used | """)
#out.append(""" chunks | """ % (createorderlink("HD",2)))
#out.append(""" last error | """ % (createorderlink("HD",3)))
#out.append(""" status | """ % (createorderlink("HD",4)))
#out.append(""" read | """ % (createorderlink("HD",5)))
#out.append(""" write | """ % (createorderlink("HD",6)))
#out.append(""" read | """ % (createorderlink("HD",7)))
#out.append(""" write | """ % (createorderlink("HD",8)))
#out.append(""" fsync | """ % (createorderlink("HD",9)))
#out.append(""" read | """ % (createorderlink("HD",10)))
#out.append(""" write | """ % (createorderlink("HD",11)))
#out.append(""" fsync | """ % (createorderlink("HD",12)))
#out.append(""" used | """ % (createorderlink("HD",20)))
#out.append(""" total | """ % (createorderlink("HD",21)))
#out.append(""" used (%%) | """ % (createorderlink("HD",22)))
out.append("""
""")
elif ttymode:
tab = Tabble("Disks",15,"r")
tab.header(("","",4),("I/O stats last %s" % ("day" if HDperiod==2 else "hour" if HDperiod==1 else "min"),"",8),("","",3))
tab.header(("info","",4),("---","",8),("space","",3))
tab.header(("","",4),("transfer","",2),("%s time" % ("avg" if HDtime==1 else "max"),"",3),("# of ops","",3),("","",3))
tab.header(("---","",15))
if len(hdd)>0 or len(shdd)==0:
tab.header("IP path","chunks","last error","status","read","write","read","write","fsync","read","write","fsync","used","total","used %")
lscanning = 0
else:
tab.header("IP path","chunks","last error","status","read","write","read","write","fsync","read","write","fsync",("progress","c",3))
lscanning = 1
else:
tab = Tabble("disks",14)
hdd.sort()
shdd.sort()
if HDrev:
hdd.reverse()
shdd.reverse()
usedsum = {}
totalsum = {}
hostavg = {}
for sf,hostkey,sortippath,ippath,hostpath,flags,errchunkid,errtime,used,total,chunkscnt,rbw,wbw,usecreadavg,usecwriteavg,usecfsyncavg,usecreadmax,usecwritemax,usecfsyncmax,rops,wops,fsyncops,rbytes,wbytes,mfrstatus in hdd+shdd:
if hostkey not in usedsum:
usedsum[hostkey]=0
totalsum[hostkey]=0
hostavg[hostkey]=0
if flags&4==0 and total>0:
usedsum[hostkey]+=used
totalsum[hostkey]+=total
if totalsum[hostkey]>0:
hostavg[hostkey] = (usedsum[hostkey] * 100.0) / totalsum[hostkey]
for sf,hostkey,sortippath,ippath,hostpath,flags,errchunkid,errtime,used,total,chunkscnt,rbw,wbw,usecreadavg,usecwriteavg,usecfsyncavg,usecreadmax,usecwritemax,usecfsyncmax,rops,wops,fsyncops,rbytes,wbytes,mfrstatus in hdd+shdd:
statuslist = []
if (flags&8):
statuslist.append('invalid')
if (flags&2) and (flags&4)==0 and (flags&8)==0:
statuslist.append('damaged')
if flags&1:
if mfrstatus==1:
statuslist.append('marked for removal (not ready)')
elif mfrstatus==2:
statuslist.append('marked for removal (ready)')
else:
statuslist.append('marked for removal')
if flags&4:
statuslist.append('scanning')
if flags==0:
statuslist.append('ok')
status = ", ".join(statuslist)
if errtime==0 and errchunkid==0:
lerror = 'no errors'
else:
if cgimode:
errtimetuple = time.localtime(errtime)
lerror = '%s' % (time.strftime("%Y-%m-%d %H:%M:%S",errtimetuple),errchunkid,time.strftime("%Y-%m-%d %H:%M",errtimetuple))
elif ttymode:
errtimetuple = time.localtime(errtime)
lerror = time.strftime("%Y-%m-%d %H:%M",errtimetuple)
else:
lerror = errtime
if cgimode:
out.append(""" """)
out.append(""" | """)
out.append(""" %s %s%s | """ % (htmlentities(sortippath),htmlentities(ippath),htmlentities(hostpath)))
out.append(""" %u | %u %s | %s | """ % (chunkscnt,errtime,lerror,status))
validdata = [1,1,1]
for i in range(3):
if rbw[i]==0 and wbw[i]==0 and usecreadmax[i]==0 and usecwritemax[i]==0 and usecfsyncmax[i]==0 and rops[i]==0 and wops[i]==0:
validdata[i] = 0
# rbw
out.append(""" """)
for i in range(3):
out.append(""" """ % i)
if validdata[i]:
out.append(""" %u %s/s""" % (rbw[i],decimal_number(rbw[i]),humanize_number(rbw[i]," ")))
else:
out.append(""" -1 -""")
out.append(""" """)
out.append(""" | """)
# wbw
out.append(""" """)
for i in range(3):
out.append(""" """ % i)
if validdata[i]:
out.append(""" %u %s/s""" % (wbw[i],decimal_number(wbw[i]),humanize_number(wbw[i]," ")))
else:
out.append(""" -1 -""")
out.append(""" """)
out.append(""" | """)
# readtime
out.append(""" """)
for i in range(3):
out.append(""" """ % i)
if validdata[i]:
out.append(""" %u us""" % usecreadmax[i])
out.append(""" %u us""" % usecreadavg[i])
else:
out.append(""" -1 -""")
out.append(""" """)
out.append(""" | """)
# writetime
out.append(""" """)
for i in range(3):
out.append(""" """ % i)
if validdata[i]:
out.append(""" %u us""" % usecwritemax[i])
out.append(""" %u us""" % usecwriteavg[i])
else:
out.append(""" -1 -""")
out.append(""" """)
out.append(""" | """)
# fsynctime
out.append(""" """)
for i in range(3):
out.append(""" """ % i)
if validdata[i]:
out.append(""" %u us""" % usecfsyncmax[i])
out.append(""" %u us""" % usecfsyncavg[i])
else:
out.append(""" -1 -""")
out.append(""" """)
out.append(""" | """)
# rops
out.append(""" """)
for i in range(3):
out.append(""" """ % i)
if validdata[i]:
if rops[i]>0:
bsize = rbytes[i]/rops[i]
else:
bsize = 0
out.append(""" %u""" % (bsize,rops[i]))
else:
out.append(""" -1 -""")
out.append(""" """)
out.append(""" | """)
# wops
out.append(""" """)
for i in range(3):
out.append(""" """ % i)
if validdata[i]:
if wops[i]>0:
bsize = wbytes[i]/wops[i]
else:
bsize = 0
out.append(""" %u""" % (bsize,wops[i]))
else:
out.append(""" -1 -""")
out.append(""" """)
out.append(""" | """)
# fsyncops
out.append(""" """)
for i in range(3):
out.append(""" """ % i)
if validdata[i]:
out.append(""" %u""" % (fsyncops[i]))
else:
out.append(""" -1 -""")
out.append(""" """)
out.append(""" | """)
# if rbw==0 and wbw==0 and rtime==0 and wtime==0 and rops==0 and wops==0:
# out.append(""" -1 - | -1 - | -1 - | -1 - | -1 - | -1 - | -1 - | -1 - | """)
# else:
# if rops>0:
# rbsize = rbytes/rops
# else:
# rbsize = 0
# if wops>0:
# wbsize = wbytes/wops
# else:
# wbsize = 0
# out.append(""" %u %s/s | %u %s/s | """ % (rbw,decimal_number(rbw),humanize_number(rbw," "),wbw,decimal_number(wbw),humanize_number(wbw," ")))
# out.append(""" %u us | %u us | %u us | %u | %u | %u | """ % (rtime,wtime,fsynctime,rbsize,rops,wbsize,wops,fsyncops))
if flags&4:
out.append(""" 0 | """ % (100.0-used,used))
else:
out.append(""" %u %s | %u %s | """ % (used,decimal_number(used),humanize_number(used," "),total,decimal_number(total),humanize_number(total," ")))
if total>0:
usedpercent = (used*100.0)/total
avgpercent = hostavg[hostkey]
if usedpercent%.10f """ % (usedpercent,100.0-usedpercent,avgpercent,usedpercent,diffstr,usedpercent))
else:
out.append(""" -1 | """)
out.append("""
""")
elif ttymode:
rtime = usecreadmax[HDperiod] if HDtime==0 else usecreadavg[HDperiod]
wtime = usecwritemax[HDperiod] if HDtime==0 else usecwriteavg[HDperiod]
fsynctime = usecfsyncmax[HDperiod] if HDtime==0 else usecfsyncavg[HDperiod]
ldata = [ippath,chunkscnt,lerror,status]
if rbw[HDperiod]==0 and wbw[HDperiod]==0 and usecreadmax[HDperiod]==0 and usecwritemax[HDperiod]==0 and usecfsyncmax[HDperiod]==0 and rops[HDperiod]==0 and wops[HDperiod]==0:
ldata.extend(("-","-","-","-","-","-","-","-"))
else:
ldata.extend(("%s/s" % humanize_number(rbw[HDperiod]," "),"%s/s" % humanize_number(wbw[HDperiod]," "),"%u us" % rtime,"%u us" % wtime,"%u us" % fsynctime,rops[HDperiod],wops[HDperiod],fsyncops[HDperiod]))
if flags&4:
if lscanning==0:
lscanning=1
tab.append(("---","",15))
tab.append("IP path","chunks","last error","status","read","write","read","write","fsync","read","write","fsync",("progress","c",3))
tab.append(("---","",15))
ldata.append(("%.0f%%" % used,"r",3))
else:
if total>0:
perc = "%.2f%%" % ((used*100.0)/total)
else:
perc = "-"
ldata.extend((humanize_number(used," "),humanize_number(total," "),perc))
tab.append(*ldata)
else:
rtime = usecreadmax[HDperiod] if HDtime==0 else usecreadavg[HDperiod]
wtime = usecwritemax[HDperiod] if HDtime==0 else usecwriteavg[HDperiod]
fsynctime = usecfsyncmax[HDperiod] if HDtime==0 else usecfsyncavg[HDperiod]
ldata = [ippath,chunkscnt,lerror,status]
if rbw[HDperiod]==0 and wbw[HDperiod]==0 and usecreadmax[HDperiod]==0 and usecwritemax[HDperiod]==0 and usecfsyncmax[HDperiod]==0 and rops[HDperiod]==0 and wops[HDperiod]==0:
ldata.extend(("-","-","-","-","-","-","-","-"))
else:
ldata.extend((rbw[HDperiod],wbw[HDperiod],rtime,wtime,fsynctime,rops[HDperiod],wops[HDperiod],fsyncops[HDperiod]))
if flags&4:
ldata.extend(("progress:",used))
else:
ldata.extend((used,total))
tab.append(*ldata)
if cgimode:
out.append("""
""")
print("\n".join(out))
else:
print(myunicode(tab))
except Exception:
print_exception()
if "EX" in sectionset:
try:
if cgimode:
out = []
out.append("""
""")
out.append(""" | Exports |
|---|
""" % (21 if masterconn.has_feature(FEATURE_EXPORT_DISABLES) else 20 if masterconn.has_feature(FEATURE_EXPORT_UMASK) else 19 if masterconn.version_at_least(1,7,0) else 18 if masterconn.version_at_least(1,6,26) else 14))
out.append(""" """)
out.append(""" | # | """)
out.append(""" ip range | """)
# out.append(""" path | """ % (createorderlink("EX",3)))
# out.append(""" minversion | """ % (createorderlink("EX",4)))
# out.append(""" alldirs | """ % (createorderlink("EX",5)))
# out.append(""" password | """ % (createorderlink("EX",6)))
# out.append(""" ro/rw | """ % (createorderlink("EX",7)))
# out.append(""" restricted ip | """ % (createorderlink("EX",8)))
# out.append(""" ignore gid | """ % (createorderlink("EX",9)))
out.append(""" path | """)
out.append(""" minversion | """)
out.append(""" alldirs | """)
out.append(""" password | """)
out.append(""" ro/rw | """)
out.append(""" restricted ip | """)
out.append(""" ignore gid | """)
if masterconn.version_at_least(1,7,0):
# out.append(""" can change quota | """ % (createorderlink("EX",10)))
out.append(""" admin | """)
out.append(""" map root | """)
out.append(""" map users | """)
if masterconn.version_at_least(1,6,26):
out.append(""" goal limit | """)
out.append(""" trashtime limit | """)
if masterconn.has_feature(FEATURE_EXPORT_UMASK):
out.append(""" global umask | """)
if masterconn.has_feature(FEATURE_EXPORT_DISABLES):
out.append(""" disables mask | """)
out.append("""
""")
out.append(""" """)
# out.append(""" | from | """ % (createorderlink("EX",1)))
# out.append(""" to | """ % (createorderlink("EX",2)))
# out.append(""" uid | """ % (createorderlink("EX",11)))
# out.append(""" gid | """ % (createorderlink("EX",12)))
# out.append(""" uid | """ % (createorderlink("EX",13)))
# out.append(""" gid | """ % (createorderlink("EX",14)))
out.append(""" from | """)
out.append(""" to | """)
out.append(""" uid | """)
out.append(""" gid | """)
out.append(""" uid | """)
out.append(""" gid | """)
if masterconn.version_at_least(1,6,26):
# out.append(""" min | """ % (createorderlink("EX",15)))
# out.append(""" max | """ % (createorderlink("EX",16)))
# out.append(""" min | """ % (createorderlink("EX",17)))
# out.append(""" max | """ % (createorderlink("EX",18)))
out.append(""" min | """)
out.append(""" max | """)
out.append(""" min | """)
out.append(""" max | """)
out.append("""
""")
elif ttymode:
tab = Tabble("Exports",(20 if masterconn.has_feature(FEATURE_EXPORT_DISABLES) else 19 if masterconn.has_feature(FEATURE_EXPORT_UMASK) else 18 if masterconn.version_at_least(1,7,0) else 17 if masterconn.version_at_least(1,6,26) else 13))
dline = ["r","r","l","c","c","c","c","c","c"]
if masterconn.version_at_least(1,7,0):
dline.append("c")
dline.extend(("r","r","r","r"))
if masterconn.version_at_least(1,6,26):
dline.extend(("r","r","r","r"))
if masterconn.has_feature(FEATURE_EXPORT_UMASK):
dline.append("c")
if masterconn.has_feature(FEATURE_EXPORT_DISABLES):
dline.append("c")
tab.defattr(*dline)
dline = [("ip range","",2),"","","","","","",""]
if masterconn.version_at_least(1,7,0):
dline.append("")
dline.extend((("map root","",2),("map users","",2)))
if masterconn.version_at_least(1,6,26):
dline.extend((("goal limit","",2),("trashtime limit","",2)))
if masterconn.has_feature(FEATURE_EXPORT_UMASK):
dline.append("")
if masterconn.has_feature(FEATURE_EXPORT_DISABLES):
dline.append("")
tab.header(*dline)
dline = [("---","",2),"path","minversion","alldirs","password","ro/rw","restrict ip","ignore gid"]
if masterconn.version_at_least(1,7,0):
dline.append("admin")
if masterconn.version_at_least(1,6,26):
dline.append(("---","",8))
else:
dline.append(("---","",4))
if masterconn.has_feature(FEATURE_EXPORT_UMASK):
dline.append("global umask")
if masterconn.has_feature(FEATURE_EXPORT_DISABLES):
dline.append("disables mask")
tab.header(*dline)
dline = ["from","to","","","","","","",""]
if masterconn.version_at_least(1,7,0):
dline.append("")
dline.extend(("uid","gid","uid","gid"))
if masterconn.version_at_least(1,6,26):
dline.extend(("min","max","min","max"))
if masterconn.has_feature(FEATURE_EXPORT_UMASK):
dline.append("")
if masterconn.has_feature(FEATURE_EXPORT_DISABLES):
dline.append("")
tab.header(*dline)
else:
tab = Tabble("exports",(20 if masterconn.has_feature(FEATURE_EXPORT_DISABLES) else 19 if masterconn.has_feature(FEATURE_EXPORT_UMASK) else 18 if masterconn.version_at_least(1,7,0) else 17 if masterconn.version_at_least(1,6,26) else 13))
servers = []
for expe in dataprovider.get_exports():
sf = expe.ipfrom + expe.ipto
if EXorder==1:
sf = expe.sortipfrom
elif EXorder==2:
sf = expe.sortipto
elif EXorder==3:
sf = expe.path
elif EXorder==4:
sf = expe.sortver
elif EXorder==5:
if expe.meta:
sf = None
else:
sf = expe.exportflags&1
elif EXorder==6:
sf = expe.exportflags&2
elif EXorder==7:
sf = expe.sesflags&1
elif EXorder==8:
sf = 2-(expe.sesflags&2)
elif EXorder==9:
if expe.meta:
sf = None
else:
sf = expe.sesflags&4
elif EXorder==10:
if expe.meta:
sf = None
else:
sf = expe.sesflags&8
elif EXorder==11:
if expe.meta:
sf = None
else:
sf = expe.rootuid
elif EXorder==12:
if expe.meta:
sf = None
else:
sf = expe.rootgid
elif EXorder==13:
if expe.meta or (expe.sesflags&16)==0:
sf = None
else:
sf = expe.mapalluid
elif EXorder==14:
if expe.meta or (expe.sesflags&16)==0:
sf = None
else:
sf = expe.mapalguid
elif EXorder==15:
sf = expe.mingoal
elif EXorder==16:
sf = expe.maxgoal
elif EXorder==17:
sf = expe.mintrashtime
elif EXorder==18:
sf = expe.maxtrashtime
elif EXorder==19:
sf = expe.umaskval
elif EXorder==20:
sf = expe.disables
servers.append((sf,expe.sortipfrom,expe.stripfrom,expe.sortipto,expe.stripto,expe.path,expe.meta,expe.sortver,expe.strver,expe.exportflags,expe.sesflags,expe.umaskval,expe.rootuid,expe.rootgid,expe.mapalluid,expe.mapallgid,expe.mingoal,expe.maxgoal,expe.mintrashtime,expe.maxtrashtime,expe.disables))
servers.sort()
if EXrev:
servers.reverse()
for sf,sortipfrom,ipfrom,sortipto,ipto,path,meta,sortver,strver,exportflags,sesflags,umaskval,rootuid,rootgid,mapalluid,mapallgid,mingoal,maxgoal,mintrashtime,maxtrashtime,disables in servers:
if cgimode:
out.append(""" """)
out.append(""" | """)
out.append(""" %s %s | """ % (sortipfrom,ipfrom))
out.append(""" %s %s | """ % (sortipto,ipto))
out.append(""" %s | """ % (". (META)" if meta else htmlentities(path)))
out.append(""" %s %s | """ % (sortver,strver))
out.append(""" %s | """ % ("-" if meta else "yes" if exportflags&1 else "no"))
out.append(""" %s | """ % ("yes" if exportflags&2 else "no"))
out.append(""" %s | """ % ("ro" if sesflags&1 else "rw"))
out.append(""" %s | """ % ("no" if sesflags&2 else "yes"))
out.append(""" %s | """ % ("-" if meta else "yes" if sesflags&4 else "no"))
if masterconn.version_at_least(1,7,0):
out.append(""" %s | """ % ("-" if meta else "yes" if sesflags&8 else "no"))
if meta:
out.append(""" -1 - | """)
out.append(""" -1 - | """)
else:
out.append(""" %u | """ % rootuid)
out.append(""" %u | """ % rootgid)
if meta or (sesflags&16)==0:
out.append(""" -1 - | """)
out.append(""" -1 - | """)
else:
out.append(""" %u | """ % mapalluid)
out.append(""" %u | """ % mapallgid)
if masterconn.version_at_least(1,6,26):
if mingoal!=None and maxgoal!=None:
out.append(""" %u | """ % mingoal)
out.append(""" %u | """ % maxgoal)
else:
out.append(""" -1 - | """)
out.append(""" -1 - | """)
if mintrashtime!=None and maxtrashtime!=None:
out.append(""" %u %s | """ % (mintrashtime,timeduration_to_fullstr(mintrashtime),timeduration_to_shortstr(mintrashtime)))
out.append(""" %u %s | """ % (maxtrashtime,timeduration_to_fullstr(maxtrashtime),timeduration_to_shortstr(maxtrashtime)))
else:
out.append(""" -1 - | """)
out.append(""" -1 - | """)
if masterconn.has_feature(FEATURE_EXPORT_UMASK):
if umaskval==None:
out.append(""" -1 - | """)
else:
out.append(""" %03o | """ % umaskval)
if masterconn.has_feature(FEATURE_EXPORT_DISABLES):
out.append(""" %u %08X | """ % (disables,disablesmask_to_string(disables),disables))
out.append("""
""")
elif ttymode:
dline = [ipfrom,ipto,". (META)" if meta else path,strver,"-" if meta else "yes" if exportflags&1 else "no","yes" if exportflags&2 else "no","ro" if sesflags&1 else "rw","no" if sesflags&2 else "yes","-" if meta else "yes" if sesflags&4 else "no"]
if masterconn.version_at_least(1,7,0):
dline.append("-" if meta else "yes" if sesflags&8 else "no")
if meta:
dline.extend(("-","-"))
else:
dline.extend((rootuid,rootgid))
if meta or (sesflags&16)==0:
dline.extend(("-","-"))
else:
dline.extend((mapalluid,mapallgid))
if masterconn.version_at_least(1,6,26):
if mingoal!=None and maxgoal!=None:
dline.extend((mingoal,maxgoal))
else:
dline.extend(("-","-"))
if mintrashtime!=None and maxtrashtime!=None:
dline.extend((timeduration_to_shortstr(mintrashtime),timeduration_to_shortstr(maxtrashtime)))
else:
dline.extend(("-","-"))
if masterconn.has_feature(FEATURE_EXPORT_UMASK):
if umaskval==None:
dline.append("-")
else:
dline.append("%03o" % umaskval)
if masterconn.has_feature(FEATURE_EXPORT_DISABLES):
dline.append("%08X (%s)" % (disables,disablesmask_to_string(disables)))
tab.append(*dline)
else:
dline = [ipfrom,ipto,". (META)" if meta else path,strver,"-" if meta else "yes" if exportflags&1 else "no","yes" if exportflags&2 else "no","ro" if sesflags&1 else "rw","no" if sesflags&2 else "yes","-" if meta else "yes" if sesflags&4 else "no"]
if masterconn.version_at_least(1,7,0):
dline.append("-" if meta else "yes" if sesflags&8 else "no")
if meta:
dline.extend(("-","-"))
else:
dline.extend((rootuid,rootgid))
if meta or (sesflags&16)==0:
dline.extend(("-","-"))
else:
dline.extend((mapalluid,mapallgid))
if masterconn.version_at_least(1,6,26):
if mingoal!=None and maxgoal!=None:
dline.extend((mingoal,maxgoal))
else:
dline.extend(("-","-"))
if mintrashtime!=None and maxtrashtime!=None:
dline.extend((mintrashtime,maxtrashtime))
else:
dline.extend(("-","-"))
if masterconn.has_feature(FEATURE_EXPORT_UMASK):
if umaskval==None:
dline.append("-")
else:
dline.append("%03o" % umaskval)
if masterconn.has_feature(FEATURE_EXPORT_DISABLES):
dline.append("%08X" % disables)
tab.append(*dline)
if cgimode:
out.append("""
""")
print("\n".join(out))
else:
print(myunicode(tab))
except Exception:
print_exception()
if "MS" in sectionset and leaderfound:
try:
if cgimode:
out = []
out.append("""
""")
out.append(""" | Active mounts (parameters) |
|---|
""" % (23 if masterconn.has_feature(FEATURE_EXPORT_DISABLES) else 22 if masterconn.has_feature(FEATURE_EXPORT_UMASK) else 21 if masterconn.version_at_least(1,7,8) else 19 if masterconn.version_at_least(1,7,0) else 18 if masterconn.version_at_least(1,6,26) else 14))
out.append(""" """)
out.append(""" | # | """)
# out.append(""" session id | """ % (createorderlink("MS",1)))
# out.append(""" host | """ % (createorderlink("MS",2)))
# out.append(""" ip | """ % (createorderlink("MS",3)))
# out.append(""" mount point | """ % (createorderlink("MS",4)))
# out.append(""" version | """ % (createorderlink("MS",5)))
# out.append(""" root dir | """ % (createorderlink("MS",6)))
# out.append(""" ro/rw | """ % (createorderlink("MS",7)))
# out.append(""" restricted ip | """ % (createorderlink("MS",8)))
# out.append(""" ignore gid | """ % (createorderlink("MS",9)))
out.append(""" session id | """)
out.append(""" host | """)
out.append(""" ip | """)
out.append(""" mount point | """)
if masterconn.version_at_least(1,7,8):
out.append(""" open files | """)
out.append(""" # of connections | """)
out.append(""" version | """)
out.append(""" root dir | """)
out.append(""" ro/rw | """)
out.append(""" restricted ip | """)
out.append(""" ignore gid | """)
if masterconn.version_at_least(1,7,0):
# out.append(""" can change quota | """ % (createorderlink("MS",10)))
out.append(""" admin | """)
out.append(""" map root | """)
out.append(""" map users | """)
if masterconn.version_at_least(1,6,26):
out.append(""" goal limits | """)
out.append(""" trashtime limits | """)
if masterconn.has_feature(FEATURE_EXPORT_UMASK):
out.append(""" global umask | """)
if masterconn.has_feature(FEATURE_EXPORT_DISABLES):
out.append(""" disables mask | """)
out.append("""
""")
out.append(""" """)
# out.append(""" | uid | """ % (createorderlink("MS",11)))
# out.append(""" gid | """ % (createorderlink("MS",12)))
# out.append(""" uid | """ % (createorderlink("MS",13)))
# out.append(""" gid | """ % (createorderlink("MS",14)))
out.append(""" uid | """)
out.append(""" gid | """)
out.append(""" uid | """)
out.append(""" gid | """)
if masterconn.version_at_least(1,6,26):
# out.append(""" min | """ % (createorderlink("MS",15)))
# out.append(""" max | """ % (createorderlink("MS",16)))
# out.append(""" min | """ % (createorderlink("MS",17)))
# out.append(""" max | """ % (createorderlink("MS",18)))
out.append(""" min | """)
out.append(""" max | """)
out.append(""" min | """)
out.append(""" max | """)
out.append("""
""")
elif ttymode:
tab = Tabble("Active mounts (parameters)",(21 if masterconn.has_feature(FEATURE_EXPORT_DISABLES) else 20 if masterconn.has_feature(FEATURE_EXPORT_UMASK) else 19 if masterconn.version_at_least(1,7,8) else 17 if masterconn.version_at_least(1,7,0) else 16 if masterconn.version_at_least(1,6,26) else 12))
dline = ["r","r","l"]
if masterconn.version_at_least(1,7,8):
dline.extend(("r","r"))
dline.extend(("r","l","c","c","c"))
if masterconn.version_at_least(1,7,0):
dline.append("c")
dline.extend(("r","r","r","r"))
if masterconn.version_at_least(1,6,26):
dline.extend(("r","r","r","r"))
if masterconn.has_feature(FEATURE_EXPORT_UMASK):
dline.append("c")
if masterconn.has_feature(FEATURE_EXPORT_DISABLES):
dline.append("c")
tab.defattr(*dline)
dline = ["","","","","","","",""]
if masterconn.version_at_least(1,7,0):
if masterconn.version_at_least(1,7,8):
dline.extend(("",""))
dline.append("")
dline.extend((("map root","",2),("map users","",2)))
if masterconn.version_at_least(1,6,26):
dline.extend((("goal limit","",2),("trashtime limit","",2)))
if masterconn.has_feature(FEATURE_EXPORT_UMASK):
dline.append("")
if masterconn.has_feature(FEATURE_EXPORT_DISABLES):
dline.append("")
tab.header(*dline)
dline = ["session id","ip/host","mount point"]
if masterconn.version_at_least(1,7,8):
dline.extend(("open files","# of connections"))
dline.extend(("version","root dir","ro/rw","restrict ip","ignore gid"))
if masterconn.version_at_least(1,7,0):
dline.append("admin")
if masterconn.version_at_least(1,6,26):
dline.append(("---","",8))
else:
dline.append(("---","",4))
if masterconn.has_feature(FEATURE_EXPORT_UMASK):
dline.append("global umask")
if masterconn.has_feature(FEATURE_EXPORT_DISABLES):
dline.append("disables mask")
tab.header(*dline)
dline = ["","","","","","","",""]
if masterconn.version_at_least(1,7,0):
if masterconn.version_at_least(1,7,8):
dline.extend(("",""))
dline.append("")
dline.extend(("uid","gid","uid","gid"))
if masterconn.version_at_least(1,6,26):
dline.extend(("min","max","min","max"))
if masterconn.has_feature(FEATURE_EXPORT_UMASK):
dline.append("")
if masterconn.has_feature(FEATURE_EXPORT_DISABLES):
dline.append("")
tab.header(*dline)
else:
tab = Tabble("active mounts, parameters",(21 if masterconn.has_feature(FEATURE_EXPORT_DISABLES) else 20 if masterconn.has_feature(FEATURE_EXPORT_UMASK) else 19 if masterconn.version_at_least(1,7,8) else 17 if masterconn.version_at_least(1,7,0) else 16 if masterconn.version_at_least(1,6,26) else 12))
servers = []
dservers = []
for ses in dataprovider.get_sessions():
sf = ses.sortip
if MSorder==1:
sf = ses.sessionid
elif MSorder==2:
sf = ses.host
elif MSorder==3:
sf = ses.sortip
elif MSorder==4:
sf = ses.info
elif MSorder==5:
sf = ses.openfiles
elif MSorder==6:
if ses.nsocks>0:
sf = ses.nsocks
else:
sf = ses.expire
elif MSorder==7:
sf = ses.sortver
elif MSorder==8:
sf = ses.path
elif MSorder==9:
sf = ses.sesflags&1
elif MSorder==10:
sf = 2-(ses.sesflags&2)
elif MSorder==11:
if ses.meta:
sf = None
else:
sf = ses.sesflags&4
elif MSorder==12:
if ses.meta:
sf = None
else:
sf = ses.sesflags&8
elif MSorder==13:
if ses.meta:
sf = None
else:
sf = ses.rootuid
elif MSorder==14:
if ses.meta:
sf = None
else:
sf = ses.rootgid
elif MSorder==15:
if ses.meta or (ses.sesflags&16)==0:
sf = None
else:
sf = ses.mapalluid
elif MSorder==16:
if ses.meta or (ses.sesflags&16)==0:
sf = None
else:
sf = ses.mapallgid
elif MSorder==17:
sf = ses.mingoal
elif MSorder==18:
sf = ses.maxgoal
elif MSorder==19:
sf = ses.mintrashtime
elif MSorder==20:
sf = ses.maxtrashtime
elif MSorder==21:
sf = ses.umaskval
elif MSorder==22:
sf = ses.disables
if ses.nsocks>0:
servers.append((sf,ses.sessionid,ses.host,ses.sortip,ses.strip,ses.info,ses.openfiles,ses.nsocks,ses.sortver,ses.strver,ses.meta,ses.path,ses.sesflags,ses.umaskval,ses.rootuid,ses.rootgid,ses.mapalluid,ses.mapallgid,ses.mingoal,ses.maxgoal,ses.mintrashtime,ses.maxtrashtime,ses.disables))
else:
dservers.append((sf,ses.sessionid,ses.host,ses.sortip,ses.strip,ses.info,ses.openfiles,ses.expire))
servers.sort()
dservers.sort()
if MSrev:
servers.reverse()
dservers.reverse()
for sf,sessionid,host,sortipnum,ipnum,info,openfiles,nsocks,sortver,strver,meta,path,sesflags,umaskval,rootuid,rootgid,mapalluid,mapallgid,mingoal,maxgoal,mintrashtime,maxtrashtime,disables in servers:
if cgimode:
if masterconn.is_pro() and not strver.endswith(" PRO"):
verclass = "BADVERSION"
elif masterconn.sort_ver() > sortver:
verclass = "LOWERVERSION"
elif masterconn.sort_ver() < sortver:
verclass = "HIGHERVERSION"
else:
verclass = "OKVERSION"
out.append(""" """)
out.append(""" | """)
out.append(""" %u | """ % sessionid)
out.append(""" %s | """ % host)
out.append(""" %s %s | """ % (sortipnum,ipnum))
out.append(""" %s | """ % htmlentities(info))
if masterconn.version_at_least(1,7,8):
out.append(""" %u | """ % openfiles)
out.append(""" %u | """ % nsocks)
out.append(""" %s %s | """ % (sortver,verclass,strver))
out.append(""" %s | """ % (". (META)" if meta else htmlentities(path)))
out.append(""" %s | """ % ("ro" if sesflags&1 else "rw"))
out.append(""" %s | """ % ("no" if sesflags&2 else "yes"))
out.append(""" %s | """ % ("-" if meta else "yes" if sesflags&4 else "no"))
if masterconn.version_at_least(1,7,0):
out.append(""" %s | """ % ("-" if meta else "yes" if sesflags&8 else "no"))
if meta:
out.append(""" -1 - | """)
out.append(""" -1 - | """)
else:
out.append(""" %u | """ % rootuid)
out.append(""" %u | """ % rootgid)
if meta or (sesflags&16)==0:
out.append(""" -1 - | """)
out.append(""" -1 - | """)
else:
out.append(""" %u | """ % mapalluid)
out.append(""" %u | """ % mapallgid)
if masterconn.version_at_least(1,6,26):
if mingoal!=None and maxgoal!=None:
out.append(""" %u | """ % mingoal)
out.append(""" %u | """ % maxgoal)
else:
out.append(""" -1 - | """)
out.append(""" -1 - | """)
if mintrashtime!=None and maxtrashtime!=None:
out.append(""" %u %s | """ % (mintrashtime,timeduration_to_fullstr(mintrashtime),timeduration_to_shortstr(mintrashtime)))
out.append(""" %u %s | """ % (maxtrashtime,timeduration_to_fullstr(maxtrashtime),timeduration_to_shortstr(maxtrashtime)))
else:
out.append(""" -1 - | """)
out.append(""" -1 - | """)
if masterconn.has_feature(FEATURE_EXPORT_UMASK):
if umaskval==None:
out.append(""" -1 - | """)
else:
out.append(""" %03o | """ % umaskval)
if masterconn.has_feature(FEATURE_EXPORT_DISABLES):
out.append(""" %u %08X | """ % (disables,disablesmask_to_string(disables),disables))
out.append("""
""")
elif ttymode:
dline = [sessionid,host,info]
if masterconn.version_at_least(1,7,8):
dline.extend((openfiles,nsocks))
dline.extend((strver,". (META)" if meta else path,"ro" if sesflags&1 else "rw","no" if sesflags&2 else "yes","-" if meta else "yes" if sesflags&4 else "no"))
if masterconn.version_at_least(1,7,0):
dline.append("-" if meta else "yes" if sesflags&8 else "no")
if meta:
dline.extend(("-","-"))
else:
dline.extend((rootuid,rootgid))
if meta or (sesflags&16)==0:
dline.extend(("-","-"))
else:
dline.extend((mapalluid,mapallgid))
if masterconn.version_at_least(1,6,26):
if mingoal!=None and maxgoal!=None:
dline.extend((mingoal,maxgoal))
else:
dline.extend(("-","-"))
if mintrashtime!=None and maxtrashtime!=None:
dline.extend((timeduration_to_shortstr(mintrashtime),timeduration_to_shortstr(maxtrashtime)))
else:
dline.extend(("-","-"))
if masterconn.has_feature(FEATURE_EXPORT_UMASK):
if umaskval==None:
dline.append("-")
else:
dline.append("%03o" % umaskval)
if masterconn.has_feature(FEATURE_EXPORT_DISABLES):
dline.append("%08X (%s)" % (disables,disablesmask_to_string(disables)))
tab.append(*dline)
else:
dline = [sessionid,host,info]
if masterconn.version_at_least(1,7,8):
dline.extend((openfiles,nsocks))
dline.extend((strver,". (META)" if meta else path,"ro" if sesflags&1 else "rw","no" if sesflags&2 else "yes","-" if meta else "yes" if sesflags&4 else "no"))
if masterconn.version_at_least(1,7,0):
dline.append("-" if meta else "yes" if sesflags&8 else "no")
if meta:
dline.extend(("-","-"))
else:
dline.extend((rootuid,rootgid))
if meta or (sesflags&16)==0:
dline.extend(("-","-"))
else:
dline.extend((mapalluid,mapallgid))
if masterconn.version_at_least(1,6,26):
if mingoal!=None and maxgoal!=None:
dline.extend((mingoal,maxgoal))
else:
dline.extend(("-","-"))
if mintrashtime!=None and maxtrashtime!=None:
dline.extend((mintrashtime,maxtrashtime))
else:
dline.extend(("-","-"))
if masterconn.has_feature(FEATURE_EXPORT_UMASK):
if umaskval==None:
dline.append("-")
else:
dline.append("%03o" % umaskval)
if masterconn.has_feature(FEATURE_EXPORT_DISABLES):
dline.append("%08X" % disables)
tab.append(*dline)
if len(dservers)>0 and masterconn.version_at_least(1,7,8):
if cgimode:
out.append("""
""")
out.append("""
""")
out.append(""" | Inactive mounts (parameters) |
|---|
""")
out.append(""" """)
out.append(""" | # | """)
out.append(""" session id | """)
out.append(""" host | """)
out.append(""" ip | """)
out.append(""" mount point | """)
out.append(""" open files | """)
out.append(""" expires | """)
out.append(""" cmd | """)
out.append("""
""")
elif ttymode:
tabcols = (21 if masterconn.has_feature(FEATURE_EXPORT_DISABLES) else 20 if masterconn.has_feature(FEATURE_EXPORT_UMASK) else 19 if masterconn.version_at_least(1,7,8) else 17 if masterconn.version_at_least(1,7,0) else 16 if masterconn.version_at_least(1,6,26) else 12)
tab.append(("---","",tabcols))
tab.append(("Inactive mounts (parameters)","1c",tabcols))
tab.append(("---","",tabcols))
dline = [("session id","c"),("ip/host","c"),("mount point","c"),("open files","c"),("expires","c"),("command to remove","c",tabcols-5)]
tab.append(*dline)
tab.append(("---","",tabcols))
else:
print(myunicode(tab))
print("")
tab = Tabble("inactive mounts, parameters",5)
for sf,sessionid,host,sortipnum,ipnum,info,openfiles,expire in dservers:
if cgimode:
out.append(""" """)
out.append(""" | """)
out.append(""" %u | """ % sessionid)
out.append(""" %s | """ % host)
out.append(""" %s %s | """ % (sortipnum,ipnum))
out.append(""" %s | """ % info)
out.append(""" %u | """ % openfiles)
out.append(""" %u | """ % expire)
out.append(""" click to remove | """ % createlink({"MSremove":("%u" % (sessionid))}))
out.append("""
""")
elif ttymode:
tabcols = (21 if masterconn.has_feature(FEATURE_EXPORT_DISABLES) else 20 if masterconn.has_feature(FEATURE_EXPORT_UMASK) else 19 if masterconn.version_at_least(1,7,8) else 17 if masterconn.version_at_least(1,7,0) else 16 if masterconn.version_at_least(1,6,26) else 12)
dline = [sessionid,host,info,openfiles,expire,("%s -H %s -P %u -CRS/%u" % (sys.argv[0],masterhost,masterport,sessionid),"l",tabcols-5)]
tab.append(*dline)
else:
dline = [sessionid,host,info,openfiles,expire]
tab.append(*dline)
if cgimode:
out.append("""
""")
print("\n".join(out))
else:
print(myunicode(tab))
except Exception:
print_exception()
if "MO" in sectionset and leaderfound:
try:
if cgimode:
out = []
out.append("""
""")
# out.append("""""")
out.append(""" | Active mounts (operations) |
|---|
""")
out.append(""" """)
out.append(""" | # | """)
# out.append(""" host | """ % (createorderlink("MO",1)))
# out.append(""" ip | """ % (createorderlink("MO",2)))
# out.append(""" mount point | """ % (createorderlink("MO",3)))
out.append(""" host | """)
out.append(""" ip | """)
out.append(""" mount point | """)
out.append(""" """)
out.append(""" operations last hour (switch to current)""")
out.append(""" operations current hour (switch to last)""")
out.append(""" | """)
out.append("""
""")
out.append(""" """)
# out.append(""" | statfs | """ % (createorderlink("MO",100)))
# out.append(""" getattr | """ % (createorderlink("MO",101)))
# out.append(""" setattr | """ % (createorderlink("MO",102)))
# out.append(""" lookup | """ % (createorderlink("MO",103)))
# out.append(""" mkdir | """ % (createorderlink("MO",104)))
# out.append(""" rmdir | """ % (createorderlink("MO",105)))
# out.append(""" symlink | """ % (createorderlink("MO",106)))
# out.append(""" readlink | """ % (createorderlink("MO",107)))
# out.append(""" mknod | """ % (createorderlink("MO",108)))
# out.append(""" unlink | """ % (createorderlink("MO",109)))
# out.append(""" rename | """ % (createorderlink("MO",110)))
# out.append(""" link | """ % (createorderlink("MO",111)))
# out.append(""" readdir | """ % (createorderlink("MO",112)))
# out.append(""" open | """ % (createorderlink("MO",113)))
# out.append(""" read | """ % (createorderlink("MO",114)))
# out.append(""" write | """ % (createorderlink("MO",115)))
# out.append(""" total | """ % (createorderlink("MO",150)))
out.append(""" statfs | """)
out.append(""" getattr | """)
out.append(""" setattr | """)
out.append(""" lookup | """)
out.append(""" mkdir | """)
out.append(""" rmdir | """)
out.append(""" symlink | """)
out.append(""" readlink | """)
out.append(""" mknod | """)
out.append(""" unlink | """)
out.append(""" rename | """)
out.append(""" link | """)
out.append(""" readdir | """)
out.append(""" open | """)
out.append(""" read | """)
out.append(""" write | """)
out.append(""" total | """)
out.append("""
""")
elif ttymode:
tab = Tabble("Active mounts (operations)",19)
tab.header("","",("operations %s hour" % ("last" if MOdata==0 else "current"),"",17))
tab.header("host/ip","mount point",("---","",17))
tab.header("","","statfs","getattr","setattr","lookup","mkdir","rmdir","symlink","readlink","mknod","unlink","rename","link","readdir","open","read","write","total")
tab.defattr("r","l","r","r","r","r","r","r","r","r","r","r","r","r","r","r","r","r","r")
else:
tab = Tabble("active mounts, operations",19)
servers = []
for ses in dataprovider.get_sessions():
sf = ses.sortip
if MOorder==1:
sf = ses.host
elif MOorder==2:
sf = ses.sortip
elif MOorder==3:
sf = ses.info
elif MOorder>=100 and MOorder<=115:
sfmul = -1 if cgimode else 1
if MOdata==0:
sf = sfmul * ses.stats_l[MOorder-100]
else:
sf = sfmul * ses.stats_c[MOorder-100]
elif MOorder==150:
sfmul = -1 if cgimode else 1
if MOdata==0:
sf = sfmul * sum(ses.stats_l)
else:
sf = sfmul * sum(ses.stats_c)
if ses.path!='.':
servers.append((sf,ses.host,ses.sortip,ses.strip,ses.info,ses.stats_c,ses.stats_l))
servers.sort()
if MOrev:
servers.reverse()
for sf,host,sortipnum,ipnum,info,stats_c,stats_l in servers:
if cgimode:
out.append(""" """)
out.append(""" | """)
out.append(""" %s | """ % host)
out.append(""" %s%s | """ % (sortipnum,ipnum))
out.append(""" %s | """ % htmlentities(info))
for st in range(16):
out.append(""" """)
out.append(""" %u""" % (stats_c[st],stats_l[st],stats_l[st]))
out.append(""" %u""" % (stats_c[st],stats_l[st],stats_c[st]))
out.append(""" | """)
out.append(""" """)
out.append(""" %u""" % (sum(stats_c),sum(stats_l),sum(stats_l)))
out.append(""" %u""" % (sum(stats_c),sum(stats_l),sum(stats_c)))
out.append(""" | """)
# if MOdata==0:
# for st in xrange(16):
# out.append(""" %u | """ % (stats_c[st],stats_l[st],stats_l[st]))
# out.append(""" %u | """ % (sum(stats_c),sum(stats_l),sum(stats_l)))
# else:
# for st in xrange(16):
# out.append(""" %u | """ % (stats_c[st],stats_l[st],stats_c[st]))
# out.append(""" %u | """ % (sum(stats_c),sum(stats_l),sum(stats_c)))
out.append("""
""")
else:
ldata = [host,info]
if MOdata==0:
ldata.extend(stats_l)
ldata.append(sum(stats_l))
else:
ldata.extend(stats_c)
ldata.append(sum(stats_c))
tab.append(*ldata)
if cgimode:
out.append("""
""")
print("\n".join(out))
else:
print(myunicode(tab))
except Exception:
print_exception()
if "RS" in sectionset and leaderfound:
if "SC" in sectionsubset:
try:
if cgimode:
out = []
out.append("""""")
out.append(""" | Storage Classes |
|---|
""")
out.append(""" """)
out.append(""" | id | """)
out.append(""" name | """)
out.append(""" admin only | """)
out.append(""" mode | """)
out.append(""" # of inodes | """)
out.append(""" # of standard chunks | """)
out.append(""" # of archived chunks | """)
out.append(""" create | """)
out.append(""" keep | """)
out.append(""" archive | """)
out.append("""
""")
out.append(""" """)
out.append(""" | files | """)
out.append(""" dirs | """)
out.append(""" under | """)
out.append(""" exact | """)
out.append(""" over | """)
out.append(""" under | """)
out.append(""" exact | """)
out.append(""" over | """)
out.append(""" can be fulfilled | """)
out.append(""" goal | """)
out.append(""" labels | """)
out.append(""" can be fulfilled | """)
out.append(""" goal | """)
out.append(""" labels | """)
out.append(""" can be fulfilled | """)
out.append(""" goal | """)
out.append(""" labels | """)
out.append(""" delay | """)
out.append("""
""")
elif ttymode:
tab = Tabble("Storage Classes",22,"r")
tab.header("","","","",("# of inodes","",2),("# of standard chunks","",3),("# of archived chunks","",3),("create","",3),("keep","",3),("archive","",4))
tab.header("id","name","admin only","mode",("---","",18))
tab.header("","","","","files","dirs","under","exact","over","under","exact","over","can be fulfilled","goal","labels","can be fulfilled","goal","labels","can be fulfilled","goal","labels","delay")
tab.defattr("r","l","c","c","r","r","r","r","r","r","r","r","c","r","l","c","r","l","c","r","l","r")
else:
tab = Tabble("storage classes",22)
sclasses = []
data,length = masterconn.command(CLTOMA_SCLASS_INFO,MATOCL_SCLASS_INFO)
scount = struct.unpack(">H",data[:2])[0]
pos = 2
while pos < length:
if masterconn.version_at_least(3,0,75):
sclassid,sclassnleng = struct.unpack_from(">BB",data,pos)
pos += 2
sclassname = data[pos:pos+sclassnleng]
sclassname = sclassname.decode('utf-8','replace')
pos += sclassnleng
files,dirs,stdchunks_under,archchunks_under,stdchunks_exact,archchunks_exact,stdchunks_over,archchunks_over,admin_only,mode,arch_delay,create_canbefulfilled,create_labelscnt,keep_canbefulfilled,keep_labelscnt,arch_canbefulfilled,arch_labelscnt = struct.unpack_from(">LLQQQQQQBBHBBBBBB",data,pos)
pos += 18 + 3 * 16
if arch_delay==0:
stdchunks_under += archchunks_under
stdchunks_exact += archchunks_exact
stdchunks_over += archchunks_over
archchunks_under = None
archchunks_exact = None
archchunks_over = None
elif masterconn.version_at_least(3,0,9):
sclassid,files,dirs,stdchunks_under,archchunks_under,stdchunks_exact,archchunks_exact,stdchunks_over,archchunks_over,mode,arch_delay,create_canbefulfilled,create_labelscnt,keep_canbefulfilled,keep_labelscnt,arch_canbefulfilled,arch_labelscnt = struct.unpack_from(">BLLQQQQQQBHBBBBBB",data,pos)
pos += 18 + 3 * 16
admin_only = 0
if sclassid<10:
sclassname = str(sclassid)
else:
sclassname = "sclass_%u" % (sclassid-9)
if arch_delay==0:
stdchunks_under += archchunks_under
stdchunks_exact += archchunks_exact
stdchunks_over += archchunks_over
archchunks_under = None
archchunks_exact = None
archchunks_over = None
else:
sclassid,files,create_canbefulfilled,create_labelscnt = struct.unpack_from(">BLBB",data,pos)
admin_only = 0
if sclassid<10:
sclassname = str(sclassid)
else:
sclassname = "sclass_%u" % (sclassid-9)
dirs = 0
if create_canbefulfilled:
create_canbefulfilled = 3
keep_canbefulfilled = create_canbefulfilled
arch_canbefulfilled = create_canbefulfilled
keep_labelscnt = create_labelscnt
arch_labelscnt = create_labelscnt
mode = 1
arch_delay = 0
stdchunks_under = None
archchunks_under = None
stdchunks_exact = None
archchunks_exact = None
stdchunks_over = None
archchunks_over = None
pos+=7
create_labellist = []
for i in xrange(create_labelscnt):
labelmasks = struct.unpack_from(">"+"L"*MASKORGROUP,data,pos)
pos+=4*MASKORGROUP
matchingservers = struct.unpack_from(">H",data,pos)[0]
pos+=2
create_labellist.append((labelmasks_to_str(labelmasks),matchingservers))
if masterconn.version_at_least(3,0,9):
keep_labellist = []
for i in xrange(keep_labelscnt):
labelmasks = struct.unpack_from(">"+"L"*MASKORGROUP,data,pos)
pos+=4*MASKORGROUP
matchingservers = struct.unpack_from(">H",data,pos)[0]
pos+=2
keep_labellist.append((labelmasks_to_str(labelmasks),matchingservers))
arch_labellist = []
for i in xrange(arch_labelscnt):
labelmasks = struct.unpack_from(">"+"L"*MASKORGROUP,data,pos)
pos+=4*MASKORGROUP
matchingservers = struct.unpack_from(">H",data,pos)[0]
pos+=2
arch_labellist.append((labelmasks_to_str(labelmasks),matchingservers))
else:
keep_labellist = create_labellist
arch_labellist = create_labellist
sf = sclassid
if SCorder==2:
sf = sclassname
elif SCorder==3:
sf = admin_only
elif SCorder==4:
sf = files
elif SCorder==5:
sf = dirs
elif SCorder==6:
sf = stdchunks_under
elif SCorder==7:
sf = stdchunks_exact
elif SCorder==8:
sf = stdchunks_over
elif SCorder==9:
sf = archchunks_under
elif SCorder==10:
sf = archchunks_exact
elif SCorder==11:
sf = archchunks_over
elif SCorder==12:
sf = mode
elif SCorder==13:
sf = create_canbefulfilled
elif SCorder==14:
sf = create_labelscnt
elif SCorder==15:
sf = create_labellist
elif SCorder==16:
sf = keep_canbefulfilled
elif SCorder==17:
sf = keep_labelscnt
elif SCorder==18:
sf = keep_labellist
elif SCorder==19:
sf = arch_canbefulfilled
elif SCorder==20:
sf = arch_labelscnt
elif SCorder==21:
sf = arch_labellist
elif SCorder==22:
sf = arch_delay
sclasses.append((sf,sclassid,sclassname,admin_only,mode,files,dirs,stdchunks_under,stdchunks_exact,stdchunks_over,archchunks_under,archchunks_exact,archchunks_over,create_canbefulfilled,create_labellist,keep_canbefulfilled,keep_labellist,arch_canbefulfilled,arch_labellist,arch_delay))
sclasses.sort()
if SCrev:
sclasses.reverse()
for sf,sclassid,sclassname,admin_only,mode,files,dirs,stdchunks_under,stdchunks_exact,stdchunks_over,archchunks_under,archchunks_exact,archchunks_over,create_canbefulfilled,create_labellist,keep_canbefulfilled,keep_labellist,arch_canbefulfilled,arch_labellist,arch_delay in sclasses:
if cgimode:
allcolor = (0,160,224)
zerocolor = (0,0,128)
out.append(""" """)
out.append(""" | %u | """ % sclassid)
out.append(""" %s | """ % htmlentities(sclassname))
out.append(""" %s | """ % ("YES" if admin_only else "NO"))
out.append(""" %s | """ % ("LOOSE" if mode==0 else "STD" if mode==1 else "STRICT"))
out.append(""" %u | """ % files)
out.append(""" %u | """ % dirs)
if stdchunks_under!=None and stdchunks_exact!=None and stdchunks_over!=None:
out.append(""" %s | """ % (("%u" % stdchunks_under) if stdchunks_under>0 else " "))
out.append(""" %u | """ % stdchunks_exact)
out.append(""" %s | """ % (("%u" % stdchunks_over) if stdchunks_over>0 else " "))
else:
out.append(""" - | """)
out.append(""" - | """)
out.append(""" - | """)
if archchunks_under!=None and archchunks_exact!=None and archchunks_over!=None:
out.append(""" %s | """ % (("%u" % archchunks_under) if archchunks_under>0 else " "))
out.append(""" %u | """ % archchunks_exact)
out.append(""" %s | """ % (("%u" % archchunks_over) if archchunks_over>0 else " "))
else:
out.append(""" - | """)
out.append(""" - | """)
out.append(""" - | """)
if create_canbefulfilled==3:
out.append(""" YES | """)
elif create_canbefulfilled==2:
out.append(""" OVERLOADED | """)
elif create_canbefulfilled==1:
out.append(""" NO SPACE | """)
else:
out.append(""" NO | """)
labelsarr = []
for labelstr,mscount in create_labellist:
if scount==0:
msperc = 0;
else:
msperc = (1.0 * mscount) / scount
perccolor = (int(zerocolor[0]+(allcolor[0]-zerocolor[0])*msperc),int(zerocolor[1]+(allcolor[1]-zerocolor[1])*msperc),int(zerocolor[2]+(allcolor[2]-zerocolor[2])*msperc))
color = "#%02X%02X%02X" % perccolor
labelsarr.append("""%s""" % (color,mscount,scount,labelstr))
out.append(""" %u | """ % (len(labelsarr)))
out.append(""" %s | """ % (" , ".join(labelsarr)))
if keep_canbefulfilled==3:
out.append(""" YES | """)
elif keep_canbefulfilled==2:
out.append(""" OVERLOADED | """)
elif keep_canbefulfilled==1:
out.append(""" NO SPACE | """)
else:
out.append(""" NO | """)
labelsarr = []
for labelstr,mscount in keep_labellist:
if scount==0:
msperc = 0;
else:
msperc = (1.0 * mscount) / scount
perccolor = (int(zerocolor[0]+(allcolor[0]-zerocolor[0])*msperc),int(zerocolor[1]+(allcolor[1]-zerocolor[1])*msperc),int(zerocolor[2]+(allcolor[2]-zerocolor[2])*msperc))
color = "#%02X%02X%02X" % perccolor
labelsarr.append("""%s""" % (color,mscount,scount,labelstr))
out.append(""" %u | """ % (len(labelsarr)))
out.append(""" %s | """ % (" , ".join(labelsarr)))
if arch_canbefulfilled==3:
out.append(""" YES | """)
elif arch_canbefulfilled==2:
out.append(""" OVERLOADED | """)
elif arch_canbefulfilled==1:
out.append(""" NO SPACE | """)
else:
out.append(""" NO | """)
labelsarr = []
for labelstr,mscount in arch_labellist:
msperc = (1.0 * mscount) / scount
perccolor = (int(zerocolor[0]+(allcolor[0]-zerocolor[0])*msperc),int(zerocolor[1]+(allcolor[1]-zerocolor[1])*msperc),int(zerocolor[2]+(allcolor[2]-zerocolor[2])*msperc))
color = "#%02X%02X%02X" % perccolor
labelsarr.append("""%s""" % (color,mscount,scount,labelstr))
out.append(""" %u | """ % (len(labelsarr)))
out.append(""" %s | """ % (" , ".join(labelsarr)))
if arch_delay>0:
out.append(""" %ud | """ % arch_delay)
else:
out.append(""" - | """)
out.append("""
""")
else:
data = [sclassid,sclassname,("YES" if admin_only else "NO"),"LOOSE" if mode==0 else "STD" if mode==1 else "STRICT",files,dirs]
if stdchunks_under!=None and stdchunks_exact!=None and stdchunks_over!=None:
data.append((stdchunks_under,'3') if stdchunks_under>0 else "-")
data.append((stdchunks_exact,'4'))
data.append((stdchunks_over,'5') if stdchunks_over>0 else "-")
else:
data.extend(["-","-","-"])
if archchunks_under!=None and archchunks_exact!=None and archchunks_over!=None:
data.append((archchunks_under,'3') if archchunks_under>0 else "-")
data.append((archchunks_exact,'4'))
data.append((archchunks_over,'5') if archchunks_over>0 else "-")
else:
data.extend(["-","-","-"])
if create_canbefulfilled==3:
data.append(("YES",'4'))
elif create_canbefulfilled==2:
data.append(("OVERLOADED",'3'))
elif create_canbefulfilled==1:
data.append(("NO SPACE",'2'))
else:
data.append(("NO",'1'))
data.append("%u" % len(create_labellist))
data.append("%s" % (" , ".join([x for x,y in create_labellist])))
if keep_canbefulfilled==3:
data.append(("YES",'4'))
elif keep_canbefulfilled==2:
data.append(("OVERLOADED",'3'))
elif keep_canbefulfilled==1:
data.append(("NO SPACE",'2'))
else:
data.append(("NO",'1'))
data.append("%u" % len(keep_labellist))
data.append("%s" % (" , ".join([x for x,y in keep_labellist])))
if arch_canbefulfilled==3:
data.append(("YES",'4'))
elif arch_canbefulfilled==2:
data.append(("OVERLOADED",'3'))
elif arch_canbefulfilled==1:
data.append(("NO SPACE",'2'))
else:
data.append(("NO",'1'))
data.append("%u" % len(arch_labellist))
data.append("%s" % (" , ".join([x for x,y in arch_labellist])))
if arch_delay>0:
data.append("%ud" % arch_delay)
else:
data.append("-")
tab.append(*data)
if cgimode:
out.append("""
""")
print("\n".join(out))
else:
print(myunicode(tab))
except Exception:
print_exception()
inodes = set()
if "OF" in sectionsubset:
try:
sessionsdata = {}
for ses in dataprovider.get_sessions():
sessionsdata[ses.sessionid]=(ses.host,ses.sortip,ses.strip,ses.info,ses.openfiles)
if cgimode:
out = []
out.append("""""")
if OFsessionid!=0:
out.append("""""")
out.append(""" | Open files by client with session id: %u |
|---|
""" % OFsessionid)
out.append(""" """)
out.append(""" | # | """)
out.append(""" session id | """)
out.append(""" host | """)
out.append(""" ip | """)
out.append(""" mount point | """)
out.append(""" inode | """)
out.append(""" paths | """)
out.append("""
""")
elif ttymode:
tab = Tabble("Open Files",5)
tab.header("session id","ip/host","mount point","inode","path")
tab.defattr("r","r","l","r","l")
else:
tab = Tabble("open file",5)
if cgimode and OFsessionid==0:
ofdata = []
else:
data,length = masterconn.command(CLTOMA_LIST_OPEN_FILES,MATOCL_LIST_OPEN_FILES,struct.pack(">L",OFsessionid))
openfiles = []
if OFsessionid==0:
n = length//8
for x in xrange(n):
sessionid,inode = struct.unpack(">LL",data[x*8:x*8+8])
openfiles.append((sessionid,inode))
inodes.add(inode)
else:
n = length//4
for x in xrange(n):
inode = struct.unpack(">L",data[x*4:x*4+4])[0]
openfiles.append((OFsessionid,inode))
inodes.add(inode)
inodepaths = resolve_inodes_paths(masterconn,inodes)
ofdata = []
for sessionid,inode in openfiles:
if sessionid in sessionsdata:
host,sortipnum,ipnum,info,openfiles = sessionsdata[sessionid]
else:
host = 'unknown'
sortipnum = ''
ipnum = ''
info = 'unknown'
if inode in inodepaths:
paths = inodepaths[inode]
else:
paths = []
sf = sortipnum
if OForder==1:
sf = sessionid
elif OForder==2:
sf = hostip
elif OForder==3:
sf = sortipnum
elif OForder==4:
sf = info
elif OForder==5:
sf = inode
elif OForder==6:
sf = paths
ofdata.append((sf,sessionid,host,sortipnum,ipnum,info,inode,paths))
ofdata.sort()
if OFrev:
ofdata.reverse()
for sf,sessionid,host,sortipnum,ipnum,info,inode,paths in ofdata:
if cgimode:
for path in paths:
out.append(""" """)
out.append(""" | """)
out.append(""" %u | """ % sessionid)
out.append(""" %s | """ % host)
out.append(""" %s %s | """ % (sortipnum,ipnum))
out.append(""" %s | """ % htmlentities(info))
out.append(""" %u | """ % inode)
out.append(""" %s | """ % htmlentities(path))
out.append("""
""")
else:
if len(paths)==0:
dline = [sessionid,host,info,inode,"unknown"]
tab.append(*dline)
else:
for path in paths:
dline = [sessionid,host,info,inode,path]
tab.append(*dline)
if cgimode:
if OFsessionid!=0:
out.append("""
""")
print("\n".join(out))
else:
#print(openfiles)
print(myunicode(tab))
except Exception:
print_exception()
if "AL" in sectionsubset:
try:
sessionsdata = {}
for ses in dataprovider.get_sessions():
sessionsdata[ses.sessionid]=(ses.host,ses.sortip,ses.strip,ses.info,ses.openfiles)
if cgimode:
if ALinode not in inodes:
ALinode = 0
out = []
if len(inodes)>0:
out.append("""""")
if ALinode!=0:
out.append("""""")
out.append(""" | Acquired locks for inode: %u |
|---|
""" % ALinode)
out.append(""" """)
out.append(""" | # | """)
out.append(""" session id | """)
out.append(""" host | """)
out.append(""" ip | """)
out.append(""" mount point | """)
out.append(""" lock type | """)
out.append(""" owner id | """)
out.append(""" pid | """)
out.append(""" start | """)
out.append(""" end | """)
out.append(""" r/w | """)
out.append("""
""")
elif ttymode:
tab = Tabble("Acquired Locks",10,"r")
tab.header("inode","session id","ip/host","mount point","lock type","owner","pid","start","end","r/w")
else:
tab = Tabble("acquired locks",10)
if cgimode and ALinode==0:
aldata = []
else:
data,length = masterconn.command(CLTOMA_LIST_ACQUIRED_LOCKS,MATOCL_LIST_ACQUIRED_LOCKS,struct.pack(">L",ALinode))
locks = []
if ALinode==0:
n = length//37
for x in xrange(n):
inode,sessionid,owner,pid,start,end,ctype = struct.unpack(">LLQLQQB",data[x*37:x*37+37])
locks.append((inode,sessionid,owner,pid,start,end,ctype))
else:
n = length//33
for x in xrange(n):
sessionid,owner,pid,start,end,ctype = struct.unpack(">LQLQQB",data[x*33:x*33+33])
locks.append((ALinode,sessionid,owner,pid,start,end,ctype))
aldata = []
for inode,sessionid,owner,pid,start,end,ctype in locks:
if sessionid in sessionsdata:
host,sortipnum,ipnum,info,openfiles = sessionsdata[sessionid]
else:
host = 'unknown'
sortipnum = ''
ipnum = ''
info = 'unknown'
if pid==0 and start==0 and end==0:
locktype = "FLOCK"
else:
locktype = "POSIX"
sf = inode
if ALorder==1:
sf = inode
elif ALorder==2:
sf = sessionid
elif ALorder==3:
sf = hostip
elif ALorder==4:
sf = sortipnum
elif ALorder==5:
sf = info
elif ALorder==6:
sf = locktype
elif ALorder==7:
sf = owner
elif ALorder==8:
sf = pid
elif ALorder==9:
sf = start
elif ALorder==10:
sf = end
elif ALorder==11:
sf = ctype
aldata.append((sf,inode,sessionid,host,sortipnum,ipnum,info,locktype,owner,pid,start,end,ctype))
aldata.sort()
if ALrev:
aldata.reverse()
for sf,inode,sessionid,host,sortipnum,ipnum,info,locktype,owner,pid,start,end,ctype in aldata:
if cgimode:
out.append(""" """)
out.append(""" | """)
out.append(""" %u | """ % sessionid)
out.append(""" %s | """ % host)
out.append(""" %s %s | """ % (sortipnum,ipnum))
out.append(""" %s | """ % htmlentities(info))
out.append(""" %s | """ % locktype)
out.append(""" %u | """ % owner)
if pid==0 and start==0 and end==0:
out.append(""" -1 | """)
out.append(""" 0 | """)
out.append(""" EOF | """)
else:
out.append(""" %u | """ % pid)
out.append(""" %u | """ % start)
if end > 0x7FFFFFFFFFFFFFFF:
out.append(""" EOF | """)
else:
out.append(""" %u | """ % end)
out.append(""" %s | """ % ("READ(SHARED)" if ctype==1 else "WRITE(EXCLUSIVE)" if ctype==2 else "???"))
out.append("""
""")
else:
if pid==0 and start==0 and end==0:
pid = "-1"
start = "0"
end = "EOF"
elif end > 0x7FFFFFFFFFFFFFFF:
end = "EOF"
if ctype==1:
ctypestr = "READ(SHARED)"
elif ctype==2:
ctypestr = "WRITE(EXCLUSIVE)"
else:
ctypestr = "???"
dline = [inode,sessionid,host,info,locktype,owner,pid,start,end,ctypestr]
tab.append(*dline)
if cgimode:
if ALinode!=0:
out.append("""
""")
print("\n".join(out))
else:
# print(locks)
print(myunicode(tab))
except Exception:
print_exception()
if "QU" in sectionset:
try:
if cgimode:
out = []
out.append("""""")
out.append(""" | Active quotas |
|---|
""")
out.append(""" """)
out.append(""" | # | """)
# out.append(""" path | """ % (createorderlink("QU",11)))
# out.append(""" exceeded | """ % (createorderlink("QU",2)))
out.append(""" path | """)
out.append(""" soft quota | """)
out.append(""" hard quota | """)
out.append(""" current values | """)
out.append("""
""")
out.append(""" """)
# out.append(""" | time to expire | """ % (createorderlink("QU",10)))
# out.append(""" inodes | """ % (createorderlink("QU",11)))
# out.append(""" length | """ % (createorderlink("QU",12)))
# out.append(""" size | """ % (createorderlink("QU",13)))
# out.append(""" real size | """ % (createorderlink("QU",14)))
# out.append(""" inodes | """ % (createorderlink("QU",21)))
# out.append(""" length | """ % (createorderlink("QU",22)))
# out.append(""" size | """ % (createorderlink("QU",23)))
# out.append(""" real size | """ % (createorderlink("QU",24)))
# out.append(""" inodes | """ % (createorderlink("QU",31)))
# out.append(""" length | """ % (createorderlink("QU",32)))
# out.append(""" size | """ % (createorderlink("QU",33)))
# out.append(""" real size | """ % (createorderlink("QU",34)))
# out.append(""" exceeded | """)
out.append(""" grace period | """)
out.append(""" time to expire | """)
out.append(""" inodes | """)
out.append(""" length | """)
out.append(""" size | """)
out.append(""" real size | """)
out.append(""" inodes | """)
out.append(""" length | """)
out.append(""" size | """)
out.append(""" real size | """)
out.append(""" inodes | """)
out.append(""" length | """)
out.append(""" size | """)
out.append(""" real size | """)
out.append("""
""")
out.append(""" """)
out.append(""" | value | """)
out.append(""" % soft | """)
out.append(""" % hard | """)
out.append(""" value | """)
out.append(""" % soft | """)
out.append(""" % hard | """)
out.append(""" value | """)
out.append(""" % soft | """)
out.append(""" % hard | """)
out.append(""" value | """)
out.append(""" % soft | """)
out.append(""" % hard | """)
out.append("""
""")
elif ttymode:
# tab = Tabble("Active quotas",14)
# tab.header("",("soft quota","",5),("hard quota","",4),("current values","",4))
# tab.header("path",("---","",13))
# tab.header("","time to expire","inodes","length","size","real size","inodes","length","size","real size","inodes","length","size","real size")
# tab.defattr("l","r","r","r","r","r","r","r","r","r","r","r","r","r")
tab = Tabble("Active quotas",23)
tab.header("",("soft quota","",6),("hard quota","",4),("current values","",12))
tab.header("",("---","",22))
tab.header("path","","","","","","","","","","",("inodes","",3),("length","",3),("size","",3),("real size","",3))
tab.header("","grace period","time to expire","inodes","length","size","real size","inodes","length","size","real size",("---","",12))
tab.header("","","","","","","","","","","","value","% soft","% hard","value","% soft","% hard","value","% soft","% hard","value","% soft","% hard")
tab.defattr("l","r","r","r","r","r","r","r","r","r","r","r","r","r","r","r","r","r","r","r","r","r","r")
else:
tab = Tabble("active quotas",16)
data,length = masterconn.command(CLTOMA_QUOTA_INFO,MATOCL_QUOTA_INFO)
if length>=4 and masterconn.version_at_least(1,7,0):
quotas = []
maxperc = 0.0
pos = 0
while posLL",data[pos:pos+8])
pos+=8
path = data[pos:pos+pleng]
path = path.decode('utf-8','replace')
pos+=pleng
if masterconn.version_at_least(3,0,9):
graceperiod,exceeded,qflags,timetoblock = struct.unpack(">LBBL",data[pos:pos+10])
pos+=10
else:
exceeded,qflags,timetoblock = struct.unpack(">BBL",data[pos:pos+6])
pos+=6
graceperiod = 0
sinodes,slength,ssize,srealsize = struct.unpack(">LQQQ",data[pos:pos+28])
pos+=28
hinodes,hlength,hsize,hrealsize = struct.unpack(">LQQQ",data[pos:pos+28])
pos+=28
cinodes,clength,csize,crealsize = struct.unpack(">LQQQ",data[pos:pos+28])
pos+=28
if (qflags&1) and sinodes>0:
perc = 100.0*cinodes/sinodes
if perc>maxperc:
maxperc = perc
if (qflags&2) and slength>0:
perc = 100.0*clength/slength
if perc>maxperc:
maxperc = perc
if (qflags&4) and ssize>0:
perc = 100.0*csize/ssize
if perc>maxperc:
maxperc = perc
if (qflags&8) and srealsize>0:
perc = 100.0*crealsize/srealsize
if perc>maxperc:
maxperc = perc
if (qflags&16) and hinodes>0:
perc = 100.0*cinodes/hinodes
if perc>maxperc:
maxperc = perc
if (qflags&32) and hlength>0:
perc = 100.0*clength/hlength
if perc>maxperc:
maxperc = perc
if (qflags&64) and hsize>0:
perc = 100.0*csize/hsize
if perc>maxperc:
maxperc = perc
if (qflags&128) and hrealsize>0:
perc = 100.0*crealsize/hrealsize
if perc>maxperc:
maxperc = perc
sf = path
if QUorder==1:
sf = path
elif QUorder==2:
sf = exceeded
elif QUorder==9:
sf = graceperiod
elif QUorder==10:
sf = timetoblock
elif QUorder==11:
sf = sinodes
elif QUorder==12:
sf = slength
elif QUorder==13:
sf = ssize
elif QUorder==14:
sf = srealsize
elif QUorder==21:
sf = hinodes
elif QUorder==22:
sf = hlength
elif QUorder==23:
sf = hsize
elif QUorder==24:
sf = hrealsize
elif QUorder==31:
sf = cinodes
elif QUorder==32:
sf = clength
elif QUorder==33:
sf = csize
elif QUorder==34:
sf = crealsize
elif QUorder==41:
sf = (-1,0) if (qflags&1)==0 else (1,0) if sinodes==0 else (0,1.0*cinodes/sinodes)
elif QUorder==42:
sf = (-1,0) if (qflags&2)==0 else (1,0) if slength==0 else (0,1.0*clength/slength)
elif QUorder==43:
sf = (-1,0) if (qflags&4)==0 else (1,0) if ssize==0 else (0,1.0*csize/ssize)
elif QUorder==44:
sf = (-1,0) if (qflags&8)==0 else (1,0) if srealsize==0 else (0,1.0*crealsize/srealsize)
elif QUorder==51:
sf = (-1,0) if (qflags&16)==0 else (1,0) if hinodes==0 else (0,1.0*cinodes/hinodes)
elif QUorder==52:
sf = (-1,0) if (qflags&32)==0 else (1,0) if hlength==0 else (0,1.0*clength/hlength)
elif QUorder==53:
sf = (-1,0) if (qflags&64)==0 else (1,0) if hsize==0 else (0,1.0*csize/hsize)
elif QUorder==54:
sf = (-1,0) if (qflags&128)==0 else (1,0) if hrealsize==0 else (0,1.0*crealsize/hrealsize)
quotas.append((sf,path,exceeded,qflags,graceperiod,timetoblock,sinodes,slength,ssize,srealsize,hinodes,hlength,hsize,hrealsize,cinodes,clength,csize,crealsize))
quotas.sort()
if QUrev:
quotas.reverse()
maxperc += 0.01
for sf,path,exceeded,qflags,graceperiod,timetoblock,sinodes,slength,ssize,srealsize,hinodes,hlength,hsize,hrealsize,cinodes,clength,csize,crealsize in quotas:
if cgimode:
out.append(""" """)
out.append(""" | """)
out.append(""" %s | """ % htmlentities(path))
# out.append(""" %s | """ % ("yes" if exceeded else "no"))
if graceperiod>0:
out.append(""" %u %s | """ % (graceperiod,timeduration_to_fullstr(graceperiod),timeduration_to_shortstr(graceperiod)))
else:
out.append(""" 0 default | """)
if timetoblock<0xFFFFFFFF:
if timetoblock>0:
# days,rest = divmod(timetoblock,86400)
# hours,rest = divmod(rest,3600)
# min,sec = divmod(rest,60)
# if days>0:
# tbstr = "%ud, %uh %um %us" % (days,hours,min,sec)
# elif hours>0:
# tbstr = "%uh %um %us" % (hours,min,sec)
# elif min>0:
# tbstr = "%um %us" % (min,sec)
# else:
# tbstr = "%us" % sec
out.append(""" %u %s | """ % (timetoblock,timeduration_to_fullstr(timetoblock),timeduration_to_shortstr(timetoblock)))
else:
out.append(""" 0 expired | """)
else:
out.append(""" -1 - | """)
if qflags&1:
out.append(""" %u | """ % (sinodes))
else:
out.append(""" -1 - | """)
if qflags&2:
out.append(""" %u %s | """ % (slength,decimal_number(slength),humanize_number(slength," ")))
else:
out.append(""" -1 - | """)
if qflags&4:
out.append(""" %u %s | """ % (ssize,decimal_number(ssize),humanize_number(ssize," ")))
else:
out.append(""" -1 - | """)
if qflags&8:
out.append(""" %u %s | """ % (srealsize,decimal_number(srealsize),humanize_number(srealsize," ")))
else:
out.append(""" -1 - | """)
if qflags&16:
out.append(""" %u | """ % (hinodes))
else:
out.append(""" -1 - | """)
if qflags&32:
out.append(""" %u %s | """ % (hlength,decimal_number(hlength),humanize_number(hlength," ")))
else:
out.append(""" -1 - | """)
if qflags&64:
out.append(""" %u %s | """ % (hsize,decimal_number(hsize),humanize_number(hsize," ")))
else:
out.append(""" -1 - | """)
if qflags&128:
out.append(""" %u %s | """ % (hrealsize,decimal_number(hrealsize),humanize_number(hrealsize," ")))
else:
out.append(""" -1 - | """)
out.append(""" %u | """ % cinodes)
if qflags&1:
if sinodes>0:
if sinodes>=cinodes:
cl="NOTEXCEEDED"
elif timetoblock>0:
cl="SEXCEEDED"
else:
cl="EXCEEDED"
out.append(""" %.2f | """ % (cl,(100.0*cinodes)/sinodes))
else:
out.append(""" %.2f inf | """ % (maxperc))
else:
out.append(""" -1 - | """)
if qflags&16:
if hinodes>0:
if hinodes>cinodes:
cl="NOTEXCEEDED"
else:
cl="EXCEEDED"
out.append(""" %.2f | """ % (cl,(100.0*cinodes)/hinodes))
else:
out.append(""" %.2f inf | """ % (maxperc))
else:
out.append(""" -1 - | """)
out.append(""" %u %s | """ % (clength,decimal_number(clength),humanize_number(clength," ")))
if qflags&2:
if slength>0:
if slength>=clength:
cl="NOTEXCEEDED"
elif timetoblock>0:
cl="SEXCEEDED"
else:
cl="EXCEEDED"
out.append(""" %.2f | """ % (cl,(100.0*clength)/slength))
else:
out.append(""" %.2f inf | """ % (maxperc))
else:
out.append(""" -1 - | """)
if qflags&32:
if hlength>0:
if hlength>clength:
cl="NOTEXCEEDED"
else:
cl="EXCEEDED"
out.append(""" %.2f | """ % (cl,(100.0*clength)/hlength))
else:
out.append(""" %.2f inf | """ % (maxperc))
else:
out.append(""" -1 - | """)
out.append(""" %u %s | """ % (csize,decimal_number(csize),humanize_number(csize," ")))
if qflags&4:
if ssize>0:
if ssize>=csize:
cl="NOTEXCEEDED"
elif timetoblock>0:
cl="SEXCEEDED"
else:
cl="EXCEEDED"
out.append(""" %.2f | """ % (cl,(100.0*csize)/ssize))
else:
out.append(""" %.2f inf | """ % (maxperc))
else:
out.append(""" -1 - | """)
if qflags&64:
if hsize>0:
if hsize>csize:
cl="NOTEXCEEDED"
else:
cl="EXCEEDED"
out.append(""" %.2f | """ % (cl,(100.0*csize)/hsize))
else:
out.append(""" %.2f inf | """ % (maxperc))
else:
out.append(""" -1 - | """)
out.append(""" %u %s | """ % (crealsize,decimal_number(crealsize),humanize_number(crealsize," ")))
if qflags&8:
if srealsize>0:
if srealsize>=crealsize:
cl="NOTEXCEEDED"
elif timetoblock>0:
cl="SEXCEEDED"
else:
cl="EXCEEDED"
out.append(""" %.2f | """ % (cl,(100.0*crealsize)/srealsize))
else:
out.append(""" %.2f inf | """ % (maxperc))
else:
out.append(""" -1 - | """)
if qflags&128:
if hrealsize>0:
if hrealsize>crealsize:
cl="NOTEXCEEDED"
else:
cl="EXCEEDED"
out.append(""" %.2f | """ % (cl,(100.0*crealsize)/hrealsize))
else:
out.append(""" %.2f inf | """ % (maxperc))
else:
out.append(""" -1 - | """)
out.append("""
""")
elif ttymode:
dline = [path] #,"yes" if exceeded else "no"]
if graceperiod>0:
dline.append(timeduration_to_shortstr(graceperiod))
else:
dline.append("default")
if timetoblock<0xFFFFFFFF:
if timetoblock>0:
dline.append((timeduration_to_shortstr(timetoblock),"2"))
else:
dline.append(("expired","1"))
else:
dline.append("-")
if qflags&1:
dline.append(sinodes)
else:
dline.append("-")
if qflags&2:
dline.append(humanize_number(slength," "))
else:
dline.append("-")
if qflags&4:
dline.append(humanize_number(ssize," "))
else:
dline.append("-")
if qflags&8:
dline.append(humanize_number(srealsize," "))
else:
dline.append("-")
if qflags&16:
dline.append(hinodes)
else:
dline.append("-")
if qflags&32:
dline.append(humanize_number(hlength," "))
else:
dline.append("-")
if qflags&64:
dline.append(humanize_number(hsize," "))
else:
dline.append("-")
if qflags&128:
dline.append(humanize_number(hrealsize," "))
else:
dline.append("-")
dline.append(cinodes)
if qflags&1:
if sinodes>0:
dline.append(("%.2f" % ((100.0*cinodes)/sinodes),"4" if sinodes>=cinodes else "2" if timetoblock>0 else "1"))
else:
dline.append(("inf","1"))
else:
dline.append("-")
if qflags&16:
if hinodes>0:
dline.append(("%.2f" % ((100.0*cinodes)/hinodes),"4" if hinodes>cinodes else "1"))
else:
dline.append(("inf","1"))
else:
dline.append("-")
dline.append(humanize_number(clength," "))
if qflags&2:
if slength>0:
dline.append(("%.2f" % ((100.0*clength)/slength),"4" if slength>=clength else "2" if timetoblock>0 else "1"))
else:
dline.append(("inf","1"))
else:
dline.append("-")
if qflags&32:
if hlength>0:
dline.append(("%.2f" % ((100.0*clength)/hlength),"4" if hlength>clength else "1"))
else:
dline.append(("inf","1"))
else:
dline.append("-")
dline.append(humanize_number(csize," "))
if qflags&4:
if ssize>0:
dline.append(("%.2f" % ((100.0*csize)/ssize),"4" if ssize>=csize else "2" if timetoblock>0 else "1"))
else:
dline.append(("inf","1"))
else:
dline.append("-")
if qflags&64:
if hsize>0:
dline.append(("%.2f" % ((100.0*csize)/hsize),"4" if hsize>csize else "1"))
else:
dline.append(("inf","1"))
else:
dline.append("-")
dline.append(humanize_number(crealsize," "))
if qflags&8:
if srealsize>0:
dline.append(("%.2f" % ((100.0*crealsize)/srealsize),"4" if srealsize>=crealsize else "2" if timetoblock>0 else "1"))
else:
dline.append(("inf","1"))
else:
dline.append("-")
if qflags&128:
if hrealsize>0:
dline.append(("%.2f" % ((100.0*crealsize)/hrealsize),"4" if hrealsize>crealsize else "1"))
else:
dline.append(("inf","1"))
else:
dline.append("-")
tab.append(*dline)
else:
dline = [path,"yes" if exceeded else "no"]
if graceperiod>0:
dline.append(graceperiod)
else:
dline.append("default")
if timetoblock<0xFFFFFFFF:
if timetoblock>0:
dline.append(timetoblock)
else:
dline.append("expired")
else:
dline.append("-")
dline.append(sinodes if qflags&1 else "-")
dline.append(slength if qflags&2 else "-")
dline.append(ssize if qflags&4 else "-")
dline.append(srealsize if qflags&8 else "-")
dline.append(hinodes if qflags&16 else "-")
dline.append(hlength if qflags&32 else "-")
dline.append(hsize if qflags&64 else "-")
dline.append(hrealsize if qflags&128 else "-")
dline.extend((cinodes,clength,csize,crealsize))
tab.append(*dline)
if cgimode:
out.append("""
""")
print("\n".join(out))
else:
print(myunicode(tab))
except Exception:
print_exception()
if "MC" in sectionset:
out = []
try:
if cgimode:
charts = (
(100,'cpu','cpu usage (percent)'),
(101,'memory','memory usage (if available - rss + virt)'),
(102,'space','raw disk space usage (total / used)'),
(103,'dels','chunk deletions per minute (successful/unsuccessful)'),
(104,'repl','chunk replications per minute (successful/unsuccessful)'),
(105,'creat','chunk creations per minute (successful/unsuccessful)'),
(106,'change','chunk internal operations per minute (successful/unsuccessful)'),
(4,'statfs','statfs operations (per minute)'),
(5,'getattr','getattr operations (per minute)'),
(6,'setattr','setattr operations (per minute)'),
(7,'lookup','lookup operations (per minute)'),
(8,'mkdir','mkdir operations (per minute)'),
(9,'rmdir','rmdir operations (per minute)'),
(10,'symlink','symlink operations (per minute)'),
(11,'readlink','readlink operations (per minute)'),
(12,'mknod','mknod operations (per minute)'),
(13,'unlink','unlink operations (per minute)'),
(14,'rename','rename operations (per minute)'),
(15,'link','link operations (per minute)'),
(16,'readdir','readdir operations (per minute)'),
(17,'open','open operations (per minute)'),
(18,'read','read operations (per minute)'),
(19,'write','write operations (per minute)'),
(21,'prcvd','packets received (per second)'),
(22,'psent','packets sent (per second)'),
(23,'brcvd','bits received (per second)'),
(24,'bsent','bits sent (per second)')
)
if MCdata=="" and leaderfound:
MCdata="%s:%u:%u" % (masterconn.host,masterconn.port,1 if masterconn.version_at_least(2,0,0) else 0)
servers = []
mixedservers = 0
if len(masterlistver)>0:
masterlistver.sort()
out.append("""""")
mchtmp = MCdata.split(":")
if len(mchtmp)==2:
mchtmp = (mchtmp[0],mchtmp[1],0)
if len(mchtmp)==3:
mahost = mchtmp[0]
maport = mchtmp[1]
manc = int(mchtmp[2])
out.append("""""")
out.append("""""")
out.append("""""")
out.append(""" """)
out.append(""" | short range | """)
out.append(""" medium range | """)
out.append(""" long range | """)
out.append(""" very long range | """)
out.append("""
""")
for id,name,desc in charts:
divclass = "CHARTDYNAMIC" if manc else "CHARTSTATIC"
divclick = 'onclick="ma_zoom(this)"' if manc else ""
out.append(""" """)
out.append(""" | """)
out.append(""" """ % (divclass,name,divclick))
out.append(""" %s""" % desc)
out.append(""" """)
out.append(""" | """)
out.append("""
""")
out.append("""
""")
out.append("""""")
elif len(mchtmp)==1 and len(MCdata)>0:
chid = 0
for id,name,desc in charts:
if name==MCdata:
chid = id
if chid==0:
try:
chid = int(MCdata)
except Exception:
pass
if chid>0 and chid<1000:
out.append("""""")
out.append("""""")
out.append("""""")
out.append(""" """)
out.append(""" | short range | """)
out.append(""" medium range | """)
out.append(""" long range | """)
out.append(""" very long range | """)
out.append("""
""")
for mahost,maport,name,desc,manc in servers:
divclass = "CHARTDYNAMIC" if manc else "CHARTSTATICMIXED" if mixedservers==3 else "CHARTSTATIC"
divclick = 'onclick="ma_zoom(this)"' if manc else ""
out.append(""" """)
out.append(""" | """)
out.append(""" """ % (divclass,name,divclick))
out.append(""" %s""" % desc)
out.append(""" """)
out.append(""" | """)
out.append("""
""")
out.append("""
""")
else:
if masterconn.version_at_least(2,0,15):
if ttymode:
tab = Tabble("Master chart data",len(MCchdata)+1,"r")
hdrstr = ["host/port ->"]
for host,port,no,mode,desc,raw in MCchdata:
if (host==None or port==None):
hdrstr.append("leader")
else:
hdrstr.append("%s:%s" % (host,port))
tab.header(*hdrstr)
tab.header(("---","",len(MCchdata)+1))
hdrstr = ["Time"]
for host,port,no,mode,desc,raw in MCchdata:
if raw:
if (no==0 or no==1 or no==100):
hdrstr.append("%s (+)" % desc)
else:
hdrstr.append("%s (raw)" % desc)
else:
hdrstr.append(desc)
tab.header(*hdrstr)
else:
tab = Tabble("Master chart data",len(MCchdata)+1)
chrange = MCrange
if chrange<0 or chrange>3:
chrange = 0
if MCcount<0 or MCcount>4095:
MCcount = 4095
chrangestep = [60,360,1800,86400][chrange]
series = set()
for host,port,no,mode,desc,raw in MCchdata:
if no==100:
series.add((host,port,0))
series.add((host,port,1))
else:
series.add((host,port,no))
for gpass in (1,2):
MCresult = {}
timestamp = 0
entries = 0
repeat = 0
for host,port,x in series:
if host==None or port==None:
data,length = masterconn.command(CLTOAN_CHART_DATA,ANTOCL_CHART_DATA,struct.pack(">LL",x*10+chrange,MCcount))
else:
conn = MFSConn(host,port)
data,length = conn.command(CLTOAN_CHART_DATA,ANTOCL_CHART_DATA,struct.pack(">LL",x*10+chrange,MCcount))
if length>=8:
ts,e = struct.unpack(">LL",data[:8])
if e*8+8==length and (entries==0 or entries==e):
entries = e
if timestamp==0 or timestamp==ts or gpass==2:
timestamp=ts
MCresult[(host,port,x)] = list(struct.unpack(">"+e*"Q",data[8:]))
else:
repeat = 1
break
else:
MCresult[(host,port,x)]=None
else:
MCresult[(host,port,x)]=None
if repeat:
continue
else:
break
for e in xrange(entries):
ts = timestamp-chrangestep*e
timestring = time.strftime("%Y-%m-%d %H:%M",time.gmtime(ts))
dline = [timestring]
for host,port,no,mode,desc,raw in MCchdata:
if no==100:
datalist1 = MCresult[(host,port,0)]
datalist2 = MCresult[(host,port,1)]
if (datalist1!=None and datalist2!=None and datalist1[e]<((2**64)-1) and datalist2[e]<((2**64)-1)):
data = datalist1[e]+datalist2[e]
else:
data = None
else:
datalist = MCresult[(host,port,no)]
if datalist!=None and datalist[e]<((2**64)-1):
data = datalist[e]
else:
data = None
if data==None:
dline.append("-")
elif mode==0:
cpu = (data/(10000.0*chrangestep))
if raw:
dline.append("%.8f%%" % (cpu))
else:
dline.append("%.2f%%" % (cpu))
elif mode==1:
if raw:
dline.append("%u" % data)
else:
data = float(data)/float(chrangestep)
dline.append("%.3f/s" % data)
elif mode==2:
if raw:
dline.append("%u" % data)
else:
dline.append("%s" % humanize_number(data," "))
tab.append(*dline)
else:
tab = Tabble("Master chart data are not supported in your version of MFS - please upgrade",1,"r")
if cgimode:
print("\n".join(out))
else:
print(myunicode(tab))
except Exception:
print_exception()
if "CC" in sectionset:
out = []
try:
if cgimode:
# get cs list
hostlist = []
for cs in dataprovider.get_chunkservers():
if (cs.flags&1)==0:
hostlist.append((cs.ip,cs.port,cs.version))
# data,length = masterconn.command(CLTOMA_CSERV_LIST,MATOCL_CSERV_LIST)
# if masterconn.version_at_least(1,7,25) and (length%64)==0:
# n = length//64
# servers = []
# for i in range(n):
# d = data[i*64:(i+1)*64]
# flags,v1,v2,v3,ip1,ip2,ip3,ip4,port = struct.unpack(">BBBBBBBBH",d[:10])
# if (flags&1)==0:
# hostlist.append(((ip1,ip2,ip3,ip4),port,(v1,v2,v3)))
# elif masterconn.version_at_least(1,6,28) and masterconn.version_less_than(1,7,25) and (length%62)==0:
# n = length//62
# servers = []
# for i in range(n):
# d = data[i*62:(i+1)*62]
# disconnected,v1,v2,v3,ip1,ip2,ip3,ip4,port = struct.unpack(">BBBBBBBBH",d[:10])
# if disconnected==0:
# hostlist.append(((ip1,ip2,ip3,ip4),port,(v1,v2,v3)))
# elif masterconn.version_less_than(1,6,28) and (length%54)==0:
# n = length//54
# servers = []
# for i in range(n):
# d = data[i*54:(i+1)*54]
# disconnected,v1,v2,v3,ip1,ip2,ip3,ip4,port = struct.unpack(">BBBBBBBBH",d[:10])
# if disconnected==0:
# hostlist.append(((ip1,ip2,ip3,ip4),port,(v1,v2,v3)))
charts = (
(100,'cpu','cpu usage (percent)'),
(107,'memory','memory usage (if available - rss + virt)'),
(101,'datain','traffic from clients and other chunkservers (bits/s - main server + replicator)'),
(102,'dataout','traffic to clients and other chunkservers (bits/s - main server + replicator)'),
(103,'bytesr','bytes read - data/other (bytes/s)'),
(104,'bytesw','bytes written - data/other (bytes/s)'),
(2,'masterin','traffic from master (bits/s)'),
(3,'masterout','traffic to master (bits/s)'),
(105,'hddopr','number of low-level read operations per minute'),
(106,'hddopw','number of low-level write operations per minute'),
(16,'hlopr','number of high-level read operations per minute'),
(17,'hlopw','number of high-level write operations per minute'),
(18,'rtime','time of data read operations'),
(19,'wtime','time of data write operations'),
(20,'repl','number of chunk replications per minute'),
(21,'create','number of chunk creations per minute'),
(22,'delete','number of chunk deletions per minute'),
(33,'change','number of chunk internal operations (duplicate,truncate,etc.) per minute'),
(108,'move','number of chunk internal rebalances per minute (low speed + high speed)'),
(28,'load','load - max operations in queue'),
)
servers = []
mixedservers = 0
if len(hostlist)>0:
hostlist.sort()
out.append("""""")
cchtmp = CCdata.split(":")
if len(cchtmp)==2:
cchtmp = (cchtmp[0],cchtmp[1],0)
if len(cchtmp)==3:
cshost = cchtmp[0]
csport = cchtmp[1]
csnc = int(cchtmp[2])
out.append("""""")
out.append("""""")
out.append("""""")
out.append(""" """)
out.append(""" | short range | """)
out.append(""" medium range | """)
out.append(""" long range | """)
out.append(""" very long range | """)
out.append("""
""")
for id,name,desc in charts:
divclass = "CHARTDYNAMIC" if csnc else "CHARTSTATIC"
divclick = 'onclick="cs_zoom(this)"' if csnc else ""
out.append(""" """)
out.append(""" | """)
out.append(""" """ % (divclass,name,divclick))
out.append(""" %s""" % desc)
out.append(""" """)
out.append(""" | """)
out.append("""
""")
out.append("""
""")
out.append("""""")
elif len(cchtmp)==1 and len(CCdata)>0:
chid = 0
for id,name,desc in charts:
if name==CCdata:
chid = id
if chid==0:
try:
chid = int(CCdata)
except Exception:
pass
if chid>0 and chid<1000:
out.append("""""")
out.append("""""")
out.append("""""")
out.append(""" """)
out.append(""" | short range | """)
out.append(""" medium range | """)
out.append(""" long range | """)
out.append(""" very long range | """)
out.append("""
""")
for cshost,csport,name,desc,csnc in servers:
divclass = "CHARTDYNAMIC" if csnc else "CHARTSTATICMIXED" if mixedservers==3 else "CHARTSTATIC"
divclick = 'onclick="cs_zoom(this)"' if csnc else ""
out.append(""" """)
out.append(""" | """)
out.append(""" """ % (divclass,name,divclick))
out.append(""" %s""" % desc)
out.append(""" """)
out.append(""" | """)
out.append("""
""")
out.append("""
""")
else:
if masterconn.version_at_least(2,0,15):
if ttymode:
tab = Tabble("Chunkserver chart data",len(CCchdata)+1,"r")
hdrstr = ["host/port ->"]
for host,port,no,mode,desc,raw in CCchdata:
hdrstr.append("%s:%s" % (host,port))
tab.header(*hdrstr)
tab.header(("---","",len(CCchdata)+1))
hdrstr = ["Time"]
for host,port,no,mode,desc,raw in CCchdata:
if raw:
if mode==0:
hdrstr.append("%s (+)" % desc)
else:
hdrstr.append("%s (raw)" % desc)
else:
hdrstr.append(desc)
tab.header(*hdrstr)
else:
tab = Tabble("Chunkserver chart data",len(CCchdata)+1)
chrange = CCrange
if chrange<0 or chrange>3:
chrange = 0
if CCcount<0 or CCcount>4095:
CCcount = 4095
chrangestep = [60,360,1800,86400][chrange]
series = set()
for host,port,no,mode,desc,raw in CCchdata:
if no==100:
series.add((host,port,0))
series.add((host,port,1))
else:
series.add((host,port,no))
for gpass in (1,2):
CCresult = {}
timestamp = 0
entries = 0
repeat = 0
for host,port,x in series:
conn = MFSConn(host,port)
data,length = conn.command(CLTOAN_CHART_DATA,ANTOCL_CHART_DATA,struct.pack(">LL",x*10+chrange,CCcount))
if length>=8:
ts,e = struct.unpack(">LL",data[:8])
if e*8+8==length and (entries==0 or entries==e):
entries = e
if timestamp==0 or timestamp==ts or gpass==2:
timestamp=ts
CCresult[(host,port,x)] = list(struct.unpack(">"+e*"Q",data[8:]))
else:
repeat = 1
break
else:
CCresult[(host,port,x)]=None
else:
CCresult[(host,port,x)]=None
if repeat:
continue
else:
break
for e in xrange(entries):
ts = timestamp-chrangestep*e
timestring = time.strftime("%Y-%m-%d %H:%M",time.gmtime(ts))
dline = [timestring]
for host,port,no,mode,desc,raw in CCchdata:
if no==100:
datalist1 = CCresult[(host,port,0)]
datalist2 = CCresult[(host,port,1)]
if (datalist1!=None and datalist2!=None):
data = datalist1[e]+datalist2[e]
else:
data = None
else:
datalist = CCresult[(host,port,no)]
if datalist!=None:
data = datalist[e]
else:
data = None
if data==None:
dline.append("-")
elif mode==0:
cpu = (data/(10000.0*chrangestep))
if raw:
dline.append("%.8f%%" % (cpu))
else:
dline.append("%.2f%%" % (cpu))
elif mode==1:
if raw:
dline.append("%u" % data)
else:
data = float(data)/float(chrangestep)
dline.append("%.3f/s" % data)
elif mode==2:
if raw:
dline.append("%u" % data)
else:
dline.append("%s" % humanize_number(data," "))
elif mode==3:
dline.append("%u threads" % data)
elif mode==4:
if raw:
dline.append("%u" % data)
else:
data = float(data)/float(chrangestep)
data /= 10000000.0
dline.append("%.2f%%" % (data))
elif mode==5:
if raw:
dline.append("%u" % data)
else:
data = float(data)/float(chrangestep)
dline.append("%.3fMB/s" % (data/(1024.0*1024.0)))
tab.append(*dline)
else:
tab = Tabble("Chunkserver chart data are not supported in your version of MFS - please upgrade",1,"r")
if cgimode:
print("\n".join(out))
else:
print(myunicode(tab))
except Exception:
print_exception()
if cgimode:
print(""" """)
print("""""")
print("""""")
