#!/usr/bin/env python3

# Copyright (C) 2025 Jakub Kruszona-Zawadzki, Saglabs SA
# 
# This file is part of MooseFS.
# 
# MooseFS is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, version 2 (only).
# 
# MooseFS is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
# 
# You should have received a copy of the GNU General Public License
# along with MooseFS; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02111-1301, USA
# or visit http://www.gnu.org/licenses/gpl-2.0.html

import os
import sys

if sys.version_info[0]<3 or (sys.version_info[0]==3 and sys.version_info[1]<4):
	print("Unsupported python version, minimum required version is 3.4")
	sys.exit(1)

import struct
import time
import traceback
import codecs
import json
import getopt

### from common.constants_ac import * # MFS_INLINE_IMPORT - inlined below:
### Imported inline from common/constants_ac.py:
VERSION = "4.57.7"

PROTO_BASE = 0

DEFAULT_MASTERNAME          = "mfsmaster"
DEFAULT_MASTER_CLIENT_PORT  = 9421
DEFAULT_MASTER_CONTROL_PORT = 9419

BIN_PATH = "/usr/bin"

### End of inline import from common/constants_ac.py

### from common.constants import *    # MFS_INLINE_IMPORT - inlined below:
### Imported inline from common/constants.py:
try:
    from common.constants_ac import *
except:
	pass # imports may be unaccessible in a single mfscli file but they should be already inlined instead

# some constants from MFSCommunication.h
ANTOAN_NOP = 0

ANTOCS_CLEAR_ERRORS        = (PROTO_BASE+306)
CSTOAN_CLEAR_ERRORS        = (PROTO_BASE+307)

CLTOMA_CSERV_LIST          = (PROTO_BASE+500)
MATOCL_CSERV_LIST          = (PROTO_BASE+501)
CLTOAN_CHART_DATA          = (PROTO_BASE+506)
ANTOCL_CHART_DATA          = (PROTO_BASE+507)
CLTOMA_SESSION_LIST        = (PROTO_BASE+508)
MATOCL_SESSION_LIST        = (PROTO_BASE+509)
CLTOMA_INFO                = (PROTO_BASE+510)
MATOCL_INFO                = (PROTO_BASE+511)
CLTOMA_FSTEST_INFO         = (PROTO_BASE+512)
MATOCL_FSTEST_INFO         = (PROTO_BASE+513)
CLTOMA_CHUNKSTEST_INFO     = (PROTO_BASE+514)
MATOCL_CHUNKSTEST_INFO     = (PROTO_BASE+515)
CLTOMA_CHUNKS_MATRIX       = (PROTO_BASE+516)
MATOCL_CHUNKS_MATRIX       = (PROTO_BASE+517)
CLTOMA_QUOTA_INFO          = (PROTO_BASE+518)
MATOCL_QUOTA_INFO          = (PROTO_BASE+519)
CLTOMA_EXPORTS_INFO        = (PROTO_BASE+520)
MATOCL_EXPORTS_INFO        = (PROTO_BASE+521)
CLTOMA_MLOG_LIST           = (PROTO_BASE+522)
MATOCL_MLOG_LIST           = (PROTO_BASE+523)
CLTOMA_CSSERV_COMMAND      = (PROTO_BASE+524)
MATOCL_CSSERV_COMMAND      = (PROTO_BASE+525)
CLTOMA_SESSION_COMMAND     = (PROTO_BASE+526)
MATOCL_SESSION_COMMAND     = (PROTO_BASE+527)
CLTOMA_MEMORY_INFO         = (PROTO_BASE+528)
MATOCL_MEMORY_INFO         = (PROTO_BASE+529)
CLTOMA_LIST_OPEN_FILES     = (PROTO_BASE+532)
MATOCL_LIST_OPEN_FILES     = (PROTO_BASE+533)
CLTOMA_LIST_ACQUIRED_LOCKS = (PROTO_BASE+534)
MATOCL_LIST_ACQUIRED_LOCKS = (PROTO_BASE+535)
CLTOMA_MASS_RESOLVE_PATHS  = (PROTO_BASE+536)
MATOCL_MASS_RESOLVE_PATHS  = (PROTO_BASE+537)
CLTOMA_SCLASS_INFO         = (PROTO_BASE+542)
MATOCL_SCLASS_INFO         = (PROTO_BASE+543)
CLTOMA_MISSING_CHUNKS      = (PROTO_BASE+544)
MATOCL_MISSING_CHUNKS      = (PROTO_BASE+545)
CLTOMA_PATTERN_INFO        = (PROTO_BASE+548)
MATOCL_PATTERN_INFO        = (PROTO_BASE+549)
CLTOMA_INSTANCE_NAME       = (PROTO_BASE+550)
MATOCL_INSTANCE_NAME       = (PROTO_BASE+551)

CLTOCS_HDD_LIST            = (PROTO_BASE+600)
CSTOCL_HDD_LIST            = (PROTO_BASE+601)
MFS_MESSAGE = 1

FEATURE_EXPORT_UMASK        = 0
FEATURE_EXPORT_DISABLES     = 1
FEATURE_SESSION_STATS_28    = 2
FEATURE_INSTANCE_NAME       = 4
FEATURE_CSLIST_MODE         = 5
FEATURE_SCLASS_IN_MATRIX    = 7
FEATURE_DEFAULT_GRACEPERIOD = 8
FEATURE_LABELMODE_OVERRIDES = 9
FEATURE_SCLASSGROUPS        = 10

MASKORGROUP = 4
SCLASS_EXPR_MAX_SIZE = 128

MFS_CSSERV_COMMAND_REMOVE         = 0
MFS_CSSERV_COMMAND_BACKTOWORK     = 1
MFS_CSSERV_COMMAND_MAINTENANCEON  = 2
MFS_CSSERV_COMMAND_MAINTENANCEOFF = 3
MFS_CSSERV_COMMAND_TMPREMOVE      = 4

MFS_SESSION_COMMAND_REMOVE = 0

PATTERN_EUGID_ANY            = 0xFFFFFFFF
PATTERN_OMASK_SCLASS         = 0x01
PATTERN_OMASK_TRASHRETENTION = 0x02
PATTERN_OMASK_EATTR          = 0x04

SCLASS_ARCH_MODE_CTIME      = 0x01
SCLASS_ARCH_MODE_MTIME      = 0x02
SCLASS_ARCH_MODE_ATIME      = 0x04
SCLASS_ARCH_MODE_REVERSIBLE = 0x08
SCLASS_ARCH_MODE_FAST       = 0x10
SCLASS_ARCH_MODE_CHUNK      = 0x20

STATUS_OK      = 0
ERROR_NOTFOUND = 41
ERROR_ACTIVE   = 42

STATE_UNREACHABLE = 0xFFFF
STATE_DUMMY       = 0x00
STATE_LEADER      = 0x01
STATE_ELECT       = 0x02
STATE_FOLLOWER    = 0x03
STATE_USURPER     = 0x04
STATE_DEPUTY      = 0x05
STATE_MASTERCE    = 0xFF
STATE_STR_UNREACHABLE = "UNREACHABLE"
STATE_STR_BUSY        = "BUSY"

#CSTOCL_HDD_LIST flags constants
CS_HDD_MFR      = 0x01
CS_HDD_DAMAGED  = 0x02
CS_HDD_SCANNING = 0x04
CS_HDD_INVALID  = 0x08

MFRSTATUS_VALIDATING = 0 # unknown after disconnect or creation or unknown, loop in progress
MFRSTATUS_INPROGRESS = 1 # chunks still needs to be replicated, can't be removed 
MFRSTATUS_READY      = 2 # can be removed, whole loop has passed

CS_HDD_CS_VALID       = 0 #valid hdd data from CS
CS_HDD_CS_TOO_OLD     = 1 #too old CS to get info on its discs
CS_HDD_CS_UNREACHABLE = 2 #can't connect to CS and get info on its discs

CS_LOAD_NORMAL	       = 0
CS_LOAD_OVERLOADED     = 1
CS_LOAD_REBALANCE      = 2
CS_LOAD_FAST_REBALANCE = 3
CS_LOAD_GRACEFUL       = 4

LASTSTORE_UNKNOWN		 = 0 # if laststore_ts==0
LASTSTORE_META_STORED_BG = 0 # Stored in background if laststore_ts>0
LASTSTORE_DOWNLOADED     = 1 # Downloaded
LASTSTORE_META_STORED_FG = 2 # Stored in foreground
LASTSTORE_CRC_STORED_BG  = 3 # CRC stored in background

MISSING_CHUNK_TYPE_NOCOPY         = 0
MISSING_CHUNK_TYPE_INVALID_COPIES = 1
MISSING_CHUNK_TYPE_WRONG_VERSIONS = 2
MISSING_CHUNK_TYPE_PARTIAL_EC     = 3

FSTEST_INFO_STR_LIMIT = 100000 # 100k limit of datastr in MATOCL_FSTEST_INFO

UNRESOLVED = "(unresolved)"

TRESHOLD_WARNING = 0.90
TRESHOLD_ERROR   = 0.95

LICVER_CE = -1 # Community Edition licver value

AJAX_NONE      = None
AJAX_CONTAINER = 1
AJAX_METRICS   = 2

# Chunk matrix summary colums
MX_COL_MISSING       = 0
MX_COL_ENDANGERED    = 1
MX_COL_UNDERGOAL     = 2
MX_COL_STABLE        = 3
MX_COL_OVERGOAL      = 4
MX_COL_DELETEPENDING = 5
MX_COL_DELETEREADY   = 6
MX_COL_TOTAL         = 7

MFS_LOCK_TYPE_UNKNOWN   = 0
MFS_LOCK_TYPE_SHARED		= 1
MFS_LOCK_TYPE_EXCLUSIVE	= 2
### End of inline import from common/constants.py

### from common.errors import *       # MFS_INLINE_IMPORT - inlined below:
### Imported inline from common/errors.py:
class MFSCommunicationError(RuntimeError):
	def __init__(self, message=""):
		super().__init__("MooseFS communication error" + (": " + message if message else ""))

### End of inline import from common/errors.py

### from common.utils import *        # MFS_INLINE_IMPORT - inlined below:
### Imported inline from common/utils.py:
import socket 
import struct
import time
from datetime import datetime

try:
	from common.constants import *
	from common.errors import *
except:
	pass # imports may be unaccessible in a single mfscli file but they should be already inlined instead

UNIQ_MASK_IP = 1 << (1+ord('Z')-ord('A'))
UNIQ_MASK_RACK = 1 << (2+ord('Z')-ord('A'))

def myunicode(x):
	return str(x)

def gettzoff(t):
	return time.localtime(t).tm_gmtoff

def shiftts(t):
	return t - gettzoff(t)

def safe_int(val, default=0):
	try:
		return int(val)
	except Exception:
		return default
	
def resolve(strip, donotresolve=0, default=None):
    if donotresolve:
        return strip
    try:
        return (socket.gethostbyaddr(strip))[0]
    except Exception:
        if default is not None:
            return default
        else:
            return strip
	
def decimal_number(number,sep=' '):
	parts = []
	while number>=1000:
		number,rest = divmod(number,1000)
		parts.append("%03u" % rest)
	parts.append(str(number))
	parts.reverse()
	return sep.join(parts)

def decimal_number_html(number):
	return decimal_number(number,"&#8239;")

# returns decimal number with non-breaking space as separator or 'n/a' if number is None
def decimal_number_na_html(number):
	if number is None:
		return 'n/a'
	return decimal_number(number,"&#8239;")


def humanize_number(number,sep='',suff='B'):
	number*=100
	scale=0
	while number>=99950:
		number = number//1024
		scale+=1
	if number<995 and scale>0:
		b = (number+5)//10
		nstr = "%u.%u" % divmod(b,10)
	else:
		b = (number+50)//100
		nstr = "%u" % b
	if scale>0:
		return "%s%s%si%s" % (nstr,sep,"-KMGTPEZY"[scale],suff)
	else:
		return "%s%s%s" % (nstr,sep,suff)

# return ordinal suffix for a number
def ordinal_suffix(i):
	if i%100 in (11,12,13):
		return "th"
	elif i%10==1:
		return "st"
	elif i%10==2:
		return "nd"
	elif i%10==3:
		return "rd"
	else:
		return "th"

def timeduration_to_shortstr(timeduration, sep=''):
	for l,s in ((604800,'w'),(86400,'d'),(3600,'h'),(60,'m'),(0,'s')):
		if timeduration>=l:
			if l>0:
				n = float(timeduration)/float(l)
			else:
				n = float(timeduration)
			rn = round(n,1)
			if n==round(n,0):
				return "%.0f%s%s" % (n,sep,s)
			else:
				return "%s%.1f%s%s" % (("~"+sep if n!=rn else ""),rn,sep,s)
	return "???"

def timeduration_to_fullstr(timeduration):
	if timeduration>=86400:
		days,dayseconds = divmod(timeduration,86400)
		daysstr = "%u day%s + " % (days,("s" if days!=1 else ""))
	else:
		dayseconds = timeduration
		daysstr = ""
	hours,hourseconds = divmod(dayseconds,3600)
	minutes,seconds = divmod(hourseconds,60)
	if seconds==round(seconds,0):
		return "%u second%s (%s%u:%02u:%02u)" % (timeduration,("" if timeduration==1 else "s"),daysstr,hours,minutes,seconds)
	else:
		seconds,fracsec = divmod(seconds,1)
		return "%.3f seconds (%s%u:%02u:%02u.%03u)" % (timeduration,daysstr,hours,minutes,seconds,round(1000*fracsec,0))

def hours_to_str(hours, sep=''):
	days,hoursinday = divmod(hours,24)
	if days>0 and hours!=24:
		if hoursinday>0:
			return "%u%sd %u%sh" % (days,sep,hoursinday,sep)
		else:
			return "%u%sd" % (days,sep)
	else:
		return "%u%sh" % (hours,sep)

def datetime_to_str(tm):
	return time.strftime("%Y-%m-%d %H:%M:%S",time.localtime(tm))

def date_to_str(tm):
	return time.strftime("%Y-%m-%d",time.localtime(tm))

def time_to_str(tm):
	return time.strftime("%H:%M:%S",time.localtime(tm))

def seconds_since_beginning_of_hour():
	now = datetime.now()  # Get the current date and time
	start_of_hour = now.replace(minute=0, second=0, microsecond=0)  # Set minutes, seconds, and microseconds to 0
	seconds_since = (now - start_of_hour).total_seconds()  # Calculate the difference in seconds
	return int(seconds_since)  # Return the result as an integer

def label_id_to_char(id):
	return chr(ord('A')+id)

def state_name(stateid):
	if   stateid==STATE_DUMMY:    return "DUMMY"
	elif stateid==STATE_USURPER:  return "USURPER"
	elif stateid==STATE_FOLLOWER: return "FOLLOWER"
	elif stateid==STATE_ELECT:    return "ELECT"
	elif stateid==STATE_DEPUTY:   return "DEPUTY"
	elif stateid==STATE_LEADER:   return "LEADER"
	elif stateid==STATE_MASTERCE: return "MASTER"
	else:                         return "???"

def state_color(stateid,sync):
	if stateid==STATE_DUMMY:
		return 8
	elif stateid==STATE_FOLLOWER or stateid==STATE_USURPER:
		if sync:
			return 5
		else:
			return 6
	elif stateid==STATE_ELECT:
		return 3
	elif stateid==STATE_DEPUTY:
		return 2
	elif stateid==STATE_LEADER:
		return 4
	else:
		return 1

def labelmask_to_str(labelmask):
	str = ""
	m = 1
	for i in range(26):
		if labelmask & m:
			str += label_id_to_char(i)
		m <<= 1
	return str

def labelmasks_to_str(labelmasks):
	if labelmasks[0]==0:
		return "*"
	r = []
	for labelmask in labelmasks:
		if labelmask==0:
			break
		r.append(labelmask_to_str(labelmask))
	return "+".join(r)

def labelexpr_to_str(labelexpr, literals = ['*','&','|','~']):
	any = literals[0]
	andop = literals[1]
	orop = literals[2]
	notop = literals[3]
	stack = []
	if len(labelexpr)==0:
		return any
	if labelexpr[0]==0:
		return any              # '*' any label
	for i in labelexpr:
		if i==255:
			stack.append((0,any)) # '*' any label
		elif i>=192 and i<255:
			n = (i-192)
			stack.append((0,chr(ord('A')+n)))
		elif i>=128 and i<192:
			n = (i-128)+2
			if n>len(stack):
				return 'EXPR ERROR'
			m = []
			for _ in range(n):
				l,s = stack.pop()
				if l>1:
					m.append("(%s)" % s)
				else:
					m.append(s)
			m.reverse()
			stack.append((1,andop.join(m)))   # '&' and operator
		elif i>=64 and i<128:
			n = (i-64)+2
			if n>len(stack):
				return 'EXPR ERROR'
			m = []
			for _ in range(n):
				l,s = stack.pop()
				if l>2:
					m.append("(%s)" % s)
				else:
					m.append(s)
			m.reverse()
			stack.append((2,orop.join(m)))   # '|' or operator
		elif i==1:
			if len(stack)==0:
				return 'EXPR ERROR'
			l,s = stack.pop()
			if l>0:
				stack.append((0,notop+"(%s)" % s)) # '~' not operator
			else:
				stack.append((0,notop+"%s" % s))   # '~' not operator
		elif i==0:
			break
		else:
			return 'EXPR ERROR'
	if len(stack)!=1:
		return 'EXPR ERROR'
	l,s = stack.pop()
	return s

def labellist_fold(labellist):
	ll = []
	prev_data = None
	count = 0
	for data in labellist:
		if (data != prev_data):
			if count>0:
				if count>1:
					ll.append(('%u%s' % (count,prev_data[0]),prev_data[1],prev_data[2]))
				else:
					ll.append(prev_data)
			prev_data = data
			count = 1
		else:
			count = count+1
	if count>0:
		if count>1:
			ll.append(('%u%s' % (count,prev_data[0]),prev_data[1],prev_data[2]))
		else:
			ll.append(prev_data)
	return ll

def uniqmask_to_str(uniqmask):
	if uniqmask==0:
		return "-"
	if uniqmask & UNIQ_MASK_IP:
		return "[IP]"
	if uniqmask & UNIQ_MASK_RACK:
		return "[RACK]"
	rstr = ""
	inrange = 0
	for i in range(26):
		if uniqmask & (1<<i):
			if inrange==0:
				rstr += chr(ord('A')+i)
				if i<24 and ((uniqmask>>i)&7)==7:
					inrange = 1
		else:
			if inrange==1:
				rstr += '-'
				rstr += chr(ord('A')+(i-1))
				inrange = 0
	if inrange:
		rstr += '-'
		rstr += chr(ord('A')+25)
	return rstr

def eattr_to_str(seteattr,clreattr):
	eattrs = ["noowner","noattrcache","noentrycache","nodatacache","snapshot","undeletable","appendonly","immutable"]
	outlist = []
	mask = 1
	for eattrname in eattrs:
		if seteattr&mask:
			outlist.append("+%s" % eattrname)
		if clreattr&mask:
			outlist.append("-%s" % eattrname)
		mask = mask << 1
	if len(outlist)>0:
		return ",".join(outlist)
	else:
		return "-"

def get_string_from_packet(data,pos,err):
	rstr = ""
	shift = 0
	if 1+pos > len(data):
		err = 1;
	if err==0:
		shift = data[pos]
		if shift+1+pos > len(data):
			err = 1
		else:
			rstr = data[pos+1:pos+1+shift]
		rstr = rstr.decode('utf-8','replace')
	return (rstr,pos+shift+1,err)

def get_longstring_from_packet(data,pos,err):
	rstr = ""
	shift = 0
	if 2+pos > len(data):
		err = 1;
	if err==0:
		shift = data[pos]*256+data[pos+1]
		if shift+2+pos > len(data):
			err = 1
		else:
			rstr = data[pos+2:pos+2+shift]
		rstr = rstr.decode('utf-8','replace')
	return (rstr,pos+shift+2,err)

def version_convert(versionxyzp):
	if versionxyzp>=(4,0,0) and versionxyzp<(4,11,0):
		return (versionxyzp,0)
	elif versionxyzp>=(2,0,0):
		return ((versionxyzp[0],versionxyzp[1],versionxyzp[2]//2),versionxyzp[2]&1)
	elif versionxyzp>=(1,7,0):
		return (versionxyzp,1)
	elif versionxyzp>(0,0,0):
		return (versionxyzp,0)
	else:
		return (versionxyzp,-1)

def version_str_sort_pro(versionxyzp):
	versionxyz,pro = version_convert(versionxyzp)
	strver = "%u.%u.%u" % versionxyz
	sortver = "%05u_%03u_%03u" % versionxyz
	if pro==1:
		strver += " PRO"
		sortver += "_2"
	elif pro==0:
		sortver += "_1"
	else:
		sortver += "_0"
	if strver == '0.0.0':
		strver = ''
	return (strver,sortver,pro)

# converts reduncancy goal and actual to class and column number
# 0: missing, 1: endangered, 2: undergoal, 3: normal, 4: overgoal, 5: delete pending, 6: delete ready
def redundancy2colclass(goal,actual):
	if goal==0:
		if actual==0:
			clz = "DELETEREADY"
			col = MX_COL_DELETEREADY
		else:
			clz = "DELETEPENDING"
			col = MX_COL_DELETEPENDING
	elif actual==0:
		clz = "MISSING"
		col = MX_COL_MISSING
	elif actual>goal:
		clz = "OVERGOAL"
		col = MX_COL_OVERGOAL
	elif actual<goal:
		if actual==1:
			clz = "ENDANGERED"
			col = MX_COL_ENDANGERED
		else:
			clz = "UNDERGOAL"
			col = MX_COL_UNDERGOAL
	else:
		clz = "NORMAL"
		col = MX_COL_STABLE
	return (col,clz)

def disablesmask_to_string_list(disables_mask):
	cmds = ["chown","chmod","symlink","mkfifo","mkdev","mksock","mkdir","unlink","rmdir","rename","move","link","create","readdir","read","write","truncate","setlength","appendchunks","snapshot","settrash","setsclass","seteattr","setxattr","setfacl"]
	l = []
	m = 1
	for cmd in cmds:
		if disables_mask & m:
			l.append(cmd)
		m <<= 1
	return l

def disablesmask_to_string(disables_mask):
	return ",".join(disablesmask_to_string_list(disables_mask))




def charts_convert_data(datalist,mul,div,raw):
	res = []
	nodata = (2**64)-1
	for v in datalist:
		if v==nodata:
			res.append(None)
		else:
			if raw:
				res.append(v)
			else:
				res.append((v*mul)/div)
	return res

# Unpacks chart data from a given (ANTOCL_CHART_DATA) packet
def unpack_chart_packet(data,length):
	if length>=8:
		ranges,series,entries,perc,base = struct.unpack(">BBLBB",data[:8])
		if length==8+ranges*(13+series*entries*8):
			res = {}
			unpackstr = ">%uQ" % entries
			for r in range(ranges):
				rpos = 8 + r * (13+series*entries*8)
				rng,ts,mul,div = struct.unpack(">BLLL",data[rpos:rpos+13])
				rpos += 13
				if series>3:
					series=3
				l1 = None
				l2 = None
				l3 = None
				if series>=1:
					l1 = list(struct.unpack(unpackstr,data[rpos:rpos+entries*8]))
				if series>=2:
					l2 = list(struct.unpack(unpackstr,data[rpos+entries*8:rpos+2*entries*8]))
				if series>=3:
					l3 = list(struct.unpack(unpackstr,data[rpos+2*entries*8:rpos+3*entries*8]))
				res[rng] = (l1,l2,l3,ts,mul,div)
			return perc,base,res
		else:
			return None,None,None
	else:
		return None,None,None

# Handles a single chart data request (CLTOAN_CHART_DATA) to the given server (mfsconn)
def get_charts_multi_data(mfsconn,chartid,dataleng):
	data,length = mfsconn.command(CLTOAN_CHART_DATA,ANTOCL_CHART_DATA,struct.pack(">LLB",chartid,dataleng,1))
	return unpack_chart_packet(data,length)

# Handles multiple, concurrent chart data requests (CLTOAN_CHART_DATA) to many chunkservers at once
def get_charts_multi_data_async(mfsmulticonn,chartid_arr,dataleng):
	all_charts = {}
	dataout_arr = []
	for chartid in chartid_arr:
		dataout_arr.append(struct.pack(">LLB",chartid,dataleng,1))
	answers=mfsmulticonn.command(CLTOAN_CHART_DATA,ANTOCL_CHART_DATA,dataout_arr) #ask all registered chunkservers about chart data
	for hostkey in answers: # hostkey is string: 'ip:port'
		data_arr,length_arr = answers[hostkey]
		if len(chartid_arr)!=len(data_arr) or len(chartid_arr)!=len(length_arr):
			raise MFSCommunicationError("charts data length mismatch")
		for i in range(len(chartid_arr)):
			chartid = chartid_arr[i]
			data = data_arr[i]
			length = length_arr[i]
			perc,base,res = unpack_chart_packet(data,length)
			if perc!=None and base!=None and res!=None:
				chartkey = hostkey + ":" + str(chartid)
				all_charts[chartkey] = (perc,base,res)
	return all_charts

# Adjust chart data multiplication/division factors based on the base value
def adjust_muldiv(mul,div,base):
	base -= 2
	if base>0:
		mul = mul*(1000**base)
	if base<0:
		div = div*(1000**(-base))
	return mul,div

### End of inline import from common/utils.py

### from common.conn import *         # MFS_INLINE_IMPORT - inlined below:
### Imported inline from common/conn.py:
import asyncio 
import sys
import struct

try:
	from common.constants import *
	from common.utils import *
except:
	pass # imports may be unaccessible in a single mfscli file but they should be already inlined instead

# Handles multiple, concurrent commands to many servers at once
class MFSMultiConn:
	# Initializes class, sets timeout for a single task
	def __init__(self,timeout=5,addresses=[]):
		self.timeout = timeout
		self.addresses = addresses

	# Registers a server (host,port), to send a command to
	def register(self,host,port):
		self.addresses.append((host,port))

	# Checks if a given server (host,port) is registered for sending commands
	def is_registered(self,host,port):
		return (host,port) in self.addresses

	# Sends a given command asynchrously to all (previously) registered servers and applies the global timeout on all of them.
	# It is ensured that this function completes within give timeout
	# returns a dictionary hostkey->(datain, length) where hostkey is 'ip:port' (eg. '10.10.10.12:9422), 
	# if a given server can't be reached or gives no valid answer its hostkey will be absent from the dictionary, thus dictinary may be empty if no command completed successfuly 
	# postprocess is a function (lambda) that will be applied to each datain before storing it in the dictionary
	def command(self,cmdout,cmdin,dataout=None,postprocess=None):
		if (sys.version_info[0]==3 and sys.version_info[1]<7):
			loop = asyncio.get_event_loop()
			return loop.run_until_complete(self.async_command(cmdout,cmdin,dataout,postprocess))
		else:
			return asyncio.run(self.async_command(cmdout,cmdin,dataout,postprocess))

	# Internal: coordinates async tasks and collects results
	async def async_command(self,cmdout,cmdin,dataout,postprocess):
		results = []
		# Create a list of tasks
		if dataout and isinstance(dataout, list):
			tasks = [self.multiple_command(host, port, cmdout, cmdin, dataout) for host, port in self.addresses]
		else:
			tasks = [self.single_command(host, port, cmdout, cmdin, dataout, postprocess) for host, port in self.addresses]
		if not tasks:
			return dict(results)
		# Schedule tasks
		if (sys.version_info[0]==3 and sys.version_info[1]<7):
			loop = asyncio.get_event_loop()
			tasks = [loop.create_task(task) for task in tasks]
		else:
			tasks = [asyncio.create_task(task) for task in tasks]
		try:
			# Attempt to wait for all tasks with a timeout
			done, pending = await asyncio.wait(tasks, timeout=self.timeout)
			for task in done:
				if not task.cancelled() and not task.exception():
					results.append(task.result()) # Collect a single task output
		except asyncio.TimeoutError:
			raise Exception("Timeout during executing single_command")  # This line will not be hit using this structure.
		for task in pending:
			task.cancel() # Cancel pending tasks after timeout
			try:
				await task
			except asyncio.CancelledError:
				pass #do nothing about it
		return dict(results) # Convert list of tuples (successfull task results) to dictionary
	
	# Internal: perform a single mfs i/o command 
	async def single_command(self,host,port,cmdout,cmdin,dataout,postprocess):
		if dataout:
			l = len(dataout)
			msg = struct.pack(">LL",cmdout,l) + dataout
		else:
			msg = struct.pack(">LL",cmdout,0)
		reader, writer = await asyncio.wait_for(asyncio.open_connection(host, port),timeout=2)
		cmdok = 0
		errcnt = 0
		error = None
		try: 
			while cmdok==0:
				badans = 0
				try:
					writer.write(msg)
					await writer.drain()
					while cmdok==0:
						header = await reader.readexactly(8)
						if header:
							cmd,length = struct.unpack(">LL",header)
							if cmd==cmdin:
								datain = await reader.readexactly(length)
								cmdok = 1
							elif cmd!=ANTOAN_NOP:
								badans = 1
								raise Exception
						else:
							raise Exception
				except Exception:
					if errcnt<3:
						writer.close()
						if not (sys.version_info[0]==3 and sys.version_info[1]<7):
							await writer.wait_closed()
						reader, writer = await asyncio.wait_for(asyncio.open_connection(host, port),timeout=3)
						errcnt+=1
					else:
						if badans:
							raise MFSCommunicationError("bad answer")
						else:
							raise MFSCommunicationError()
		except Exception as e:
			error = e
		finally: #clean up whatever happened
			writer.close()
			if not (sys.version_info[0]==3 and sys.version_info[1]<7):
				await writer.wait_closed()
		hostkey = "%s:%u" % (host,port)
		if postprocess: # apply postprocess function to datain
			return hostkey,postprocess(host,port,datain,length,error)
		else: # or return datain as is
			return hostkey,(datain,length)

	# Internal: perform synchronously multiple mfs i/o commands with a single peer (during a single connection) sending different data to each command
	# returns a list of answers (datain, length) for all commands
	async def multiple_command(self,host,port,cmdout,cmdin,dataout_arr):
		datain_arr,length_arr = [],[]
		reader, writer = await asyncio.wait_for(asyncio.open_connection(host, port),timeout=2)
		try:
			for dataout in dataout_arr:
				cmdok = 0
				errcnt = 0
				l = len(dataout)
				msg = struct.pack(">LL",cmdout,l) + dataout
				while cmdok==0:
					badans = 0
					try:
						writer.write(msg)
						await writer.drain()
						while cmdok==0:
							header = await reader.readexactly(8)
							if header:
								cmd,length = struct.unpack(">LL",header)
								if cmd==cmdin:
									datain = await reader.readexactly(length)
									cmdok = 1
								elif cmd!=ANTOAN_NOP:
									badans = 1
									raise Exception
							else:
								raise Exception
					except Exception:
						if errcnt<3:
							writer.close()
							if not (sys.version_info[0]==3 and sys.version_info[1]<7):
								await writer.wait_closed()
							reader, writer = await asyncio.wait_for(asyncio.open_connection(host, port),timeout=3)
							errcnt+=1
						else:
							if badans:
								raise MFSCommunicationError("bad answer")
							else:
								raise MFSCommunicationError()
				datain_arr.append(datain)
				length_arr.append(length)
		finally: #clean up whatever happened
			writer.close()
			if not (sys.version_info[0]==3 and sys.version_info[1]<7):
				await writer.wait_closed()
		hostkey = "%s:%u" % (host,port)
		return hostkey,(datain_arr,length_arr)


########################################################################################
# Handles a single connection for sending requests and commands to any MooseFS server
class MFSConn:
	def __init__(self,host,port):
		self.host = host
		self.port = port
		self.socket = None
		self.connect()

	def __del__(self):
		try:
			if self.socket:
				self.socket.close()
#				print "connection closed with: %s:%u" % (self.host,self.port)
			self.socket = None
		except AttributeError:
			pass

	def connect(self):
		cnt = 0
		while self.socket == None and cnt<3:
			self.socket = socket.socket()
			self.socket.settimeout(1)
			try:
				self.socket.connect((self.host,self.port))
			except Exception:
				self.socket.close()
				self.socket = None
				cnt += 1
		if self.socket==None:
			self.socket = socket.socket()
			self.socket.settimeout(1)
			self.socket.connect((self.host,self.port))
#		else:
#			print "connected to: %s:%u" % (self.host,self.port)

	def close(self):
		if self.socket:
			self.socket.close()
			self.socket = None

	def mysend(self,msg):
		if self.socket == None:
			self.connect()
		totalsent = 0
		while totalsent < len(msg):
			sent = self.socket.send(msg[totalsent:])
			if sent == 0:
				raise RuntimeError("socket connection broken")
			totalsent = totalsent + sent

	def myrecv(self,leng):
		msg = bytes(0)
		while len(msg) < leng:
			chunk = self.socket.recv(leng-len(msg))
			if len(chunk) == 0:
				raise RuntimeError("socket connection broken")
			msg = msg + chunk
		return msg
	
	def command(self,cmdout,cmdin,dataout=None):
		if dataout:
			l = len(dataout)
			msg = struct.pack(">LL",cmdout,l) + dataout
		else:
			msg = struct.pack(">LL",cmdout,0)
		cmdok = 0
		errcnt = 0
		while cmdok==0:
			badans = 0
			try:
				self.mysend(msg)
				while cmdok==0:
					header = self.myrecv(8)
					cmd,length = struct.unpack(">LL",header)
					if cmd==cmdin:
						datain = self.myrecv(length)
						cmdok = 1
					elif cmd!=ANTOAN_NOP:
						badans = 1
						raise Exception
			except Exception:
				if errcnt<3:
					self.close()
					self.connect()
					errcnt+=1
				else:
					if badans:
						raise MFSCommunicationError("bad answer")
					else:
						raise MFSCommunicationError()
		return datain,length

# Handles a single connection for sending requests and commands to Master server (leader or follower)
class MasterConn(MFSConn):
	def __init__(self,host,port):
		MFSConn.__init__(self,host,port)
		self.version = (0,0,0)
		self.pro = -1
		self.featuremask = 0

	def set_version(self,versionxyzp):
		self.version,self.pro = version_convert(versionxyzp)
		(_,self.sortver,self.pro) = version_str_sort_pro(versionxyzp)
		if self.version>=(3,0,72):
			self.featuremask |= (1<<FEATURE_EXPORT_UMASK)
		if (self.version>=(3,0,112) and self.version[0]==3) or self.version>=(4,21,0):
			self.featuremask |= (1<<FEATURE_EXPORT_DISABLES)
		if self.version>=(4,27,0):
			self.featuremask |= (1<<FEATURE_SESSION_STATS_28)
		if self.version>=(4,29,0):
			self.featuremask |= (1<<FEATURE_INSTANCE_NAME)
		if self.version>=(4,35,0):
			self.featuremask |= (1<<FEATURE_CSLIST_MODE)
		if self.version>=(4,44,0):
			self.featuremask |= (1<<FEATURE_SCLASS_IN_MATRIX)
		if self.version>=(4,51,0):
			self.featuremask |= (1<<FEATURE_DEFAULT_GRACEPERIOD)
		if self.version>=(4,53,0):
			self.featuremask |= (1<<FEATURE_LABELMODE_OVERRIDES)
		if self.version>=(4,57,0):
			self.featuremask |= (1<<FEATURE_SCLASSGROUPS)	

	def version_at_least(self,v1,v2,v3):
		return (self.version>=(v1,v2,v3))
	def version_less_than(self,v1,v2,v3):
		return (self.version<(v1,v2,v3))
	def version_is(self,v1,v2,v3):
		return (self.version==(v1,v2,v3))
	def version_unknown(self):
		return (self.version==(0,0,0))
	def is_pro(self):
		return self.pro
	def has_feature(self,featureid):
		return True if (self.featuremask & (1<<featureid)) else False
	
	def sort_ver(self):
		sortver = "%05u_%03u_%03u" % self.version
		if self.pro==1:
			sortver += "_2"
		elif self.pro==0:
			sortver += "_1"
		else:
			sortver += "_0"
		return sortver

### End of inline import from common/conn.py

### from common.models import *       # MFS_INLINE_IMPORT - inlined below:
### Imported inline from common/models.py:
import json

try:
	from common.constants import *
	from common.utils import *
except:
	pass # imports may be unaccessible in a single mfscli file but they should be already inlined instead

#######################################
# A set of classes representing data models for particluar entities in a cluster (servers, disks, sessions, storage classes etc.)
class MasterServer:
	def __init__(self,host,port,versionxyzp,workingstate,sync,statestr,statecolor,metaversion,memusage,syscpu,usercpu,lastsuccessfulstore,lastsaveseconds,lastsavestatus,exportschecksum,metaid,lastsavemetaversion,lastsavemetachecksum,usectime,chlogtime):
		self.host = host
		self.port = port
		try:
			iptab = tuple(map(int,host.split('.')))
			self.strip = "%u.%u.%u.%u" % iptab
			self.sortip = "%03u_%03u_%03u_%03u" % iptab
		except Exception:
			self.strip = host
			self.sortip = host
		self.version = versionxyzp
		self.strver, self.sortver, self.pro = version_str_sort_pro(versionxyzp)
		self.workingstate = workingstate
		self.sync = sync
		self.statestr = statestr
		self.statecolor = statecolor
		self.metaversion = metaversion
		self.memusage = memusage
		self.syscpu = syscpu
		self.usercpu = usercpu
		self.lastsuccessfulstore = lastsuccessfulstore
		self.lastsaveseconds = lastsaveseconds
		self.lastsavestatus = lastsavestatus
		self.exportschecksum = exportschecksum
		self.metaid = metaid
		self.lastsavemetaversion = lastsavemetaversion
		self.lastsavemetachecksum = lastsavemetachecksum
		self.usectime = usectime
		self.chlogtime = chlogtime
		self.secdelta = None  #updated separately by update_masterservers_delays
		self.metadelay = None #updated separately by update_masterservers_delays
		
		if self.workingstate==STATE_FOLLOWER:
			if sync==0:	self.statestr += " (DESYNC)"
			if sync==2:	self.statestr += " (DELAYED)"
			if sync==3:	self.statestr += " (INIT)"

	def is_active(self):
		return self.workingstate != STATE_UNREACHABLE

# 		self.featuremask = 0
# 		if self.version>=(3,0,72):
# 			self.featuremask |= (1<<FEATURE_EXPORT_UMASK)
# 		if (self.version>=(3,0,112) and self.version[0]==3) or self.version>=(4,21,0):
# 			self.featuremask |= (1<<FEATURE_EXPORT_DISABLES)
# 		if self.version>=(4,27,0):
# 			self.featuremask |= (1<<FEATURE_SESSION_STATS_28)
# 		if self.version>=(4,29,0):
# 			self.featuremask |= (1<<FEATURE_INSTANCE_NAME)
# 		if self.version>=(4,35,0):
# 			self.featuremask |= (1<<FEATURE_CSLIST_MODE)
# 		if self.version>=(4,44,0):
# 			self.featuremask |= (1<<FEATURE_SCLASS_IN_MATRIX)
# 		if self.version>=(4,51,0):
# 			self.featuremask |= (1<<FEATURE_DEFAULT_GRACEPERIOD)
# 		if self.version>=(4,53,0):
# 			self.featuremask |= (1<<FEATURE_LABELMODE_OVERRIDES)
# 		if self.version>=(4,57,0):
# 			self.featuremask |= (1<<FEATURE_SCLASSGROUPS)	

# 	def version_at_least(self,v1,v2,v3):
# 		return (self.version>=(v1,v2,v3))
# 	def version_less_than(self,v1,v2,v3):
# 		return (self.version<(v1,v2,v3))
# 	def version_is(self,v1,v2,v3):
# 		return (self.version==(v1,v2,v3))
# 	def version_unknown(self):
# 		return (self.version==(0,0,0))
# 	def is_pro(self):
# 		return self.pro
# 	def has_feature(self,featureid):
# 		return True if (self.featuremask & (1<<featureid)) else False
	


class Metalogger:
	# ip should be tuple: (ip1,ip2,ip3,ip4), version should be tuple: (v1,v2,v3)
	def __init__(self, ip, donotresolve, version):
		self.strip = "%u.%u.%u.%u" % ip
		self.sortip = "%03u_%03u_%03u_%03u" % ip
		self.host = resolve(self.strip, donotresolve)
		self.strver,self.sortver,self.pro = version_str_sort_pro(version)

class ClusterInfo:
	def __init__(self, version,memusage,syscpu,usercpu,totalspace,availspace,freespace,trspace,trfiles,respace,refiles,nodes,dirs,files,chunks,lastsuccessfulstore,lastsaveseconds,lastsavestatus,metainfomode,
																	allcopies,regularcopies,copychunks,ec8chunks,ec4chunks,chunkcopies,chunkec8parts,chunkec4parts,chunkhypcopies):
		self.version = version
		self.memusage = memusage
		self.syscpu = syscpu
		self.usercpu = usercpu
		self.totalspace = totalspace
		self.availspace = availspace
		self.freespace = freespace
		self.trspace = trspace
		self.trfiles = trfiles
		self.respace = respace
		self.refiles = refiles
		self.nodes = nodes
		self.dirs = dirs
		self.files = files
		self.chunks = chunks
		self.lastsuccessfulstore = lastsuccessfulstore
		self.lastsaveseconds = lastsaveseconds
		self.lastsavestatus = lastsavestatus
		self.metainfomode = metainfomode
		self.allcopies = allcopies
		self.regularcopies = regularcopies
		self.copychunks = copychunks
		self.ec8chunks = ec8chunks
		self.ec4chunks = ec4chunks
		self.chunkcopies = chunkcopies
		self.chunkec8parts = chunkec8parts
		self.chunkec4parts = chunkec4parts
		self.chunkhypcopies = chunkhypcopies
		self.strver,self.sortver,_ = version_str_sort_pro(version)

		if metainfomode==1:
			if (copychunks + ec8chunks + ec4chunks) > 0:
				self.ecchunkspercent = 100.0 * (ec8chunks + ec4chunks) / (copychunks + ec8chunks + ec4chunks)
				self.dataredundancyratio = (chunkcopies + 0.125 * chunkec8parts + 0.25 * chunkec4parts) / (copychunks + ec8chunks + ec4chunks)
			else:
				self.ecchunkspercent = None
				self.dataredundancyratio = None
			if (chunkcopies + 0.125 * chunkec8parts + 0.25 * chunkec4parts) > 0.0:
				noecratio = (chunkhypcopies / (chunkcopies + 0.125 * chunkec8parts + 0.25 * chunkec4parts))
				if noecratio>1.0:
					extranoecspace = noecratio - 1.0
				else:
					extranoecspace = 0.0
				if freespace!=None:
					self.savedbyec = int((totalspace-freespace) * extranoecspace)
				else:
					self.savedbyec = int((totalspace-availspace) * extranoecspace)
			else:
				self.savedbyec = None



class Licence:
	def __init__(self,licver,lictype,v1,v2,v3,licmaxtime,licleft,licmaxsize,currentsize,licid,lictypestr,licissuer,licuser,licjson,addinfo,quota,csmaxsize,csmaxcnt):
		self.licver = licver
		self.lictype = lictype
		self.v1 = v1
		self.v2 = v2
		self.v3 = v3
		self.licmaxtime = licmaxtime
		self.licleft = licleft
		self.licmaxsize = licmaxsize
		self.currentsize = currentsize
		self.licid = licid
		self.lictypestr = lictypestr
		self.licissuer = licissuer
		self.licuser = licuser
		self.licjson = licjson
		self.addinfo = addinfo
		self.quota = quota
		self.csmaxsize = csmaxsize
		self.csmaxcnt = csmaxcnt
		if self.licver and self.licver>=1 and len(self.licjson)>0:
			self.licextrainfo = json.loads(self.licjson)
		else:
			self.licextrainfo = {}

	def get_max_version_str(self):
		if self.v1==0xFFFF or self.licver == LICVER_CE:
			return "unlimited"
		elif self.v2==255:
			return "%u.x" % (self.v1)
		elif self.v3==255:
			return "%u.%u.x" % (self.v1,self.v2)
		else:
			return "%u.%u.%u" % (self.v1,self.v2,self.v3)

	# Returns true if given software version (v1,v2,v3) is allowed by the licence
	def is_allowed_version(self,version):
		if (self.licver == LICVER_CE):
			return True
		v1,v2,v3 = version
		if self.v1==0xFFFF:
			return True #unlimited
		if v1<self.v1:
			return True
		elif v1>self.v1:
			return False
		if self.v2==255:
			True		#A.x unlimited
		if v2<self.v2:
			return True
		elif v2>self.v2:
			return False
		if self.v3==255:
			True		#A.B.x unlimited
		if v3<self.v3:
			return True
		elif v3>self.v3:
			return False
		return True

	def is_time_unlimited(self):
		return self.licleft==0xFFFFFFFF or self.licmaxtime==0xFFFFFFFF or self.licver == LICVER_CE
	
	def is_cs_size_unlimited(self):
		return self.csmaxsize==0xFFFFFFFFFFFFFFFF or self.licver == LICVER_CE
	
	def is_cs_cnt_unlimited(self):
		return self.csmaxcnt==0xFFFF or self.licver == LICVER_CE
	
	def is_size_unlimited(self):
		return self.licmaxsize==0xFFFFFFFFFFFFFFFF or (self.licmaxsize==0 and self.currentsize==0) or self.licver == LICVER_CE


class HealthSelfCheck:
	def __init__(self,loopstart,loopend,files,ugfiles,mfiles,mtfiles,msfiles,chunks,ugchunks,mchunks,msgbuffleng,datastr):
		self.loopstart = loopstart
		self.loopend = loopend
		self.files = files
		self.ugfiles = ugfiles
		self.mfiles = mfiles
		self.mtfiles = mtfiles
		self.msfiles = msfiles
		self.chunks = chunks
		self.ugchunks = ugchunks
		self.mchunks = mchunks
		self.msgbuffleng = msgbuffleng
		self.datastr = datastr

# Missing chunk
class MissingChunk:
	def __init__(self,paths,inode,indx,chunkid,mtype):
		self.paths = paths
		self.inode = inode
		self.indx = indx
		self.chunkid = chunkid
		self.mtype = mtype

	def get_mtype_str(self):
		if self.mtype==MISSING_CHUNK_TYPE_NOCOPY:
			return "No copy"
		elif self.mtype==MISSING_CHUNK_TYPE_INVALID_COPIES:
			return "Invalid copies"
		elif self.mtype==MISSING_CHUNK_TYPE_WRONG_VERSIONS:
			return "Wrong versions"
		elif self.mtype==MISSING_CHUNK_TYPE_PARTIAL_EC:
			return "Missing EC parts"
		else:
			return "Other"

	def get_chunkid_str(self):
		return "%016X" % self.chunkid

class MemoryUsage:
	def __init__(self, memlabels,abrlabels,totalused,totalallocated,memusage):
		self.memlabels = memlabels
		self.abrlabels = abrlabels
		self.totalused = totalused
		self.totalallocated = totalallocated
		self.memusage = memusage

class ChunkServer:
	def __init__(self,oip,ip,donotresolve,port,csid,v1,v2,v3,flags,used,total,chunks,tdused,tdtotal,tdchunks,errcnt,queue,gracetime,labels,mfrstatus,maintenanceto):
		self.oip = oip
		self.ip = ip
		self.version = (v1,v2,v3)
		self.stroip = "%u.%u.%u.%u" % oip
		self.strip = "%u.%u.%u.%u" % ip
		self.sortip = "%03u_%03u_%03u_%03u" % ip
		self.strver,self.sortver,self.pro = version_str_sort_pro((v1,v2,v3))
		self.host = resolve(self.strip, donotresolve)
		self.port = port
		self.csid = csid
		self.flags = flags
		self.used = used
		self.total = total
		self.chunks = chunks
		self.tdused = tdused
		self.tdtotal = tdtotal
		self.tdchunks = tdchunks
		self.errcnt = errcnt
		self.queue = queue
		self.gracetime = gracetime
		self.labels = labels
		self.mfrstatus = mfrstatus
		self.maintenanceto = maintenanceto
		self.hostkey = "%s:%s" % (self.strip,self.port)

		if self.is_maintenance_off():
			self.mmto = "n/a"
		elif self.maintenanceto==None:
			self.mmto = "unknown"
		elif self.maintenanceto==0xFFFFFFFF:
			self.mmto = "permanent"
		else:
			self.mmto = "%u seconds left" % self.maintenanceto

		if self.gracetime>=0xC0000000:
			self.queue_state = CS_LOAD_OVERLOADED
			self.queue_state_str = "Overloaded"
			self.queue_state_msg = "Overloaded"
			self.queue_state_info = "server queue is heavy loaded (overloaded)"
			self.queue_cgi = "<%u>" % self.queue
		elif self.gracetime>=0x80000000:
			self.queue_state = CS_LOAD_REBALANCE
			self.queue_state_str = "Rebalance"
			self.queue_state_msg = "Rebalancing"
			self.queue_state_info = "internal rebalance in progress"
			self.queue_cgi = "(%u)" % self.queue
		elif self.gracetime>=0x40000000:
			self.queue_state = CS_LOAD_FAST_REBALANCE
			self.queue_state_str = "Fast rebalance"
			self.queue_state_msg = "Fast rebalancing"
			self.queue_state_info = "high speed rebalance in progress"
			self.queue_cgi = "{%u}" % self.queue
			# queue_state_has_link = 1
		elif self.gracetime>0:
			self.queue_state = CS_LOAD_GRACEFUL
			self.queue_state_str = "G(%u)" % self.gracetime
			self.queue_state_msg = "%u secs graceful" % self.gracetime
			self.queue_state_info = "server in graceful period - back to normal after %u seconds" % self.gracetime
			self.queue_cgi = "[%u]" % self.queue
		else:
			self.queue_state = CS_LOAD_NORMAL
			self.queue_state_str = "Normal"
			self.queue_state_msg = "Normal load"
			self.queue_state_info = "server is responsive, working with low load"
			self.queue_cgi = "%u" % self.queue

		if self.labels==0xFFFFFFFF or self.labels==0:
			self.labelstr = "-"
		else:
			labelstab = []
			for bit,char in enumerate(map(chr,range(ord('A'),ord('Z')+1))):
				if self.labels & (1<<bit):
					labelstab.append(char)
			self.labelstr = ",".join(labelstab)		

	def is_maintenance_off(self):
		return (self.flags&2)==0

	def is_maintenance_on(self):
		return (self.flags&4)==0

	def is_connected(self):
		return (self.flags&1)==0

	def get_mfr_status_str(self):
		if self.tdchunks!=0:
			if self.mfrstatus==MFRSTATUS_VALIDATING:
				return 'not ready for removal (validating)'
			elif self.mfrstatus==MFRSTATUS_INPROGRESS:
				return 'not ready for removal (in progress)'
			elif self.mfrstatus==MFRSTATUS_READY:
				return 'removal ready'
			else:
				return 'not ready for removal (unrecognized status)'
		else:
			return ''
		
# Chunkserver's hard disk drive
class HDD:
	def __init__(self,csvalid,hostkey,hoststr,hostip,port,hddpath,sortippath,ippath,hostpath,flags,clearerrorarg,errchunkid,errtime,used,total,chunkscnt,rbw,wbw,usecreadavg,usecwriteavg,usecfsyncavg,usecreadmax,usecwritemax,usecfsyncmax,rops,wops,fsyncops,rbytes,wbytes,mfrstatus):
		self.csvalid = csvalid
		self.hostkey = hostkey
		self.hoststr = hoststr
		self.hostip = hostip
		self.port = port
		self.hddpath = hddpath
		self.sortippath = sortippath
		self.ippath = ippath
		self.hostpath = hostpath
		self.flags = flags
		self.clearerrorarg = clearerrorarg
		self.errchunkid = errchunkid
		self.errtime = errtime
		self.used = used
		self.total = total
		self.chunkscnt = chunkscnt
		self.rbw = rbw
		self.wbw = wbw
		self.usecreadavg = usecreadavg
		self.usecwriteavg = usecwriteavg
		self.usecfsyncavg = usecfsyncavg
		self.usecreadmax = usecreadmax
		self.usecwritemax = usecwritemax
		self.usecfsyncmax = usecfsyncmax
		self.rops = rops
		self.wops = wops
		self.fsyncops = fsyncops
		self.rbytes = rbytes
		self.wbytes = wbytes
		self.mfrstatus = mfrstatus

	def __lt__(self, other):
		return self.sortippath < other.sortippath
	
	def is_valid(self):
		return self.csvalid==CS_HDD_CS_VALID
	def has_errors(self):
		return self.errtime!=0 or self.errchunkid!=0
	
	def get_statuslist(self):
		statuslist = []
		if (self.csvalid == CS_HDD_CS_TOO_OLD):
			statuslist.append('unknown (too old chunkserver)')
		elif (self.csvalid == CS_HDD_CS_UNREACHABLE):
			statuslist.append('unknown (unreachable chunkserver)')
		else:
			if (self.flags&CS_HDD_INVALID):
				statuslist.append('invalid')
			if (self.flags&CS_HDD_DAMAGED) and (self.flags&CS_HDD_SCANNING)==0 and (self.flags&CS_HDD_INVALID)==0:
				statuslist.append('damaged')
			if self.flags&CS_HDD_MFR:
				if self.mfrstatus==MFRSTATUS_VALIDATING:
					statuslist.append('removal not ready (validating)')
				elif self.mfrstatus==MFRSTATUS_INPROGRESS:
					statuslist.append('removal not ready (in progress)')
				elif self.mfrstatus==MFRSTATUS_READY:
					statuslist.append('removal ready')
				else:
					statuslist.append('removal not ready (unrecognized status)')
			if self.flags&CS_HDD_SCANNING:
				statuslist.append('scanning')
			if self.flags==0:
				if self.has_errors():
					statuslist.append('ok (errors)')
				else:
					statuslist.append('ok')
		return statuslist

	# Returns a string with a status of the HDD
	def get_status_str(self):
		return ", ".join(self.get_statuslist())

class ExportsEntry:
	def __init__(self,fip1,fip2,fip3,fip4,tip1,tip2,tip3,tip4,path,meta,v1,v2,v3,exportflags,sesflags,umaskval,rootuid,rootgid,mapalluid,mapallgid,sclassgroups,mingoal,maxgoal,mintrashretention,maxtrashretention,disables):
		self.ipfrom = (fip1,fip2,fip3,fip4)
		self.ipto = (tip1,tip2,tip3,tip4)
		self.version = (v1,v2,v3)
		self.stripfrom = "%u.%u.%u.%u" % (fip1,fip2,fip3,fip4)
		self.sortipfrom = "%03u_%03u_%03u_%03u" % (fip1,fip2,fip3,fip4)
		self.stripto = "%u.%u.%u.%u" % (tip1,tip2,tip3,tip4)
		self.sortipto = "%03u_%03u_%03u_%03u" % (tip1,tip2,tip3,tip4)
		self.strver,self.sortver,self.pro = version_str_sort_pro((v1,v2,v3))
		self.meta = meta
		self.path = path
		self.exportflags = exportflags
		self.sesflags = sesflags
		self.umaskval = umaskval
		self.rootuid = rootuid
		self.rootgid = rootgid
		self.mapalluid = mapalluid
		self.mapallgid = mapallgid
		if sclassgroups==None:
			if mingoal==None and maxgoal==None:
				self.sclassgroups = 0xFFFF
			else:
				self.sclassgroups = ((0xFFFF<<mingoal) & (((0xFFFF<<(maxgoal+1))&0xFFFF)^0xFFFF)) | 1
		else:
			self.sclassgroups = sclassgroups
		self.mintrashretention = mintrashretention
		self.maxtrashretention = maxtrashretention
		self.disables = disables

		if self.sclassgroups==0:
			self.sclassgroups_sort = 0
			self.sclassgroups_str = 'NONE'
		elif self.sclassgroups==0xFFFF:
			self.sclassgroups_sort = 0xFFFF
			self.sclassgroups_str = "ALL"
		else:
			self.sclassgroups_sort = 0
			sclassgroups_list = []
			for b in range(16):
				self.sclassgroups_sort<<=1
				if self.sclassgroups & (1<<b):
					sclassgroups_list.append(b)
					self.sclassgroups_sort |= 1
			self.sclassgroups_str = ",".join(map(str,sclassgroups_list))

	def is_alldirs(self):
		return self.exportflags&1
	def is_password(self):
		return self.exportflags&2
	def is_readonly(self):
		return self.sesflags&1
	def is_unrestricted(self):
		return self.sesflags&2
	def ignore_gid(self):
		return self.sesflags&4
	def is_admin(self):
		return self.sesflags&8
	def map_user(self):
		return self.sesflags&16


class Session:
	def __init__(self,sessionid,ip,donotresolve,info,openfiles,nsocks,expire,v1,v2,v3,meta,path,sesflags,umaskval,rootuid,rootgid,mapalluid,mapallgid,sclassgroups,mingoal,maxgoal,mintrashretention,maxtrashretention,disables,stats_c,stats_l):
		self.ip = ip
		self.version = (v1,v2,v3)
		self.strip = "%u.%u.%u.%u" % ip
		self.sortip = "%03u_%03u_%03u_%03u" % ip
		self.strver,self.sortver,self.pro = version_str_sort_pro((v1,v2,v3))
		self.host = resolve(self.strip, donotresolve)
		self.sessionid = sessionid
		self.info = info
		self.openfiles = openfiles
		self.nsocks = nsocks
		self.expire = expire
		self.meta = meta
		self.path = path
		self.sesflags = sesflags
		self.umaskval = umaskval
		self.rootuid = rootuid
		self.rootgid = rootgid
		self.mapalluid = mapalluid
		self.mapallgid = mapallgid
		if sclassgroups==None:
			if mingoal==None and maxgoal==None:
				self.sclassgroups = 0xFFFF
			else:
				self.sclassgroups = ((0xFFFF<<mingoal) & (((0xFFFF<<(maxgoal+1))&0xFFFF)^0xFFFF)) | 1
		else:
			self.sclassgroups = sclassgroups
		self.mintrashretention = mintrashretention
		self.maxtrashretention = maxtrashretention
		self.disables = disables
		self.stats_c = stats_c
		self.stats_l = stats_l

	def get_sessionstr(self):
		if self.sessionid & 0x80000000:
			return "TMP/%u" % (self.sessionid&0x7FFFFFFF)
		else:
			return "%u" % (self.sessionid)
		
	def is_tmp(self):
		return self.sessionid & 0x80000000

	def get_sclassgroups_sort(self):
		if self.sclassgroups==0:
			sclassgroups_sort = 0
		elif self.sclassgroups==0xFFFF:
			sclassgroups_sort = 0xFFFF
		else:
			sclassgroups_sort = 0
			for b in range(16):
				sclassgroups_sort<<=1
				if self.sclassgroups & (1<<b):
					sclassgroups_sort |= 1
		return sclassgroups_sort

	def get_sclassgroups_str(self):
		if self.sclassgroups==0:
			sclassgroups_str = 'NONE'
		elif self.sclassgroups==0xFFFF:
			sclassgroups_str = "ALL"
		else:
			sclassgroups_list = []
			for b in range(16):
				if self.sclassgroups & (1<<b):
					sclassgroups_list.append(b)
			sclassgroups_str = ",".join(map(str,sclassgroups_list))
		return sclassgroups_str

# Represents just a short info about sclass used for sclass listing
class StorageClassName:
	def __init__(self,name,has_chunks):
		self.name = name
		self.has_chunks = has_chunks

class StorageClass:
	def __init__(self,sclassid,sclassname,sclassdesc,priority,export_group,admin_only,labels_mode,arch_mode,arch_delay,arch_min_size,min_trashretention,files,dirs,states,availableservers,labels_ver):
		self.sclassid = sclassid
		self.sclassname = sclassname
		self.sclassdesc = sclassdesc
		self.priority = priority
		self.export_group = export_group
		self.admin_only = admin_only
		self.labels_mode = labels_mode
		self.arch_mode = arch_mode
		self.arch_delay = arch_delay
		self.arch_min_size = arch_min_size
		self.min_trashretention = min_trashretention
		self.files = files
		self.dirs = dirs
		self.states = states
		self.availableservers = availableservers
		self.labels_ver = labels_ver

		arch_mode_list = []
		if arch_mode&SCLASS_ARCH_MODE_CHUNK:
			arch_mode_list.append("CHUNK")
		elif arch_mode&SCLASS_ARCH_MODE_FAST:
			arch_mode_list.append("FAST")
		else:
			arch_mode_list.append("[")
			if arch_mode&SCLASS_ARCH_MODE_CTIME:
				arch_mode_list.append("C")
			if arch_mode&SCLASS_ARCH_MODE_MTIME:
				arch_mode_list.append("M")
			if arch_mode&SCLASS_ARCH_MODE_ATIME:
				arch_mode_list.append("A")
			arch_mode_list.append("]TIME")
			if arch_mode&SCLASS_ARCH_MODE_REVERSIBLE:
				arch_mode_list.append("/REVERSIBLE")
			else:
				arch_mode_list.append("/ONEWAY")
		self.arch_mode_str = "".join(arch_mode_list)

		self.defined_create = False
		self.defined_archive = False
		self.defined_trash = False	
		for state in self.states:
			if state.name=="CREATE":
				self.defined_create = state.defined
			elif state.name=="ARCH":
				self.defined_archive = state.defined
			elif state.name=="TRASH":
				self.defined_trash = state.defined
		# admin_only_str = "YES" if admin_only else "NO"
		# labels_mode_str = "LOOSE" if labels_mode==0 else "STD" if labels_mode==1 else "STRICT"
		# arch_delay_str = hours_to_str(arch_delay) if (arch_delay>0 and (arch_mode&SCLASS_ARCH_MODE_FAST)==0) else "-"
		# min_trashretention_str = hours_to_str(min_trashretention) if min_trashretention>0 else "-"

	def get_admin_only_str(self):
		return "YES" if self.admin_only else "NO"
	def get_labels_mode_str(self):
		return "LOOSE" if self.labels_mode==0 else "STD" if self.labels_mode==1 else "STRICT"
	def get_min_trashretention_str(self):
		return hours_to_str(self.min_trashretention) if self.min_trashretention>0 else "-"
	def get_arch_delay_str(self):
		return hours_to_str(self.arch_delay) if (self.arch_delay>0 and (self.arch_mode&SCLASS_ARCH_MODE_FAST)==0) else "-"
	def get_arch_mode_str(self):
		return self.arch_mode_str
	def isKeepOnly(self):
		return not (self.defined_create or self.defined_archive or self.defined_trash)

class StorageClassState:
	def __init__(self,defined,name,counters,ec_level,labellist,uniqmask,labelsmodeover,canbefulfilled):
		self.defined = defined
		self.name = name
		self.counters = counters
		self.ec_level = ec_level
		self.labellist = labellist
		self.uniqmask = uniqmask
		self.labelsmodeover = labelsmodeover
		self.canbefulfilled = canbefulfilled
		self.fullname = "ARCHIVE" if name=="ARCH" else name

		self.ec_data_parts = 0
		self.ec_chksum_parts = 0
		if self.ec_level!=None and self.ec_level>0:
			self.ec_data_parts = self.ec_level >> 4
			self.ec_chksum_parts = self.ec_level & 0xF
			if self.ec_data_parts==0:
				self.ec_data_parts = 8

	def isEC(self):
		return self.ec_level!=None and self.ec_level>0

class OPattern:
	def __init__(self,globname,euid,egid,priority,sclassname,trashretention,seteattr,clreattr):
		self.globname = globname
		self.euid = euid
		self.egid = egid
		self.priority = priority
		self.sclassname = sclassname
		self.trashretention = trashretention
		self.seteattr = seteattr
		self.clreattr = clreattr

		self.euidstr = "ANY" if self.euid==PATTERN_EUGID_ANY else ("%u" % self.euid)
		self.egidstr = "ANY" if self.egid==PATTERN_EUGID_ANY else ("%u" % self.egid)
		self.eattrstr = eattr_to_str(self.seteattr,self.clreattr)

class ChunkTestInfo72:
	def __init__(self,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,rebalance,labels_dont_match,locked_unused,locked_used):
		self.loopstart = loopstart
		self.loopend = loopend
		self.del_invalid = del_invalid
		self.ndel_invalid = ndel_invalid
		self.del_unused = del_unused
		self.ndel_unused = ndel_unused
		self.del_dclean = del_dclean
		self.ndel_dclean = ndel_dclean
		self.del_ogoal = del_ogoal
		self.ndel_ogoal = ndel_ogoal
		self.rep_ugoal = rep_ugoal
		self.nrep_ugoal = nrep_ugoal
		self.rep_wlab = rep_wlab
		self.nrep_wlab = nrep_wlab
		self.rebalance = rebalance
		self.labels_dont_match = labels_dont_match
		self.locked_unused = locked_unused
		self.locked_used = locked_used		

class ChunkTestInfo96:
	def __init__(self,loopstart,loopend,fixed,forcekeep,delete_invalid,delete_no_longer_needed,delete_wrong_version,delete_duplicated_ecpart,delete_excess_ecpart,delete_excess_copy,delete_diskclean_ecpart,delete_diskclean_copy,replicate_dupserver_ecpart,replicate_needed_ecpart,replicate_needed_copy,replicate_wronglabels_ecpart,replicate_wronglabels_copy,split_copy_into_ecparts,join_ecparts_into_copy,recover_ecpart,calculate_ecchksum,locked_unused,locked_used,replicate_rebalance):
		self.loopstart = loopstart
		self.loopend = loopend
		self.fixed = fixed
		self.forcekeep = forcekeep
		self.delete_invalid = delete_invalid
		self.delete_no_longer_needed = delete_no_longer_needed
		self.delete_wrong_version = delete_wrong_version
		self.delete_duplicated_ecpart = delete_duplicated_ecpart
		self.delete_excess_ecpart = delete_excess_ecpart
		self.delete_excess_copy = delete_excess_copy
		self.delete_diskclean_ecpart = delete_diskclean_ecpart
		self.delete_diskclean_copy = delete_diskclean_copy
		self.replicate_dupserver_ecpart = replicate_dupserver_ecpart
		self.replicate_needed_ecpart = replicate_needed_ecpart
		self.replicate_needed_copy = replicate_needed_copy
		self.replicate_wronglabels_ecpart = replicate_wronglabels_ecpart
		self.replicate_wronglabels_copy = replicate_wronglabels_copy
		self.split_copy_into_ecparts = split_copy_into_ecparts
		self.join_ecparts_into_copy = join_ecparts_into_copy
		self.recover_ecpart = recover_ecpart
		self.calculate_ecchksum = calculate_ecchksum
		self.locked_unused = locked_unused
		self.locked_used = locked_used
		self.replicate_rebalance = replicate_rebalance
	
class OpenFile:
	def __init__(self,sessionid,host,sortipnum,ipnum,info,inode,paths):
		self.sessionid = sessionid
		self.host = host
		self.sortipnum = sortipnum
		self.ipnum = ipnum
		self.info = info
		self.inode = inode
		self.paths = paths

class AcquiredLock:
	def __init__(self,inode,sessionid,host,sortipnum,ipnum,info,owner,pid,start,end,ctype):
		self.inode = inode
		self.sessionid = sessionid
		self.host = host
		self.sortipnum = sortipnum
		self.ipnum = ipnum
		self.info = info
		self.owner = owner
		self.pid = pid
		self.start = start
		self.end = end
		self.ctype = ctype

		if self.pid==0 and self.start==0 and self.end==0:
			self.locktype = "FLOCK"
		else:
			self.locktype = "POSIX"

class Quota:
	def __init__(self,path,exceeded,qflags,graceperiod,timetoblock,sinodes,slength,ssize,srealsize,hinodes,hlength,hsize,hrealsize,cinodes,clength,csize,crealsize):
		self.path = path
		self.exceeded = exceeded
		self.qflags = qflags
		self.graceperiod = graceperiod
		self.timetoblock = timetoblock
		self.sinodes = sinodes
		self.slength = slength
		self.ssize = ssize
		self.srealsize = srealsize
		self.hinodes = hinodes
		self.hlength = hlength
		self.hsize = hsize
		self.hrealsize = hrealsize
		self.cinodes = cinodes
		self.clength = clength
		self.csize = csize
		self.crealsize = crealsize
### End of inline import from common/models.py

### from common.cluster import *      # MFS_INLINE_IMPORT - inlined below:
### Imported inline from common/cluster.py:
try:
	from common.constants import *
	from common.utils import *
	from common.conn import *
	from common.models import *
except:
	pass # imports may be unaccessible in a single mfscli file but they should be already inlined instead

# # called asynchronously after receiving the answer to the info command from each master server
# # it should decode the answer and built the master server object
# def process_info_answer(host,port,data,length,error):
# 	# print("process_info_answer data: %s\n\n" % data)
# 	version = (0,0,0)
# 	workingstate = STATE_DUMMY
# 	statestr = ""
# 	statecolor = 1
# 	memusage = 0
# 	syscpu = 0
# 	usercpu = 0
# 	lastsuccessfulstore = 0
# 	lastsaveseconds = 0
# 	lastsavestatus = 0
# 	metaversion = 0
# 	exportschecksum = None
# 	metaid = None
# 	lastsavemetaversion = None
# 	lastsavemetachecksum = None
# 	usectime = None
# 	chlogtime = 0
# 	try:
# 		if length==52:
# 			version = (1,4,0)
# 		elif length==60:
# 			version = (1,5,0)
# 		elif length==68 or length==76 or length==101: #(size < 121 => version < 2.0.0)
# 			version = struct.unpack(">HBB",data[:4])
# 		# (size = 121,version >= 2.0.0) (size = 129,version >= 3.0.32) (size = 173,version >= 4.4.0)
# 		elif length==121 or length==129 or length==137 or length==149 or length==173 or length==181 or length==193 or length==205:
# 			offset = 8 if (length>=137 and length!=173) else 0
# 			version = struct.unpack(">HBB",data[:4])
# 			memusage,syscpu,usercpu = struct.unpack(">QQQ",data[4:28])
# 			syscpu/=10000000.0
# 			usercpu/=10000000.0
# 			if length==205:
# 				offset += 4
# 			lastsuccessfulstore,lastsaveseconds,lastsavestatus = struct.unpack(">LLB",data[offset+92:offset+101])
# 			if version>(2,0,14):
# 				lastsaveseconds = lastsaveseconds / 1000.0
# 			workingstate,nextstate,stablestate,sync,leaderip,changetime,metaversion = struct.unpack(">BBBBLLQ",data[offset+101:offset+121])
# 			if length>=129:
# 				exportschecksum = struct.unpack(">Q",data[offset+121:offset+129])[0]
# 			if length>=173:
# 				metaid,lastsavemetaversion,lastsavemetachecksum = struct.unpack(">QQL",data[offset+129:offset+149])
# 			if length==149 or length==193 or length==205:
# 				usectime,chlogtime = struct.unpack(">QL",data[length-12:length])
# 			if workingstate==STATE_MASTERCE and nextstate==STATE_MASTERCE and stablestate==STATE_MASTERCE and sync==STATE_MASTERCE:
# 				statestr = state_name(workingstate) # "MASTER"
# 				statecolor = 0
# 			elif stablestate==0 or workingstate!=nextstate:
# 				statestr = "transition %s -> %s" % (state_name(workingstate),state_name(nextstate))
# 				statecolor = 8
# 			else:
# 				statestr = state_name(workingstate)
# 				statecolor = state_color(workingstate,sync)
# 		else:
# 			version = (0,0,0) # unknown version
# 		# except Exception:
# 		# 	statestr = STATE_STR_BUSY
# 		# 	statecolor = 7
# 	except Exception:
# 		workingstate = STATE_UNREACHABLE
# 		statestr = STATE_STR_UNREACHABLE
# 	ms = MasterServer(host,port,version,workingstate,sync,statestr,statecolor,metaversion,memusage,syscpu,usercpu,lastsuccessfulstore,lastsaveseconds,lastsavestatus,exportschecksum,metaid,lastsavemetaversion,lastsavemetachecksum,usectime,chlogtime)
# 	return ms

# Represents state of master servers in the cluster: leader, elect etc.
class Cluster:
	# possible_leader_ip is a hint for possible leading master IP address (the previously known leader)
	def __init__(self, masterhost, masterport, possible_leader_ip=None):
		self.masterhost = masterhost
		self.masterport = masterport

		# Don't use the following underscored variables directly, use the methods instead
		self._masterconn = None
		self._masterlist = None
		self._masterinfo = None
		self._master_exportschecksum = 0
		self._master_metaid = 0
		self._leader_usectime = None

		self._leaderfound = 0
		self._electfound = 0
		self._usurperfound = 0
		self._followerfound = 0
		self._deputyfound = 0

		# Resolve master hostname to all IP addresses
		self.addresses = []
		for mhost in self.masterhost.replace(';',' ').replace(',',' ').split():
			try:
				for i in socket.getaddrinfo(mhost,self.masterport,socket.AF_INET,socket.SOCK_STREAM,socket.SOL_TCP):
					if i[0]==socket.AF_INET and i[1]==socket.SOCK_STREAM and i[2]==socket.SOL_TCP:
						self.addresses.append(i[4])
						# print("Master address: %s:%u" % i[4])
			except Exception:
				pass

		# self.find_all_masters()
		
		if possible_leader_ip:
			# put possible leader to the beginning of the list
			self.addresses.sort(key=lambda x: x[0]!=possible_leader_ip)

		# Find master servers in the cluster, find them all if there is no hint for possible leading master IP address
		self.find_masters(find_all=(possible_leader_ip==None))

	# Returns True if any master server is found in the cluster
	def anyfound(self):
		return self._leaderfound or self._electfound or self._usurperfound or self._followerfound or self._deputyfound
	
	# Returns True if any leading master server is found in the cluster (leader, elect, usurper, or deputy)
	def leadingfound(self):
		return self._leaderfound or self._electfound or self._usurperfound or self._deputyfound

	# Return the current leading master server (connection)
	def master(self):
		return self._masterconn

	def leaderfound(self):
		return self._leaderfound
	def followerfound(self):
		return self._followerfound
	def electfound(self):
		return self._electfound
	def usurperfound(self):
		return self._usurperfound
	def deputyfound(self):
		return self._deputyfound

	def masterinfo(self):
		return self._masterinfo
	def master_metaid(self):
		return self._master_metaid
	def master_exportschecksum(self):
		return self._master_exportschecksum


	# def find_all_masters(self):
	# 	multiconn = MFSMultiConn(0.5,self.addresses)
	# 	answers=multiconn.command(CLTOMA_INFO,MATOCL_INFO,None,process_info_answer) 



	def find_masters(self, find_all):
		# Don't use the following variables directly, use the methods instead
		self._masterconn = None
		self._masterlist = None
		self._masterinfo = None
		self._master_exportschecksum = 0
		self._master_metaid = 0
		self._leader_usectime = None

		self._leaderfound = 0
		self._electfound = 0
		self._usurperfound = 0
		self._followerfound = 0
		self._deputyfound = 0

		leaderinfo = None
		leader_exportschecksum = None
		leader_metaid = None
		leaderconn = None

		electinfo = None
		elect_exportschecksum = None
		elect_metaid = None
		electconn = None

		usurperinfo = None
		usurper_exportschecksum = None
		usurper_metaid = None
		usurperconn = None

		followerinfo = None
		follower_exportschecksum = None
		follower_metaid = None
		followerconn = None

		if find_all:
			self._masterlist = []

		# find leader
		for mhost,mport in self.addresses:
			conn = None
			version = (0,0,0)
			workingstate = STATE_DUMMY
			sync = 0
			statestr = "???"
			statecolor = 1
			memusage = 0
			syscpu = 0
			usercpu = 0
			lastsuccessfulstore = 0
			lastsaveseconds = 0
			lastsavestatus = 0
			metaversion = 0
			exportschecksum = None
			metaid = None
			lastsavemetaversion = None
			lastsavemetachecksum = None
			usectime = None
			chlogtime = 0
			try:
				conn = MasterConn(mhost,mport)
				try:
					data,length = conn.command(CLTOMA_INFO,MATOCL_INFO)
					if length==52:
						version = (1,4,0)
						conn.set_version(version)
						if self._leaderfound==0:
							leaderconn = conn
							leaderinfo = data
							self._leaderfound = 1
						statestr = "OLD MASTER (LEADER ONLY)"
						statecolor = 0
					elif length==60:
						version = (1,5,0)
						conn.set_version(version)
						if self._leaderfound==0:
							leaderconn = conn
							leaderinfo = data
							self._leaderfound = 1
						statestr = "OLD MASTER (LEADER ONLY)"
						statecolor = 0
					elif length==68 or length==76 or length==101:
						version = struct.unpack(">HBB",data[:4])
						conn.set_version(version)
						if self._leaderfound==0 and version<(1,7,0):
							leaderconn = conn
							leaderinfo = data
							self._leaderfound = 1
						if length==76:
							memusage = struct.unpack(">Q",data[4:12])[0]
						if length==101:
							memusage,syscpu,usercpu = struct.unpack(">QQQ",data[4:28])
							syscpu/=10000000.0
							usercpu/=10000000.0
							lastsuccessfulstore,lastsaveseconds,lastsavestatus = struct.unpack(">LLB",data[92:101])
						if version<(1,7,0):
							statestr = "OLD MASTER (LEADER ONLY)"
							statecolor = 0
						else:
							statestr = "UPGRADE THIS UNIT!"
							statecolor = 2
					elif length==121 or length==129 or length==137 or length==149 or length==173 or length==181 or length==193 or length==205:
						offset = 8 if (length>=137 and length!=173) else 0
						version = struct.unpack(">HBB",data[:4])
						conn.set_version(version)
						memusage,syscpu,usercpu = struct.unpack(">QQQ",data[4:28])
						syscpu/=10000000.0
						usercpu/=10000000.0
						if length==205:
							offset += 4
						lastsuccessfulstore,lastsaveseconds,lastsavestatus = struct.unpack(">LLB",data[offset+92:offset+101])
						if conn.version_at_least(2,0,14):
							lastsaveseconds = lastsaveseconds / 1000.0
						workingstate,nextstate,stablestate,sync,leaderip,changetime,metaversion = struct.unpack(">BBBBLLQ",data[offset+101:offset+121])
						if length>=129:
							exportschecksum = struct.unpack(">Q",data[offset+121:offset+129])[0]
						if length>=173:
							metaid,lastsavemetaversion,lastsavemetachecksum = struct.unpack(">QQL",data[offset+129:offset+149])
						if length==149 or length==193 or length==205:
							usectime,chlogtime = struct.unpack(">QL",data[length-12:length])
						if workingstate==STATE_MASTERCE and nextstate==STATE_MASTERCE and stablestate==STATE_MASTERCE and sync==0xFF:
							if self._leaderfound==0:
								leaderconn = conn
								leaderinfo = data
								self._leaderfound = 1
								leader_exportschecksum = exportschecksum
								leader_metaid = metaid
								self._leader_usectime = usectime
							statestr = state_name(workingstate) # "MASTER"
							statecolor = 0
						elif stablestate==0 or workingstate!=nextstate:
							statestr = "transition %s -> %s" % (state_name(workingstate),state_name(nextstate))
							statecolor = 8
						else:
							statestr = state_name(workingstate)
							statecolor = state_color(workingstate,sync)
							if workingstate==STATE_FOLLOWER:
								# if sync==0:
								# 	statestr += " (DESYNC)"
								# if sync==2:
								# 	statestr += " (DELAYED)"
								# if sync==3:
								# 	statestr += " (INIT)"
								self._followerfound = 1
								followerconn = conn
								followerinfo = data
								follower_exportschecksum = exportschecksum
								follower_metaid = metaid
							if workingstate==STATE_USURPER and self._usurperfound==0:
								self._usurperfound = 1
								usurperconn = conn
								usurperinfo = data
								usurper_exportschecksum = exportschecksum
								usurper_metaid = metaid
							if workingstate==STATE_ELECT and self._electfound==0:
								self._electfound = 1
								electconn = conn
								electinfo = data
								elect_exportschecksum = exportschecksum
								elect_metaid = metaid
							if (workingstate==STATE_LEADER or workingstate==STATE_DEPUTY) and self._leaderfound==0:
								leaderconn = conn
								leaderinfo = data
								self._leaderfound = 1
								if (workingstate==STATE_DEPUTY):
									self._deputyfound = 1
								leader_exportschecksum = exportschecksum
								leader_metaid = metaid
								self._leader_usectime = usectime
				except Exception:
					statestr = STATE_STR_BUSY
					statecolor = 7
			except Exception:
				workingstate = STATE_UNREACHABLE
				statestr = STATE_STR_UNREACHABLE

			if conn and conn!=leaderconn and conn!=electconn and conn!=usurperconn and conn!=followerconn:
				del conn
			if find_all:
				self._masterlist.append(MasterServer(mhost,mport,version,workingstate,sync,statestr,statecolor,metaversion,memusage,syscpu,usercpu,lastsuccessfulstore,lastsaveseconds,lastsavestatus,exportschecksum,metaid,lastsavemetaversion,lastsavemetachecksum,usectime,chlogtime))

			if self._leaderfound:
				self._masterconn = leaderconn
				self._masterinfo = leaderinfo
				self._master_exportschecksum = leader_exportschecksum
				self._master_metaid = leader_metaid
				if not find_all:
					break # don't need to find other masters if leader is found
			elif self._electfound:
				self._masterconn = electconn
				self._masterinfo = electinfo
				self._master_exportschecksum = elect_exportschecksum
				self._master_metaid = elect_metaid
			elif self._usurperfound:
				self._masterconn = usurperconn
				self._masterinfo = usurperinfo
				self._master_exportschecksum = usurper_exportschecksum
				self._master_metaid = usurper_metaid
			elif self._followerfound:
				self._masterconn = followerconn
				self._masterinfo = followerinfo
				self._master_exportschecksum = follower_exportschecksum
				self._master_metaid = follower_metaid



	# Returns a list of all master servers in the cluster along with its highest metaversion and checksum (tuple)
	# Sorts if IMorder - sort order is provided, IMrev - reverse order
	def get_masterservers(self, IMorder=0, IMrev=False):
		if self._masterlist==None: # _masterlist could not be initialized if only the leader was found on initialization
			self.find_masters(True)
			# self.find_all_masters(None, True)

		if IMorder==None:
			return self._masterlist
		masterservers = []
		for ms in self._masterlist:
			if   IMorder==0:	key=lambda ms: (ms.sortip, ms.port)
			elif IMorder==1:	key=lambda ms: (ms.sortip)
			elif IMorder==2:	key=lambda ms: (ms.sortver)
			elif IMorder==3:	key=lambda ms: (ms.statecolor)
			elif IMorder==4:	key=lambda ms: (ms.usectime if ms.usectime!=None else 0)
			elif IMorder==5:	key=lambda ms: (ms.metaversion)
			elif IMorder==6:	key=lambda ms: (ms.metaid)
			elif IMorder==7:	key=lambda ms: (ms.chlogtime if ms.chlogtime!=None else 0)
			elif IMorder==8:	key=lambda ms: (ms.memusage)
			elif IMorder==9:	key=lambda ms: (ms.syscpu+ms.usercpu)
			elif IMorder==10:	key=lambda ms: (ms.lastsuccessfulstore)
			elif IMorder==11:	key=lambda ms: (ms.lastsaveseconds)
			elif IMorder==12:	key=lambda ms: (ms.lastsavestatus)
			elif IMorder==13:	key=lambda ms: (ms.lastsavemetaversion)
			elif IMorder==14:	key=lambda ms: (ms.lastsavemetachecksum)
			elif IMorder==15:	key=lambda ms: (ms.exportschecksum)
			else:				      key=lambda ms: (0)
			masterservers.append(ms)
		masterservers.sort(key=key)
		if IMrev:
			masterservers.reverse()
		return masterservers

	# Returns a list of all master servers in the cluster along with secdelta and metadelay
	# Sorts if IMorder - sort order is provided, IMrev - reverse order
	def update_masterservers_delays(self, IMorder=0, IMrev=False):
		mservers = self.get_masterservers(IMorder, IMrev)
		# Calculate necessary metrics from all metadata servers
		highest_saved_metaversion = 0
		highest_metaversion_checksum = 0
		master_minusectime = None
		master_maxusectime = None
		master_deltausectime = None
		for ms in mservers:
			if ms.lastsavemetaversion!=None and ms.lastsavemetachecksum!=None:
				if ms.lastsavemetaversion>highest_saved_metaversion:
					highest_saved_metaversion = ms.lastsavemetaversion
					highest_metaversion_checksum = ms.lastsavemetachecksum
				elif ms.lastsavemetaversion==highest_saved_metaversion:
					highest_metaversion_checksum |= ms.lastsavemetachecksum
			if self._leader_usectime==None or self._leader_usectime==0:
				if ms.usectime!=None and ms.usectime>0:
					if master_minusectime==None or ms.usectime<master_minusectime:
						master_minusectime = ms.usectime
					if master_maxusectime==None or ms.usectime>master_maxusectime:
						master_maxusectime = ms.usectime
				if master_maxusectime and master_minusectime:
					master_deltausectime = master_maxusectime - master_minusectime
		updated_masterlist = []
		for ms in mservers:
			secdelta = 0.0
			if ms.usectime!=None and ms.usectime!=0:
				if self._leader_usectime==None or self._leader_usectime==0:
					if master_deltausectime!=None:
						secdelta = (master_deltausectime) / 1000000.0
				else:
					if self._leader_usectime > ms.usectime:
						secdelta = (self._leader_usectime - ms.usectime) / 1000000.0
					else:
						secdelta = (ms.usectime - self._leader_usectime) / 1000000.0
			if ms.chlogtime==None or ms.chlogtime==0 or self._leader_usectime==None or self._leader_usectime==0:
				metadelay = None
			else:
				metadelay = self._leader_usectime/1000000.0 - ms.chlogtime
				if metadelay>1.0:
					metadelay-=1.0
				else:
					metadelay=0.0
			ms.secdelta = secdelta
			ms.metadelay = metadelay
			updated_masterlist.append(ms)
		self._masterlist = updated_masterlist
		return highest_saved_metaversion, highest_metaversion_checksum

### End of inline import from common/cluster.py

### from common.dataprovider import * # MFS_INLINE_IMPORT - inlined below:
### Imported inline from common/dataprovider.py:
import struct
from typing import List

try:
	from common.constants import *
	from common.errors import *
	from common.utils import *
	from common.models import *
	from common.conn import *
except:
	pass # imports may be unaccessible in a single mfscli file but they should be already inlined instead

class DataProvider:
	def __init__(self, cluster, donotresolve):
		self.cluster = cluster

		# Caching variables - to prevent many requests to the master:
		self.clusterinfo = None
		self.metaloggers = None
		self.matrices = {}
		self.matrix_summary = None
		self.missing_chunks = None
		self.chunkservers = None
		self.sessions = None
		self.exports = None
		self.sclasses_names = None
		self.sclasses = None
		self.opatterns = None
		self.chunktestinfo = None
		self.openfiles = None
		self.acquiredlocks = None
		self.quotas = None
		self.quotas_maxperc = 0

		self.donotresolve = donotresolve # don't resolve IPs to hostnames
		if self.master()!=None and self.master().has_feature(FEATURE_SESSION_STATS_28):
			self.stats_to_show = 28
		else:
			self.stats_to_show = 16

	def master(self):
		return self.cluster.master()
	
	def get_masterservers(self, IMorder=0, IMrev=False):
		return self.cluster.get_masterservers(IMorder, IMrev)

	def get_metaloggers(self, order=1, rev=False):
		if self.metaloggers==None:
			self.metaloggers=[]
			data,length = self.master().command(CLTOMA_MLOG_LIST,MATOCL_MLOG_LIST)
			if (length%8)==0:
				n = length//8
				for i in range(n):
					d = data[i*8:(i+1)*8]
					v1,v2,v3,ip1,ip2,ip3,ip4 = struct.unpack(">HBBBBBB",d)
					mls = Metalogger((ip1,ip2,ip3,ip4),self.donotresolve,(v1,v2,v3))
					self.metaloggers.append(mls)

		if order is None:
			return self.metaloggers
		
		if   order==1: key=lambda entry: (entry.host)
		elif order==2: key=lambda entry: (entry.sortip)
		elif order==3: key=lambda entry: (entry.sortver)
		else:          key=lambda entry: (entry.host)
		self.metaloggers.sort(key=key)
		if rev:
			self.metaloggers.reverse()
		return self.metaloggers
	
	def get_clusterinfo(self):
		if self.clusterinfo==None:
			masterinfo = self.cluster.masterinfo()
			length = len(masterinfo)
			if length==121 or length==129 or length==137 or length==149 or length==173 or length==181 or length==193 or length==205:
				offset = 8 if (length>=137 and length!=173) else 0
				if offset==8:
					v1,v2,v3,memusage,syscpu,usercpu,totalspace,availspace,freespace,trspace,trfiles,respace,refiles,nodes,dirs,files,chunks = struct.unpack(">HBBQQQQQQQLQLLLLL",masterinfo[:84+offset])
				else:
					v1,v2,v3,memusage,syscpu,usercpu,totalspace,availspace,trspace,trfiles,respace,refiles,nodes,dirs,files,chunks = struct.unpack(">HBBQQQQQQLQLLLLL",masterinfo[:84])
					freespace = None
				if length==205:
					lastsuccessfulstore,lastsaveseconds,lastsavestatus = struct.unpack(">LLB",masterinfo[offset+96:offset+105])
				else:
					lastsuccessfulstore,lastsaveseconds,lastsavestatus = struct.unpack(">LLB",masterinfo[offset+92:offset+101])

				if length>=173:
					metainfomode = 1
					if length==205:
						copychunks,ec8chunks,ec4chunks = struct.unpack(">LLL",masterinfo[offset+84:offset+96])
					else:
						copychunks,ec8chunks = struct.unpack(">LL",masterinfo[offset+84:offset+92])
						ec4chunks = 0
					if length==205:
						chunkcopies,chunkec8parts,chunkec4parts,chunkhypcopies = struct.unpack(">QQQQ",masterinfo[offset+153:offset+185])
					else:
						chunkcopies,chunkec8parts,chunkhypcopies = struct.unpack(">QQQ",masterinfo[offset+149:offset+173])
						chunkec4parts = 0
					allcopies = regularcopies = None
				else:
					metainfomode = 0
					allcopies,regularcopies = struct.unpack(">LL",masterinfo[offset+84:offset+92])
					copychunks = ec8chunks = ec4chunks = None
					chunkcopies = chunkec8parts = chunkec4parts = chunkhypcopies = None
				
				syscpu/=10000000.0
				usercpu/=10000000.0
				lastsaveseconds = lastsaveseconds / 1000.0
			else:
				raise Exception("Unrecognized MATOCL_INFO answer from the Master server (too old version?)")
			
			self.clusterinfo = ClusterInfo((v1,v2,v3),memusage,syscpu,usercpu,totalspace,availspace,freespace,trspace,trfiles,respace,refiles,nodes,dirs,files,chunks,lastsuccessfulstore,lastsaveseconds,lastsavestatus,metainfomode,
																	allcopies,regularcopies,copychunks,ec8chunks,ec4chunks,chunkcopies,chunkec8parts,chunkec4parts,chunkhypcopies)
		return self.clusterinfo
	
	def get_licence(self):
		return None
		
	def get_matrix(self, sclassid=-1):
		if not sclassid in self.matrices or self.progressstatus!=0:
			if self.master().has_feature(FEATURE_SCLASS_IN_MATRIX):
				if sclassid>=0:
					data,length = self.master().command(CLTOMA_CHUNKS_MATRIX,MATOCL_CHUNKS_MATRIX,struct.pack(">BB",0,sclassid))
				else:
					data,length = self.master().command(CLTOMA_CHUNKS_MATRIX,MATOCL_CHUNKS_MATRIX)
			else:
				if sclassid>=0:
					raise RuntimeError("storage class id in matrix is not supported by your master")
				data,length = self.master().command(CLTOMA_CHUNKS_MATRIX,MATOCL_CHUNKS_MATRIX)
			if length==(1+484*2):
				self.progressstatus = struct.unpack(">B",data[0:1])[0]
				self.matrices[sclassid] = ([],[])
				for x in range(2):
					for i in range(11):
						self.matrices[sclassid][x].append(list(struct.unpack(">LLLLLLLLLLL",data[1+x*484+i*44:45+x*484+i*44])))
			elif length==(1+484*6):
				self.progressstatus = struct.unpack(">B",data[0:1])[0]
				self.matrices[sclassid] = ([],[],[],[],[],[])
				for x in range(6):
					for i in range(11):
						self.matrices[sclassid][x].append(list(struct.unpack(">LLLLLLLLLLL",data[1+x*484+i*44:45+x*484+i*44])))
			elif length==(1+484*8):
				self.progressstatus = struct.unpack(">B",data[0:1])[0]
				self.matrices[sclassid] = ([],[],[],[],[],[],[],[])
				for x in range(8):
					for i in range(11):
						self.matrices[sclassid][x].append(list(struct.unpack(">LLLLLLLLLLL",data[1+x*484+i*44:45+x*484+i*44])))
		return (self.matrices[sclassid], self.progressstatus)

	# Calculate sums of missing, undergoal and endangered (for all sclasses)
	# Returns an array of 8: [missing, endangered, undergoal, stable, overgoal, pending deletion, ready to be removed, and total no of chunks
	def get_matrix_summary(self):
		if self.matrix_summary:
			return (self.matrix_summary, self.progressstatus)
		self.matrix_summary = [0] * (MX_COL_TOTAL+1)
		(matrix,_)=self.get_matrix()

		for goal in range(11):
			for actual in range(11):
				(col,_)=redundancy2colclass(goal,actual)
				for i in range(len(matrix)):
					self.matrix_summary[col]+=matrix[0][goal][actual]
					self.matrix_summary[MX_COL_TOTAL]+=matrix[0][goal][actual]
		return (self.matrix_summary, self.progressstatus)

	def get_health_selfcheck(self):
		if (self.master().version_at_least(2,0,66) and self.master().version_less_than(3,0,0)) or self.master().version_at_least(3,0,19):
			data,length = self.master().command(CLTOMA_FSTEST_INFO,MATOCL_FSTEST_INFO,struct.pack(">B",0))
			pver = 1
		else:
			data,length = self.master().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:
				mtfiles = None
				msfiles = None
				loopstart,loopend,files,ugfiles,mfiles,chunks,ugchunks,mchunks,msgbuffleng = struct.unpack(">LLLLLLLLL",data[:36])
				datastr = data[36:].decode('utf-8','replace')
			return HealthSelfCheck(loopstart,loopend,files,ugfiles,mfiles,mtfiles,msfiles,chunks,ugchunks,mchunks,msgbuffleng,datastr)
		else:
			raise RuntimeError("MFS packet malformed (MATOCL_FSTEST_INFO)")


	# Returns a list of missing chunks (along with files paths) 
	def get_missing_chunks(self, MForder=0, MFrev=False):
		if self.missing_chunks==None:
			self.missing_chunks = []
			missing_inodes = set()
			missings = []
			if (self.master().version_at_least(3,0,25)):
				# get missing chunks list from master
				data,length = self.master().command(CLTOMA_MISSING_CHUNKS,MATOCL_MISSING_CHUNKS,struct.pack(">B",1))
				if length%17==0:
					n = length//17
					for x in range(n):
						chunkid,inode,indx,mtype = struct.unpack(">QLLB",data[x*17:x*17+17])
						missing_inodes.add(inode)
						missings.append((chunkid,inode,indx,mtype))
			inodepaths = self.resolve_inodes_paths(missing_inodes)
			for chunkid,inode,indx,mtype in missings:
				# resolve paths for inode if possible
				if inode in inodepaths:
					paths = inodepaths[inode]
				else:
					paths = []
				self.missing_chunks.append(MissingChunk(paths,inode,indx,chunkid,mtype))

		if MForder is None:
			return self.missing_chunks

		if   MForder==1:  key=lambda mc: (mc.paths)
		elif MForder==2:  key=lambda mc: (mc.inode)
		elif MForder==3:  key=lambda mc: (mc.indx)
		elif MForder==4:  key=lambda mc: (mc.chunkid)
		elif MForder==4:  key=lambda mc: (mc.mtype)
		else:             key=lambda mc: (mc.paths)

		self.missing_chunks.sort(key=key)
		if MFrev:
			self.missing_chunks.reverse()		
		return self.missing_chunks

	# Resolve paths for a list of inodes
	def resolve_inodes_paths(self, inodes):
		def create_chunks(list_name, n):
			listobj = list(list_name)
			for i in range(0, len(listobj), n):
				yield listobj[i:i + n]
		inodepaths = {}
		for chunk in create_chunks(inodes,100):
			if len(chunk)>0:
				data,length = self.master().command(CLTOMA_MASS_RESOLVE_PATHS,MATOCL_MASS_RESOLVE_PATHS,struct.pack(">"+len(chunk)*"L",*chunk))
				pos = 0
				while pos+8<=length:
					inode,psize = struct.unpack(">LL",data[pos:pos+8])
					pos+=8
					if psize == 0:
						if inode not in inodepaths:
							inodepaths[inode] = []
						inodepaths[inode].append("./META")
					elif pos + psize <= length:
						while psize>=4:
							pleng = struct.unpack(">L",data[pos:pos+4])[0]
							pos+=4
							psize-=4
							path = data[pos:pos+pleng]
							pos+=pleng
							psize-=pleng
							path = path.decode('utf-8','replace')
							if inode not in inodepaths:
								inodepaths[inode] = []
							inodepaths[inode].append(path)
						if psize!=0:
							raise RuntimeError("MFS packet malformed (MATOCL_MASS_RESOLVE_PATHS)")
				if pos!=length:
					raise RuntimeError("MFS packet malformed (MATOCL_MASS_RESOLVE_PATHS)")
		return inodepaths

	def get_memory_usage(self):
		data,length = self.master().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 range(len(memusage)>>1):
				totalused += memusage[1+i*2]
				totalallocated += memusage[i*2]
			return MemoryUsage(memlabels,abrlabels,totalused,totalallocated,memusage)
		else:
			raise RuntimeError("MFS packet malformed (MATOCL_MEMORY_INFO)")

	# Returns a list of all chunkservers in the cluster
	# CSorder - order of chunkservers in the list, None - no ordering, Default - order by IP address and port nunmber	
	# CSrev - reverse order in the returned list
	# CScsid - return only chunkserver with given id (used for displaying a single chunkserver info)
	def get_chunkservers(self, CSorder=0, CSrev=False):
		if self.chunkservers==None:
			self.chunkservers=[]
			if self.master().has_feature(FEATURE_CSLIST_MODE):
				data,length = self.master().command(CLTOMA_CSERV_LIST,MATOCL_CSERV_LIST,struct.pack(">B",1))
			else:
				data,length = self.master().command(CLTOMA_CSERV_LIST,MATOCL_CSERV_LIST)
			cs = None
			if self.master().version_at_least(4,35,0) and (length%77)==0:
				n = length//77
				for i in range(n):
					d = data[i*77:(i+1)*77]
					flags,v1,v2,v3,oip1,oip2,oip3,oip4,ip1,ip2,ip3,ip4,port,csid,used,total,chunks,tdused,tdtotal,tdchunks,errcnt,queue,gracetime,labels,mfrstatus,maintenanceto = struct.unpack(">BBBBBBBBBBBBHHQQLQQLLLLLBL",d)
					cs = ChunkServer((oip1,oip2,oip3,oip4),(ip1,ip2,ip3,ip4),self.donotresolve,port,csid,v1,v2,v3,flags,used,total,chunks,tdused,tdtotal,tdchunks,errcnt,queue,gracetime,labels,mfrstatus,maintenanceto)
					self.chunkservers.append(cs)
			elif self.master().version_at_least(4,26,0) and self.master().version_less_than(4,35,0) and (length%73)==0:
				n = length//73
				for i in range(n):
					d = data[i*73:(i+1)*73]
					flags,v1,v2,v3,oip1,oip2,oip3,oip4,ip1,ip2,ip3,ip4,port,csid,used,total,chunks,tdused,tdtotal,tdchunks,errcnt,queue,gracetime,labels,mfrstatus = struct.unpack(">BBBBBBBBBBBBHHQQLQQLLLLLB",d)
					cs = ChunkServer((oip1,oip2,oip3,oip4),(ip1,ip2,ip3,ip4),self.donotresolve,port,csid,v1,v2,v3,flags,used,total,chunks,tdused,tdtotal,tdchunks,errcnt,queue,gracetime,labels,mfrstatus,None)
					self.chunkservers.append(cs)
			elif self.master().version_at_least(3,0,38) and self.master().version_less_than(4,26,0) and (length%69)==0:
				n = length//69
				for i in range(n):
					d = data[i*69:(i+1)*69]
					flags,v1,v2,v3,ip1,ip2,ip3,ip4,port,csid,used,total,chunks,tdused,tdtotal,tdchunks,errcnt,queue,gracetime,labels,mfrstatus = struct.unpack(">BBBBBBBBHHQQLQQLLLLLB",d)
					cs = ChunkServer((ip1,ip2,ip3,ip4),(ip1,ip2,ip3,ip4),self.donotresolve,port,csid,v1,v2,v3,flags,used,total,chunks,tdused,tdtotal,tdchunks,errcnt,queue,gracetime,labels,mfrstatus,None)
					self.chunkservers.append(cs)
			elif self.master().version_at_least(2,1,0) and self.master().version_less_than(3,0,38) and (length%68)==0:
				n = length//68
				for i in range(n):
					d = data[i*68:(i+1)*68]
					flags,v1,v2,v3,ip1,ip2,ip3,ip4,port,csid,used,total,chunks,tdused,tdtotal,tdchunks,errcnt,queue,gracetime,labels = struct.unpack(">BBBBBBBBHHQQLQQLLLLL",d)
					cs = ChunkServer((ip1,ip2,ip3,ip4),(ip1,ip2,ip3,ip4),self.donotresolve,port,csid,v1,v2,v3,flags,used,total,chunks,tdused,tdtotal,tdchunks,errcnt,queue,gracetime,labels,None,None)
					self.chunkservers.append(cs)
			else:
				raise RuntimeError("Invalid chunkservers list data (MATOCL_CSERV_LIST)")

		if CSorder is None:
			return self.chunkservers
		
		if   CSorder==0:  key=lambda cs: (cs.sortip,cs.port)
		elif CSorder==1:  key=lambda cs: (cs.host)
		elif CSorder==2:  key=lambda cs: (cs.sortip,cs.port)
		elif CSorder==3:  key=lambda cs: (cs.port)
		elif CSorder==4:  key=lambda cs: (cs.csid)
		elif CSorder==5:  key=lambda cs: (cs.sortver)
		elif CSorder==6:  key=lambda cs: (cs.gracetime,cs.queue)
		elif CSorder==7:  key=lambda cs: (cs.queue)
		elif CSorder==10: key=lambda cs: (cs.chunks)
		elif CSorder==11: key=lambda cs: (cs.used)
		elif CSorder==12: key=lambda cs: (cs.total)
		elif CSorder==13: key=lambda cs: ((1.0*cs.used)/cs.total if cs.total>0 else 0)
		elif CSorder==20: key=lambda cs: (cs.tdchunks)
		elif CSorder==21: key=lambda cs: (cs.tdused)
		elif CSorder==22: key=lambda cs: (cs.tdtotal)
		elif CSorder==23: key=lambda cs: ((1.0*cs.tdused)/cs.tdtotal if cs.tdtotal>0 else 0)
		else:             key=lambda cs: (0)

		self.chunkservers.sort(key=key)
		if CSrev:
			self.chunkservers.reverse()

		return self.chunkservers

	# Returns a tuple of two lists: first list contains connected chunkservers, 
	# second list contains disconnected chunkservers
	def get_chunkservers_by_state(self, CSorder=0, CSrev=False):
		servers = []
		dservers = []
		for cs in self.get_chunkservers(CSorder, CSrev):
			if cs.is_connected():
				servers.append(cs)
			else:
				dservers.append(cs)
		return servers,dservers


	# Get list of hdds for chunk servers, 
	# HDdata - selects what disks should be returned: "ALL" - all, "ERR" - only with errors, "NOK" - only w/out ok status, "ip:port" - only for a given ip/port chunk server
	# HDorder - sort order
	# HDrev - reverse sort order
	# returns tuple: (hdds,scanhdds)
	def get_hdds(self, HDdata, HDperiod=0, HDtime=0, HDorder=0, HDrev=False):
		# get cs list
		hostlist = []
		multiconn = MFSMultiConn()
		for cs in self.get_chunkservers(None): # don't sort
			if cs.port>0 and cs.is_connected():
				hostip = "%u.%u.%u.%u" % cs.ip
				hostkey = "%s:%u" % (hostip,cs.port)
				sortip = "%03u.%03u.%03u.%03u:%05u" % (cs.ip[0],cs.ip[1],cs.ip[2],cs.ip[3],cs.port)
				if HDdata=="ALL" or HDdata=="ERR" or HDdata=="NOK" or HDdata==hostkey:
					hostlist.append((hostkey,hostip,sortip,cs.port,cs.version,cs.mfrstatus))
					multiconn.register(hostip,cs.port) #register CS to send command to

		if len(hostlist)==0:
			return ([], [])

		# get hdd lists - from all cs at once
		answers=multiconn.command(CLTOCS_HDD_LIST,CSTOCL_HDD_LIST) #ask all registered chunk servers about hdds
		hdds = []
		scanhdds = []
		for hostkey,hostip,sortip,port,version,mfrstatus in hostlist:
			hoststr = resolve(hostip, self.donotresolve)
			if version<=(1,6,8):
				hdds.append((sortip,HDD(CS_HDD_CS_TOO_OLD,hostkey,hoststr,hostip,port,"",sortip,hostkey,hoststr,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,0],0)))
			elif hostkey not in answers:
				hdds.append((sortip,HDD(CS_HDD_CS_UNREACHABLE,hostkey,hoststr,hostip,port,"",sortip,hostkey,hoststr,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,0],0)))
			else:
				data,length = answers[hostkey]
				while length>0:
					entrysize = struct.unpack(">H",data[:2])[0]
					entry = data[2:2+entrysize]
					data = data[2+entrysize:]
					length -= 2+entrysize
					plen = entry[0]
					hddpathhex = entry[1:plen+1].hex()
					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)
					clearerrorarg = "%s:%u:%s" % (hostip,port,hddpathhex)
					sortippath = "%s:%s" % (sortip,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])
					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])
					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 #default sort field
					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:	sf = usecreadavg[HDperiod] if HDtime==1 else usecreadmax[HDperiod]
					elif HDorder==8:	sf = usecwriteavg[HDperiod] if HDtime==1 else usecwritemax[HDperiod]
					elif HDorder==9:	sf = usecfsyncavg[HDperiod] if HDtime==1 else usecfsyncmax[HDperiod]
					elif HDorder==10:	sf = rops[HDperiod]
					elif HDorder==11:	sf = wops[HDperiod]
					elif HDorder==12:	sf = fsyncops[HDperiod]
					elif HDorder==20:	sf = used if flags&CS_HDD_SCANNING==0 else 0
					elif HDorder==21:	sf = total if flags&CS_HDD_SCANNING else 0
					elif HDorder==22:	sf = (1.0*used)/total if flags&CS_HDD_SCANNING==0 and total>0 else 0

					if (HDdata=="ERR" and errtime>0) or (HDdata=="NOK" and flags!=0) or (HDdata!="ERR" and HDdata!="NOK"):
						hdd = HDD(CS_HDD_CS_VALID,hostkey,hoststr,hostip,port,hddpath,sortippath,ippath,hostpath,flags,clearerrorarg,errchunkid,errtime,used,total,chunkscnt,rbw,wbw,usecreadavg,usecwriteavg,usecfsyncavg,usecreadmax,usecwritemax,usecfsyncmax,rops,wops,fsyncops,rbytes,wbytes,mfrstatus)
						if flags&CS_HDD_SCANNING: #and not cgimode and ttymode:
							scanhdds.append((sf,hdd))
						else:
							hdds.append((sf,hdd))
		hdds.sort()
		scanhdds.sort()
		if HDrev:
			hdds.reverse()
			scanhdds.reverse()
		return (hdds, scanhdds)
	
	# Summarizes hdd info for given chunkserver,
	# returns tuple: string status of all disks (unknown or ok or warnings or errors) and a list of disks with a few basic fields only
	def cs_hdds_status(self, cs, hdds_all):
		hdds_out = []
		hdds_status = 'ok'
		for (_,hdd) in hdds_all:
			if cs.hostkey!=hdd.hostkey:
				continue
			if (hdd.flags&CS_HDD_INVALID):
				status = 'invalid'
				hdds_status = 'errors'
			elif hdd.flags&CS_HDD_SCANNING:
				status = 'scanning'
			elif (hdd.flags&CS_HDD_DAMAGED) and (hdd.flags&CS_HDD_SCANNING)==0 and (hdd.flags&CS_HDD_INVALID)==0:
				status = 'damaged'
				hdds_status = 'errors'
			elif hdd.flags&CS_HDD_MFR:
				status = 'marked for removal'
			elif hdd.flags==0:
				status = 'ok'
			else:
				status = 'unknown'
				if hdds_status!='errors':
					hdds_status = 'warnings' 
			if hdd.errtime>0:
				status = 'warning' 
				if hdds_status!='errors':
					hdds_status = 'warnings' 
			hdds_out.append({
				'flags': hdd.flags,
				'errtime': hdd.errtime,
				'status': status,
				'used': hdd.used,
				'total': hdd.total
				})
		return (hdds_status, hdds_out)


	
	def get_exports(self, EXorder=0, EXrev=False):
		if self.exports==None:
			self.exports=[]
			if self.master().has_feature(FEATURE_SCLASSGROUPS):
				data,length = self.master().command(CLTOMA_EXPORTS_INFO,MATOCL_EXPORTS_INFO,struct.pack(">B",4))
			elif self.master().has_feature(FEATURE_EXPORT_DISABLES):
				data,length = self.master().command(CLTOMA_EXPORTS_INFO,MATOCL_EXPORTS_INFO,struct.pack(">B",3))
			elif self.master().has_feature(FEATURE_EXPORT_UMASK):
				data,length = self.master().command(CLTOMA_EXPORTS_INFO,MATOCL_EXPORTS_INFO,struct.pack(">B",2))
			else: #if self.master().version_at_least(1,6,26):
				data,length = self.master().command(CLTOMA_EXPORTS_INFO,MATOCL_EXPORTS_INFO,struct.pack(">B",1))
			pos = 0
			while pos<length:
				fip1,fip2,fip3,fip4,tip1,tip2,tip3,tip4,pleng = struct.unpack(">BBBBBBBBL",data[pos:pos+12])
				pos+=12
				path = data[pos:pos+pleng]
				path = path.decode('utf-8','replace')
				pos+=pleng
				if self.master().has_feature(FEATURE_SCLASSGROUPS):
					v1,v2,v3,exportflags,sesflags,umaskval,rootuid,rootgid,mapalluid,mapallgid,sclassgroups,mintrashretention,maxtrashretention,disables = struct.unpack(">HBBBBHLLLLHLLL",data[pos:pos+38])
					pos+=38
					mingoal = None
					maxgoal = None
					if mintrashretention==0 and maxtrashretention==0xFFFFFFFF:
						mintrashretention = None
						maxtrashretention = None
				elif self.master().has_feature(FEATURE_EXPORT_DISABLES):
					v1,v2,v3,exportflags,sesflags,umaskval,rootuid,rootgid,mapalluid,mapallgid,mingoal,maxgoal,mintrashretention,maxtrashretention,disables = struct.unpack(">HBBBBHLLLLBBLLL",data[pos:pos+38])
					pos+=38
					sclassgroups = None
					if mingoal<=1 and maxgoal>=9:
						mingoal = None
						maxgoal = None
					if mintrashretention==0 and maxtrashretention==0xFFFFFFFF:
						mintrashretention = None
						maxtrashretention = None
				elif self.master().has_feature(FEATURE_EXPORT_UMASK):
					v1,v2,v3,exportflags,sesflags,umaskval,rootuid,rootgid,mapalluid,mapallgid,mingoal,maxgoal,mintrashretention,maxtrashretention = struct.unpack(">HBBBBHLLLLBBLL",data[pos:pos+34])
					pos+=34
					disables = 0
					sclassgroups = None
					if mingoal<=1 and maxgoal>=9:
						mingoal = None
						maxgoal = None
					if mintrashretention==0 and maxtrashretention==0xFFFFFFFF:
						mintrashretention = None
						maxtrashretention = None
				else: #if self.master().version_at_least(1,6,26):
					v1,v2,v3,exportflags,sesflags,rootuid,rootgid,mapalluid,mapallgid,mingoal,maxgoal,mintrashretention,maxtrashretention = struct.unpack(">HBBBBLLLLBBLL",data[pos:pos+32])
					pos+=32
					disables = 0
					sclassgroups = None
					if mingoal<=1 and maxgoal>=9:
						mingoal = None
						maxgoal = None
					if mintrashretention==0 and maxtrashretention==0xFFFFFFFF:
						mintrashretention = None
						maxtrashretention = None
					umaskval = None
				if path=='.':
					meta = 1
					umaskval = None
					disables = 0
				else:
					meta = 0
				expent = ExportsEntry(fip1,fip2,fip3,fip4,tip1,tip2,tip3,tip4,path,meta,v1,v2,v3,exportflags,sesflags,umaskval,rootuid,rootgid,mapalluid,mapallgid,sclassgroups,mingoal,maxgoal,mintrashretention,maxtrashretention,disables)
				self.exports.append(expent)
		
		if EXorder is None:
			return self.exports
		
		if EXorder==1:  key=lambda ee: (ee.sortipfrom + ee.sortipto)
		elif EXorder==2:  key=lambda ee: (ee.sortipto + ee.sortipfrom)
		elif EXorder==3:  key=lambda ee: (ee.path)
		elif EXorder==4:  key=lambda ee: (ee.sortver)
		elif EXorder==5:  key=lambda ee: (None if ee.meta else ee.is_alldirs())
		elif EXorder==6:  key=lambda ee: (ee.is_password())
		elif EXorder==7:  key=lambda ee: (ee.is_readonly())
		elif EXorder==8:  key=lambda ee: (2-(ee.is_unrestricted()))
		elif EXorder==9:  key=lambda ee: (None if ee.meta else ee.ignore_gid())
		elif EXorder==10: key=lambda ee: (None if ee.meta else ee.is_admin())
		elif EXorder==11: key=lambda ee: (None if ee.meta else ee.rootuid)
		elif EXorder==12: key=lambda ee: (None if ee.meta else ee.rootgid)
		elif EXorder==13: key=lambda ee: (None if ee.meta or (ee.map_user())==0 else ee.mapalluid)
		elif EXorder==14: key=lambda ee: (None if ee.meta or (ee.map_user())==0 else ee.mapallgid)
		elif EXorder==15: key=lambda ee: (ee.sclassgroups)
		elif EXorder==16: key=lambda ee: (ee.sclassgroups)
		elif EXorder==17: key=lambda ee: (ee.mintrashretention)
		elif EXorder==18: key=lambda ee: (ee.maxtrashretention)
		elif EXorder==19: key=lambda ee: (ee.umaskval)
		elif EXorder==20: key=lambda ee: (ee.disables)
		else: key=lambda ee: (ee.sortipfrom + ee.sortipto)

		self.exports.sort(key=key)
		if EXrev:
			self.exports.reverse()

		return self.exports
	
	# Returns a list of all sessions (clients) connected to the cluster
	# MSorder - order of master servers in the list, None - no ordering, default 0 - order by IP
	# MSrev - reverse order in the returned list
	# Returns a list of Session objects
	def get_sessions(self, MSorder=0, MSrev=False):
		if self.sessions==None:
			self.sessions=[]
			if self.master().has_feature(FEATURE_SCLASSGROUPS):
				data,length = self.master().command(CLTOMA_SESSION_LIST,MATOCL_SESSION_LIST,struct.pack(">B",5))
			elif self.master().has_feature(FEATURE_EXPORT_DISABLES):
				data,length = self.master().command(CLTOMA_SESSION_LIST,MATOCL_SESSION_LIST,struct.pack(">B",4))
			elif self.master().has_feature(FEATURE_EXPORT_UMASK):
				data,length = self.master().command(CLTOMA_SESSION_LIST,MATOCL_SESSION_LIST,struct.pack(">B",3))
			else: #if self.master().version_at_least(1,7,8):
				data,length = self.master().command(CLTOMA_SESSION_LIST,MATOCL_SESSION_LIST,struct.pack(">B",2))
			statscnt = struct.unpack(">H",data[0:2])[0]
			pos = 2
			while pos<length:
				sessionid,ip1,ip2,ip3,ip4,v1,v2,v3,openfiles,nsocks,expire,ileng = struct.unpack(">LBBBBHBBLBLL",data[pos:pos+25])
				pos+=25
				info = data[pos:pos+ileng]
				pos+=ileng
				pleng = struct.unpack(">L",data[pos:pos+4])[0]
				pos+=4
				path = data[pos:pos+pleng]
				pos+=pleng
				info = info.decode('utf-8','replace')
				path = path.decode('utf-8','replace')
				if self.master().has_feature(FEATURE_SCLASSGROUPS):
					sesflags,umaskval,rootuid,rootgid,mapalluid,mapallgid,sclassgroups,mintrashretention,maxtrashretention,disables = struct.unpack(">BHLLLLHLLL",data[pos:pos+33])
					pos+=33
					mingoal = None
					maxgoal = None
					if mintrashretention==0 and maxtrashretention==0xFFFFFFFF:
						mintrashretention = None
						maxtrashretention = None
				elif self.master().has_feature(FEATURE_EXPORT_DISABLES):
					sesflags,umaskval,rootuid,rootgid,mapalluid,mapallgid,mingoal,maxgoal,mintrashretention,maxtrashretention,disables = struct.unpack(">BHLLLLBBLLL",data[pos:pos+33])
					pos+=33
					sclassgroups = None
					if mingoal<=1 and maxgoal>=9:
						mingoal = None
						maxgoal = None
					if mintrashretention==0 and maxtrashretention==0xFFFFFFFF:
						mintrashretention = None
						maxtrashretention = None
				elif self.master().has_feature(FEATURE_EXPORT_UMASK):
					sesflags,umaskval,rootuid,rootgid,mapalluid,mapallgid,mingoal,maxgoal,mintrashretention,maxtrashretention = struct.unpack(">BHLLLLBBLL",data[pos:pos+29])
					pos+=29
					disables = 0
					sclassgroups = None
					if mingoal<=1 and maxgoal>=9:
						mingoal = None
						maxgoal = None
					if mintrashretention==0 and maxtrashretention==0xFFFFFFFF:
						mintrashretention = None
						maxtrashretention = None
				else: #if self.master().version_at_least(1,6,26):
					sesflags,rootuid,rootgid,mapalluid,mapallgid,mingoal,maxgoal,mintrashretention,maxtrashretention = struct.unpack(">BLLLLBBLL",data[pos:pos+27])
					pos+=27
					disables = 0
					sclassgroups = None
					if mingoal<=1 and maxgoal>=9:
						mingoal = None
						maxgoal = None
					if mintrashretention==0 and maxtrashretention==0xFFFFFFFF:
						mintrashretention = None
						maxtrashretention = None
					umaskval = None
				if statscnt<self.stats_to_show:
					stats_c = struct.unpack(">"+"L"*statscnt,data[pos:pos+4*statscnt])+(0,)*(self.stats_to_show-statscnt)
					pos+=statscnt*4
					stats_l = struct.unpack(">"+"L"*statscnt,data[pos:pos+4*statscnt])+(0,)*(self.stats_to_show-statscnt)
					pos+=statscnt*4
				else:
					stats_c = struct.unpack(">"+"L"*self.stats_to_show,data[pos:pos+4*self.stats_to_show])
					pos+=statscnt*4
					stats_l = struct.unpack(">"+"L"*self.stats_to_show,data[pos:pos+4*self.stats_to_show])
					pos+=statscnt*4
				if path=='.':
					meta=1
				else:
					meta=0
				ses = Session(sessionid,(ip1,ip2,ip3,ip4),self.donotresolve,info,openfiles,nsocks,expire,v1,v2,v3,meta,path,sesflags,umaskval,rootuid,rootgid,mapalluid,mapallgid,sclassgroups,mingoal,maxgoal,mintrashretention,maxtrashretention,disables,stats_c,stats_l)
				self.sessions.append(ses)

		if MSorder is None:
			return self.sessions

		if   MSorder==1:	key=lambda ses: (ses.sessionid)
		elif MSorder==2:	key=lambda ses: (ses.host)
		elif MSorder==3:	key=lambda ses: (ses.sortip)
		elif MSorder==4:	key=lambda ses: (ses.info)
		elif MSorder==5:	key=lambda ses: (ses.openfiles)
		elif MSorder==6:	key=lambda ses: (ses.nsocks if ses.nsocks>0 else ses.expire)
		elif MSorder==7:	key=lambda ses: (ses.sortver)
		elif MSorder==8:	key=lambda ses: (ses.path)
		elif MSorder==9:	key=lambda ses: (ses.sesflags&1)
		elif MSorder==10:	key=lambda ses: (2-(ses.sesflags&2))
		elif MSorder==11:	key=lambda ses: (-1 if ses.meta else ses.sesflags&4)
		elif MSorder==12:	key=lambda ses: (-1 if ses.meta else ses.sesflags&8)
		elif MSorder==13:	key=lambda ses: (-1 if ses.meta else ses.rootuid)
		elif MSorder==14:	key=lambda ses: (-1 if ses.meta else ses.rootgid)
		elif MSorder==15:	key=lambda ses: (-1 if ses.meta or (ses.sesflags&16)==0 else ses.mapalluid)
		elif MSorder==16:	key=lambda ses: (-1 if ses.meta or (ses.sesflags&16)==0 else ses.mapallgid)
		elif MSorder==17:	key=lambda ses: (ses.sclassgroups)
		elif MSorder==18:	key=lambda ses: (ses.sclassgroups)
		elif MSorder==19:	key=lambda ses: (ses.mintrashretention)
		elif MSorder==20:	key=lambda ses: (ses.maxtrashretention)
		elif MSorder==21:	key=lambda ses: (ses.umaskval)
		elif MSorder==22:	key=lambda ses: (ses.disables)
		else:             key=lambda ses: (ses.sortip)

		self.sessions.sort(key=key)
		if MSrev:
			self.sessions.reverse()
		return self.sessions
	
	# Returns a tuple of two lists: first list contains connected sessions (with nsocks>0), second list contains disconnected sessions with nsocks==0
	def get_sessions_by_state(self, MSorder, MSrev):
		sessions = []
		dsessions = []
		for ses in self.get_sessions(MSorder,MSrev):
			if ses.nsocks>0:
				sessions.append(ses)
			else:
				dsessions.append(ses)
		return sessions,dsessions
	
	# Returns a list of sessions ordered by MO (operations) related parameters
	def get_sessions_order_by_mo(self, MOorder=1, MOrev=False, MOdata=0):
		msessions = []
		for ses in self.get_sessions(None): #don't sort
			if ses.path!='.':
				msessions.append(ses)

		if MOorder is None:
			return msessions

		if   MOorder == 1: key=lambda ses: (ses.host)
		elif MOorder == 2: key=lambda ses: (ses.sortip)
		elif MOorder == 3: key=lambda ses: (ses.info)
		elif MOorder >= 100 and MOorder < 100 + self.stats_to_show:
			if MOdata == 0:
				key=lambda ses: (-ses.stats_l[MOorder-100])
			else:
				key=lambda ses: (-ses.stats_c[MOorder-100])
		elif MOorder == 150:
			if MOdata == 0:
				key=lambda ses: (-sum(ses.stats_l))
			else:
				key=lambda ses: (-sum(ses.stats_c))
		else: key=lambda ses: (ses.host)
		
		msessions.sort(key=key)
		if MOrev:
			msessions.reverse()
		return msessions

	# Returns a list of storage classes names (e.g. for knobs or selects)
	def get_used_sclasses_names(self, order=1):
		if self.sclasses_names==None:
			self.sclasses_names = {}
			data,length = self.master().command(CLTOMA_SCLASS_INFO,MATOCL_SCLASS_INFO,struct.pack(">B",128))
			pos = 0
			while pos < length:
				sclassid,sclassnleng = struct.unpack_from(">BB",data,pos)
				pos += 2
				sclassname = data[pos:pos+sclassnleng]
				sclassname = sclassname.decode('utf-8','replace')
				pos += sclassnleng
				has_chunks = struct.unpack_from(">B",data,pos)[0]
				pos += 1
				sclassobj = StorageClassName(sclassname,has_chunks)
				self.sclasses_names[sclassid] = sclassobj
		if order==1:	
			self.sclasses_names = dict(sorted(self.sclasses_names.items()))
		return self.sclasses_names
	
	# Returns a list of storage classes
	def get_sclasses(self, SCorder=0, SCrev=False):
		if self.sclasses==None:
			self.sclasses = []
			show_copy_and_ec = self.master().version_at_least(4,5,0)
			if self.master().has_feature(FEATURE_SCLASSGROUPS):
				data,length = self.master().command(CLTOMA_SCLASS_INFO,MATOCL_SCLASS_INFO,struct.pack(">B",5))
				fver = 5
			elif self.master().has_feature(FEATURE_LABELMODE_OVERRIDES):
				data,length = self.master().command(CLTOMA_SCLASS_INFO,MATOCL_SCLASS_INFO,struct.pack(">B",4))
				fver = 4
			elif self.master().version_at_least(4,34,0):
				data,length = self.master().command(CLTOMA_SCLASS_INFO,MATOCL_SCLASS_INFO,struct.pack(">B",3))
				fver = 3
			elif self.master().version_at_least(4,5,0):
				data,length = self.master().command(CLTOMA_SCLASS_INFO,MATOCL_SCLASS_INFO,struct.pack(">B",2))
				fver = 2
			elif self.master().version_at_least(4,2,0):
				data,length = self.master().command(CLTOMA_SCLASS_INFO,MATOCL_SCLASS_INFO,struct.pack(">B",1))
				fver = 1
			else:
				data,length = self.master().command(CLTOMA_SCLASS_INFO,MATOCL_SCLASS_INFO)
				fver = 0
			availableservers = struct.unpack(">H",data[:2])[0]
			pos = 2
			while pos < length:
				if show_copy_and_ec:
					createcounters = 6*[None]
					keepcounters = 6*[None]
					archcounters = 6*[None]
					trashcounters = 6*[None]
				else:
					createcounters = 3*[None]
					keepcounters = 3*[None]
					archcounters = 3*[None]
					trashcounters = 3*[None]
				if self.master().version_at_least(4,0,0):
					sclassid,sclassnleng = struct.unpack_from(">BB",data,pos)
					pos += 2
					sclassname = data[pos:pos+sclassnleng]
					sclassname = sclassname.decode('utf-8','replace')
					pos += sclassnleng
					if fver>=5:
						sclassdleng = data[pos]
						pos+=1
						sclassdesc = data[pos:pos+sclassdleng]
						sclassdesc = sclassdesc.decode('utf-8','replace')
						pos += sclassdleng
					else:
						sclassdesc = ""
						sclassdleng = 0
					files,dirs = struct.unpack_from(">LL",data,pos)
					pos += 8
					if fver>=2:
						for cntid in range(6):
							keepcounters[cntid],archcounters[cntid],trashcounters[cntid] = struct.unpack_from(">QQQ",data,pos)
							pos += 3*8
					else:
						for cntid in range(3):
							keepcounters[cntid],archcounters[cntid],trashcounters[cntid] = struct.unpack_from(">QQQ",data,pos)
							pos += 3*8
					if fver>=5:
						priority,export_group = struct.unpack_from(">LB",data,pos)
						pos += 5
					else:
						priority = None
						export_group = sclassid if sclassid<10 else 0
					if fver>=3:
						admin_only,labels_mode,arch_mode,arch_delay,arch_min_size,min_trashretention = struct.unpack_from(">BBBHQH",data,pos)
						pos += 15
					elif fver>=1:
						admin_only,labels_mode,arch_mode,arch_delay,min_trashretention = struct.unpack_from(">BBBHH",data,pos)
						arch_min_size = 0
						pos += 7
					else:
						admin_only,labels_mode,arch_delay,min_trashretention = struct.unpack_from(">BBHH",data,pos)
						arch_mode = 1
						arch_min_size = 0
						pos += 6
					if fver>=4:
						create_canbefulfilled,create_labelscnt,create_uniqmask,create_labelsmode = struct.unpack_from(">BBLB",data,pos)
						pos += 7
						keep_canbefulfilled,keep_labelscnt,keep_uniqmask,keep_labelsmode = struct.unpack_from(">BBLB",data,pos)
						pos += 7
						arch_canbefulfilled,arch_labelscnt,arch_ec_level,arch_uniqmask,arch_labelsmode = struct.unpack_from(">BBBLB",data,pos)
						pos += 8
						trash_canbefulfilled,trash_labelscnt,trash_ec_level,trash_uniqmask,trash_labelsmode = struct.unpack_from(">BBBLB",data,pos)
						pos += 8
					else:
						create_canbefulfilled,create_labelscnt,create_uniqmask = struct.unpack_from(">BBL",data,pos)
						pos += 6
						keep_canbefulfilled,keep_labelscnt,keep_uniqmask = struct.unpack_from(">BBL",data,pos)
						pos += 6
						arch_canbefulfilled,arch_labelscnt,arch_ec_level,arch_uniqmask = struct.unpack_from(">BBBL",data,pos)
						pos += 7
						trash_canbefulfilled,trash_labelscnt,trash_ec_level,trash_uniqmask = struct.unpack_from(">BBBL",data,pos)
						pos += 7
						create_labelsmode = -1
						keep_labelsmode = -1
						arch_labelsmode = -1
						trash_labelsmode = -1
				elif self.master().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')
					sclassdesc = ""
					sclassdleng = 0
					priority = None
					export_group = sclassid if sclassid<10 else 0
					pos += sclassnleng
					files,dirs,keepcounters[0],archcounters[0],keepcounters[1],archcounters[1],keepcounters[2],archcounters[2],admin_only,labels_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:
						for cntid in range(3):
							keepcounters[cntid] += archcounters[cntid]
							archcounters[cntid] = None
					min_trashretention = 0
					trash_canbefulfilled = None
					trash_labelscnt = None
					trash_ec_level = 0
					arch_ec_level = 0
					create_uniqmask = 0
					keep_uniqmask = 0
					arch_uniqmask = 0
					trash_uniqmask = 0
					create_labelsmode = -1
					keep_labelsmode = -1
					arch_labelsmode = -1
					trash_labelsmode = -1
					arch_mode = 1
					arch_min_size = 0
				elif self.master().version_at_least(3,0,9):
					sclassid,files,dirs,keepcounters[0],archcounters[0],keepcounters[1],archcounters[1],keepcounters[2],archcounters[2],labels_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
					sclassdesc = ""
					sclassdleng = 0
					priority = None
					export_group = sclassid if sclassid<10 else 0
					admin_only = 0
					if sclassid<10:
						sclassname = str(sclassid)
					else:
						sclassname = "sclass_%u" % (sclassid-9)
					if arch_delay==0:
						for cntid in range(3):
							keepcounters[cntid] += archcounters[cntid]
							archcounters[cntid] = None
					min_trashretention = 0
					trash_canbefulfilled = None
					trash_labelscnt = None
					trash_ec_level = 0
					arch_ec_level = 0
					create_uniqmask = 0
					keep_uniqmask = 0
					arch_uniqmask = 0
					trash_uniqmask = 0
					create_labelsmode = -1
					keep_labelsmode = -1
					arch_labelsmode = -1
					trash_labelsmode = -1
					arch_mode = 1
					arch_min_size = 0
				else:
					sclassid,files,create_canbefulfilled,create_labelscnt = struct.unpack_from(">BLBB",data,pos)
					pos+=7
					sclassdesc = ""
					sclassdleng = 0
					priority = None
					export_group = sclassid if sclassid<10 else 0
					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
					labels_mode = 1
					arch_mode = 1
					arch_delay = 0
					arch_min_size = 0
					min_trashretention = 0
					trash_canbefulfilled = None
					trash_labelscnt = None
					trash_ec_level = 0
					arch_ec_level = 0
					create_uniqmask = 0
					keep_uniqmask = 0
					arch_uniqmask = 0
					trash_uniqmask = 0
					create_labelsmode = -1
					keep_labelsmode = -1
					arch_labelsmode = -1
					trash_labelsmode = -1
				if self.master().version_at_least(4,0,0):
					labels_ver = 4
					create_labellist = []
					keep_labellist = []
					arch_labellist = []
					trash_labellist = []
					for i in range(create_labelscnt):
						labelexpr = struct.unpack_from(">"+"B"*SCLASS_EXPR_MAX_SIZE,data,pos)
						pos+=SCLASS_EXPR_MAX_SIZE
						matchingservers = struct.unpack_from(">H",data,pos)[0]
						pos+=2
						create_labellist.append((labelexpr_to_str(labelexpr),matchingservers,labelexpr))
					for i in range(keep_labelscnt):
						labelexpr = struct.unpack_from(">"+"B"*SCLASS_EXPR_MAX_SIZE,data,pos)
						pos+=SCLASS_EXPR_MAX_SIZE
						matchingservers = struct.unpack_from(">H",data,pos)[0]
						pos+=2
						keep_labellist.append((labelexpr_to_str(labelexpr),matchingservers,labelexpr))
					for i in range(arch_labelscnt):
						labelexpr = struct.unpack_from(">"+"B"*SCLASS_EXPR_MAX_SIZE,data,pos)
						pos+=SCLASS_EXPR_MAX_SIZE
						matchingservers = struct.unpack_from(">H",data,pos)[0]
						pos+=2
						arch_labellist.append((labelexpr_to_str(labelexpr),matchingservers,labelexpr))
					for i in range(trash_labelscnt):
						labelexpr = struct.unpack_from(">"+"B"*SCLASS_EXPR_MAX_SIZE,data,pos)
						pos+=SCLASS_EXPR_MAX_SIZE
						matchingservers = struct.unpack_from(">H",data,pos)[0]
						pos+=2
						trash_labellist.append((labelexpr_to_str(labelexpr),matchingservers,labelexpr))
				else:
					labels_ver = 3
					create_labellist = []
					for i in range(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,labelmasks))
					if self.master().version_at_least(3,0,9):
						keep_labellist = []
						for i in range(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,labelmasks))
						arch_labellist = []
						for i in range(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,labelmasks))
					else:
						keep_labellist = create_labellist
						arch_labellist = create_labellist
					trash_labellist = []
					
				states = []
				if len(create_labellist)>0:
					states.append(StorageClassState(1,"CREATE",createcounters,None,create_labellist,create_uniqmask,create_labelsmode,create_canbefulfilled))
				else:
					states.append(StorageClassState(0,"CREATE",createcounters,None,keep_labellist,keep_uniqmask,keep_labelsmode,keep_canbefulfilled))
				states.append(StorageClassState(1,"KEEP",keepcounters,None,keep_labellist,keep_uniqmask,keep_labelsmode,keep_canbefulfilled))
				if len(arch_labellist)>0 or arch_ec_level>0:
					states.append(StorageClassState(1,"ARCH",archcounters,arch_ec_level,arch_labellist,arch_uniqmask,arch_labelsmode,arch_canbefulfilled))
				else:
					states.append(StorageClassState(0,"ARCH",archcounters,None,keep_labellist,keep_uniqmask,keep_labelsmode,keep_canbefulfilled))
				if len(trash_labellist)>0 or trash_ec_level>0:
					states.append(StorageClassState(1,"TRASH",trashcounters,trash_ec_level,trash_labellist,trash_uniqmask,trash_labelsmode,trash_canbefulfilled))
				else:
					states.append(StorageClassState(0,"TRASH",trashcounters,None,keep_labellist,keep_uniqmask,keep_labelsmode,keep_canbefulfilled))
			
				sc = StorageClass(sclassid,sclassname,sclassdesc,priority,export_group,admin_only,labels_mode,arch_mode,arch_delay,arch_min_size,min_trashretention,files,dirs,states,availableservers,labels_ver)
				self.sclasses.append(sc)

		if SCorder is None:
			return self.sclasses

		if   SCorder==1:  key=lambda sc: (sc.sclassid)
		elif SCorder==2:  key=lambda sc: (sc.sclassname)
		elif SCorder==3:  key=lambda sc: (sc.admin_only)
		elif SCorder==4:  key=lambda sc: (sc.labels_mode)
		elif SCorder==5:  key=lambda sc: (sc.arch_mode)
		elif SCorder==6:  key=lambda sc: (sc.arch_delay)
		elif SCorder==7:  key=lambda sc: (sc.arch_min_size)
		elif SCorder==8:  key=lambda sc: (sc.min_trashretention)
		elif SCorder==9:  key=lambda sc: (sc.files)
		elif SCorder==10: key=lambda sc: (sc.dirs)
		else: key=lambda sc: (sc.sclassname)

		self.sclasses.sort(key=key)
		if SCrev:
			self.sclasses.reverse()

		return self.sclasses

	def get_opatterns(self, PAorder=1, PArev=False):
		if self.opatterns==None:
			self.opatterns = []
			data,length = self.master().command(CLTOMA_PATTERN_INFO,MATOCL_PATTERN_INFO)
			pos = 0
			while pos < length:
				globleng = struct.unpack_from(">B",data,pos)[0]
				pos += 1
				globname = data[pos:pos+globleng]
				globname = globname.decode('utf-8','replace')
				pos += globleng
				euid,egid,priority,omask,sclassleng = struct.unpack_from(">LLBBB",data,pos)
				pos += 11
				sclassname = data[pos:pos+sclassleng]
				sclassname = sclassname.decode('utf-8','replace')
				pos += sclassleng
				trashretention,seteattr,clreattr = struct.unpack_from(">HBB",data,pos)
				if (omask&PATTERN_OMASK_SCLASS)==0:
					sclassname = None
				if (omask&PATTERN_OMASK_TRASHRETENTION)==0:
					trashretention = None
				if (omask&PATTERN_OMASK_EATTR)==0:
					seteattr = 0
					clreattr = 0
				pos += 4
				self.opatterns.append(OPattern(globname,euid,egid,priority,sclassname,trashretention,seteattr,clreattr))

		if PAorder is None:
			return self.opatterns

		if PAorder==1: key=lambda op: (op.globname)
		elif PAorder==2: key=lambda op: (op.euid)
		elif PAorder==3: key=lambda op: (op.egid)
		elif PAorder==4: key=lambda op: (op.priority)
		elif PAorder==5: key=lambda op: (op.sclassname)
		elif PAorder==6: key=lambda op: (op.trashretention)
		elif PAorder==7: key=lambda op: (op.seteattr|op.clreattr)
		else: key=lambda op: (op.globname)

		self.opatterns.sort(key=key)
		if PArev:
			self.opatterns.reverse()
		
		return self.opatterns
	
	def get_chunktestinfo(self):
		if self.chunktestinfo==None:
			data,length = self.master().command(CLTOMA_CHUNKSTEST_INFO,MATOCL_CHUNKSTEST_INFO)
			if length==72:
				self.chunktestinfo = ChunkTestInfo72(*struct.unpack(">LLLLLLLLLLLLLLLLLL",data))
			elif length==96:
				self.chunktestinfo = ChunkTestInfo96(*struct.unpack(">"+24*"L",data))
			else:
				raise Exception("Invalid length of chunktestinfo response")
		return self.chunktestinfo
	
	# returns a list of open files for a given session, if sessionid is 0, returns a list of all open files
	def get_openfiles(self, OFsessionid=0, OForder=1, OFrev=False):
		if self.openfiles==None:
			self.openfiles = []
			sessionsdata = {}
			for ses in self.get_sessions():
				if ses.sessionid>0 and ses.sessionid < 0x80000000:
					sessionsdata[ses.sessionid]=(ses.host,ses.sortip,ses.strip,ses.info,ses.openfiles)
			inodes = set()
			data,length = self.master().command(CLTOMA_LIST_OPEN_FILES,MATOCL_LIST_OPEN_FILES,struct.pack(">L",OFsessionid))
			openfiles = []
			if OFsessionid==0:
				n = length//8
				for x in range(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 range(n):
					inode = struct.unpack(">L",data[x*4:x*4+4])[0]
					openfiles.append((OFsessionid,inode))
					inodes.add(inode)
			inodepaths = self.resolve_inodes_paths(inodes)

			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 = []
				self.openfiles.append(OpenFile(sessionid,host,sortipnum,ipnum,info,inode,paths))

		if OForder is None:
			return self.openfiles

		if   OForder==1: key=lambda of: (of.sessionid)
		elif OForder==2: key=lambda of: (of.host)
		elif OForder==3: key=lambda of: (of.sortipnum)
		elif OForder==4: key=lambda of: (of.info)
		elif OForder==5: key=lambda of: (of.inode)
		elif OForder==6: key=lambda of: (of.paths)
		else:            key=lambda of: (of.sortipnum)

		self.openfiles.sort(key=key)
		if OFrev:
			self.openfiles.reverse()
		
		return self.openfiles
	
	def get_acquiredlocks(self, ALinode=0, ALorder=1, ALrev=False):
		if self.acquiredlocks==None:
			self.acquiredlocks = []
			sessionsdata = {}
			for ses in self.get_sessions():
				if ses.sessionid>0 and ses.sessionid < 0x80000000:
					sessionsdata[ses.sessionid]=(ses.host,ses.sortip,ses.strip,ses.info)

			data,length = self.master().command(CLTOMA_LIST_ACQUIRED_LOCKS,MATOCL_LIST_ACQUIRED_LOCKS,struct.pack(">L",ALinode))
			locks = []
			if ALinode==0:
				n = length//37
				for x in range(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 range(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))
			for inode,sessionid,owner,pid,start,end,ctype in locks:
				if sessionid in sessionsdata:
					host,sortipnum,ipnum,info = sessionsdata[sessionid]
				else:
					host = 'unknown'
					sortipnum = ''
					ipnum = ''
					info = 'unknown'
				self.acquiredlocks.append(AcquiredLock(inode,sessionid,host,sortipnum,ipnum,info,owner,pid,start,end,ctype))

		if ALorder is None:
			return self.acquiredlocks

		if   ALorder==1: key=lambda al: (al.inode)
		elif ALorder==2: key=lambda al: (al.sessionid)
		elif ALorder==3: key=lambda al: (al.host)
		elif ALorder==4: key=lambda al: (al.sortipnum)
		elif ALorder==5: key=lambda al: (al.info)
		elif ALorder==6: key=lambda al: (al.locktype)
		elif ALorder==7: key=lambda al: (al.owner)
		elif ALorder==8: key=lambda al: (al.pid)
		elif ALorder==9: key=lambda al: (al.start)
		elif ALorder==10: key=lambda al: (al.end)
		elif ALorder==11: key=lambda al: (al.ctype)
		else:            key=lambda of: (of.inode)

		self.acquiredlocks.sort(key=key)
		if ALrev:
			self.acquiredlocks.reverse()
		
		return self.acquiredlocks		

	def get_quotas(self, QUorder=1, QUrev=False):
		if self.quotas==None:
			self.quotas = []
			self.quotas_maxperc = 0.0
			if self.master().has_feature(FEATURE_DEFAULT_GRACEPERIOD):
				data,length = self.master().command(CLTOMA_QUOTA_INFO,MATOCL_QUOTA_INFO,struct.pack(">B",1))
			else:
				data,length = self.master().command(CLTOMA_QUOTA_INFO,MATOCL_QUOTA_INFO)
			if length>=4:
				maxperc = 0.0
				pos = 0
				while pos<length:
					inode,pleng = struct.unpack(">LL",data[pos:pos+8])
					pos+=8
					path = data[pos:pos+pleng]
					path = path.decode('utf-8','replace')
					pos+=pleng
					if self.master().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
					self.quotas.append(Quota(path,exceeded,qflags,graceperiod,timetoblock,sinodes,slength,ssize,srealsize,hinodes,hlength,hsize,hrealsize,cinodes,clength,csize,crealsize))
				self.quotas_maxperc = maxperc + 0.01

		if QUorder is None:
			return self.quotas_maxperc,self.quotas
				
		if   QUorder==1:  key=lambda qu: (qu.path)
		elif QUorder==2:  key=lambda qu: (qu.exceeded)
		elif QUorder==9:  key=lambda qu: (qu.graceperiod)
		elif QUorder==10: key=lambda qu: (qu.timetoblock)
		elif QUorder==11: key=lambda qu: (qu.sinodes)
		elif QUorder==12: key=lambda qu: (qu.slength)
		elif QUorder==13: key=lambda qu: (qu.ssize)
		elif QUorder==14: key=lambda qu: (qu.srealsize)
		elif QUorder==21: key=lambda qu: (qu.hinodes)
		elif QUorder==22: key=lambda qu: (qu.hlength)
		elif QUorder==23: key=lambda qu: (qu.hsize)
		elif QUorder==24: key=lambda qu: (qu.hrealsize)
		elif QUorder==31: key=lambda qu: (qu.cinodes)
		elif QUorder==32: key=lambda qu: (qu.clength)
		elif QUorder==33: key=lambda qu: (qu.csize)
		elif QUorder==34: key=lambda qu: (qu.crealsize)
		elif QUorder==41: key=lambda qu: ((-1,0) if (qu.qflags&1)==0 else (1,0) if qu.sinodes==0 else (0,1.0*qu.cinodes/qu.sinodes))
		elif QUorder==42: key=lambda qu: ((-1,0) if (qu.qflags&2)==0 else (1,0) if qu.slength==0 else (0,1.0*qu.clength/qu.slength))
		elif QUorder==43: key=lambda qu: ((-1,0) if (qu.qflags&4)==0 else (1,0) if qu.ssize==0 else (0,1.0*qu.csize/qu.ssize))
		elif QUorder==44: key=lambda qu: ((-1,0) if (qu.qflags&8)==0 else (1,0) if qu.srealsize==0 else (0,1.0*qu.crealsize/qu.srealsize))
		elif QUorder==51: key=lambda qu: ((-1,0) if (qu.qflags&16)==0 else (1,0) if qu.hinodes==0 else (0,1.0*qu.cinodes/qu.hinodes))
		elif QUorder==52: key=lambda qu: ((-1,0) if (qu.qflags&32)==0 else (1,0) if qu.hlength==0 else (0,1.0*qu.clength/qu.hlength))
		elif QUorder==53: key=lambda qu: ((-1,0) if (qu.qflags&64)==0 else (1,0) if qu.hsize==0 else (0,1.0*qu.csize/qu.hsize))
		elif QUorder==54: key=lambda qu: ((-1,0) if (qu.qflags&128)==0 else (1,0) if qu.hrealsize==0 else (0,1.0*qu.crealsize/qu.hrealsize))
		else:             key=lambda of: (of.path)

		self.quotas.sort(key=key)
		if QUrev:
			self.quotas.reverse()
		
		return self.quotas_maxperc,self.quotas
	

### End of inline import from common/dataprovider.py

### from common.organization import * # MFS_INLINE_IMPORT - inlined below:
### Imported inline from common/organization.py:
class Organization:
	def __init__(self, dp, guimode=False, ajax_request=False):
		self.sectionset = None
		self.subsectionset = None
		self.guimode = guimode
		cl = dp.cluster
		# Define menu & subsections structure
		if guimode:
			if cl.leaderfound():
				self.menu_tree = [
					["ST", ["ST"]],
					["IN", ["IG", "IM", "LI", "IC", "FL", "CL", "MU"]],
					["CS", ["CS", "MB"]],
					["HD", ["HD"]],
					["EX", ["EX"]],
					["MD", ["MS", "MO", "OF"]],
					["RP", ["SC", "PA"]],
					["QU", ["QU"]],
					["XC", ["MC", "CC"]]
				]
			elif cl.electfound():
				self.menu_tree = [
					["ST", ["ST"]],
					["IN", ["IG", "IM", "LI", "IC", "FL", "CL", "MU"]],
					["CS", ["CS", "MB"]],
					["HD", ["HD"]],
					["EX", ["EX"]],
					["QU", ["QU"]],
					["XC", ["MC", "CC"]]
				]
			elif cl.followerfound() or cl.usurperfound():
				self.menu_tree = [
					["IN", ["IG", "IM", "LI", "IC", "FL", "CL", "MU"]],
					["MC", ["MC"]]
				]
			else:
				self.menu_tree = [
					["IN", ["IG", "IM", "LI", "IC", "FL", "CL", "MU"]]
				]
		else:
			# Define menu & subsections structure
			if cl.leaderfound():
				self.menu_tree = [
					["IN", ["IG", "IM", "LI", "IC", "IL", "MF", "MU"]],
					["CS", ["CS"]],
					["MB", ["MB"]],
					["HD", ["HD"]],
					["EX", ["EX"]],
					["MD", ["MS", "OF", "AL", "MO"]],
					["RP", ["SC", "PA"]],
					["RS", ["SC", "PA", "OF", "AL"]], # backwards compatibility
					["QU", ["QU"]],
					["MC", ["MC"]],
					["CC", ["CC"]]
				]
			elif cl.electfound():
				self.menu_tree = [
					["IN", ["IG", "IM", "LI", "IC", "IL", "MF", "MU"]],
					["CS", ["CS"]],
					["MB", ["MB"]],
					["HD", ["HD"]],
					["EX", ["EX"]],
					["QU", ["QU"]],
					["MC", ["MC"]],
					["CC", ["CC"]]
				]
			elif cl.followerfound() or cl.usurperfound():
				self.menu_tree = [
					["IN", ["IG", "IM", "LI", "IC", "IL", "MF", "MU"]],
					["MC", ["MC"]]
				]
			elif cl.anyfound():
				self.menu_tree = [
					["IN", ["IG", "IM", "LI", "IC", "IL", "MF", "MU"]]
				]
			else:
				self.menu_tree = None


		# sections names and render conditions
		self.sections_defs = {
			"ST":("Status",										 lambda: guimode and (cl.leaderfound() or cl.electfound())),
			"IN":("Info",                      lambda: True),
				"IG":("Cluster Summary",           lambda: cl.master()!=None),
				"IM":("Metadata Servers (Masters)",lambda: len(dp.get_masterservers(None))>0),
				"MB":("Metadata backup loggers",   lambda: cl.leaderfound() and cl.master()!=None),
				"LI":("Licence Info",              lambda: cl.leaderfound() and cl.master()!=None and cl.master().is_pro()),
				"IC":("Chunk Matrix Table",        lambda: cl.leaderfound()),
				"IL":("Self-check Loops",          lambda: cl.leaderfound() and not guimode),
				"MF":("Missing Files",             lambda: cl.leaderfound() and ((cl.master().version_at_least(2,0,66) and cl.master().version_less_than(3,0,0)) or cl.master().version_at_least(3,0,19))),
				"FL":("Filesystem Self-check Loop",lambda: cl.leaderfound() and guimode), #GUI only
				"CL":("Chunks Housekeeping Loop",  lambda: cl.leaderfound() and guimode), #GUI only
				"MU":("Memory Usage",              lambda: cl.leaderfound() and cl.master()!=None),
			"CS":("Chunkservers",                lambda: cl.master()!=None),
			"HD":("Disks",                     lambda: cl.master()!=None),
			"EX":("Exports",                   lambda: cl.master()!=None),
			"MD":("Mounts",                    lambda: cl.leaderfound()),
				"MS":("Parameters",                lambda: cl.leaderfound()),
				"MO":("Operations",                lambda: cl.leaderfound()),
				"OF":("Open files and locks",      lambda: cl.leaderfound()),
				"AL":("Acquired locks",            lambda: cl.leaderfound() and not guimode), #CLI only, for GUI "AL" is in "OF"
			"RP":("Redundancy",                lambda: cl.leaderfound()),
				"SC":("Storage Classes",           lambda: cl.leaderfound()),
				"PA":("Override Patterns",         lambda: cl.leaderfound() and cl.master().version_at_least(4,2,0)),
			"RS":("Resources",                 lambda: cl.leaderfound()),# backwards compatibility
			"QU":("Quotas",                    lambda: cl.master()!=None),
			"XC":("Charts",                    lambda: cl.master()!=None and not ajax_request),
				"MC":("Master servers",            lambda: cl.master()!=None and not ajax_request),
				"CC":("Chunkservers",              lambda: cl.master()!=None and not ajax_request)
		}

	def set_sections(self, sectionset, subsectionset=None):
		self.sectionset = sectionset
		self.subsectionset = subsectionset

	def get_default_section(self):
		return self.menu_tree[0][0]
	
	# returns list of subsections ids for given menu section
	def menu_subitems(self, section):
		for menu_item in self.menu_tree:
			if menu_item[0]==section:
				return menu_item[1]
		return []

	# Decide if section should be rendered
	def shall_render(self, section):
		if self.sectionset==None:
			raise Exception("Organization object is not initialized properly: set_sections() must be called before shall_render()")
		
		# render section if it's in the sectionset
		effective_sectionset = set(self.sectionset)

		if self.guimode:
			if self.subsectionset==None:
				raise Exception("Organization object is not initialized properly: set_sections() must be called before shall_render()")
			# adjust default subsections
			if "RP" in self.sectionset: 
				if len(self.subsectionset.intersection(set(self.menu_subitems("RP"))))==0:
					self.subsectionset |= set(("SC",)) # add Storage Classes section by default if Redundancy Policy is selected
			if "IN" in self.sectionset:
				if len(self.subsectionset.intersection(set(self.menu_subitems("IN"))))==0:
					self.subsectionset |= set((self.menu_subitems("IN"))) # add all subsections by default if Info is selected
			# render subsection only if 
			#    its main section is visible and it's in the subsectionset 
			# or its main section is visible and there no subsections for this main section specified
			for main_section in self.sectionset:
				subitemset = set(self.menu_subitems(main_section))
				itsmainsectionvisible = section in subitemset
				if itsmainsectionvisible and section in self.subsectionset:
					effective_sectionset |= set((section,))
					break
		else:
			# for CLI render all subsections if the main section is selected
			for s in self.sectionset:
				effective_sectionset |= set(self.menu_subitems(s))

		if section in effective_sectionset:
			return self.sections_defs[section][1]() # render this section if condition is met

		return False # don't render




### End of inline import from common/organization.py


donotresolve = 0     #resolve or not various ip addresses
instancename = "My MooseFS"

masterhost = DEFAULT_MASTERNAME
masterport = DEFAULT_MASTER_CLIENT_PORT


frameset = -1
ptxtsep = "\t"
forceplaintext = 0
jsonmode = 0
colormode = 0
sectionset = []
# subsectionset = set([]) not used in CLI
clicommands = []

# order and data parameters
ICsclassid = -1
ICmatrix = 0
IMorder = 0
IMrev = 0
MForder = 0
MFrev = 0
CSorder = 0
CSrev = 0
MBorder = 0
MBrev = 0
HDdata = ""
HDorder = 0
HDrev = 0
HDperiod = 0
HDtime = 0
EXorder = 0
EXrev = 0
MSorder = 0
MSrev = 0
SCorder = 0
SCrev = 0
PAorder = 0
PArev = 0
OForder = 0
OFrev = 0
OFsessionid = 0
ALorder = 0
ALrev = 0
ALinode = 0
MOorder = 0
MOrev = 0
MOdata = 0
QUorder = 0
QUrev = 0
MCrange = 0
MCcount = 25
MCchdata = []
CCrange = 0
CCcount = 25
CCchdata = []

time_s = time.time()

# modes:
#  0 - percent (sum - cpu)
#  1 - ops/s (operations)
#  2 - humanized format in bytes (memory/disk space)
#  3,4 - not used in master
#  5 - in MB/s (data bytes read/written)
#  6 - raw data (number of chunks/files etc.)
#  7 - seconds
#  8 - percent (max - udiff)
mcchartslist = [
		('ucpu',0,0,'User cpu usage'),
		('scpu',1,0,'System cpu usage'),
		('delete',2,1,'Number of chunk deletion attempts'),
		('replicate',3,1,'Number of chunk replication attempts'),
		('statfs',4,1,'Number of statfs operations'),
		('getattr',5,1,'Number of getattr operations'),
		('setattr',6,1,'Number of setattr operations'),
		('lookup',7,1,'Number of lookup operations'),
		('mkdir',8,1,'Number of mkdir operations'),
		('rmdir',9,1,'Number of rmdir operations'),
		('symlink',10,1,'Number of symlink operations'),
		('readlink',11,1,'Number of readlink operations'),
		('mknod',12,1,'Number of mknod operations'),
		('unlink',13,1,'Number of unlink operations'),
		('rename',14,1,'Number of rename operations'),
		('link',15,1,'Number of link operations'),
		('readdir',16,1,'Number of readdir operations'),
		('open',17,1,'Number of open operations'),
		('read_chunk',18,1,'Number of chunk_read operations'),
		('write_chunk',19,1,'Number of chunk_write operations'),
		('memoryrss',20,2,'Resident memory usage'),
		('prcvd',21,1,'Packets received by master'),
		('psent',22,1,'Packets sent by master'),
		('brcvd',23,5,'Bytes received by master'),
		('bsent',24,5,'Bytes sent by master'),
		('memoryvirt',25,2,'Virtual memory usage'),
		('usedspace',26,2,'RAW disk space usage'),
		('totalspace',27,2,'RAW disk space connected'),
		('create',28,1,'Number of chunk creation attempts'),
		('change',29,1,'Number of chunk internal operation attempts'),
		('delete_ok',30,1,'Number of successful chunk deletions'),
		('delete_err',31,1,'Number of unsuccessful chunk deletions'),
		('replicate_ok',32,1,'Number of successful chunk replications'),
		('replicate_err',33,1,'Number of unsuccessful chunk replications'),
		('create_ok',34,1,'Number of successful chunk creations'),
		('create_err',35,1,'Number of unsuccessful chunk creations'),
		('change_ok',36,1,'Number of successful chunk internal operations'),
		('change_err',37,1,'Number of unsuccessful chunk internal operations'),
		('split_ok',38,1,'Number of successful chunk split operations'),
		('split_err',39,1,'Number of unsuccessful chunk split operations'),
		('fileobjects',40,6,'Number of file object'),
		('metaobjects',41,6,'Number of non-file objects (directories,symlinks,etc.)'),
		('chunksec8',42,6,'Total number of chunks stored in EC8 format'),
		('chunksec4',43,6,'Total number of chunks stored in EC4 format'),
		('chunkscopy',44,6,'Total number of chunks stored in COPY format'),
		('chregdanger',45,6,'Number of endangered chunks (mark for removal excluded)'),
		('chregunder',46,6,'Number of undergoal chunks (mark for removal excluded)'),
		('challdanger',47,6,'Number of endangered chunks (mark for removal included)'),
		('challunder',48,6,'Number of undergoal chunks (mark for removal included)'),
		('bytesread',49,5,'Traffic from cluster (data + overhead), bytes per second'),
		('byteswrite',50,5,'Traffic to cluster (data + overhead), bytes per second'),
		('read',51,1,'Number of read operations'),
		('write',52,1,'Number of write operations'),
		('fsync',53,1,'Number of fsync operations'),
		('lock',54,1,'Number of lock operations'),
		('snapshot',55,1,'Number of snapshot operations'),
		('truncate',56,1,'Number of truncate operations'),
		('getxattr',57,1,'Number of getxattr operations'),
		('setxattr',58,1,'Number of setxattr operations'),
		('getfacl',59,1,'Number of getfacl operations'),
		('setfacl',60,1,'Number of setfacl operations'),
		('createobj',61,1,'Number of create operations'),
		('meta',62,1,'Number of extra metadata operations (sclass,trashretention,eattr etc.)'),
		('servers',64,6,'Number of all registered chunk servers (both connected and disconnected)'),
		('mdservers',65,6,'Number of disconnected chunk servers that are in maintenance mode'),
		('dservers',66,6,'Number of disconnected chunk servers that are not in maintenance mode'),
		('udiff',67,8,'Difference in space usage percent between the most and least used chunk server'),
		('mountbytrcvd',68,5,'Traffic from cluster (data only), bytes per second'),
		('mountbytsent',69,5,'Traffic to cluster (data only), bytes per second'),
		('cpu',100,0,'Cpu usage (total sys+user)')
]
mcchartsabr = {
		'delete':['del'],
		'replicate':['rep','repl'],
		'memoryrss':['memrss','rmem','mem'],
		'memoryvirt':['memvirt','vmem']
}

# modes:
#  0 - percent (sum - cpu)
#  1 - ops/s (operations)
#  2 - humanized format in bytes (memory/disk space)
#  3 - threads (load)
#  4 - time
#  5 - in MB/s (data bytes read/written)
#  6 - raw data (number of chunks/files etc.)
#  7 - not used in CS
#  8 - percent (max - udiff)
ccchartslist = [
		('ucpu',0,0,'User cpu usage'),
		('scpu',1,0,'System cpu usage'),
		('masterin',2,5,'Data received from master'),
		('masterout',3,5,'Data sent to master'),
		('csrepin',4,5,'Data received by replicator'),
		('csrepout',5,5,'Data sent by replicator'),
		('csservin',6,5,'Data received by csserv'),
		('csservout',7,5,'Data sent by csserv'),
		('hdrbytesr',8,5,'Bytes read (headers)'),
		('hdrbytesw',9,5,'Bytes written (headers)'),
		('hdrllopr',10,1,'Low level reads (headers)'),
		('hdrllopw',11,1,'Low level writes (headers)'),
		('databytesr',12,5,'Bytes read (data)'),
		('databytesw',13,5,'Bytes written (data)'),
		('datallopr',14,1,'Low level reads (data)'),
		('datallopw',15,1,'Low level writes (data)'),
		('hlopr',16,1,'High level reads'),
		('hlopw',17,1,'High level writes'),
		('rtime',18,4,'Read time'),
		('wtime',19,4,'Write time'),
		('repl',20,1,'Replicate chunk ops'),
		('create',21,1,'Create chunk ops'),
		('delete',22,1,'Delete chunk ops'),
		('version',23,1,'Set version ops'),
		('duplicate',24,1,'Duplicate ops'),
		('truncate',25,1,'Truncate ops'),
		('duptrunc',26,1,'Duptrunc (duplicate+truncate) ops'),
		('test',27,1,'Test chunk ops'),
		('load',28,3,'Server load'),
		('memoryrss',29,2,'Resident memory usage'),
		('memoryvirt',30,2,'Virtual memory usage'),
		('movels',31,1,'Low speed move ops'),
		('movehs',32,1,'High speed move ops'),
		('split',34,1,'Split ops'),
		('usedspace',35,2,'Used HDD space in bytes (mark for removal excluded)'),
		('totalspace',36,2,'Total HDD space in bytes (mark for removal excluded)'),
		('chunkcount',37,6,'Number of stored chunks (mark for removal excluded)'),
		('tdusedspace',38,2,'Used HDD space in bytes on disks marked for removal'),
		('tdtotalspace',39,2,'Total HDD space in bytes on disks marked for removal'),
		('tdchunkcount',40,6,'Number of chunks stored on disks marked for removal'),
		('copychunks',41,6,'Number of stored chunks (all disks)'),
		('ec4chunks',42,6,'Number of stored chunk parts in EC4 format (all disks)'),
		('ec8chunks',43,6,'Number of stored chunk parts in EC8 format (all disks)'),
		('hddok',44,6,'Number of valid folders (hard drives)'),
		('hddmfr',45,6,'Number of folders (hard drives) that are marked for removal'),
		('hdddmg',46,6,'Number of folders (hard drives) that are marked as damaged'),
		('udiff',47,8,'Difference in usage percent between the most and least used disk'),
		('cpu',100,0,'Cpu usage (total sys+user)')
]
ccchartsabr = {
		'memoryrss':['memrss','rmem','mem'],
		'memoryvirt':['memvirt','vmem']
}

jcollect = {
		"version": VERSION,
		"timestamp": time_s,
		"shifted_timestamp": shiftts(time_s),
		"timestamp_str": time.ctime(time_s),
		"dataset":{},
		"errors":[]
}

mccharts = {}
cccharts = {}
for name,no,mode,desc in mcchartslist:
	mccharts[name] = (no,mode,desc)
for name,abrlist in mcchartsabr.items():
	for abr in abrlist:
		mccharts[abr] = mccharts[name]
for name,no,mode,desc in ccchartslist:
	cccharts[name] = (no,mode,desc)
for name,abrlist in ccchartsabr.items():
	for abr in abrlist:
		cccharts[abr] = cccharts[name]

lastsval = ''
lastorder = None
lastrev = None
lastid = None
lastmode = None
try:
	opts,args = getopt.getopt(sys.argv[1:],"hjvH:P:S:C:f:ps:no:rm:i:a:b:c:d:28")
except Exception:
	opts = [('-h',None)]
for opt,val in opts:
	if val==None:
		val=""
	if opt=='-h':
		print("usage:")
		print("\t%s [-hjpn28] [-H master_host] [-P master_port] [-f 0..3] -S(IN|IM|IG|MU|IC|IL|MF|CS|MB|HD|EX|MD|MS|OF|AL|MO|RS|SC|PA|QU|MC|CC) [-s separator] [-o order_id [-r]] [-m mode_id] [i id] [-a master_data_count] [-b master_data_desc] [-c chunkserver_data_count] [-d chunkserver_data_desc]" % sys.argv[0])
		print("\t%s [-hjpn28] [-H master_host] [-P master_port] [-f 0..3] -C(RC/ip/port|TR/ip/port|BW/ip/port|M[01]/ip/port|RS/sessionid)" % sys.argv[0])
		print("\t%s -v" % sys.argv[0])
		print("\ncommon:\n")
		print("\t-h : print this message and exit")
		print("\t-v : print version number and exit")
		print("\t-j : print result in JSON format")
		print("\t-p : force plain text format on tty devices")
		print("\t-s separator : field separator to use in plain text format on tty devices (forces -p)")
		print("\t-2 : force 256-color terminal color codes")
		print("\t-8 : force 8-color terminal color codes")
		print("\t-H master_host : master address (default: %s)" % DEFAULT_MASTERNAME)
		print("\t-P master_port : master client port (default: %u)" % DEFAULT_MASTER_CLIENT_PORT)
		print("\t-n : do not resolve ip addresses (default when output device is not tty)")
		print("\t-f frame charset number : set frame charset to be displayed as table frames in ttymode")
		print("\t\t-f0 : use simple ascii frames '+','-','|' (default for non utf-8 encodings)")
		if (sys.stdout.encoding=='UTF-8' or sys.stdout.encoding=='utf-8'):
			print("\t\t-f1 : use utf-8 frames: \u250f\u2533\u2513\u2523\u254b\u252b\u2517\u253b\u251b\u2501\u2503\u2578\u2579\u257a\u257b")
			print("\t\t-f2 : use utf-8 frames: \u250c\u252c\u2510\u251c\u253c\u2524\u2514\u2534\u2518\u2500\u2502\u2574\u2575\u2576\u2577")
			print("\t\t-f3 : use utf-8 frames: \u2554\u2566\u2557\u2560\u256c\u2563\u255a\u2569\u255d\u2550\u2551 (default for utf-8 encodings)")
		else:
			print("\t\t-f1 : use utf-8 frames (thick single)")
			print("\t\t-f2 : use utf-8 frames (thin single)")
			print("\t\t-f3 : use utf-8 frames (double - default for utf-8 encodings)")
		print("\nmonitoring:\n")
		print("\t-S data set : defines data set to be displayed")
		sin_includes = "SIM, SIG, SMU, SIC, SIL, SMF"
		print("\t\t-SIN : show full master info (includes: %s)" % sin_includes)
		print("\t\t-SIG : show only general cluster summary")
		print("\t\t-SIM : show only masters states")
		print("\t\t-SIC : show only chunks info (target/current redundancy level matrices)")
		print("\t\t-SIL : show only self-check loops info (with messages)")
		print("\t\t-SMF : show only missing chunks/files")
		print("\t\t-SMU : show only master memory usage")
		print("\t\t-SCS : show connected chunk servers")
		print("\t\t-SMB : show connected metadata backup servers")
		print("\t\t-SHD : show hdd data")
		print("\t\t-SEX : show exports")
		print("\t\t-SMD : show mounts details (includes: SMS, SOF, SAL, SMO)")
		print("\t\t-SMS : show only active mounts")
		print("\t\t-SOF : show only open files")
		print("\t\t-SAL : show only acquired locks")
		print("\t\t-SMO : show only operations counters")
		print("\t\t-SRP : show redundancy policy (includes: SSC, SPA)")
		print("\t\t-SSC : show storage classes")
		print("\t\t-SPA : show patterns overrides")
		print("\t\t-SQU : show quota info")
		print("\t\t-SMC : show master charts data (use with -a and -b)")
		print("\t\t-SCC : show chunkserver charts data (use with -c and -d)")
		print("\t-o order_id : sort data by column specified by 'order id' (depends on data set)")
		print("\t-r : reverse order")
		print("\t-m mode_id : show data specified by 'mode id' (depends on data set)")
		print("\t-i id : storage class id for -SIN/SIC, sessionid for -SOF or inode for -SAL")
		print("\t-a master_data_count : how many master data charts entries (-SMC) should be shown")
		print("\t-b master_data_desc : define master data charts (-SMC) columns\n\t\tuse 'all' as a chart name for all available charts\n\t\tprefix with '+' for raw data\n\t\t(pro only) prefix with 'ip:[port:]' for server choice (by default leader master will be used)")
		print("\t-c chunkserver_data_count : how many chunkserver data charts (-SCC) entries should be shown")
		print("\t-d chunkserver_data_desc : define chunkserver data charts (-SCC) columns\n\t\tuse 'all' as a chart name for all available charts\n\t\tprefix with '+' for raw data\n\t\tprefix with 'ip:[port:]' for server choice (by default all servers will be used)")
		print("\n\tavailable master data charts columns (-SMC):")
		for name,no,mode,desc in mcchartslist:
			if name in mcchartsabr:
				name = "%s,%s" % (name,",".join(mcchartsabr[name]))
			print("\t\t%s - %s" % (name,desc))
		print("\t\tall - Get all above columns")
		print("\n\tavailable chunkserver data charts columns (-SCC):")
		for name,no,mode,desc in ccchartslist:
			if name in ccchartsabr:
				name = "%s,%s" % (name,",".join(ccchartsabr[name]))
			print("\t\t%s - %s" % (name,desc))
		print("\t\tall - Get all above columns")
		print("\ncommands:\n")
		print("\t-C command : perform particular command")
		print("\t\t-CRC/ip/port : remove given chunkserver from the list of active chunkservers")
		print("\t\t-CTR/ip/port : temporarily remove given chunkserver from the list of active chunkservers (master elect only)")
		print("\t\t-CBW/ip/port : send given chunkserver back to work (from the grace state)")
		print("\t\t-CM1/ip/port : switch given chunkserver to maintenance mode")
		print("\t\t-CM0/ip/port : switch given chunkserver to standard mode (from maintenance mode)")
		print("\t\t-CRS/sessionid : remove given session")
		print("\nexamples:\n")
		print("\tmfscli -SIC -2")
		print("\t\tshows a table with chunk state matrix (the number of chunks for each combination of valid copies and the goal set by the user) using extended terminal colors (256-colors)")
		print("\tmfscli -SCS -f 1")
		print("\t\tshows a table with all chunkservers using unicode thick frames")
		print("\tmfscli -SMS -p -s ','")
		print("\t\tshows current sessions (mounts) using plain text format and comma as a separator")
		print("\tmfscli -SOF -i 123")
		print("\t\tshows files open by processes using session (mount) with id 123")
		print("\tmfscli -SMC -a 10 -b cpu,memoryrss,delete,replicate")
		print("\t\tshows the master cpu usage, amount of resident memory used by master, number of chunk deletions and number of chunk replications during last ten minutes")
		print("\tmfscli -SCC -c 15 -d 192.168.1.10:9422:cpu,192.168.1.11:9422:cpu")
		print("\t\tshows cpu usage of chunkservers located on machines with IP 192.168.1.10 and 192.168.1.11 during last fifteen minutes")
		print("\tmfscli -SCC -d mem")
		print("\t\tshows resident memory usage of all connected chunkservers (current mfscli)")
		print("\tmfscli -SIN -j")
		print("\t\tprints basic infos in JSON format")
		sys.exit(0)
	elif opt=='-v':
		print("version: %s" % VERSION)
		sys.exit(0)
	elif opt=='-2':
		colormode = 2
	elif opt=='-8':
		colormode = 1
	elif opt=='-j':
		jsonmode = 1
	elif opt=='-p':
		forceplaintext = 1
	elif opt=='-s':
		ptxtsep = val
		forceplaintext = 1
	elif opt=='-n':
		donotresolve = 1
	elif opt=='-f':
		frameset = int(val)
	elif opt=='-H':
		masterhost = val
	elif opt=='-P':
		masterport = int(val)
	elif opt=='-S':
		lastsval = val
		if 'IN' in val:
			sectionset.append("IN")
			if lastmode!=None:  ICmatrix = lastmode
			if lastid!=None:    ICsclassid = lastid
			if lastorder!=None: IMorder = lastorder
			if lastrev:         IMrev = 1
		if 'IM' in val:
			sectionset.append("IM")
			if lastorder!=None: IMorder = lastorder
			if lastrev:         IMrev = 1
		if 'IG' in val:
			sectionset.append("IG")
		if 'MU' in val:
			sectionset.append("MU")
		if 'IC' in val:
			sectionset.append("IC")
			if lastmode!=None: ICmatrix = lastmode
			if lastid!=None:   ICsclassid = lastid
		if 'IL' in val:
			sectionset.append("IL")
		if 'MF' in val:
			sectionset.append("MF")
			if lastorder!=None: MForder = lastorder
			if lastrev:         MFrev = 1
		if 'CS' in val:
			sectionset.append("CS")
			if lastorder!=None: CSorder = lastorder
			if lastrev:         CSrev = 1
		if 'MB' in val:
			sectionset.append("MB")
			if lastorder!=None: MBorder = lastorder
			if lastrev:         MBrev = 1
		if 'HD' in val:
			sectionset.append("HD")
			if lastorder!=None: HDorder = lastorder
			if lastrev:         HDrev = 1
			if lastmode!=None:
				if lastmode>=0 and lastmode<6:
					HDperiod,HDtime = divmod(lastmode,2)
		if 'EX' in val:
			sectionset.append("EX")
			if lastorder!=None: EXorder = lastorder
			if lastrev:         EXrev = 1

		if 'MD' in val:
			sectionset.append("MD")
		if 'MS' in val:
			sectionset.append("MS")
			if lastorder!=None: MSorder = lastorder
			if lastrev:         MSrev = 1
		if 'OF' in val:
			sectionset.append("OF")
			if lastorder!=None: OForder = lastorder
			if lastrev!=None:   OFrev = 1
			if lastid!=None:    OFsessionid = lastid
		if 'AL' in val:
			sectionset.append("AL")
			if lastorder!=None: ALorder = lastorder
			if lastrev!=None:   ALrev = 1
			if lastid!=None:    ALinode = lastid
		if 'MO' in val:
			sectionset.append("MO")
			if lastorder!=None: MOorder = lastorder
			if lastrev:         MOrev = 1
			if lastmode!=None:  MOdata = lastmode

		if 'RP' in val or 'RS' in val: # backward compatibility as RS->RP (4.57)
			sectionset.append("RP")
			sectionset.append("RS")
		if 'SC' in val:
			sectionset.append("SC")
			if lastorder!=None: SCorder = lastorder
			if lastrev:         SCrev = 1
		if 'PA' in val:
			sectionset.append("PA")
			if lastorder!=None: PAorder = lastorder
			if lastrev:         PArev = 1
		if 'QU' in val:
			sectionset.append("QU")
			if lastorder!=None: QUorder = lastorder
			if lastrev:         QUrev = 1
		if 'MC' in val:
			sectionset.append("MC")
			if lastmode!=None: MCrange = lastmode
		if 'CC' in val:
			sectionset.append("CC")
			if lastmode!=None: CCrange = lastmode
		lastorder = None
		lastrev = 0
		lastmode = None
	elif opt=='-o':
		if 'IM' in lastsval: IMorder = int(val)
		if 'MF' in lastsval: MForder = int(val)
		if 'CS' in lastsval: CSorder = int(val)
		if 'MB' in lastsval: MBorder = int(val)
		if 'HD' in lastsval: HDorder = int(val)
		if 'EX' in lastsval: EXorder = int(val)
		if 'MS' in lastsval: MSorder = int(val)
		if 'MO' in lastsval: MOorder = int(val)
		if 'SC' in lastsval: SCorder = int(val)
		if 'PA' in lastsval: PAorder = int(val)
		if 'OF' in lastsval: OForder = int(val)
		if 'AL' in lastsval: ALorder = int(val)
		if 'QU' in lastsval: QUorder = int(val)
		if lastsval=='': lastorder = int(val)
	elif opt=='-r':
		if 'IM' in lastsval: IMrev = 1
		if 'MF' in lastsval: MFrev = 1
		if 'CS' in lastsval: CSrev = 1
		if 'MB' in lastsval: MBrev = 1
		if 'HD' in lastsval: HDrev = 1
		if 'EX' in lastsval: EXrev = 1
		if 'MS' in lastsval: MSrev = 1
		if 'MO' in lastsval: MOrev = 1
		if 'SC' in lastsval: SCrev = 1
		if 'PA' in lastsval: PArev = 1
		if 'OF' in lastsval: OFrev = 1
		if 'AL' in lastsval: ALrev = 1
		if 'QU' in lastsval: QUrev = 1
		if lastsval=='': lastrev = 1
	elif opt=='-m':
		if 'HD' in lastsval:
			d = int(val)
			if d>=0 and d<6:
				HDperiod,HDtime = divmod(d,2)
		if 'MO' in lastsval: MOdata = int(val)
		if 'IN' in lastsval or 'IC' in lastsval: ICmatrix = int(val)
		if 'MC' in lastsval: MCrange = int(val)
		if 'CC' in lastsval: CCrange = int(val)
		if lastsval=='': lastmode = int(val)
	elif opt=='-i':
		if 'OF' in lastsval: OFsessionid = int(val)
		if 'AL' in lastsval: ALinode = int(val)
		if 'IN' in lastsval or 'IC' in lastsval:
			ICsclassid = int(val)
		if lastsval=='':
			lastid = int(val)
	elif opt=='-a':
		MCcount = safe_int(val)
	elif opt=='-b':
		for x in val.split(','):
			x = x.strip()
			if ':' in x:
				xs = x.split(':')
				if len(xs)==2:
					chhost = xs[0]
					chport = 9421
					x = xs[1]
				elif len(xs)==3:
					chhost = xs[0]
					chport = int(xs[1])
					x = xs[2]
				else:
					print("Wrong chart definition: %s" % x)
					sys.exit(0)
			else:
				chhost = None
				chport = None
			if x!='' and x[0]=='+':
				x = x[1:]
				rawmode = 1
			else:
				rawmode = 0
			if x in mccharts:
				MCchdata.append((chhost,chport,mccharts[x][0],mccharts[x][1],mccharts[x][2],x,rawmode))
			elif x=='all':
				for name,no,mode,desc in mcchartslist:
					if (no<100):
						MCchdata.append((chhost,chport,no,mode,desc,name,rawmode))
			else:
				print("Unknown master chart name: %s" % x)
				sys.exit(0)
	elif opt=='-c':
		CCcount = safe_int(val)
	elif opt=='-d':
		for x in val.split(','):
			x = x.strip()
			if ':' in x:
				xs = x.split(':')
				if len(xs)==2:
					chhost = xs[0]
					chport = 9422
					x = xs[1]
				elif len(xs)==3:
					chhost = xs[0]
					chport = int(xs[1])
					x = xs[2]
				else:
					print("Unknown chart name: %s" % x)
					sys.exit(0)
			else:
				chhost = None
				chport = None
			if x!='' and x[0]=='+':
				x = x[1:]
				rawmode = 1
			else:
				rawmode = 0
#				if chhost==None or chport==None:
#					print("in chunkserver chart data server ip/host must be specified")
#					sys.exit(0)
			if x in cccharts:
				CCchdata.append((chhost,chport,cccharts[x][0],cccharts[x][1],cccharts[x][2],x,rawmode))
			elif x=='all':
				for name,no,mode,desc in ccchartslist:
					if (no<100):
						CCchdata.append((chhost,chport,no,mode,desc,name,rawmode))
			else:
				print("Unknown chunkserver chart name: %s" % x)
				sys.exit(0)
	elif opt=='-C':
		clicommands.append(val)
sectionset = set(sectionset)
if len(sectionset)==0 and len(clicommands)==0:
	print("Specify data to be shown (option -S) or command (option -C). Use '-h' for help.")
	sys.exit(0)

ttymode = 1 if forceplaintext==0 and os.isatty(1) and jsonmode==0 else 0
# frames:
#  +-----+-----+-----+-----+
#  |     |     |     |     |
#  |     |     |     |  |  |
#  |  +- | -+- | -+  |  +- |
#  |  |  |  |  |  |  |  |  |
#  |     |     |     |     |
#  +-----+-----+-----+-----+
#  |     |     |     |     |
#  |  |  |  |  |  |  |  |  |
#  | -+- | -+  |  +- | -+- |
#  |  |  |  |  |     |     |
#  |     |     |     |     |
#  +-----+-----+-----+-----+
#  |     |     |     |     |
#  |  |  |     |  |  |     |
#  | -+  | -+- |  +  | -+  |
#  |     |     |  |  |     |
#  |     |     |     |     |
#  +-----+-----+-----+-----+
#  |     |     |     |     |
#  |  |  |     |     |     |
#  |  +  |  +- |  +  |  +  |
#  |     |     |  |  |     |
#  |     |     |     |     |
#  +-----+-----+-----+-----+
#  
if ttymode:
	try:
		import curses
		curses.setupterm()
		if curses.tigetnum("colors")>=256:
			colors256 = 1
		else:
			colors256 = 0
	except Exception:
		colors256 = 1 if 'TERM' in os.environ and '256' in os.environ['TERM'] else 0
	# colors: 0 - white,1 - red,2 - orange,3 - yellow,4 - green,5 - cyan,6 - blue,7 - violet,8 - gray
	CSI="\x1B["
	if colors256:
		ttyreset=CSI+"0m"
		colorcode=[CSI+"38;5;196m",CSI+"38;5;208m",CSI+"38;5;226m",CSI+"38;5;34m",CSI+"38;5;30m",CSI+"38;5;19m",CSI+"38;5;55m",CSI+"38;5;244m"]
	else:
		ttysetred=CSI+"31m"
		ttysetyellow=CSI+"33m"
		ttysetgreen=CSI+"32m"
		ttysetcyan=CSI+"36m"
		ttysetblue=CSI+"34m"
		ttysetmagenta=CSI+"35m"
		ttyreset=CSI+"0m"
		# no orange - use red, no gray - use white
		colorcode=[ttysetred,ttysetred,ttysetyellow,ttysetgreen,ttysetcyan,ttysetblue,ttysetmagenta,""]
else:
	colorcode=["","","","","","","",""]

if ttymode and (sys.stdout.encoding=='UTF-8' or sys.stdout.encoding=='utf-8'):
	if frameset>=0 and frameset<=3:
		tableframes=frameset
	else:
		tableframes=0
else:
	tableframes=0

# terminal encoding mambo jumbo (mainly replace unicode chars that can't be printed with '?' instead of throwing exception)
term_encoding = sys.stdout.encoding
if term_encoding==None:
	term_encoding = 'utf-8'
if sys.version_info[1]<7:
	sys.stdout = codecs.getwriter(term_encoding)(sys.stdout.detach(),'replace')
	sys.stdout.encoding = term_encoding
else:
	sys.stdout.reconfigure(errors='replace')
	
class Table:
	Needseparator = 0
	def __init__(self,title,ccnt,defattr=""):
		if tableframes==1:
			self.frames = ['\u250f', '\u2533', '\u2513', '\u2523', '\u254b', '\u252b', '\u2517', '\u253b', '\u251b', '\u2501', '\u2503', '\u2578', '\u2579', '\u257a', '\u257b', ' ']
		elif tableframes==2:
			self.frames = ['\u250c', '\u252c', '\u2510', '\u251c', '\u253c', '\u2524', '\u2514', '\u2534', '\u2518', '\u2500', '\u2502', '\u2574', '\u2575', '\u2576', '\u2577', ' ']
		elif tableframes==3:
			self.frames = ['\u2554', '\u2566', '\u2557', '\u2560', '\u256c', '\u2563', '\u255a', '\u2569', '\u255d', '\u2550', '\u2551', ' ', '\u2551', ' ', '\u2551', ' ']
		else:
			self.frames = ['+','+','+','+','+','+','+','+','+','-','|',' ','|',' ','|',' ']
		self.title = title
		self.ccnt = ccnt
		self.head = []
		self.body = []
		self.defattrs = []
		self.cwidth = []
		for _ in range(ccnt):
			self.defattrs.append(defattr)
			self.cwidth.append(0)
	def combineattr(self,attr,defattr):
		attrcolor = ""
		for c in ("0","1","2","3","4","5","6","7","8"):
			if c in defattr:
				attrcolor = c
		for c in ("0","1","2","3","4","5","6","7","8"):
			if c in attr:
				attrcolor = c
		attrjust = ""
		for c in ("l","L","r","R","c","C"):
			if c in defattr:
				attrjust = c
		for c in ("l","L","r","R","c","C"):
			if c in attr:
				attrjust = c
		return attrcolor+attrjust
	def header(self,*rowdata):
		ccnt = 0
		for celldata in rowdata:
			if type(celldata) is tuple:
				if len(celldata)==3:
					ccnt+=celldata[2]
				else:
					if celldata[0]!=None:
						cstr = myunicode(celldata[0])
						if len(cstr) > self.cwidth[ccnt]:
							self.cwidth[ccnt] = len(cstr)
					ccnt+=1
			else:
				if celldata!=None:
					cstr = myunicode(celldata)
					if len(cstr) > self.cwidth[ccnt]:
						self.cwidth[ccnt] = len(cstr)
				ccnt+=1
		if ccnt != self.ccnt:
			raise IndexError
		self.head.append(rowdata)
	def defattr(self,*rowdata):
		if len(rowdata) != self.ccnt:
			raise IndexError
		self.defattrs = rowdata
	def append(self,*rowdata):
		ccnt = 0
		rdata = []
		for celldata in rowdata:
			if type(celldata) is tuple:
				if celldata[0]!=None:
					cstr = myunicode(celldata[0])
				else:
					cstr = ""
				if len(celldata)==3:
					rdata.append((cstr,self.combineattr(celldata[1],self.defattrs[ccnt]),celldata[2]))
					ccnt+=celldata[2]
				else:
					if len(cstr) > self.cwidth[ccnt]:
						self.cwidth[ccnt] = len(cstr)
					if len(celldata)==2:
						rdata.append((cstr,self.combineattr(celldata[1],self.defattrs[ccnt])))
					else:
						rdata.append((cstr,self.defattrs[ccnt]))
					ccnt+=1
			else:
				if celldata!=None:
					cstr = myunicode(celldata)
					if ccnt >= len(self.cwidth):
						raise IndexError("ccnt: %u, self.ccnt: %u, len(self.cwidth): %u" % (ccnt, self.ccnt, len(self.cwidth)))
					if len(cstr) > self.cwidth[ccnt]:
						self.cwidth[ccnt] = len(cstr)
					rdata.append((cstr,self.defattrs[ccnt]))
				else:
					rdata.append(celldata)
				ccnt+=1
		if ccnt != self.ccnt:
			raise IndexError("ccnt: %u, self.ccnt: %u" % (ccnt, self.ccnt))
		self.body.append(rdata)
	def attrdata(self,cstr,cattr,cwidth):
		retstr = ""
		if "1" in cattr:
			retstr += colorcode[0]
			needreset = 1
		elif "2" in cattr:
			retstr += colorcode[1]
			needreset = 1
		elif "3" in cattr:
			retstr += colorcode[2]
			needreset = 1
		elif "4" in cattr:
			retstr += colorcode[3]
			needreset = 1
		elif "5" in cattr:
			retstr += colorcode[4]
			needreset = 1
		elif "6" in cattr:
			retstr += colorcode[5]
			needreset = 1
		elif "7" in cattr:
			retstr += colorcode[6]
			needreset = 1
		elif "8" in cattr:
			retstr += colorcode[7]
			needreset = 1
		else:
			needreset = 0
		if cstr=="--":
			retstr += " "+"-"*cwidth+" "
		elif cstr=="---":
			retstr += "-"*(cwidth+2)
		elif "L" in cattr or "l" in cattr:
			retstr += " "+cstr.ljust(cwidth)+" "
		elif "R" in cattr or "r" in cattr:
			retstr += " "+cstr.rjust(cwidth)+" "
		else:
			retstr += " "+cstr.center(cwidth)+" "
		if needreset:
			retstr += ttyreset
		return retstr
	def lines(self):
		outstrtab = []
		if ttymode:
			tabdata = []
			# upper frame
			tabdata.append((("---","",self.ccnt),))
			# title
			tabdata.append(((self.title,"",self.ccnt),))
			# header
			if len(self.head)>0:
				tabdata.append((("---","",self.ccnt),))
				tabdata.extend(self.head)
			# head and data separator
			tabdata.append((("---","",self.ccnt),))
			# data
			if len(self.body)==0:
				tabdata.append((("no data","",self.ccnt),))
			else:
				tabdata.extend(self.body)
			# bottom frame
			tabdata.append((("---","",self.ccnt),))
			# check col-spaned headers and adjust column widths if necessary
			for rowdata in tabdata:
				ccnt = 0
				for celldata in rowdata:
					if type(celldata) is tuple and len(celldata)==3 and celldata[0]!=None:
						cstr = myunicode(celldata[0])
						clen = len(cstr)
						cwidth = sum(self.cwidth[ccnt:ccnt+celldata[2]])+3*(celldata[2]-1)
						if clen > cwidth:
							add = clen - cwidth
							adddm = divmod(add,celldata[2])
							cadd = adddm[0]
							if adddm[1]>0:
								cadd+=1
							for i in range(celldata[2]):
								self.cwidth[ccnt+i] += cadd
						ccnt += celldata[2]
					else:
						ccnt += 1
			separators = []
			# before tab - no separators
			seplist = []
			for i in range(self.ccnt+1):
				seplist.append(0)
			separators.append(seplist)
			for rowdata in tabdata:
				seplist = [1]
				for celldata in rowdata:
					if type(celldata) is tuple and len(celldata)==3:
						for i in range(celldata[2]-1):
							seplist.append(1 if celldata[0]=='---' else 0)
					seplist.append(1)
				separators.append(seplist)
			# after tab - no separators
			seplist = []
			for i in range(self.ccnt+1):
				seplist.append(0)
			separators.append(seplist)
			# add upper and lower separators:
			updownsep = [[a*2 + b for (a,b) in zip(x,y)] for (x,y) in zip(separators[2:],separators[:-2])]
			# create table
			for (rowdata,sepdata) in zip(tabdata,updownsep):
				ccnt = 0
				line = ""
				nsep = 0 #self.frames[10]
				for celldata in rowdata:
					cpos = ccnt
					cattr = ""
					if type(celldata) is tuple:
						if celldata[1]!=None:
							cattr = celldata[1]
						if len(celldata)==3:
							cwidth = sum(self.cwidth[ccnt:ccnt+celldata[2]])+3*(celldata[2]-1)
							ccnt+=celldata[2]
						else:
							cwidth = self.cwidth[ccnt]
							ccnt+=1
						cstr = celldata[0]
					else:
						cstr = celldata
						cwidth = self.cwidth[ccnt]
						ccnt+=1
					if cstr==None:
						cstr = ""
					cstr = myunicode(cstr)
					if cstr=="---":
						if nsep==0:
							line += self.frames[(13,6,0,3)[sepdata[cpos]]]
						else:
							line += self.frames[(9,7,1,4)[sepdata[cpos]]]
						nsep = 1 #self.frames[4]
						for ci in range(cpos,ccnt-1):
							line += self.frames[9]*(self.cwidth[ci]+2)
							line += self.frames[(9,7,1,4)[sepdata[ci+1]]]
						line += self.frames[9]*(self.cwidth[ccnt-1]+2)
					else:
						if nsep==0:
							line += self.frames[(15,12,14,10)[sepdata[cpos]]]
						else:
							line += self.frames[(11,8,2,5)[sepdata[cpos]]]
						nsep = 0
						line += self.attrdata(cstr,cattr,cwidth)
				if nsep==0:
					line += self.frames[(15,12,14,10)[sepdata[ccnt]]]
				else:
					line += self.frames[(11,8,2,5)[sepdata[ccnt]]]
				outstrtab.append(line)
		else:
			for rowdata in self.body:
				row = []
				for celldata in rowdata:
					if type(celldata) is tuple:
						cstr = myunicode(celldata[0])
					elif celldata!=None:
						cstr = myunicode(celldata)
					else:
						cstr = ""
					row.append(cstr)
				outstrtab.append("%s:%s%s" % (self.title,ptxtsep,ptxtsep.join(row)))
		return outstrtab
	def __str__(self):
		if Table.Needseparator:
			sep = "\n"
		else:
			sep = ""
			Table.Needseparator = 1
		return sep+("\n".join(self.lines()))

def print_error(msg):
	if jsonmode:
		json_er_dict = {}
		json_er_errors = []
		json_er_errors.append({"message":msg})
		json_er_dict["errors"] = json_er_errors
		jcollect["errors"].append(json_er_dict)
	elif ttymode:
		tab = Table("Error",1)
		tab.header("message")
		tab.defattr("l")
		tab.append(msg)
		print("%s%s%s" % (colorcode[1],tab,ttyreset))
	else:
		print("""Oops, an error has occurred:""")
		print(msg)

def print_exception():
	exc_type, exc_value, exc_traceback = sys.exc_info()
	try:
		if jsonmode:
			json_er_dict = {}
			json_er_traceback = []
			for d in traceback.extract_tb(exc_traceback):
				json_er_traceback.append({"file":d[0] , "line":d[1] , "in":d[2] , "text":repr(d[3])})
			json_er_dict["traceback"] = json_er_traceback
			json_er_errors = []
			for d in traceback.format_exception_only(exc_type, exc_value):
				json_er_errors.append(repr(d.strip()))
			json_er_dict["errors"] = json_er_errors
			jcollect["errors"].append(json_er_dict)
		elif ttymode:
			tab = Table("Exception Traceback",4)
			tab.header("file","line","in","text")
			tab.defattr("l","r","l","l")
			for d in traceback.extract_tb(exc_traceback):
				tab.append(d[0],d[1],d[2],repr(d[3]))
			tab.append(("---","",4))
			tab.append(("Error","c",4))
			tab.append(("---","",4))
			for d in traceback.format_exception_only(exc_type, exc_value):
				tab.append((repr(d.strip()),"",4))
			print("%s%s%s" % (colorcode[1],tab,ttyreset))
		else:
			print("""---------------------------------------------------------------- error -----------------------------------------------------------------""")
			print(traceback.format_exc().strip())
			print("""----------------------------------------------------------------------------------------------------------------------------------------""")
	except Exception:
		print(traceback.format_exc().strip())

# connect to masters and find who is the leader etc
cl = Cluster(masterhost, masterport)

errmsg = None
if cl.master()==None:
	errmsg = """Can't connect to the MooseFS Master server (%s)""" % (masterhost)
if (cl.leaderfound() or cl.electfound() or cl.usurperfound() or cl.followerfound()):
	if cl.master().version_unknown():
		errmsg = """Can't detect the MooseFS Master server version (%s)""" % (masterhost)
	elif cl.master().version_less_than(3,0,0):
		errmsg = """This version of MooseFS Master server (%s) is not supported (pre 3.0.0)""" % (masterhost)
if errmsg:
	if jsonmode:
		jcollect["errors"].append(errmsg)
		print(json.dumps(jcollect))
	else:
		print(errmsg)
	sys.exit(1)

# initialize data provider
dataprovider = DataProvider(cl, donotresolve)

# CLI commands
if cl.leaderfound():
	for cmd in clicommands:
		cmddata = cmd.split('/')
		if cmddata[0]=='RC':
			cmd_success = 0
			try:
				csip = list(map(int,cmddata[1].split(".")))
				csport = int(cmddata[2])
				if len(csip)==4:
					data,length = cl.master().command(CLTOMA_CSSERV_COMMAND,MATOCL_CSSERV_COMMAND,struct.pack(">BBBBBH",MFS_CSSERV_COMMAND_REMOVE,csip[0],csip[1],csip[2],csip[3],csport))
					if length==1:
						status = (struct.unpack(">B",data))[0]
						cmd_success = 1
				if cmd_success:
					if status==STATUS_OK:
						print("Chunkserver %s/%s has been removed" % (cmddata[1],cmddata[2]))
					elif status==ERROR_NOTFOUND:
						print("Chunkserver %s/%s hasn't been found" % (cmddata[1],cmddata[2]))
					elif status==ERROR_ACTIVE:
						print("Chunkserver %s/%s can't be removed because is still active" % (cmddata[1],cmddata[2]))
					else:
						print("Can't remove chunkserver %s/%s (status:%u)" % (cmddata[1],cmddata[2],status))
				else:
					print("Can't remove chunkserver %s/%s" % (cmddata[1],cmddata[2]))
			except Exception:
				print_exception()
		if cmddata[0]=='BW':
			cmd_success = 0
			try:
				csip = list(map(int,cmddata[1].split(".")))
				csport = int(cmddata[2])
				if len(csip)==4:
					if cl.master().version_at_least(1,6,28):
						data,length = cl.master().command(CLTOMA_CSSERV_COMMAND,MATOCL_CSSERV_COMMAND,struct.pack(">BBBBBH",MFS_CSSERV_COMMAND_BACKTOWORK,csip[0],csip[1],csip[2],csip[3],csport))
						if length==1:
							status = (struct.unpack(">B",data))[0]
							cmd_success = 1
				if cmd_success:
					if status==STATUS_OK:
						print("Chunkserver %s/%s has back to work" % (cmddata[1],cmddata[2]))
					elif status==ERROR_NOTFOUND:
						print("Chunkserver %s/%s hasn't been found" % (cmddata[1],cmddata[2]))
					else:
						print("Can't turn chunkserver %s/%s back to work (status:%u)" % (cmddata[1],cmddata[2],status))
				else:
					print("Can't turn chunkserver %s/%s back to work" % (cmddata[1],cmddata[2]))
			except Exception:
				print_exception()
		if cmddata[0]=='M1':
			cmd_success = 0
			try:
				csip = list(map(int,cmddata[1].split(".")))
				csport = int(cmddata[2])
				if len(csip)==4:
					if cl.master().version_at_least(2,0,11):
						data,length = cl.master().command(CLTOMA_CSSERV_COMMAND,MATOCL_CSSERV_COMMAND,struct.pack(">BBBBBH",MFS_CSSERV_COMMAND_MAINTENANCEON,csip[0],csip[1],csip[2],csip[3],csport))
						if length==1:
							status = (struct.unpack(">B",data))[0]
							cmd_success = 1
				if cmd_success:
					if status==STATUS_OK:
						print("Chunkserver %s/%s has been switched to maintenance mode" % (cmddata[1],cmddata[2]))
					elif status==ERROR_NOTFOUND:
						print("Chunkserver %s/%s hasn't been found" % (cmddata[1],cmddata[2]))
					else:
						print("Can't switch chunkserver %s/%s to maintenance mode (status:%u)" % (cmddata[1],cmddata[2],status))
				else:
					print("Can't switch chunkserver %s/%s to maintenance mode" % (cmddata[1],cmddata[2]))
			except Exception:
				print_exception()
		if cmddata[0]=='M0':
			cmd_success = 0
			try:
				csip = list(map(int,cmddata[1].split(".")))
				csport = int(cmddata[2])
				if len(csip)==4:
					if cl.master().version_at_least(2,0,11):
						data,length = cl.master().command(CLTOMA_CSSERV_COMMAND,MATOCL_CSSERV_COMMAND,struct.pack(">BBBBBH",MFS_CSSERV_COMMAND_MAINTENANCEOFF,csip[0],csip[1],csip[2],csip[3],csport))
						if length==1:
							status = (struct.unpack(">B",data))[0]
							cmd_success = 1
				if cmd_success:
					if status==STATUS_OK:
						print("Chunkserver %s/%s has been switched to standard mode" % (cmddata[1],cmddata[2]))
					elif status==ERROR_NOTFOUND:
						print("Chunkserver %s/%s hasn't been found" % (cmddata[1],cmddata[2]))
					else:
						print("Can't switch chunkserver %s/%s to standard mode (status:%u)" % (cmddata[1],cmddata[2],status))
				else:
					print("Can't switch chunkserver %s/%s to standard mode" % (cmddata[1],cmddata[2]))
			except Exception:
				print_exception()
		if cmddata[0]=='RS':
			cmd_success = 0
			try:
				sessionid = int(cmddata[1])
				data,length = cl.master().command(CLTOMA_SESSION_COMMAND,MATOCL_SESSION_COMMAND,struct.pack(">BL",MFS_SESSION_COMMAND_REMOVE,sessionid))
				if length==1:
					status = (struct.unpack(">B",data))[0]
					cmd_success = 1
				if cmd_success:
					if status==STATUS_OK:
						print("Session %u has been removed" % (sessionid))
					elif status==ERROR_NOTFOUND:
						print("Session %u hasn't been found" % (sessionid))
					elif status==ERROR_ACTIVE:
						print("Session %u can't be removed because is still active" % (sessionid))
					else:
						print("Can't remove session %u (status:%u)" % (sessionid,status))
				else:
					print("Can't remove session %u" % (sessionid))
			except Exception:
				print_exception()
elif len(clicommands)>0:
	print("Can't perform any operation because there is no leading master")

# organization of sections
org = Organization(dataprovider, guimode=False)
if org.menu_tree==None: # missing menu_tree means we can't connect to the master
	print_error("Can't connect to MooseFS Master server (%s)" % masterhost)
	exit(1)
org.set_sections(sectionset)


#######################################################
###                 RENDER OUTPUT                   ###
#######################################################

if cl.leaderfound()==0:
	if jsonmode:
		if not cl.anyfound():
			jcollect["errors"].append("Can't find masters (resolve '%s')!" % (masterhost))
		else:
			jcollect["errors"].append("Working master servers not found! Maybe you are using wrong port number or wrong dns name")
	else:
		if not cl.anyfound():
			print("Can't find masters (resolve '%s')!" % (masterhost))
		else:
			print("Working master servers not found! Maybe you are using wrong port number or wrong dns name")
	Table.Needseparator=1

# parse cgi parameters, data ordering and fix order id's
if CSorder>=2: 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 MSorder>=3: MSorder+=1
if MSorder==0: MSorder=2 # default order: host name

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


#######################################################
###                 RENDER SECTIONS                 ###
#######################################################


# Info section
if jsonmode:
	json_in_dict = {}

#Cluster summary subsection
if org.shall_render("IG"):
	try:
		ci = dataprovider.get_clusterinfo()
		if jsonmode:
			json_ig_dict = {}
			json_ig_dict["strver"] = ci.strver
			if ci.strver.endswith(" PRO"):
				json_ig_dict["version"] = ci.strver[:-4]
				json_ig_dict["pro"] = True
			else:
				json_ig_dict["version"] = ci.strver
				json_ig_dict["pro"] = False
			if ci.memusage>0:
				json_ig_dict["memory_usage"] = ci.memusage
				json_ig_dict["memory_usage_human"] = humanize_number(ci.memusage," ")
			else:
				json_ig_dict["memory_usage"] = None
				json_ig_dict["memory_usage_human"] = ""
			if ci.syscpu>0 or ci.usercpu>0:
				json_ig_dict["cpu_usage_percent"] = ci.syscpu+ci.usercpu
				json_ig_dict["cpu_system_percent"] = ci.syscpu
				json_ig_dict["cpu_user_percent"] = ci.usercpu
			else:
				json_ig_dict["cpu_usage_percent"] = None
				json_ig_dict["cpu_system_percent"] = None
				json_ig_dict["cpu_user_percent"] = None
			json_ig_dict["total_space"] = ci.totalspace
			json_ig_dict["total_space_human"] = humanize_number(ci.totalspace," ")
			json_ig_dict["avail_space"] = ci.availspace
			json_ig_dict["avail_space_human"] = humanize_number(ci.availspace," ")
			json_ig_dict["free_space"] = ci.freespace
			json_ig_dict["free_space_human"] = humanize_number(ci.freespace," ")
			json_ig_dict["trash_space"] = ci.trspace
			json_ig_dict["trash_space_human"] = humanize_number(ci.trspace," ")
			json_ig_dict["trash_files"] = ci.trfiles
			json_ig_dict["sustained_space"] = ci.respace
			json_ig_dict["sustained_space_human"] = humanize_number(ci.respace," ")
			json_ig_dict["sustained_files"] = ci.refiles
			json_ig_dict["filesystem_objects"] = ci.nodes
			json_ig_dict["directories"] = ci.dirs
			json_ig_dict["files"] = ci.files
			json_ig_dict["chunks"] = ci.chunks
			if ci.metainfomode:
				json_ig_dict["copy_chunks"] = ci.copychunks
				json_ig_dict["ec8_chunks"] = ci.ec8chunks
				json_ig_dict["ec4_chunks"] = ci.ec4chunks
				json_ig_dict["full_chunk_copies"] = ci.chunkcopies
				json_ig_dict["ec8_chunk_parts"] = ci.chunkec8parts
				json_ig_dict["ec4_chunk_parts"] = ci.chunkec4parts
				json_ig_dict["hypothetical_chunk_copies"] = ci.chunkhypcopies
				json_ig_dict["ec_bytes_saved"] = ci.savedbyec
				if ci.savedbyec!=None:
					json_ig_dict["ec_bytes_saved_human"] = humanize_number(ci.savedbyec," ")
				else:
					json_ig_dict["ec_bytes_saved_human"] = ""
				json_ig_dict["redundancy_ratio"] = ci.dataredundancyratio
				json_ig_dict["chunks_in_ec_percent"] = ci.ecchunkspercent
			else:
				json_ig_dict["all_copies"] = ci.allcopies
				json_ig_dict["regular_copies"] = ci.regularcopies
			if ci.lastsuccessfulstore>0:
				json_ig_dict["last_metadata_save_time"] = ci.lastsuccessfulstore
				json_ig_dict["last_metadata_save_time_str"] = time.asctime(time.localtime(ci.lastsuccessfulstore))
				json_ig_dict["last_metadata_save_duration"] = ci.lastsaveseconds
				json_ig_dict["last_metadata_save_duration_human"] = timeduration_to_shortstr(ci.lastsaveseconds)
			else:
				json_ig_dict["last_metadata_save_time"] = None
				json_ig_dict["last_metadata_save_time_str"] = ""
				json_ig_dict["last_metadata_save_duration"] = None
				json_ig_dict["last_metadata_save_duration_human"] = ""
			if ci.lastsuccessfulstore>0 or ci.lastsavestatus>0:
				json_ig_dict["last_metadata_save_status"] = ci.lastsavestatus
				json_ig_dict["last_metadata_save_status_txt"] = "Saved in background" if ci.lastsavestatus==0 else "Downloaded from another master" if ci.lastsavestatus==1 else "Saved in foreground" if ci.lastsavestatus==2 else "CRC saved in background" if ci.lastsavestatus==3 else ("Unknown status: %u" % ci.lastsavestatus)
			else:
				json_ig_dict["last_metadata_save_status"] = None
				json_ig_dict["last_metadata_save_status_txt"] = ""

			json_in_dict["general"] = json_ig_dict
		else:
			if ttymode:
				tab = Table("Cluster summary",2)
			else:
				tab = Table("cluster summary",2)
			tab.defattr("l","r")
			tab.append("master version",ci.strver)
			if ci.memusage>0:
				if ttymode:
					tab.append("RAM used",humanize_number(ci.memusage," "))
				else:
					tab.append("RAM used",ci.memusage)
			else:
				tab.append("RAM used","not available")
			if ci.syscpu>0 or ci.usercpu>0:
				if ttymode:
					tab.append("CPU used","%.2f%%" % (ci.syscpu+ci.usercpu))
					tab.append("CPU used (system)","%.2f%%" % (ci.syscpu))
					tab.append("CPU used (user)","%.2f%%" % (ci.usercpu))
				else:
					tab.append("CPU used (system)","%.9f" % (ci.syscpu/100.0))
					tab.append("CPU used (user)","%.9f" % (ci.usercpu/100.0))
			else:
				tab.append("CPU used","not available")
			if ttymode:
				tab.append("total space",humanize_number(ci.totalspace," "))
				tab.append("avail space",humanize_number(ci.availspace," "))
				if ci.freespace!=None:
					tab.append("free space",humanize_number(ci.freespace," "))
				tab.append("trash space",humanize_number(ci.trspace," "))
			else:
				tab.append("total space",ci.totalspace)
				tab.append("avail space",ci.availspace)
				if ci.freespace!=None:
					tab.append("free space",ci.freespace)
				tab.append("trash space",ci.trspace)
			tab.append("trash files",ci.trfiles)
			if ttymode:
				tab.append("sustained space",humanize_number(ci.respace," "))
			else:
				tab.append("sustained space",ci.respace)
			tab.append("sustained files",ci.refiles)
			tab.append("all fs objects",ci.nodes)
			tab.append("directories",ci.dirs)
			tab.append("files",ci.files)
			tab.append("chunks",ci.chunks)
			if ci.metainfomode:
				if ttymode:
					if ci.ecchunkspercent!=None:
						tab.append("percent of chunks in EC format","%.1f%%" % ci.ecchunkspercent)
					if ci.dataredundancyratio!=None:
						tab.append("real data redundancy ratio","%.3f" % ci.dataredundancyratio)
					if ci.savedbyec!=None:
						tab.append("storage bytes saved by EC",humanize_number(ci.savedbyec," "))
				else:
					if ci.copychunks!=None:
						tab.append("chunks in copy format",ci.copychunks)
					if ci.ec8chunks!=None:
						tab.append("chunks in EC8 format",ci.ec8chunks)
					if ci.ec4chunks!=None:
						tab.append("chunks in EC4 format",ci.ec4chunks)
					if ci.chunkcopies!=None:
						tab.append("all full chunk copies",ci.chunkcopies)
					if ci.chunkec8parts!=None:
						tab.append("all chunk EC8 parts",ci.chunkec8parts)
					if ci.chunkec4parts!=None:
						tab.append("all chunk EC4 parts",ci.chunkec4parts)
					if ci.chunkhypcopies!=None:
						tab.append("hypothetical full chunk copies",ci.chunkhypcopies)
					if ci.savedbyec!=None:
						tab.append("storage bytes saved by EC",ci.savedbyec)
			else:
				if ci.allcopies!=None:
					tab.append("all chunk copies",ci.allcopies)
				if ci.regularcopies!=None:
					tab.append("regular chunk copies",ci.regularcopies)
			if ci.lastsuccessfulstore>0:
				if ttymode:
					tab.append("last successful store",time.asctime(time.localtime(ci.lastsuccessfulstore)))
					tab.append("last save duration",timeduration_to_shortstr(ci.lastsaveseconds))
				else:
					tab.append("last successful store",ci.lastsuccessfulstore)
					tab.append("last save duration","%.3f" % ci.lastsaveseconds)
			else:
				tab.append("last successful store","-")
				tab.append("last save duration","-")
			if ci.lastsuccessfulstore>0 or ci.lastsavestatus>0:
				tab.append("last save status",("Saved in background","4") if ci.lastsavestatus==0 else ("Downloaded from another master","4") if ci.lastsavestatus==1 else ("Saved in foreground","2") if ci.lastsavestatus==2 else ("CRC saved in background","5") if ci.lastsavestatus==3 else ("Unknown status: %u" % ci.lastsavestatus,"1"))
			else:
				tab.append("last save status","-")
			print(myunicode(tab))
	except Exception:
		print_exception()

#Metadata servers subsection
if org.shall_render("IM"):
	try:		
		if jsonmode:
			json_im_array = []
		elif ttymode:
			tab = Table("Metadata Servers (masters)",15,"r")
			tab.header("ip","version","state","local time","metadata version","metadata id","metadata delay","RAM used","CPU used","last meta save","last save duration","last save status","last save version","last save checksum","exports checksum")
		else:
			tab = Table("metadata servers (masters)",15)

		# update master servers delay times prior to getting the list of master servers
		highest_saved_metaversion, highest_metaversion_checksum = cl.update_masterservers_delays()
		mservers = dataprovider.get_masterservers(IMorder, IMrev)
		for ms in mservers:
			if jsonmode:
				json_im_dict = {}
				json_im_dict["ip"] = ms.strip
				json_im_dict["strver"] = ms.strver
				if ms.strver.endswith(" PRO"):
					json_im_dict["version"] = ms.strver[:-4]
					json_im_dict["pro"] = True
				else:
					json_im_dict["version"] = ms.strver
					json_im_dict["pro"] = False
				json_im_dict["state"] = ms.statestr
				if ms.usectime==None:
					json_im_dict["localtime"] = None
					json_im_dict["localtime_str"] = ""
				else:
					json_im_dict["localtime"] = ms.usectime/1000000.0
					json_im_dict["localtime_str"] = time.asctime(time.localtime(ms.usectime//1000000))
				json_im_dict["metadata_version"] = ms.metaversion
				json_im_dict["metadata_id"] = ms.metaid
				json_im_dict["metadata_delay"] = ms.metadelay
				if ms.memusage>0:
					json_im_dict["memory_usage"] = ms.memusage
					json_im_dict["memory_usage_human"] = humanize_number(ms.memusage," ")
				else:
					json_im_dict["memory_usage"] = None
					json_im_dict["memory_usage_human"] = ""
				if ms.syscpu>0 or ms.usercpu>0:
					json_im_dict["cpu_usage_percent"] = ms.syscpu+ms.usercpu
					json_im_dict["cpu_system_percent"] = ms.syscpu
					json_im_dict["cpu_user_percent"] = ms.usercpu
				else:
					json_im_dict["cpu_usage_percent"] = None
					json_im_dict["cpu_system_percent"] = None
					json_im_dict["cpu_user_percent"] = None
				if ms.lastsuccessfulstore>0:
					json_im_dict["last_metadata_save_time"] = ms.lastsuccessfulstore
					json_im_dict["last_metadata_save_time_str"] = time.asctime(time.localtime(ms.lastsuccessfulstore))
					json_im_dict["last_metadata_save_duration"] = ms.lastsaveseconds
					json_im_dict["last_metadata_save_duration_human"] = timeduration_to_shortstr(ms.lastsaveseconds)
				else:
					json_im_dict["last_metadata_save_time"] = None
					json_im_dict["last_metadata_save_time_str"] = ""
					json_im_dict["last_metadata_save_duration"] = None
					json_im_dict["last_metadata_save_duration_human"] = ""
				if ms.lastsuccessfulstore>0 or ms.lastsavestatus>0:
					json_im_dict["last_metadata_save_status"] = ms.lastsavestatus
					json_im_dict["last_metadata_save_status_txt"] = "Saved in background" if ms.lastsavestatus==0 else "Downloaded from other master" if ms.lastsavestatus==1 else "Saved in foreground" if ms.lastsavestatus==2 else "CRC saved in background" if ms.lastsavestatus==3 else ("Unknown status: %u" % ms.lastsavestatus)
				else:
					json_im_dict["last_metadata_save_status"] = None
					json_im_dict["last_metadata_save_status_txt"] = ""
				if ms.lastsuccessfulstore>0 and (ms.lastsavestatus==0 or ms.lastsavestatus>=2) and ms.lastsavemetaversion!=None:
					json_im_dict["last_metadata_save_version"] = ms.lastsavemetaversion
				else:
					json_im_dict["last_metadata_save_version"] = None
				if ms.lastsuccessfulstore>0 and (ms.lastsavestatus==0 or ms.lastsavestatus>=2) and ms.lastsavemetaversion!=None and ms.lastsavemetachecksum!=None:
					json_im_dict["last_metadata_save_checksum"] = "%08X" % ms.lastsavemetachecksum
				else:
					json_im_dict["last_metadata_save_checksum"] = None
				if ms.exportschecksum!=None:
					json_im_dict["exports_checksum"] = "%016X" % ms.exportschecksum
				else:
					json_im_dict["exports_checksum"] = None
				json_im_array.append(json_im_dict)
			else:
				clist = [ms.strip,ms.strver,(ms.statestr,"c%u" % ms.statecolor)]
				if ms.usectime==None:
					clist.append("not available")
				else:
					if ttymode:
						clist.append((time.asctime(time.localtime(ms.usectime//1000000)),("1" if ms.secdelta>2.0 else "3" if ms.secdelta>1.0 else "4" if ms.secdelta>0.0 else "0")))
					else:
						clist.append("%.6lf" % (ms.usectime/1000000.0))
				clist.append(decimal_number(ms.metaversion))
				if ms.metaid!=None:
					clist.append((("%016X" % ms.metaid),("1" if ms.metaid != cl.master_metaid() else "4")))
				else:
					clist.append("-")
				if ms.metadelay==None:
					clist.append("not available")
				else:
					if ttymode:
						clist.append((("%.0f s" % ms.metadelay),("4" if ms.metadelay<1.0 else "3" if ms.metadelay<6.0 else "1")))
					else:
						clist.append(int(ms.metadelay))
				if ms.memusage>0:
					if ttymode:
						clist.append(humanize_number(ms.memusage," "))
					else:
						clist.append(ms.memusage)
				else:
					clist.append("not available")
				if ms.syscpu>0 or ms.usercpu>0:
					if ttymode:
						clist.append("all:%.2f%% sys:%.2f%% user:%.2f%%" % (ms.syscpu+ms.usercpu,ms.syscpu,ms.usercpu))
					else:
						clist.append("all:%.7f%% sys:%.7f%% user:%.7f%%" % (ms.syscpu+ms.usercpu,ms.syscpu,ms.usercpu))
				else:
					clist.append("not available")
				if ms.lastsuccessfulstore>0:
					if ttymode:
						clist.append(time.asctime(time.localtime(ms.lastsuccessfulstore)))
						clist.append(timeduration_to_shortstr(ms.lastsaveseconds))
					else:
						clist.append(ms.lastsuccessfulstore)
						clist.append("%.3f" % ms.lastsaveseconds)
				else:
					clist.append("-")
					clist.append("-")
				if ms.lastsuccessfulstore>0 or ms.lastsavestatus>0:
					clist.append(("Saved in background","4") if ms.lastsavestatus==0 else ("Downloaded from other master","4") if ms.lastsavestatus==1 else ("Saved in foreground","2") if ms.lastsavestatus==2 else ("CRC saved in background","5") if ms.lastsavestatus==3 else ("Unknown status: %u" % ms.lastsavestatus,"1"))
				else:
					clist.append("-")
				if ms.lastsuccessfulstore>0 and (ms.lastsavestatus==0 or ms.lastsavestatus>=2) and ms.lastsavemetaversion!=None:
					clist.append((decimal_number(ms.lastsavemetaversion),("4" if ms.lastsavemetaversion==highest_saved_metaversion else "8")))
				else:
					clist.append("-")
				if ms.lastsuccessfulstore>0 and (ms.lastsavestatus==0 or ms.lastsavestatus>=2) and ms.lastsavemetaversion!=None and ms.lastsavemetachecksum!=None:
					clist.append((("%08X" % ms.lastsavemetachecksum),("4" if ms.lastsavemetaversion==highest_saved_metaversion and ms.lastsavemetachecksum==highest_metaversion_checksum else "1" if ms.lastsavemetaversion==highest_saved_metaversion and ms.lastsavemetachecksum!=highest_metaversion_checksum else "8")))
				else:
					clist.append("-")
				if ms.exportschecksum!=None:
					clist.append((("%016X" % ms.exportschecksum),("1" if ms.exportschecksum != cl.master_exportschecksum() else "4")))
				else:
					clist.append("-")
				tab.append(*clist)

		if len(mservers)==0:
			if not jsonmode:
				tab.append(("""Servers not found! Check your DNS""","c",9))

		if jsonmode:
			json_in_dict["masters"] = json_im_array
		else:
			print(myunicode(tab))
	except Exception:
		print_exception()


# Chunks matrix
if org.shall_render("IC"):
	try:
		sclass_dict = {}
		sclass_name = "Error"
		sclass_desc = "Error"
		if cl.master().has_feature(FEATURE_SCLASS_IN_MATRIX):
			sclass_dict = dataprovider.get_used_sclasses_names()
			if ICsclassid<0:
				sclass_name = ""
				sclass_desc = "all storage classes"
			elif ICsclassid in sclass_dict:
				sclass_name = sclass_dict[ICsclassid].name
				sclass_desc = "storage class '%s'" % sclass_name
			else:
				sclass_name = "[%u]" % ICsclassid
				sclass_desc = "non existent storage class id:%u" % ICsclassid
		(matrix,progressstatus)=dataprovider.get_matrix(ICsclassid)
		progressstr = "disconnections" if (progressstatus==1) else "connections" if (progressstatus==2) else "connections and disconnections"
		if len(matrix)==2 or len(matrix)==6 or len(matrix)==8:
			if jsonmode:
				json_ic_dict = {}
				json_ic_sum_dict = {}
				matrixkeys = ['allchunks','regularchunks','allchunks_copies','regularchunks_copies','allchunks_ec8','regularchunks_ec8','allchunks_ec4', 'regularchunks_ec4']
				sumkeys = ['missing','endangered','undergoal','stable','overgoal','pending_deletion','ready_to_remove']
				#sumlist has to be clean for JSON mode
				sumlist = []
			elif ttymode:
				tabtypesc = "" if (ICsclassid<0) else (" (data only for %s)" % sclass_desc)
				tabtypear = "Regular" if (ICmatrix&1) else "All"
				tabtypeec = "Both copies and EC chunks" if ((ICmatrix>>1)==0) else "Only chunks stored in full copies" if ((ICmatrix>>1)==1) else "Only chunks stored using Raid-like Erasure Codes in 8+N format" if ((ICmatrix>>1)==2) else "Only chunks stored using Raid-like Erasure Codes in 4+N format"
				tab = Table("%s chunks state matrix%s - %s mode" % (tabtypear,tabtypesc,tabtypeec),13,"r")
				if progressstatus>0:
					tab.header(("Warning: counters may not be valid - %s in progress" % progressstr,"1c",13))
					tab.header(("---","",13))
				if (ICmatrix>>1)==0:
					tab.header("target",("current redundancy level (RL = N means EC: (8+N) or (4+N) parts, GOAL: (1+N) copies)","",12))
				elif (ICmatrix>>1)==1:
					tab.header("target",("current number of valid copies","",12))
				elif (ICmatrix>>1)==2:
					tab.header("target",("current number of EC8 parts","",12))
				else:
					tab.header("target",("current number of EC4 parts","",12))
				tab.header("redundancy",("---","",12))
				if (ICmatrix>>1)==0:
					tab.header("level"," missing ","  RL = 0  ","  RL = 1  ","  RL = 2  ","  RL = 3  ","  RL = 4  ","  RL = 5  ","  RL = 6  ","  RL = 7  ","  RL = 8  ","  RL >= 9  ","   all   ")
				elif (ICmatrix>>1)==1:
					tab.header("level"," missing ","1+0 copies","1+1 copies","1+2 copies","1+3 copies","1+4 copies","1+5 copies","1+6 copies","1+7 copies","1+8 copies",">1+9 copies","   all   ")
				elif (ICmatrix>>1)==2:
					tab.header("level"," missing ","8+0 parts ","8+1 parts ","8+2 parts ","8+3 parts ","8+4 parts ","8+5 parts ","8+6 parts ","8+7 parts ","8+8 parts ",">8+9 parts ","   all   ")
				else:
					tab.header("level"," missing ","4+0 parts ","4+1 parts ","4+2 parts ","4+3 parts ","4+4 parts ","4+5 parts ","4+6 parts ","4+7 parts ","4+8 parts ",">4+9 parts ","   all   ")
			else:
				out = []
				if ICmatrix==0:
					mtypeprefix=("all chunks matrix:%s" % ptxtsep)
				elif ICmatrix==1:
					mtypeprefix=("regular chunks matrix:%s" % ptxtsep)
				elif ICmatrix==2:
					mtypeprefix=("all chunks matrix - copies only:%s" % ptxtsep)
				elif ICmatrix==3:
					mtypeprefix=("regular chunks matrix - copies only:%s" % ptxtsep)
				elif ICmatrix==4:
					mtypeprefix=("all chunks matrix - EC8 only:%s" % ptxtsep)
				elif ICmatrix==5:
					mtypeprefix=("regular chunks matrix - EC8 only:%s" % ptxtsep)
				elif ICmatrix==6:
					mtypeprefix=("all chunks matrix - EC4 only:%s" % ptxtsep)
				elif ICmatrix==7:
					mtypeprefix=("regular chunks matrix - EC4 only:%s" % ptxtsep)
				else:
					mtypeprefix=("UNKNOWN chunks matrix:%s" % ptxtsep)
				if ICsclassid>=0:
					mtypeprefix=("%s%s%s" % (mtypeprefix,sclass_desc,ptxtsep))
			classsum = []
			sumlist = []
			for i in range(len(matrix)):
				classsum.append(7*[0])
				sumlist.append(11*[0])
			left_col_once=1
			for goal in range(11):
				if goal==0:
					clist = ["deleted"]
				else:
					if (ICmatrix>>1)==0:
						clist = ["RL = %u" % (goal-1)]
					elif (ICmatrix>>1)==1:
						if goal>9:
							clist = ["-"]
						else:
							clist = ["1+%u copies" % (goal-1)]
					elif (ICmatrix>>1)==2:
						if goal==1:
							clist = ["-"]
						else:
							clist = ["8+%u parts" % (goal-1)]
					else:
						if goal==1:
							clist = ["-"]
						else:
							clist = ["4+%u parts" % (goal-1)]
				for actual in range(11):
					(col,_)=redundancy2colclass(goal,actual)
					for i in range(len(matrix)):
						classsum[i][col]+=matrix[i][goal][actual]
					if jsonmode:
						pass
					elif ttymode:
						if ICmatrix<len(matrix) and matrix[ICmatrix][goal][actual]>0:
							clist.append((matrix[ICmatrix][goal][actual],"1234678"[col]))
						else:
							clist.append("-")
					else:
						if ICmatrix<len(matrix) and matrix[ICmatrix][goal][actual]>0:
							if goal==0:
								goalstr = "missing"
							else:
								if ICmatrix>>1==0:
									goalstr = "%u" % (goal-1)
								elif ICmatrix>>1==1:
									goalstr = "1+%u" % (goal-1)
								elif ICmatrix>>1==2:
									goalstr = "8+%u" % (goal-1)
								else:
									goalstr = "4+%u" % (goal-1)
							if actual==0:
								vcstr = "missing"
							else:
								if ICmatrix>>1==0:
									vcstr = "%u" % (actual-1)
								elif ICmatrix>>1==1:
									vcstr = "1+%u" % (actual-1)
								elif ICmatrix>>1==2:
									vcstr = "8+%u" % (actual-1)
								else:
									vcstr = "4+%u" % (actual-1)
							if ICmatrix>>1==0:
								descstr = "redundancy level"
							elif ICmatrix>>1==1:
								descstr = "copies"
							elif ICmatrix>>1==2:
								descstr = "EC8 parts"
							else:
								descstr = "EC4 parts"
							out.append("""%s%s target/current/chunks:%s%s%s%s%s%u""" % (mtypeprefix,descstr,ptxtsep,goalstr,ptxtsep,vcstr,ptxtsep,matrix[ICmatrix][goal][actual]))
				if ttymode:
					clist.append(sum(matrix[ICmatrix][goal]))
					tab.append(*clist)
				if goal>0:
					for i in range(len(matrix)):
						sumlist[i] = [ a + b for (a,b) in zip(sumlist[i],matrix[i][goal])]
			if jsonmode:
				#Go through all available matrices:
				for mx in range(len(matrix)):
					classsum = []
					for i in range(len(matrix)):
						classsum.append(7*[0])
						sumlist.append(11*[0])
					cssumdict = {}
					mxarray = []
					if mx>7:
						mtypeprefix = "unknown"
					else:
						mtypeprefix = matrixkeys[mx]
					for goal in range(11):
						for actual in range(11):
							tccdict = {}
							(col,_)=redundancy2colclass(goal,actual)
							for i in range(len(matrix)):
								classsum[i][col]+=matrix[i][goal][actual]
							#Goal String
							if matrix[mx][goal][actual]>0:
								if goal==0:
									goalstr = "0"
								else:
									if mx>>1==0:
										goalstr = "%u" % (goal)
									elif mx>>1==1:
										goalstr = "1+%u" % (goal)
									elif mx>>1==2:
										goalstr = "8+%u" % (goal)
									else:
										goalstr = "4+%u" % (goal)
								if actual==0:
									vcstr = "0"
								else:
									if mx>>1==0:
										vcstr = "%u" % (actual)
									elif mx>>1==1:
										vcstr = "1+%u" % (actual)
									elif mx>>1==2:
										vcstr = "8+%u" % (actual)
									else:
										vcstr = "4+%u" % (actual)
								if mx>>1==0:
									descstr = "redundancy level"
								elif mx>>1==1:
									descstr = "copies"
								elif mx>>1==2:
									descstr = "EC 8 parts"
								else:
									descstr = "EC 4 parts"
								tccdict['target'] = goalstr
								tccdict['current'] = vcstr
								tccdict['chunks'] = matrix[mx][goal][actual]
								mxarray.append(tccdict)
					
					for index,key in enumerate(sumkeys):
						cssumdict[key] = classsum[mx][index]
					json_ic_sum_dict[matrixkeys[mx]] = cssumdict
					json_ic_dict[mtypeprefix]=mxarray

				json_ic_dict['summary'] = json_ic_sum_dict
				json_ic_dict['progress_status'] = progressstatus
				if progressstatus>0:
					json_ic_dict['progress_str'] = "counters may not be valid - %s in progress" % progressstr
				else:
					json_ic_dict['progress_str'] = "counters are valid"
				json_ic_dict['storage_class_id'] = ICsclassid
				json_ic_dict['storage_class_name'] = sclass_name
				json_ic_dict['storage_class_desc'] = sclass_desc
				#Add created dictionaries to the main dictionary
				json_in_dict['chunks'] = json_ic_dict
			elif ttymode:
				clist = ["all 1+"]
				for actual in range(11):
					clist.append(sumlist[ICmatrix][actual])
				clist.append(sum(sumlist[ICmatrix]))
				tab.append(*clist)
				tab.append(("---","",13))
				tab.append(("missing: %u / endangered: %u / undergoal: %u / stable: %u / overgoal: %u / pending deletion: %u / to be removed: %u" % (classsum[ICmatrix][0],classsum[ICmatrix][1],classsum[ICmatrix][2],classsum[ICmatrix][3],classsum[ICmatrix][4],classsum[ICmatrix][5],classsum[ICmatrix][6]),"c",13))
				print(myunicode(tab))
			else:
				if ICmatrix < len(classsum):
					out.append("%schunkclass missing:%s%u" % (mtypeprefix,ptxtsep,classsum[ICmatrix][0]))
					out.append("%schunkclass endangered:%s%u" % (mtypeprefix,ptxtsep,classsum[ICmatrix][1]))
					out.append("%schunkclass undergoal:%s%u" % (mtypeprefix,ptxtsep,classsum[ICmatrix][2]))
					out.append("%schunkclass stable:%s%u" % (mtypeprefix,ptxtsep,classsum[ICmatrix][3]))
					out.append("%schunkclass overgoal:%s%u" % (mtypeprefix,ptxtsep,classsum[ICmatrix][4]))
					out.append("%schunkclass pending deletion:%s%u" % (mtypeprefix,ptxtsep,classsum[ICmatrix][5]))
					out.append("%schunkclass to be removed:%s%u" % (mtypeprefix,ptxtsep,classsum[ICmatrix][6]))
				print(str(Table("",0))+"\n".join(out))
	except Exception:
		print_exception()

# Both filesystem self-chek and chunk house-keeping loop (CLI only)
if org.shall_render("IL"):
	try: # Filesystem self-check loop
		hsc = dataprovider.get_health_selfcheck()
		if jsonmode:
			if hsc.loopstart>0:
				json_il_dict = {}
				json_il_dict["start_time"] = hsc.loopstart
				json_il_dict["end_time"] = hsc.loopend
				json_il_dict["start_time_str"] = time.asctime(time.localtime(hsc.loopstart))
				json_il_dict["end_time_str"] = time.asctime(time.localtime(hsc.loopend))
				json_il_dict["files"] = hsc.files
				json_il_dict["undergoal_files"] = hsc.ugfiles
				json_il_dict["missing_files"] = hsc.mfiles
				if hsc.mtfiles!=None:
					json_il_dict["missing_trash_files"] = hsc.mtfiles
				if hsc.msfiles!=None:
					json_il_dict["missing_sustained_files"] = hsc.msfiles
				json_il_dict["chunks"] = hsc.chunks
				json_il_dict["undergoal_chunks"] = hsc.ugchunks
				json_il_dict["missing_chunks"] = hsc.mchunks
				json_in_dict['fs_loop'] = json_il_dict
			else:
				json_in_dict['fs_loop'] = None
		elif ttymode:
			tab = Table("Filesystem self-check",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")
			if hsc.loopstart>0:
				if hsc.mtfiles!=None and hsc.msfiles!=None:
					tab.append((time.asctime(time.localtime(hsc.loopstart)),"c"),(time.asctime(time.localtime(hsc.loopend)),"c"),hsc.files,hsc.ugfiles,hsc.mfiles,hsc.mtfiles,hsc.msfiles,hsc.chunks,hsc.ugchunks,hsc.mchunks)
				else:
					tab.append((time.asctime(time.localtime(hsc.loopstart)),"c"),(time.asctime(time.localtime(hsc.loopend)),"c"),hsc.files,hsc.ugfiles,hsc.mfiles,'n/a','n/a',hsc.chunks,hsc.ugchunks,hsc.mchunks)
				if hsc.msgbuffleng>0:
					tab.append(("---","",tabwidth))
					if hsc.msgbuffleng==100000:
						tab.append(("Important messages (first 100k):","c",tabwidth))
					else:
						tab.append(("Important messages:","c",tabwidth))
					tab.append(("---","",tabwidth))
					for line in hsc.datastr.strip().split("\n"):
						tab.append((line.strip(),"l",tabwidth))
			else:
				tab.append(("no data","c",tabwidth))
			print(myunicode(tab))
		else:
			out = []
			if hsc.loopstart>0:
				out.append("""check loop%sstart:%s%u""" % (ptxtsep,ptxtsep,hsc.loopstart))
				out.append("""check loop%send:%s%u""" % (ptxtsep,ptxtsep,hsc.loopend))
				out.append("""check loop%sfiles:%s%u""" % (ptxtsep,ptxtsep,hsc.files))
				out.append("""check loop%sunder-goal files:%s%u""" % (ptxtsep,ptxtsep,hsc.ugfiles))
				out.append("""check loop%smissing files:%s%u""" % (ptxtsep,ptxtsep,hsc.mfiles))
				if hsc.mtfiles!=None:
					out.append("""check loop%smissing trash files:%s%u""" % (ptxtsep,ptxtsep,hsc.mtfiles))
				if hsc.msfiles!=None:
					out.append("""check loop%smissing sustained files:%s%u""" % (ptxtsep,ptxtsep,hsc.msfiles))
				out.append("""check loop%schunks:%s%u""" % (ptxtsep,ptxtsep,hsc.chunks))
				out.append("""check loop%sunder-goal chunks:%s%u""" % (ptxtsep,ptxtsep,hsc.ugchunks))
				out.append("""check loop%smissing chunks:%s%u""" % (ptxtsep,ptxtsep,hsc.mchunks))
				if hsc.msgbuffleng>0:
					for line in hsc.datastr.strip().split("\n"):
						out.append("check loop%simportant messages:%s%s" % (ptxtsep,ptxtsep,line.strip()))
			else:
				out.append("""check loop: no data""")
			print(str(Table("",0))+"\n".join(out))
	except Exception:
		print_exception()

	try: # Chunk operations loop
		ci = dataprovider.get_chunktestinfo()
		if type(ci)==ChunkTestInfo72:
			if jsonmode:
				if ci.loopstart>0:
					json_il_dict = {}
					json_il_dict["start_time"] = ci.loopstart
					json_il_dict["end_time"] = ci.loopend
					json_il_dict["start_time_str"] = time.asctime(time.localtime(ci.loopstart))
					json_il_dict["end_time_str"] = time.asctime(time.localtime(ci.loopend))
					json_il_dict["del_invalid"] = ci.del_invalid
					json_il_dict["ndel_invalid"] = ci.ndel_invalid
					json_il_dict["del_unused"] = ci.del_unused
					json_il_dict["ndel_unused"] = ci.ndel_unused
					json_il_dict["del_dclean"] = ci.del_dclean
					json_il_dict["ndel_dclean"] = ci.ndel_dclean
					json_il_dict["del_ogoal"] = ci.del_ogoal
					json_il_dict["ndel_ogoal"] = ci.ndel_ogoal
					json_il_dict["rep_ugoal"] = ci.rep_ugoal
					json_il_dict["nrep_ugoal"] = ci.nrep_ugoal
					json_il_dict["rep_wlab"] = ci.rep_wlab
					json_il_dict["nrep_wlab"] = ci.nrep_wlab
					json_il_dict["rebalance"] = ci.rebalance
					json_il_dict["locked_unused"] = ci.locked_unused
					json_il_dict["locked_used"] = ci.locked_used
					json_in_dict["chunk_loop"] = json_il_dict
				else:
					json_in_dict["chunk_loop"] = None
			elif ttymode:
				tab = Table("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 ci.loopstart>0:
					tab.append((time.asctime(time.localtime(ci.loopstart)),"c"),(time.asctime(time.localtime(ci.loopend)),"c"),"%u/%u" % (ci.del_invalid,ci.del_invalid+ci.ndel_invalid),"%u/%u" % (ci.del_unused,ci.del_unused+ci.ndel_unused),"%u/%u" % (ci.del_dclean,ci.del_dclean+ci.ndel_dclean),"%u/%u" % (ci.del_ogoal,ci.del_ogoal+ci.ndel_ogoal),"%u/%u" % (ci.rep_ugoal,ci.rep_ugoal+ci.nrep_ugoal),"%u/%u/%u" % (ci.rep_wlab,ci.labels_dont_match,ci.rep_wlab+ci.nrep_wlab+ci.labels_dont_match),ci.rebalance,ci.locked_unused,ci.locked_used)
				else:
					tab.append(("no data yet","c",11))
				print(myunicode(tab))
			else:
				out = []
				if ci.loopstart>0:
					out.append("""chunk loop%sstart:%s%u""" % (ptxtsep,ptxtsep,ci.loopstart))
					out.append("""chunk loop%send:%s%u""" % (ptxtsep,ptxtsep,ci.loopend))
					out.append("""chunk loop%sdeletions%sinvalid:%s%u/%u""" % (ptxtsep,ptxtsep,ptxtsep,ci.del_invalid,ci.del_invalid+ci.ndel_invalid))
					out.append("""chunk loop%sdeletions%sunused:%s%u/%u""" % (ptxtsep,ptxtsep,ptxtsep,ci.del_unused,ci.del_unused+ci.ndel_unused))
					out.append("""chunk loop%sdeletions%sdisk clean:%s%u/%u""" % (ptxtsep,ptxtsep,ptxtsep,ci.del_dclean,ci.del_dclean+ci.ndel_dclean))
					out.append("""chunk loop%sdeletions%sover goal:%s%u/%u""" % (ptxtsep,ptxtsep,ptxtsep,ci.del_ogoal,ci.del_ogoal+ci.ndel_ogoal))
					out.append("""chunk loop%sreplications%sunder goal:%s%u/%u""" % (ptxtsep,ptxtsep,ptxtsep,ci.rep_ugoal,ci.rep_ugoal+ci.nrep_ugoal))
					out.append("""chunk loop%sreplications%swrong labels:%s%u/%u/%u""" % (ptxtsep,ptxtsep,ptxtsep,ci.rep_wlab,ci.labels_dont_match,ci.rep_wlab+ci.nrep_wlab+ci.labels_dont_match))
					out.append("""chunk loop%sreplications%srebalance:%s%u""" % (ptxtsep,ptxtsep,ptxtsep,ci.rebalance))
					out.append("""chunk loop%slocked%sunused:%s%u""" % (ptxtsep,ptxtsep,ptxtsep,ci.locked_unused))
					out.append("""chunk loop%slocked%sused:%s%u""" % (ptxtsep,ptxtsep,ptxtsep,ci.locked_used))
				else:
					out.append("""chunk loop%sno data yet""" % ptxtsep)
				print(str(Table("",0))+"\n".join(out))
		elif type(ci)==ChunkTestInfo96:
			if jsonmode:
				if ci.loopstart>0:
					json_il_dict = {}
					json_il_dict["start_time"] =ci.loopstart
					json_il_dict["end_time"] = ci.loopend
					json_il_dict["start_time_str"] = time.asctime(time.localtime(ci.loopstart))
					json_il_dict["end_time_str"] = time.asctime(time.localtime(ci.loopend))
					json_il_dict["fixed_chunks"] = ci.fixed
					json_il_dict["forced_keep"] = ci.forcekeep
					json_il_dict["locked_unused"] = ci.locked_unused
					json_il_dict["locked_used"] = ci.locked_used
					json_il_dict["del_invalid_copies"] = ci.delete_invalid
					json_il_dict["del_no_longer_needed"] = ci.delete_no_longer_needed
					json_il_dict["del_wrong_version"] = ci.delete_wrong_version
					json_il_dict["del_duplicate_ecpart"] = ci.delete_duplicated_ecpart
					json_il_dict["del_excess_ecpart"] = ci.delete_excess_ecpart
					json_il_dict["del_excess_copy"] = ci.delete_excess_copy
					json_il_dict["del_mfr_ecpart"] = ci.delete_diskclean_ecpart
					json_il_dict["del_mfr_copy"] = ci.delete_diskclean_copy
					json_il_dict["rep_dupserver_ecpart"] = ci.replicate_dupserver_ecpart
					json_il_dict["rep_needed_ecpart"] = ci.replicate_needed_ecpart
					json_il_dict["rep_needed_copy"] = ci.replicate_needed_copy
					json_il_dict["rep_wronglabels_ecpart"] = ci.replicate_wronglabels_ecpart
					json_il_dict["rep_wronglabels_copy"] = ci.replicate_wronglabels_copy
					json_il_dict["rep_split_copy_into_ecparts"] = ci.split_copy_into_ecparts
					json_il_dict["rep_join_ecparts_into_copy"] = ci.join_ecparts_into_copy
					json_il_dict["rep_recover_ecpart"] = ci.recover_ecpart
					json_il_dict["rep_calculate_ecchksum"] = ci.calculate_ecchksum
					json_il_dict["rep_replicate_rebalance"] = ci.replicate_rebalance
					json_in_dict["chunk_loop"] = json_il_dict
				else:
					json_in_dict["chunk_loop"] = None
			elif ttymode:
				if ci.loopstart>0:
					tab = Table("Chunks housekeeping operations",2)
					tab.defattr("l","r")
					tab.append("Loop start",time.asctime(time.localtime(ci.loopstart)))
					tab.append("Loop end",time.asctime(time.localtime(ci.loopend)))
					tab.append("Locked unused chunks",ci.locked_unused)
					tab.append("Locked chunks",ci.locked_used)
					tab.append("Fixed chunks",ci.fixed)
					tab.append("Forced keep mode",ci.forcekeep)
					tab.append(("---","",2))
					tab.append(("Chunk copies - deletions","c",2))
					tab.append(("---","",2))
					tab.append("Invalid",ci.delete_invalid)
					tab.append("Removed",ci.delete_no_longer_needed)
					tab.append("Wrong version",ci.delete_wrong_version)
					tab.append("Excess",ci.delete_excess_copy)
					tab.append("Marked for removal",ci.delete_diskclean_copy)
					tab.append(("---","",2))
					tab.append(("Chunk copies - replications","c",2))
					tab.append(("---","",2))
					tab.append("Needed",ci.replicate_needed_copy)
					tab.append("Wrong labels",ci.replicate_wronglabels_copy)
					tab.append(("---","",2))
					tab.append(("EC parts - deletions","c",2))
					tab.append(("---","",2))
					tab.append("Duplicated",ci.delete_duplicated_ecpart)
					tab.append("Excess",ci.delete_excess_ecpart)
					tab.append("Marked for removal",ci.delete_diskclean_ecpart)
					tab.append(("---","",2))
					tab.append(("EC parts - replications","c",2))
					tab.append(("---","",2))
					tab.append("Duplicated server",ci.replicate_dupserver_ecpart)
					tab.append("Needed",ci.replicate_needed_ecpart)
					tab.append("Wrong labels",ci.replicate_wronglabels_ecpart)
					tab.append("Recovered",ci.recover_ecpart)
					tab.append("Calculated checksums",ci.calculate_ecchksum)
					tab.append(("---","",2))
					tab.append(("Copies <-> EC parts","c",2))
					tab.append(("---","",2))
					tab.append("Split: copies -> EC parts",ci.split_copy_into_ecparts)
					tab.append("Join: EC parts -> copies",ci.join_ecparts_into_copy)
					tab.append(("---","",2))
					tab.append(("Replications","c",2))
					tab.append(("---","",2))
					tab.append("rebalance",ci.replicate_rebalance)
					print(myunicode(tab))
				else:
					tab = Table("Chunks housekeeping operations",1,"c")
					tab.append("no data yet")
					print(myunicode(tab))
			else:
				out = []
				if ci.loopstart>0:
					out.append("""chunk loop%sgeneral info%sloop start:%s%u""" % (ptxtsep,ptxtsep,ptxtsep,ci.loopstart))
					out.append("""chunk loop%sgeneral info%sloop end:%s%u""" % (ptxtsep,ptxtsep,ptxtsep,ci.loopend))
					out.append("""chunk loop%sgeneral info%slocked unused chunks:%s%u""" % (ptxtsep,ptxtsep,ptxtsep,ci.locked_unused))
					out.append("""chunk loop%sgeneral info%slocked chunks:%s%u""" % (ptxtsep,ptxtsep,ptxtsep,ci.locked_used))
					out.append("""chunk loop%sgeneral info%sfixed chunks:%s%u""" % (ptxtsep,ptxtsep,ptxtsep,ci.fixed))
					out.append("""chunk loop%sgeneral info%sforced keep mode:%s%u""" % (ptxtsep,ptxtsep,ptxtsep,ci.forcekeep))
					out.append("""chunk loop%sdeletions%sinvalid copies:%s%u""" % (ptxtsep,ptxtsep,ptxtsep,ci.delete_invalid))
					out.append("""chunk loop%sdeletions%sremoved chunk copies:%s%u""" % (ptxtsep,ptxtsep,ptxtsep,ci.delete_no_longer_needed))
					out.append("""chunk loop%sdeletions%swrong version copies:%s%u""" % (ptxtsep,ptxtsep,ptxtsep,ci.delete_wrong_version))
					out.append("""chunk loop%sdeletions%sduplicated EC parts:%s%u""" % (ptxtsep,ptxtsep,ptxtsep,ci.delete_duplicated_ecpart))
					out.append("""chunk loop%sdeletions%sexcess EC parts:%s%u""" % (ptxtsep,ptxtsep,ptxtsep,ci.delete_excess_ecpart))
					out.append("""chunk loop%sdeletions%sexcess copies:%s%u""" % (ptxtsep,ptxtsep,ptxtsep,ci.delete_excess_copy))
					out.append("""chunk loop%sdeletions%sMFR EC parts:%s%u""" % (ptxtsep,ptxtsep,ptxtsep,ci.delete_diskclean_ecpart))
					out.append("""chunk loop%sdeletions%sMFR copies:%s%u""" % (ptxtsep,ptxtsep,ptxtsep,ci.delete_diskclean_copy))
					out.append("""chunk loop%sreplications%sdup server EC parts:%s%u""" % (ptxtsep,ptxtsep,ptxtsep,ci.replicate_dupserver_ecpart))
					out.append("""chunk loop%sreplications%sneeded EC parts:%s%u""" % (ptxtsep,ptxtsep,ptxtsep,ci.replicate_needed_ecpart))
					out.append("""chunk loop%sreplications%sneeded copies:%s%u""" % (ptxtsep,ptxtsep,ptxtsep,ci.replicate_needed_copy))
					out.append("""chunk loop%sreplications%swrong labels EC parts:%s%u""" % (ptxtsep,ptxtsep,ptxtsep,ci.replicate_wronglabels_ecpart))
					out.append("""chunk loop%sreplications%swrong labels copies:%s%u""" % (ptxtsep,ptxtsep,ptxtsep,ci.replicate_wronglabels_copy))
					out.append("""chunk loop%sreplications%srecovered EC parts:%s%u""" % (ptxtsep,ptxtsep,ptxtsep,ci.recover_ecpart))
					out.append("""chunk loop%sreplications%scalculated EC checksums:%s%u""" % (ptxtsep,ptxtsep,ptxtsep,ci.calculate_ecchksum))
					out.append("""chunk loop%sreplications%ssplit copies into EC parts:%s%u""" % (ptxtsep,ptxtsep,ptxtsep,ci.split_copy_into_ecparts))
					out.append("""chunk loop%sreplications%sjoined EC parts into copies:%s%u""" % (ptxtsep,ptxtsep,ptxtsep,ci.join_ecparts_into_copy))
					out.append("""chunk loop%sreplications%srebalance:%s%u""" % (ptxtsep,ptxtsep,ptxtsep,ci.replicate_rebalance))
				else:
					out.append("""chunk loop%sno data yet""" % ptxtsep)
				print(str(Table("",0))+"\n".join(out))
	except Exception:
		print_exception()

# Missing files (CLI only)
if org.shall_render("MF"):
	try:
		mchunks = dataprovider.get_missing_chunks(MForder,MFrev)
		mccnt = len(mchunks)
		
		if jsonmode:
			json_mf_array = []
		elif ttymode:
			tab = Table("Missing Files/Chunks (gathered by the previous filesystem self-check loop)",5)
			tab.header("path","inode","index","chunk id","type of missing chunk")
			tab.defattr("l","r","r","r","r")
		else:
			tab = Table("missing files",5)
		for mc in mchunks:
			if jsonmode:
				json_mf_dict = {}
				if len(mc.paths)==0:
					json_mf_dict["paths"] = " * unknown path * (deleted file)"
				else:
					json_mf_dict["paths"] = mc.paths
				json_mf_dict["inode"] = mc.inode
				json_mf_dict["index"] = mc.indx
				json_mf_dict["chunkid"] = mc.get_chunkid_str()
				json_mf_dict["type"] = mc.mtype
				json_mf_dict["type_txt"] = mc.get_mtype_str()
				json_mf_array.append(json_mf_dict)
			else:
				if len(mc.paths)==0:
					dline = [" * unknown path * (deleted file)",mc.inode,mc.indx, mc.get_chunkid_str()]
					dline.append(mc.get_mtype_str())
					tab.append(*dline)
				else:
					for path in mc.paths:
						dline = [path,mc.inode,mc.indx,mc.get_chunkid_str()]
						dline.append(mc.get_mtype_str())
						tab.append(*dline)
		if jsonmode:
			json_in_dict["missing"] = json_mf_array
		else:
			print(myunicode(tab))
	except Exception:
		print_exception()

# memory usage table
if org.shall_render("MU"):
	try:
		mu = dataprovider.get_memory_usage()
		if jsonmode:
			json_mu_dict = {}
			for i,label in enumerate(mu.memlabels):
				json_label = label.replace(" ","_")
				json_mu_dict[json_label] = {"allocated": mu.memusage[i*2], "used": mu.memusage[1+i*2], "allocated_human": humanize_number(mu.memusage[i*2]," "), "used_human": humanize_number(mu.memusage[1+i*2]," ")}
			json_mu_dict["total"] = {"allocated": mu.totalallocated, "used": mu.totalused, "allocated_human": humanize_number(mu.totalallocated," "), "used_human": humanize_number(mu.totalused," ")}
			json_in_dict["memory"] = json_mu_dict
		else:
			if ttymode:
				tab = Table("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 = Table("memory usage detailed info",3)
				tab.defattr("l","r","r")
				tab.header("object name","memory used","memory allocated")
			for i,label in enumerate(mu.memlabels):
				if ttymode:
					if mu.memusage[i*2]>0:
						upercent = "%.2f %%" % (100.0 * mu.memusage[1+i*2] / mu.memusage[i*2])
					else:
						upercent = "-"
					if mu.totalallocated:
						tpercent = "%.2f %%" % (100.0 * mu.memusage[i*2] / mu.totalallocated)
					else:
						tpercent = "-"
					tab.append(label,humanize_number(mu.memusage[1+i*2]," "),humanize_number(mu.memusage[i*2]," "),upercent,tpercent)
				else:
					tab.append(label,mu.memusage[1+i*2],mu.memusage[i*2])
			if ttymode:
				tab.append(("---","",5))
				if mu.totalallocated:
					totalpercent = "%.2f %%" % (100.0 * mu.totalused / mu.totalallocated)
				else:
					totalpercent = "-"
				tab.append("total",humanize_number(mu.totalused," "),humanize_number(mu.totalallocated," "),totalpercent,"-")
			print(myunicode(tab))
	except Exception:
		print_exception()

if jsonmode and len(json_in_dict)>0:
	jcollect["dataset"]["info"] = json_in_dict

# Chunkservers section
if org.shall_render("CS"):
	try:
		servers,dservers = dataprovider.get_chunkservers_by_state(CSorder,CSrev)

		out = []
		if len(servers)>0:
			if jsonmode:
				json_cs_array = []
			elif ttymode:
				if cl.master().version_at_least(3,0,38):
					tab = Table("Chunk Servers",17,"r")
					tab.header("","","","","","","","",("'regular' hdd space","",4),("'marked for removal' hdd space","",5))
					tab.header("ip/host","port","id","labels","version","queue","queue state","maintenance",("---","",9))
					tab.header("","","","","","","","","chunks","used","total","% used","status","chunks","used","total","% used")
				else: #if cl.master().version_at_least(2,1,0):
					tab = Table("Chunk Servers",15,"r")
					tab.header("","","","","","","",("'regular' hdd space","",4),("'marked for removal' hdd space","",4))
					tab.header("ip/host","port","id","labels","version","queue","maintenance",("---","",8))
					tab.header("","","","","","","","chunks","used","total","% used","chunks","used","total","% used")
			else:
				if cl.master().version_at_least(3,0,38):
					tab = Table("chunk servers",15)
				else: #if cl.master().version_at_least(2,1,0):
					tab = Table("chunk servers",13)
			
			# iterate all connected servers
			for cs in servers:
				if cs.strip!=cs.stroip:
					cs.strip = "%s -> %s" % (cs.stroip,cs.strip)

				if jsonmode:
					#Connected chunk servers
					json_cs_dict = {}
					json_cs_dict["connected"] = True
					json_cs_dict["strver"] = cs.strver
					if cs.strver.endswith(" PRO"):
						json_cs_dict["version"] = cs.strver[:-4]
						json_cs_dict["pro"] = True
					else:
						json_cs_dict["version"] = cs.strver
						json_cs_dict["pro"] = False
					json_cs_dict["flags"] = cs.flags
					json_cs_dict["maintenance_mode_timeout"] =cs.mmto
					if cl.leaderfound()==0:
						json_cs_dict["maintenance_mode"] = "not available"
					elif cs.is_maintenance_off():
						json_cs_dict["maintenance_mode"] = "off"
					elif cs.is_maintenance_on():
						json_cs_dict["maintenance_mode"] = "on"
					else:
						json_cs_dict["maintenance_mode"] = "on (temp)"
					json_cs_dict["hostname"] = cs.host
					json_cs_dict["ip"] = cs.strip
					json_cs_dict["port"] = cs.port
					json_cs_dict["csid"] = cs.csid
					json_cs_dict["errors"] = cs.errcnt
					json_cs_dict["gracetime"] = cs.gracetime
					json_cs_dict["load"] = cs.queue
					json_cs_dict["queue"] = cs.queue
					json_cs_dict["queue_state"] = cs.queue_state
					json_cs_dict["queue_state_msg"] = cs.queue_state_msg.lower()
					if cs.labels==0xFFFFFFFF or cs.labels==0:
						labelstab = []
					else:
						labelstab = []
						for bit,char in enumerate(map(chr,range(ord('A'),ord('Z')+1))):
							if cs.labels & (1<<bit):
								labelstab.append(char)
					json_cs_dict["labels"] = labelstab
					json_cs_dict["labels_str"] = ",".join(labelstab)
					json_cs_dict["hdd_regular_used"] = cs.used
					json_cs_dict["hdd_regular_used_human"] = humanize_number(cs.used," ")
					json_cs_dict["hdd_regular_total"] = cs.total
					json_cs_dict["hdd_regular_total_human"] = humanize_number(cs.total," ")
					json_cs_dict["hdd_regular_free"] = cs.total-cs.used
					json_cs_dict["hdd_regular_free_human"] = humanize_number(cs.total-cs.used," ")
					if cs.total>0:
						json_cs_dict["hdd_regular_used_percent"] = (cs.used*100.0)/cs.total
					else:
						json_cs_dict["hdd_regular_used_percent"] = 0.0
					json_cs_dict["hdd_regular_chunks"] = cs.chunks
					json_cs_dict["hdd_removal_used"] = cs.tdused
					json_cs_dict["hdd_removal_used_human"] = humanize_number(cs.tdused," ")
					json_cs_dict["hdd_removal_total"] = cs.tdtotal
					json_cs_dict["hdd_removal_total_human"] = humanize_number(cs.tdtotal," ")
					json_cs_dict["hdd_removal_free"] = cs.tdtotal-cs.tdused
					json_cs_dict["hdd_removal_free_human"] = humanize_number(cs.tdtotal-cs.tdused," ")
					if cs.tdtotal>0:
						json_cs_dict["hdd_removal_used_percent"] = (cs.tdused*100.0)/cs.tdtotal
					else:
						json_cs_dict["hdd_removal_used_percent"] = 0.0
					json_cs_dict["hdd_removal_chunks"] = cs.tdchunks
					if cl.master().version_at_least(3,0,38):
						if cs.tdchunks==0 or cl.leaderfound()==0:
							json_cs_dict["hdd_removal_stat"] = "-"
						elif cs.mfrstatus==MFRSTATUS_INPROGRESS:
							json_cs_dict["hdd_removal_stat"] = "NOT READY (IN PROGRESS)"
						elif cs.mfrstatus==MFRSTATUS_READY:
							json_cs_dict["hdd_removal_stat"] = "READY"
						else: #MFRSTATUS_VALIDATING
							json_cs_dict["hdd_removal_stat"] = "NOT READY (VALIDATING)"
					else:
						json_cs_dict["hdd_removal_stat"] = None
					json_cs_array.append(json_cs_dict)
				elif ttymode:
					if cs.total>0:
						regperc = "%.2f%%" % ((cs.used*100.0)/cs.total)
					else:
						regperc = "-"
					if cs.tdtotal>0:
						tdperc = "%.2f%%" % ((cs.tdused*100.0)/cs.tdtotal)
					else:
						tdperc = "-"
					data = [cs.host,cs.port]
					data.append(cs.csid)
					data.append(cs.labelstr)
					data.append(cs.strver)
					if cl.master().version_at_least(3,0,38):
						data.append(cs.queue)
						data.append(cs.queue_state_str)
					else:
						data.append(cs.queue_cgi)
					if cl.leaderfound()==0:
						data.append("not available")
					elif cs.is_maintenance_off():
						data.append("off")
					elif cs.is_maintenance_on():
						data.append("on (%s)" % cs.mmto)
					else:
						data.append("on (temp ; %s)" % cs.mmto)
					data.extend([cs.chunks,humanize_number(cs.used," "),humanize_number(cs.total," "),regperc])
					if cl.master().version_at_least(3,0,38):
						if cs.tdchunks==0 or cl.leaderfound()==0:
							data.append("-")
						elif cs.mfrstatus==MFRSTATUS_INPROGRESS:
							data.append(("NOT READY",'3'))
						elif cs.mfrstatus==MFRSTATUS_READY:
							data.append(("READY",'4'))
						else:
							data.append("NOT READY")
					data.extend([cs.tdchunks,humanize_number(cs.tdused," "),humanize_number(cs.tdtotal," "),tdperc])
					tab.append(*data)
				else:
					data = [cs.host,cs.port]
					data.append(cs.csid)
					data.append(cs.labelstr)
					data.append(cs.strver)
					if cl.master().version_at_least(3,0,38):
						data.append(cs.queue)
						data.append(cs.queue_state_str)
					else:
						data.append(cs.queue_cgi)
					if cl.leaderfound()==0:
						data.append("-")
					elif cs.is_maintenance_off():
						data.append("maintenance_off")
					elif cs.is_maintenance_on():
						data.append("maintenance_on")
					else:
						data.append("maintenance_tmp_on")
					data.extend([cs.chunks,cs.used,cs.total])
					if cl.master().version_at_least(3,0,38):
						if cs.tdchunks==0 or cl.leaderfound()==0:
							data.append("-")
						elif cs.mfrstatus==MFRSTATUS_INPROGRESS:
							data.append("NOT READY")
						elif cs.mfrstatus==MFRSTATUS_READY:
							data.append("READY")
						else: #MFRSTATUS_VALIDATING
							data.append("NOT READY")
					data.extend([cs.tdchunks,cs.tdused,cs.tdtotal])
					tab.append(*data)

		if len(dservers)>0:
			if jsonmode:
				pass
			elif ttymode:
				if cl.master().version_at_least(3,0,38):
					tab.append(("---","",17))
					tab.append(("disconnected servers","1c",17))
					tab.append(("---","",17))
					tab.append(("ip/host","c"),("port","c"),("id","r"),("maintenance","c",2),("change maintenance command","c",6),("remove command","c",6))
					tab.append(("---","",17))
				else: #if cl.master().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))
			else:
				try:
					print(myunicode(tab))
				except NameError: # tab may not be defined if no servers are connected
					pass 
				print("")
				tab = Table("Disconnected chunk servers",4)
			
			# iterate all disconnected servers
			for cs in dservers:
				if cs.strip!=cs.stroip:
					cs.strip = "%s -> %s" % (cs.stroip,cs.strip)
				if jsonmode:
					json_cs_dict = {}
					json_cs_dict["connected"] = False
					json_cs_dict["strver"] = None
					json_cs_dict["version"] = None
					json_cs_dict["pro"] = None
					json_cs_dict["flags"] = cs.flags
					json_cs_dict["maintenance_mode_timeout"] = cs.mmto
					if cl.leaderfound()==0:
						json_cs_dict["maintenance_mode"] = "not available"
					elif cs.is_maintenance_off():
						json_cs_dict["maintenance_mode"] = "off"
					elif cs.is_maintenance_on():
						json_cs_dict["maintenance_mode"] = "on"
					else:
						json_cs_dict["maintenance_mode"] = "on (temp)"
					json_cs_dict["hostname"] = cs.host
					json_cs_dict["ip"] = cs.strip
					json_cs_dict["port"] = cs.port
					json_cs_dict["csid"] = cs.csid
					json_cs_dict["errors"] = None
					json_cs_dict["load"] = None
					json_cs_dict["queue"] = None
					json_cs_dict["queue_state"] = "not available"
					json_cs_dict["queue_cgi"] = "not available"
					json_cs_dict["labels"] = []
					json_cs_dict["labels_str"] = "not available"
					json_cs_dict["hdd_regular_used"] = None
					json_cs_dict["hdd_regular_used_human"] = ""
					json_cs_dict["hdd_regular_total"] = None
					json_cs_dict["hdd_regular_total_human"] = ""
					json_cs_dict["hdd_regular_free"] = None
					json_cs_dict["hdd_regular_free_human"] = ""
					json_cs_dict["hdd_regular_used_percent"] = 0.0
					json_cs_dict["hdd_regular_chunks"] = None
					json_cs_dict["hdd_removal_used"] = None
					json_cs_dict["hdd_removal_used_human"] = ""
					json_cs_dict["hdd_removal_total"] = None
					json_cs_dict["hdd_removal_total_human"] = ""
					json_cs_dict["hdd_removal_free"] = None
					json_cs_dict["hdd_removal_free_human"] = ""
					json_cs_dict["hdd_removal_used_percent"] = 0.0
					json_cs_dict["hdd_removal_chunks"] = None
					json_cs_dict["hdd_removal_stat"] = None
					json_cs_array.append(json_cs_dict)
				elif ttymode:
					data = [cs.host,cs.port]
					data.append(cs.csid)
					if cl.leaderfound()==0:
						mm = "-"
						mmcmd = "not available"
					elif cs.is_maintenance_off():
						mm = "off"
						mmcmd = "%s -H %s -P %u -CM1/%s/%s" % (sys.argv[0],masterhost,masterport,cs.stroip,cs.port)
					elif cs.is_maintenance_on():
						mm = "on (%s)" % cs.mmto
						mmcmd = "%s -H %s -P %u -CM0/%s/%s" % (sys.argv[0],masterhost,masterport,cs.stroip,cs.port)
					else:
						mm = "on (temp ; %s)" % cs.mmto
						mmcmd = "%s -H %s -P %u -CM0/%s/%s" % (sys.argv[0],masterhost,masterport,cs.stroip,cs.port)
					if cl.master().version_at_least(3,0,38):
						data.append((mm,"c",2))
					else:
						data.append(mm)
					if cl.master().version_at_least(3,0,38):
						data.append((mmcmd,"l",6))
					else:
						data.append((mmcmd,"l",5))
					if cl.leaderfound() and cl.deputyfound()==0:
						rmcmd = "%s -H %s -P %u -CRC/%s/%s" % (sys.argv[0],masterhost,masterport,cs.stroip,cs.port)
					elif cl.master().version_at_least(3,0,67):
						rmcmd = "%s -H %s -P %u -CTR/%s/%s" % (sys.argv[0],masterhost,masterport,cs.stroip,cs.port)
					else:
						rmcmd = "not available"
					data.append((rmcmd,"l",6))
					tab.append(*data)
				else:
					if cl.leaderfound()==0:
						mm = "-"
					elif cs.is_maintenance_off():
						mm = "maintenance off"
					elif cs.is_maintenance_on():
						mm = "maintenance on (%s)" % cs.mmto
					else:
						mm = "maintenance on (temp ; %s)" % cs.mmto
					tab.append(cs.host,cs.port,cs.csid,mm)
		try:
			if jsonmode:
				jcollect["dataset"]["chunkservers"] = json_cs_array
			else:
				print(myunicode(tab))
		except NameError: # tab/json_cs_array may not be defined if no servers are available
			pass
	except Exception:
		print_exception()

#Metadata servers subsection (CLI only)
if org.shall_render("MB"):
	try:
		if jsonmode:
			json_mb_array = []
		elif ttymode:
			tab = Table("Metadata Backup Loggers",2,"r")
			tab.header("ip/host","version")
		else:
			tab = Table("metadata backup loggers",2)
		for ml in dataprovider.get_metaloggers(MBorder, MBrev):
			if jsonmode:
				json_mb_dict = {}
				json_mb_dict["hostname"] = ml.host
				json_mb_dict["ip"] = ml.strip
				json_mb_dict["strver"] = ml.strver
				if ml.strver.endswith(" PRO"):
					json_mb_dict["version"] = ml.strver[:-4]
					json_mb_dict["pro"] = True
				else:
					json_mb_dict["version"] = ml.strver
					json_mb_dict["pro"] = False
				json_mb_array.append(json_mb_dict)
			else:
				tab.append(ml.host,ml.strver)
		if jsonmode:
			jcollect["dataset"]["metaloggers"] = json_mb_array
		else:
			print(myunicode(tab))
	except Exception:
		print_exception()

# Disks section
if org.shall_render("HD"):
	try:
		(hdds, scanhdds) = dataprovider.get_hdds("ALL", HDperiod, HDtime, HDorder, HDrev)
		# preapare headers
		if len(hdds)>0 or len(scanhdds)>0:
			if jsonmode:
				json_hd_array = []
			elif ttymode:
				tab = Table("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(hdds)>0 or len(scanhdds)==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 = Table("disks",14)

			# calculate some stats
			usedsum = {}
			totalsum = {}
			hostavg = {}
			for _,hdd in hdds+scanhdds:
				if hdd.hostkey not in usedsum:
					usedsum[hdd.hostkey]=0
					totalsum[hdd.hostkey]=0
					hostavg[hdd.hostkey]=0
				if hdd.flags&CS_HDD_SCANNING==0 and hdd.total and hdd.total>0:
					usedsum[hdd.hostkey]+=hdd.used
					totalsum[hdd.hostkey]+=hdd.total
					if totalsum[hdd.hostkey]>0:
						hostavg[hdd.hostkey] = (usedsum[hdd.hostkey] * 100.0) / totalsum[hdd.hostkey]
			
			for sf,hdd in hdds+scanhdds:
				if not hdd.is_valid():
					lerror= '-'
				elif not hdd.has_errors():
					lerror = 'no errors'
				else:
					errtimetuple = time.localtime(hdd.errtime)
					errtimelong = time.strftime("%Y-%m-%d %H:%M:%S",errtimetuple)
					errtimeshort = time.strftime("%Y-%m-%d %H:%M",errtimetuple)
					if jsonmode:
						lerror = time.asctime(time.localtime(hdd.errtime))
					elif ttymode:
						errtimetuple = time.localtime(hdd.errtime)
						lerror = errtimeshort
					else:
						lerror = hdd.errtime

				if jsonmode:
					json_hd_dict = {}
					json_hd_dict["hostname"] = hdd.hoststr
					json_hd_dict["ip"] = hdd.hostip
					json_hd_dict["port"] = hdd.port
					json_hd_dict["path"] = hdd.hddpath
					json_hd_dict["ip_path"] = hdd.ippath
					json_hd_dict["hostname_path"] = hdd.hostpath
					json_hd_dict["chunks"] = hdd.chunkscnt
					json_hd_dict["flags"] = hdd.flags
					json_hd_dict["mfrstatus"] = hdd.mfrstatus
					json_hd_dict["status"] = hdd.get_statuslist()
					json_hd_dict["status_str"] = hdd.get_status_str()
					json_hd_dict["last_error_time"] = hdd.errtime
					json_hd_dict["last_error_time_str"] = lerror
					json_hd_dict["last_error_chunkid"] = hdd.errchunkid
					if hdd.flags&CS_HDD_SCANNING:
						json_hd_dict["scan_progress"] = hdd.used
						json_hd_dict["used"] = None
						json_hd_dict["used_human"] = ""
						json_hd_dict["total"] = None
						json_hd_dict["total_human"] = ""
						json_hd_dict["used_percent"] = 0.0
					else:
						json_hd_dict["scan_progress"] = 100.0
						json_hd_dict["used"] = hdd.used
						json_hd_dict["used_human"] = humanize_number(hdd.used," ")
						json_hd_dict["total"] = hdd.total
						json_hd_dict["total_human"] = humanize_number(hdd.total," ")
						if hdd.total>0:
							json_hd_dict["used_percent"] = (hdd.used*100.0)/hdd.total
						else:
							json_hd_dict["used_percent"] = 0.0
					for i,name in enumerate(['min','hour','day']):
						json_hd_stats = {}
						json_hd_stats["rbw"] = hdd.rbw[i]
						json_hd_stats["wbw"] = hdd.wbw[i]
						json_hd_stats["read_avg_usec"] = hdd.usecreadavg[i]
						json_hd_stats["write_avg_usec"] = hdd.usecwriteavg[i]
						json_hd_stats["fsync_avg_usec"] = hdd.usecfsyncavg[i]
						json_hd_stats["read_max_usec"] = hdd.usecreadmax[i]
						json_hd_stats["write_max_usec"] = hdd.usecwritemax[i]
						json_hd_stats["fsync_max_usec"] = hdd.usecfsyncmax[i]
						json_hd_stats["read_ops"] = hdd.rops[i]
						json_hd_stats["write_ops"] = hdd.wops[i]
						json_hd_stats["fsync_ops"] = hdd.fsyncops[i]
						json_hd_stats["read_bytes"] = hdd.rbytes[i]
						json_hd_stats["write_bytes"] = hdd.wbytes[i]
						json_hd_dict["stats_%s" % name] = json_hd_stats
					json_hd_array.append(json_hd_dict)
				elif ttymode:
					rtime = hdd.usecreadmax[HDperiod] if HDtime==0 else hdd.usecreadavg[HDperiod]
					wtime = hdd.usecwritemax[HDperiod] if HDtime==0 else hdd.usecwriteavg[HDperiod]
					fsynctime = hdd.usecfsyncmax[HDperiod] if HDtime==0 else hdd.usecfsyncavg[HDperiod]
					if hdd.is_valid():
						chunkscnttxt = hdd.chunkscnt
						usedtxt = humanize_number(hdd.used," ")
						totaltxt = humanize_number(hdd.total," ")
					else:
						chunkscnttxt = '-'
						usedtxt = '-'
						totaltxt = '-'
					ldata = [hdd.ippath,chunkscnttxt,lerror,hdd.get_status_str()]
					if hdd.rbw[HDperiod]==0 and hdd.wbw[HDperiod]==0 and hdd.usecreadmax[HDperiod]==0 and hdd.usecwritemax[HDperiod]==0 and hdd.usecfsyncmax[HDperiod]==0 and hdd.rops[HDperiod]==0 and hdd.wops[HDperiod]==0:
						ldata.extend(("-","-","-","-","-","-","-","-"))
					else:
						ldata.extend(("%s/s" % humanize_number(hdd.rbw[HDperiod]," "),"%s/s" % humanize_number(hdd.wbw[HDperiod]," "),"%u us" % rtime,"%u us" % wtime,"%u us" % fsynctime,hdd.rops[HDperiod],hdd.wops[HDperiod],hdd.fsyncops[HDperiod]))
					if hdd.flags&CS_HDD_SCANNING:
						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%%" % hdd.used,"r",3))
					else:
						if hdd.total>0:
							perc = "%.2f%%" % ((hdd.used*100.0)/hdd.total)
						else:
							perc = "-"
						ldata.extend((usedtxt,totaltxt,perc))
					tab.append(*ldata)
				else:
					if not hdd.is_valid():
						hdd.chunkscnt = '-'
						hdd.used = '-'
						hdd.total = '-'
					rtime = hdd.usecreadmax[HDperiod] if HDtime==0 else hdd.usecreadavg[HDperiod]
					wtime = hdd.usecwritemax[HDperiod] if HDtime==0 else hdd.usecwriteavg[HDperiod]
					fsynctime = hdd.usecfsyncmax[HDperiod] if HDtime==0 else hdd.usecfsyncavg[HDperiod]
					ldata = [hdd.ippath,hdd.chunkscnt,lerror,hdd.get_status_str()]
					if hdd.rbw[HDperiod]==0 and hdd.wbw[HDperiod]==0 and hdd.usecreadmax[HDperiod]==0 and hdd.usecwritemax[HDperiod]==0 and hdd.usecfsyncmax[HDperiod]==0 and hdd.rops[HDperiod]==0 and hdd.wops[HDperiod]==0:
						ldata.extend(("-","-","-","-","-","-","-","-"))
					else:
						ldata.extend((hdd.rbw[HDperiod],hdd.wbw[HDperiod],rtime,wtime,fsynctime,hdd.rops[HDperiod],hdd.wops[HDperiod],hdd.fsyncops[HDperiod]))
					if hdd.flags&CS_HDD_SCANNING:
						ldata.extend(("progress:",hdd.used))
					else:
						ldata.extend((hdd.used,hdd.total))
					tab.append(*ldata)
			if jsonmode:
				jcollect["dataset"]["disks"] = json_hd_array
			else:
				print(myunicode(tab))
	except TimeoutError:
		print_error("Timeout connecting chunk servers. Hint: check if chunk servers are available from this server (the one hosting GUI/CLI).")
	except Exception:
		print_exception()

# Exports section
if org.shall_render("EX"):
	try:
		if jsonmode:
			json_ex_array = []
		elif ttymode:
			tab = Table("Exports",(19 if cl.master().has_feature(FEATURE_EXPORT_DISABLES) else 18 if cl.master().has_feature(FEATURE_EXPORT_UMASK) else 17))

			dline = ["r","r","l","c","c","c","c","c","c"]
			dline.append("c")
			dline.extend(("r","r","r","r"))
			dline.extend(("c","r","r"))
			if cl.master().has_feature(FEATURE_EXPORT_UMASK):
				dline.append("c")
			if cl.master().has_feature(FEATURE_EXPORT_DISABLES):
				dline.append("c")
			tab.defattr(*dline)

			dline = [("ip range","",2),"","","","","","",""]
			dline.append("")
			dline.extend((("map root","",2),("map users","",2)))
			dline.extend(("",("trashretention limit","",2)))
			if cl.master().has_feature(FEATURE_EXPORT_UMASK):
				dline.append("")
			if cl.master().has_feature(FEATURE_EXPORT_DISABLES):
				dline.append("")
			tab.header(*dline)

			dline = [("---","",2),"path","minversion","alldirs","password","ro/rw","restrict ip","ignore gid"]
			dline.append("admin")
			dline.append(("---","",4))
			dline.append("allowed sclasses")
			dline.append(("---","",2))
			if cl.master().has_feature(FEATURE_EXPORT_UMASK):
				dline.append("global umask")
			if cl.master().has_feature(FEATURE_EXPORT_DISABLES):
				dline.append("disables mask")
			tab.header(*dline)

			dline = ["from","to","","","","","","",""]
			dline.append("")
			dline.extend(("uid","gid","uid","gid"))
			dline.extend(("","min","max"))
			if cl.master().has_feature(FEATURE_EXPORT_UMASK):
				dline.append("")
			if cl.master().has_feature(FEATURE_EXPORT_DISABLES):
				dline.append("")
			tab.header(*dline)
		else:
			tab = Table("exports",(19 if cl.master().has_feature(FEATURE_EXPORT_DISABLES) else 18 if cl.master().has_feature(FEATURE_EXPORT_UMASK) else 17))

		for ee in dataprovider.get_exports(EXorder,EXrev):
			if jsonmode:
				json_ex_dict = {}
				json_ex_dict["ip_range_from"] = ee.stripfrom
				json_ex_dict["ip_range_to"] = ee.stripto
				json_ex_dict["meta"] = ee.meta
				json_ex_dict["path"] = "META" if ee.meta else ee.path
				json_ex_dict["export_flags"] = ee.exportflags
				json_ex_dict["session_flags"] = ee.sesflags
				json_ex_dict["minver"] = ee.strver
				json_ex_dict["alldirs"] = None if ee.meta else True if ee.is_alldirs() else False
				json_ex_dict["password"] = True if ee.is_password() else False
				json_ex_dict["access_rw"] = False if ee.is_readonly() else True
				json_ex_dict["restricted"] = False if ee.is_unrestricted() else True
				json_ex_dict["ignore_gid"] = None if ee.meta else True if ee.ignore_gid() else False
				json_ex_dict["admin"] = None if ee.meta else True if ee.is_admin() else False
				if ee.meta:
					json_ex_dict["map_root_uid"] = None
					json_ex_dict["map_root_gid"] = None
				else:
					json_ex_dict["map_root_uid"] = ee.rootuid
					json_ex_dict["map_root_gid"] = ee.rootgid
				if ee.meta or (ee.map_user())==0:
					json_ex_dict["map_user_uid"] = None
					json_ex_dict["map_user_gid"] = None
				else:
					json_ex_dict["map_user_uid"] = ee.mapalluid
					json_ex_dict["map_user_gid"] = ee.mapallgid
				json_ex_dict["allowed_storage_classes"] = ee.sclassgroups
				json_ex_dict["allowed_storage_classes_str"] = ee.sclassgroups_str
				if ee.mintrashretention!=None and ee.maxtrashretention!=None:
					json_ex_dict["trash_retention_min"] = ee.mintrashretention
					json_ex_dict["trash_retention_max"] = ee.maxtrashretention
				else:
					json_ex_dict["trash_retention_min"] = None
					json_ex_dict["trash_retention_max"] = None
				if cl.master().has_feature(FEATURE_EXPORT_UMASK):
					if ee.umaskval==None:
						json_ex_dict["global_umask"] = None
					else:
						json_ex_dict["global_umask"] = "%03o" % ee.umaskval
				else:
					json_ex_dict["global_umask"] = None
				if cl.master().has_feature(FEATURE_EXPORT_DISABLES):
					json_ex_dict["disables_mask"] = None if ee.meta else "%08X" % ee.disables
					json_ex_dict["disables_str"] = "" if ee.meta else disablesmask_to_string(ee.disables)
					json_ex_dict["disables"] = [] if ee.meta else disablesmask_to_string_list(ee.disables)
				else:
					json_ex_dict["disables_mask"] = None
					json_ex_dict["disables_str"] = ""
					json_ex_dict["disables"] = []
				json_ex_array.append(json_ex_dict)
			elif ttymode:
				dline = [ee.stripfrom,ee.stripto,". (META)" if ee.meta else ee.path,ee.strver,"-" if ee.meta else "yes" if ee.is_alldirs() else "no","yes" if ee.is_password() else "no","ro" if ee.is_readonly() else "rw","no" if ee.is_unrestricted() else "yes","-" if ee.meta else "yes" if ee.ignore_gid() else "no"]
				dline.append("-" if ee.meta else "yes" if ee.is_admin() else "no")
				if ee.meta:
					dline.extend(("-","-"))
				else:
					dline.extend((ee.rootuid,ee.rootgid))
				if ee.meta or (ee.map_user())==0:
					dline.extend(("-","-"))
				else:
					dline.extend((ee.mapalluid,ee.mapallgid))
				dline.append("%04X (%s)" % (ee.sclassgroups,ee.sclassgroups_str))
				if ee.mintrashretention!=None and ee.maxtrashretention!=None:
					dline.extend((timeduration_to_shortstr(ee.mintrashretention),timeduration_to_shortstr(ee.maxtrashretention)))
				else:
					dline.extend(("-","-"))
				if cl.master().has_feature(FEATURE_EXPORT_UMASK):
					if ee.umaskval==None:
						dline.append("-")
					else:
						dline.append("%03o" % ee.umaskval)
				if cl.master().has_feature(FEATURE_EXPORT_DISABLES):
					dline.append("%08X (%s)" % (ee.disables,disablesmask_to_string(ee.disables)))
				tab.append(*dline)
			else:
				dline = [ee.stripfrom,ee.stripto,". (META)" if ee.meta else ee.path,ee.strver,"-" if ee.meta else "yes" if ee.is_alldirs() else "no","yes" if ee.is_password() else "no","ro" if ee.is_readonly() else "rw","no" if ee.is_unrestricted() else "yes","-" if ee.meta else "yes" if ee.ignore_gid() else "no"]
				dline.append("-" if ee.meta else "yes" if ee.is_admin() else "no")
				if ee.meta:
					dline.extend(("-","-"))
				else:
					dline.extend((ee.rootuid,ee.rootgid))
				if ee.meta or (ee.map_user())==0:
					dline.extend(("-","-"))
				else:
					dline.extend((ee.mapalluid,ee.mapallgid))
				dline.append("%04X" % ee.sclassgroups)
				if ee.mintrashretention!=None and ee.maxtrashretention!=None:
					dline.extend((ee.mintrashretention,ee.maxtrashretention))
				else:
					dline.extend(("-","-"))
				if cl.master().has_feature(FEATURE_EXPORT_UMASK):
					if ee.umaskval==None:
						dline.append("-")
					else:
						dline.append("%03o" % ee.umaskval)
				if cl.master().has_feature(FEATURE_EXPORT_DISABLES):
					dline.append("%08X" % ee.disables)
				tab.append(*dline)

		if jsonmode:
			jcollect["dataset"]["exports"] = json_ex_array
		else:
			print(myunicode(tab))
	except Exception:
		print_exception()

# Mounts - parameters section
if org.shall_render("MS"):
	try:
		if ttymode:
			tab = Table("Active mounts (parameters)",(20 if cl.master().has_feature(FEATURE_EXPORT_DISABLES) else 19 if cl.master().has_feature(FEATURE_EXPORT_UMASK) else 18 if cl.master().version_at_least(1,7,8) else 16 if cl.master().version_at_least(1,7,0) else 15 if cl.master().version_at_least(1,6,26) else 12))

			dline = ["r","r","l"]
			if cl.master().version_at_least(1,7,8):
				dline.extend(("r","r"))
			dline.extend(("r","l","c","c","c"))
			if cl.master().version_at_least(1,7,0):
				dline.append("c")
			dline.extend(("r","r","r","r"))
			if cl.master().version_at_least(1,6,26):
				dline.extend(("l","r","r"))
			if cl.master().has_feature(FEATURE_EXPORT_UMASK):
				dline.append("c")
			if cl.master().has_feature(FEATURE_EXPORT_DISABLES):
				dline.append("c")
			tab.defattr(*dline)

			dline = ["","","","","","","",""]
			dline.extend(("",""))
			dline.append("")
			dline.extend((("map root","",2),("map users","",2)))
			dline.extend(("",("trashretention limit","",2)))
			if cl.master().has_feature(FEATURE_EXPORT_UMASK):
				dline.append("")
			if cl.master().has_feature(FEATURE_EXPORT_DISABLES):
				dline.append("")
			tab.header(*dline)

			dline = ["session id","ip/host","mount point"]
			dline.extend(("open files","# of connections"))
			dline.extend(("version","root dir","ro/rw","restrict ip","ignore gid"))
			dline.append("admin")
			dline.append(("---","",4))
			dline.append("allowed sclasses")
			dline.append(("---","",2))
			if cl.master().has_feature(FEATURE_EXPORT_UMASK):
				dline.append("global umask")
			if cl.master().has_feature(FEATURE_EXPORT_DISABLES):
				dline.append("disables mask")
			tab.header(*dline)

			dline = ["","","","","","","",""]
			dline.extend(("",""))
			dline.append("")
			dline.extend(("uid","gid","uid","gid"))
			dline.extend(("","min","max"))
			if cl.master().has_feature(FEATURE_EXPORT_UMASK):
				dline.append("")
			if cl.master().has_feature(FEATURE_EXPORT_DISABLES):
				dline.append("")
			tab.header(*dline)
		elif jsonmode:
			json_ms_array = []
		else:
			tab = Table("active mounts, parameters",(20 if cl.master().has_feature(FEATURE_EXPORT_DISABLES) else 19 if cl.master().has_feature(FEATURE_EXPORT_UMASK) else 18))

		sessions,dsessions = dataprovider.get_sessions_by_state(MSorder, MSrev)

		# Show active mounts
		for ses in sessions:
			if ttymode:
				dline = [ses.get_sessionstr(),ses.host,ses.info]
				dline.extend((ses.openfiles,ses.nsocks))
				dline.extend((ses.strver,". (META)" if ses.meta else ses.path,"ro" if ses.sesflags&1 else "rw","no" if ses.sesflags&2 else "yes","-" if ses.meta else "yes" if ses.sesflags&4 else "no"))
				dline.append("-" if ses.meta else "yes" if ses.sesflags&8 else "no")
				if ses.meta:
					dline.extend(("-","-"))
				else:
					dline.extend((ses.rootuid,ses.rootgid))
				if ses.meta or (ses.sesflags&16)==0:
					dline.extend(("-","-"))
				else:
					dline.extend((ses.mapalluid,ses.mapallgid))
				dline.append("%04X (%s)" % (ses.sclassgroups,ses.get_sclassgroups_str()))
				if ses.mintrashretention!=None and ses.maxtrashretention!=None:
					dline.extend((timeduration_to_shortstr(ses.mintrashretention),timeduration_to_shortstr(ses.maxtrashretention)))
				else:
					dline.extend(("-","-"))
				if cl.master().has_feature(FEATURE_EXPORT_UMASK):
					if ses.umaskval==None:
						dline.append("-")
					else:
						dline.append("%03o" % ses.umaskval)
				if cl.master().has_feature(FEATURE_EXPORT_DISABLES):
					dline.append("%08X (%s)" % (ses.disables,disablesmask_to_string(ses.disables)))
				tab.append(*dline)
			elif jsonmode:
				json_ms_dict = {}
				json_ms_dict["connected"] = True
				json_ms_dict["temporary"] = ses.is_tmp()
				json_ms_dict["session_id"] = ses.sessionid
				json_ms_dict["session_id_str"] = ses.get_sessionstr()
				json_ms_dict["hostname"] = ses.host
				json_ms_dict["ip"] = ses.strip
				json_ms_dict["mount_point"] = ses.info
				json_ms_dict["open_files"] = ses.openfiles
				json_ms_dict["number_of_sockets"] = ses.nsocks
				json_ms_dict["seconds_to_expire"] = None
				json_ms_dict["strver"] = ses.strver
				if ses.strver.endswith(" PRO"):
					json_ms_dict["version"] = ses.strver[:-4]
					json_ms_dict["pro"] = True
				else:
					json_ms_dict["version"] = ses.strver
					json_ms_dict["pro"] = False
				json_ms_dict["meta"] = ses.meta
				json_ms_dict["path"] = "META" if ses.meta else ses.path
				json_ms_dict["session_flags"] = ses.sesflags
				json_ms_dict["access_rw"] = False if ses.sesflags&1 else True
				json_ms_dict["restricted"] = False if ses.sesflags&2 else True
				json_ms_dict["ignore_gid"] = None if ses.meta else True if ses.sesflags&4 else False
				json_ms_dict["admin"] = None if ses.meta else True if ses.sesflags&8 else False
				if ses.meta:
					json_ms_dict["map_root_uid"] = None
					json_ms_dict["map_root_gid"] = None
				else:
					json_ms_dict["map_root_uid"] = ses.rootuid
					json_ms_dict["map_root_gid"] = ses.rootgid
				if ses.meta or (ses.sesflags&16)==0:
					json_ms_dict["map_user_uid"] = None
					json_ms_dict["map_user_gid"] = None
				else:
					json_ms_dict["map_user_uid"] = ses.mapalluid
					json_ms_dict["map_user_gid"] = ses.mapallgid
				json_ms_dict["allowed_storage_classes"] = ses.sclassgroups
				json_ms_dict["allowed_storage_classes_str"] = ses.get_sclassgroups_str()
				if ses.mintrashretention!=None and ses.maxtrashretention!=None:
					json_ms_dict["trash_retention_min"] = ses.mintrashretention
					json_ms_dict["trash_retention_max"] = ses.maxtrashretention
				else:
					json_ms_dict["trash_retention_min"] = None
					json_ms_dict["trash_retention_max"] = None
				if cl.master().has_feature(FEATURE_EXPORT_UMASK):
					if ses.umaskval==None:
						json_ms_dict["global_umask"] = None
					else:
						json_ms_dict["global_umask"] = "%03o" % ses.umaskval
				else:
					json_ms_dict["global_umask"] = None
				if cl.master().has_feature(FEATURE_EXPORT_DISABLES):
					json_ms_dict["disables_mask"] = None if ses.meta else "%08X" % ses.disables
					json_ms_dict["disables_str"] = "" if ses.meta else disablesmask_to_string(ses.disables)
					json_ms_dict["disables"] = [] if ses.meta else disablesmask_to_string_list(ses.disables)
				else:
					json_ms_dict["disables_mask"] = None
					json_ms_dict["disables_str"] = ""
					json_ms_dict["disables"] = []
				json_ms_array.append(json_ms_dict)
			else:
				dline = [ses.get_sessionstr(),ses.host,ses.info]
				dline.extend((ses.openfiles,ses.nsocks))
				dline.extend((ses.strver,". (META)" if ses.meta else ses.path,"ro" if ses.sesflags&1 else "rw","no" if ses.sesflags&2 else "yes","-" if ses.meta else "yes" if ses.sesflags&4 else "no"))
				dline.append("-" if ses.meta else "yes" if ses.sesflags&8 else "no")
				if ses.meta:
					dline.extend(("-","-"))
				else:
					dline.extend((ses.rootuid,ses.rootgid))
				if ses.meta or (ses.sesflags&16)==0:
					dline.extend(("-","-"))
				else:
					dline.extend((ses.mapalluid, ses.mapallgid))
				dline.append("%04X" % ses.sclassgroups)
				if ses.mintrashretention!=None and ses.maxtrashretention!=None:
					dline.extend((ses.mintrashretention, ses.maxtrashretention))
				else:
					dline.extend(("-","-"))
				if cl.master().has_feature(FEATURE_EXPORT_UMASK):
					if ses.umaskval==None:
						dline.append("-")
					else:
						dline.append("%03o" % ses.umaskval)
				if cl.master().has_feature(FEATURE_EXPORT_DISABLES):
					dline.append("%08X" % ses.disables)
				tab.append(*dline)
		# Show inactive mounts		
		if len(dsessions)>0:
			if ttymode:
				tabcols = (20 if cl.master().has_feature(FEATURE_EXPORT_DISABLES) else 19 if cl.master().has_feature(FEATURE_EXPORT_UMASK) else 18 if cl.master().version_at_least(1,7,8) else 16 if cl.master().version_at_least(1,7,0) else 15 if cl.master().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))
			elif jsonmode:
				pass
			else:
				print(myunicode(tab))
				print("")
				tab = Table("inactive mounts, parameters",5)
		for ses in dsessions:
			if ttymode:
				tabcols = (20 if cl.master().has_feature(FEATURE_EXPORT_DISABLES) else 19 if cl.master().has_feature(FEATURE_EXPORT_UMASK) else 18 if cl.master().version_at_least(1,7,8) else 16 if cl.master().version_at_least(1,7,0) else 15 if cl.master().version_at_least(1,6,26) else 12)
				dline = [ses.sessionid,ses.host,ses.info,ses.openfiles,ses.expire,("%s -H %s -P %u -CRS/%u" % (sys.argv[0],masterhost,masterport,ses.sessionid),"l",tabcols-5)]
				tab.append(*dline)
			elif jsonmode:
				json_ms_dict = {}
				json_ms_dict["connected"] = False
				json_ms_dict["temporary"] = False
				json_ms_dict["session_id"] = ses.sessionid
				json_ms_dict["session_id_str"] = ("%u" % ses.sessionid)
				json_ms_dict["hostname"] = ses.host
				json_ms_dict["ip"] = ses.strip
				json_ms_dict["mount_point"] = ses.info
				json_ms_dict["open_files"] = ses.openfiles
				json_ms_dict["number_of_sockets"] = 0
				json_ms_dict["seconds_to_expire"] = ses.expire
				json_ms_dict["strver"] = None
				json_ms_dict["version"] = None
				json_ms_dict["pro"] = None
				json_ms_dict["meta"] = None
				json_ms_dict["path"] = None
				json_ms_dict["session_flags"] = None
				json_ms_dict["access_rw"] = None
				json_ms_dict["restricted"] = None
				json_ms_dict["ignore_gid"] = None
				json_ms_dict["admin"] = None
				json_ms_dict["map_root_uid"] = None
				json_ms_dict["map_root_gid"] = None
				json_ms_dict["map_user_uid"] = None
				json_ms_dict["map_user_gid"] = None
				json_ms_dict["allowed_storage_classes"] = None
				json_ms_dict["allowed_storage_classes_str"] = None
				json_ms_dict["trash_retention_min"] = None
				json_ms_dict["trash_retention_max"] = None
				json_ms_dict["global_umask"] = None
				json_ms_dict["disables_mask"] = None
				json_ms_dict["disables_str"] = ""
				json_ms_dict["disables"] = []
				json_ms_array.append(json_ms_dict)
			else:
				dline = [ses.sessionid,ses.host,ses.info,ses.openfiles,ses.expire]
				tab.append(*dline)
		if jsonmode:
			jcollect["dataset"]["mounts"] = json_ms_array
		else:
			print(myunicode(tab))
	except Exception:
		print_exception()

# Mounts - operations section
if org.shall_render("MO"):
		try:
			if jsonmode:
				if (dataprovider.stats_to_show<=16):
					json_stats_keys = ["statfs","getattr","setattr","lookup","mkdir","rmdir","symlink","readlink","mknod","unlink","rename","link","readdir","open","read","write"]
				else:
					json_stats_keys = ["statfs","getattr","setattr","lookup","mkdir","rmdir","symlink","readlink","mknod","unlink","rename","link","readdir","open","rchunk","wchunk","read","write","fsync","snapshot","truncate","getxattr","setxattr","getfacl","setfacl","create","lock","meta"]
				json_mo_array = []
			elif ttymode:
				tab = Table("Active mounts (operations)",3+dataprovider.stats_to_show)
				tab.header("","",("operations %s hour" % ("last" if MOdata==0 else "current"),"",1+dataprovider.stats_to_show))
				tab.header("host/ip","mount point",("---","",1+dataprovider.stats_to_show))
				if (dataprovider.stats_to_show<=16):
					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.header("","","statfs","getattr","setattr","lookup","mkdir","rmdir","symlink","readlink","mknod","unlink","rename","link","readdir","open","rchunk","wchunk","read","write","fsync","snapshot","truncate","getxattr","setxattr","getfacl","setfacl","create","lock","meta","total")
					tab.defattr("r","l","r","r","r","r","r","r","r","r","r","r","r","r","r","r","r","r","r","r","r","r","r","r","r","r","r","r","r","r","r")
			else:
				tab = Table("active mounts, operations",3+dataprovider.stats_to_show)
			for ses in dataprovider.get_sessions_order_by_mo(MOorder,MOrev,MOdata):
				if jsonmode:
					json_mo_dict = {}
					json_mo_dict["hostname"] = ses.host
					json_mo_dict["ip"] = ses.strip
					json_mo_dict["mount_point"] = ses.info
					json_stats_c_dict = {}
					json_stats_l_dict = {}
					for i,name in enumerate(json_stats_keys):
						json_stats_c_dict[name] = ses.stats_c[i]
						json_stats_l_dict[name] = ses.stats_l[i]
					json_stats_c_dict["total"] = sum(ses.stats_c)
					json_stats_l_dict["total"] = sum(ses.stats_l)
					json_mo_dict["stats_current_hour"] = json_stats_c_dict
					json_mo_dict["stats_last_hour"] = json_stats_l_dict
					json_mo_array.append(json_mo_dict)
				else:
					ldata = [ses.host,ses.info]
					if MOdata==0:
						ldata.extend(ses.stats_l)
						ldata.append(sum(ses.stats_l))
					else:
						ldata.extend(ses.stats_c)
						ldata.append(sum(ses.stats_c))
					tab.append(*ldata)
					
			if jsonmode:
				jcollect["dataset"]["operations"] = json_mo_array
			else:
				print(myunicode(tab))
		except Exception:
			print_exception()

# Open files section
if org.shall_render("OF"):
	try:
		if jsonmode:
			json_of_array = []
		elif ttymode:
			tab = Table("Open Files",5)
			tab.header("session id","ip/host","mount point","inode","path")
			tab.defattr("r","r","l","r","l")
		else:
			tab = Table("open file",5)
		
		for of in dataprovider.get_openfiles(OFsessionid, OForder, OFrev):
			if jsonmode:
				json_of_dict = {}
				json_of_dict["session_id"] = of.sessionid
				json_of_dict["hostname"] = of.host
				json_of_dict["ip"] = of.ipnum
				json_of_dict["mount_point"] = of.info
				json_of_dict["inode"] = of.inode
				json_of_dict["paths"] = of.paths
				json_of_array.append(json_of_dict)
			else:
				if len(of.paths)==0:
					dline = [of.sessionid,of.host,of.info,of.inode,"unknown"]
					tab.append(*dline)
				else:
					for path in of.paths:
						dline = [of.sessionid,of.host,of.info,of.inode,path]
						tab.append(*dline)
		if jsonmode:
			jcollect["dataset"]["openfiles"] = json_of_array
		else:
			print(myunicode(tab))
	except Exception:
		print_exception()

# Acquired locks section CLI only
if org.shall_render("AL"):
	try:
		sessionsdata = {}
		for ses in dataprovider.get_sessions():
			if ses.sessionid>0 and ses.sessionid < 0x80000000:
				sessionsdata[ses.sessionid]=(ses.host,ses.sortip,ses.strip,ses.info,ses.openfiles)
			
		if jsonmode:
			json_al_array = []
		elif ttymode:
			tab = Table("Acquired Locks",10,"r")
			tab.header("inode","session id","ip/host","mount point","lock type","owner","pid","start","end","r/w")
		else:
			tab = Table("acquired locks",10)

		for al in dataprovider.get_acquiredlocks(ALinode, ALorder, ALrev):
			if jsonmode:
				json_al_dict = {}
				json_al_dict["inode"] = al.inode
				json_al_dict["session_id"] = al.sessionid
				json_al_dict["hostname"] = al.host
				json_al_dict["ip"] = al.ipnum
				json_al_dict["mount_point"] = al.info
				json_al_dict["lock_type"] = al.ctype
				if al.ctype==MFS_LOCK_TYPE_SHARED:
					json_al_dict["lock_type_str"] = "READ(SHARED)"
				elif al.ctype==MFS_LOCK_TYPE_EXCLUSIVE:
					json_al_dict["lock_type_str"] = "WRITE(EXCLUSIVE)"
				else:
					json_al_dict["lock_type_str"] = "UNKNOWN"
				json_al_dict["owner"] = al.owner
				json_al_dict["pid"] = al.pid
				json_al_dict["start"] = al.start
				json_al_dict["end"] = al.end
				if al.pid==0 and al.start==0 and al.end==0:
					json_al_dict["pid_str"] = "-1"
					json_al_dict["start_str"] = "0"
					json_al_dict["end_str"] = "EOF"
				elif al.end > 0x7FFFFFFFFFFFFFFF:
					json_al_dict["pid_str"] = "%u" % al.pid
					json_al_dict["start_str"] = "%u" % al.start
					json_al_dict["end_str"] = "EOF"
				else:
					json_al_dict["pid_str"] = "%u" % al.pid
					json_al_dict["start_str"] = "%u" % al.start
					json_al_dict["end_str"] = "%u" % al.end
				json_al_array.append(json_al_dict)
			else:
				if al.pid==0 and al.start==0 and al.end==0:
					pid = "-1"
					start = "0"
					end = "EOF"
				elif al.end > 0x7FFFFFFFFFFFFFFF:
					al.end = "EOF"
				if al.ctype==MFS_LOCK_TYPE_SHARED:
					ctypestr = "READ(SHARED)"
				elif al.ctype==MFS_LOCK_TYPE_EXCLUSIVE:
					ctypestr = "WRITE(EXCLUSIVE)"
				else:
					ctypestr = "UNKNOWN"
				dline = [al.inode,al.sessionid,al.host,al.info,al.locktype,al.owner,al.pid,al.start,al.end,ctypestr]
				tab.append(*dline)
		if jsonmode:
			jcollect["dataset"]["locks"] = json_al_array
		else:
			print(myunicode(tab))
	except Exception:
		print_exception()
	
# Storage classes section
if org.shall_render("SC"):
	try:
		show_copy_and_ec = cl.master().version_at_least(4,5,0)
		show_arch_min_size = cl.master().version_at_least(4,34,0)
		show_labelmode_overrides = cl.master().has_feature(FEATURE_LABELMODE_OVERRIDES)
		show_export_group_and_priority = cl.master().has_feature(FEATURE_SCLASSGROUPS)

		if jsonmode:
			json_sc_array = []
		elif ttymode:
			if show_copy_and_ec:
				if show_arch_min_size:
					if show_labelmode_overrides:
						if show_export_group_and_priority:
							tab = Table("Storage Classes",24,"r")
							tab.header("","","","","","","","","","",("# of inodes","",2),("state statistics and definitions","",12))
							tab.header("","","","","","","","","","",("---","",14))
							tab.header("id","name","join priority","export group","admin only","labels mode","arch mode","arch delay","arch min size","min trashretention","","","",("chunks under","",2),("chunks exact","",2),("chunks over","",2),"","","","","")
							tab.header("","","","","","","","","","","files","dirs","state",("---","",6),"can be fulfilled","labels mode override","redundancy level","labels","distribution")
							tab.header("","","","","","","","","","","","","","COPY","EC","COPY","EC","COPY","EC","","","","","")
							tab.defattr("r","l","r","r","c","c","c","r","r","r","r","r","c","r","r","r","r","r","r","c","c","c","c","c")
						else:
							tab = Table("Storage Classes",22,"r")
							tab.header("","","","","","","","",("# of inodes","",2),("state statistics and definitions","",12))
							tab.header("","","","","","","","",("---","",14))
							tab.header("id","name","admin only","labels mode","arch mode","arch delay","arch min size","min trashretention","","","",("chunks under","",2),("chunks exact","",2),("chunks over","",2),"","","","","")
							tab.header("","","","","","","","","files","dirs","state",("---","",6),"can be fulfilled","labels mode override","redundancy level","labels","distribution")
							tab.header("","","","","","","","","","","","COPY","EC","COPY","EC","COPY","EC","","","","","")
							tab.defattr("r","l","c","c","c","r","r","r","r","r","c","r","r","r","r","r","r","c","c","c","c","c")
					else:
						tab = Table("Storage Classes",21,"r")
						tab.header("","","","","","","","",("# of inodes","",2),("state statistics and definitions","",11))
						tab.header("","","","","","","","",("---","",13))
						tab.header("id","name","admin only","labels mode","arch mode","arch delay","arch min size","min trashretention","","","",("chunks under","",2),("chunks exact","",2),("chunks over","",2),"","","","")
						tab.header("","","","","","","","","files","dirs","state",("---","",6),"can be fulfilled","redundancy level","labels","distribution")
						tab.header("","","","","","","","","","","","COPY","EC","COPY","EC","COPY","EC","","","","")
						tab.defattr("r","l","c","c","c","r","r","r","r","r","c","r","r","r","r","r","r","c","c","c","c")
				else:
					tab = Table("Storage Classes",20,"r")
					tab.header("","","","","","","",("# of inodes","",2),("state statistics and definitions","",11))
					tab.header("","","","","","","",("---","",13))
					tab.header("id","name","admin only","labels mode","arch mode","arch delay","min trashretention","","","",("chunks under","",2),("chunks exact","",2),("chunks over","",2),"","","","")
					tab.header("","","","","","","","files","dirs","state",("---","",6),"can be fulfilled","redundancy level","labels","distribution")
					tab.header("","","","","","","","","","","COPY","EC","COPY","EC","COPY","EC","","","","")
					tab.defattr("r","l","c","c","c","r","r","r","r","c","r","r","r","r","r","r","c","c","c","c")
			else:
				tab = Table("Storage Classes",17,"r")
				tab.header("","","","","","","",("# of inodes","",2),("state statistics and definitions","",8))
				tab.header("id","name","admin only","labels mode","arch mode","arch delay","min trashretention",("---","",10))
				tab.header("","","","","","","","files","dirs","state","chunks under","chunks exact","chunks over","can be fulfilled","redundancy level","labels","distribution")
				tab.defattr("r","l","c","c","c","r","r","r","r","c","r","r","r","c","c","c","c")
		else:
			if show_copy_and_ec:
				tab = Table("storage classes",13)
			else:
				tab = Table("storage classes",10)

		firstrow = 1
		for sc in dataprovider.get_sclasses(SCorder,SCrev):
			if jsonmode:
				json_sc_dict = {}

				json_sc_dict["sclassid"] = sc.sclassid
				json_sc_dict["sclassname"] = sc.sclassname
				if show_export_group_and_priority:
					json_sc_dict["sclassdesc"] = sc.sclassdesc
					json_sc_dict["priority"] = sc.priority
					json_sc_dict["export_group"] = sc.export_group
				else:
					json_sc_dict["sclassdesc"] = None
					json_sc_dict["priority"] = None
					json_sc_dict["export_group"] = None
				json_sc_dict["admin_only"] = True if sc.admin_only else False
				json_sc_dict["labels_mode"] = sc.labels_mode
				json_sc_dict["labels_mode_str"] = sc.get_labels_mode_str()
				json_sc_dict["arch_mode"] = sc.arch_mode
				json_sc_dict["arch_mode_str"] = sc.get_arch_mode_str()
				json_sc_dict["arch_delay"] = sc.arch_delay
				json_sc_dict["arch_delay_str"] = sc.get_arch_delay_str()
				json_sc_dict["arch_min_size"] = sc.arch_min_size
				json_sc_dict["arch_min_size_human"] = humanize_number(sc.arch_min_size," ")
				json_sc_dict["min_trashretention"] = sc.min_trashretention
				json_sc_dict["min_trashretention_str"] = sc.get_min_trashretention_str()
				json_sc_dict["files"] = sc.files
				json_sc_dict["dirs"] = sc.dirs

				json_sc_def_dict = {}
				# for defined,name,counters,ec_level,labellist,uniqmask,labelsmodeover,canbefulfilled in sc.states:
				for st in sc.states:
					ec_data_parts = 0
					ec_chksum_parts = 0
					if st.ec_level!=None and st.ec_level>0:
						ec_data_parts = st.ec_level >> 4
						ec_chksum_parts = st.ec_level & 0xF
						if ec_data_parts==0:
							ec_data_parts = 8
					labels_mode_over_str = "LOOSE" if st.labelsmodeover==0 else "STD" if st.labelsmodeover==1 else "STRICT" if st.labelsmodeover==2 else sc.get_labels_mode_str()
					if st.defined:
						json_sc_state_dict = {}
						if show_copy_and_ec:
							json_sc_state_dict["chunks_undergoal_copy"] = st.counters[0]
							json_sc_state_dict["chunks_undergoal_ec"] = st.counters[1]
							json_sc_state_dict["chunks_exactgoal_copy"] = st.counters[2]
							json_sc_state_dict["chunks_exactgoal_ec"] = st.counters[3]
							json_sc_state_dict["chunks_overgoal_copy"] = st.counters[4]
							json_sc_state_dict["chunks_overgoal_ec"] = st.counters[5]
						else:
							json_sc_state_dict["chunks_undergoal_copy"] = st.counters[0]
							json_sc_state_dict["chunks_undergoal_ec"] = None
							json_sc_state_dict["chunks_exactgoal_copy"] = st.counters[1]
							json_sc_state_dict["chunks_exactgoal_ec"] = None
							json_sc_state_dict["chunks_overgoal_copy"] = st.counters[2]
							json_sc_state_dict["chunks_overgoal_ec"] = None
						json_sc_state_dict["can_be_fulfilled"] = st.canbefulfilled
						if st.canbefulfilled==3:
							json_sc_state_dict["can_be_fulfilled_str"] = "YES"
						elif st.canbefulfilled==2:
							json_sc_state_dict["can_be_fulfilled_str"] = "OVERLOADED"
						elif st.canbefulfilled==1:
							json_sc_state_dict["can_be_fulfilled_str"] = "NO SPACE"
						elif st.canbefulfilled==4:
							json_sc_state_dict["can_be_fulfilled_str"] = "EC ON HOLD"
						else:
							json_sc_state_dict["can_be_fulfilled_str"] = "NO"
						if st.ec_level!=None and st.ec_level>0:
							json_sc_state_dict["ec_data_parts"] = ec_data_parts
							json_sc_state_dict["ec_chksum_parts"] = ec_chksum_parts
							json_sc_state_dict["full_copies"] = 0
							json_sc_state_dict["redundancy_level_str"] = "EC %u+%u" % (ec_data_parts,ec_chksum_parts)
						else:
							json_sc_state_dict["ec_data_parts"] = 0
							json_sc_state_dict["ec_chksum_parts"] = 0
							json_sc_state_dict["full_copies"] = len(st.labellist)
							json_sc_state_dict["redundancy_level_str"] = "COPIES: %u (1+%u)" % (len(st.labellist),len(st.labellist)-1)
						json_sc_labels_array = []
						for labelstr,matchingservers,_ in st.labellist:
							json_sc_labels_dict = {}
							json_sc_labels_dict["definition"] = labelstr
							json_sc_labels_dict["matching_servers"] = matchingservers
							json_sc_labels_dict["available_servers"] = sc.availableservers
							json_sc_labels_array.append(json_sc_labels_dict)
						json_sc_state_dict["labels_list"] = json_sc_labels_array
						json_sc_state_dict["labels_str"] = "%s" % (",".join([x for x,_,_ in labellist_fold(st.labellist)]))
						json_sc_state_dict["uniqmask"] = st.uniqmask
						json_sc_state_dict["uniqmask_str"] = uniqmask_to_str(st.uniqmask)
						json_sc_state_dict["labels_mode"] = st.labelsmodeover
						json_sc_state_dict["labels_mode_str"] = labels_mode_over_str
						json_sc_def_dict[st.name.lower()] = json_sc_state_dict
				json_sc_dict["storage_modes"] = json_sc_def_dict
				json_sc_array.append(json_sc_dict)
			elif ttymode:
				if firstrow:
					firstrow = 0
				else:
					if show_copy_and_ec:
						if show_arch_min_size:
							if show_labelmode_overrides:
								if show_export_group_and_priority:
									tab.append(("---","",24))
								else:
									tab.append(("---","",22))
							else:
								tab.append(("---","",21))
						else:
							tab.append(("---","",20))
					else:
						tab.append(("---","",17))
				first = 1
				# for defined,name,counters,ec_level,labellist,uniqmask,labelsmodeover,canbefulfilled in sc.states:
				for st in sc.states:
					ec_data_parts = 0
					ec_chksum_parts = 0
					if st.ec_level!=None and st.ec_level>0:
						ec_data_parts = st.ec_level >> 4
						ec_chksum_parts = st.ec_level & 0xF
						if ec_data_parts==0:
							ec_data_parts = 8
					if first:
						first = 0
						if show_export_group_and_priority:
							data = [sc.sclassid,sc.sclassname,sc.priority,sc.export_group,sc.get_admin_only_str(),sc.get_labels_mode_str(),sc.get_arch_mode_str(),sc.get_arch_delay_str(),humanize_number(sc.arch_min_size," "),sc.get_min_trashretention_str(),sc.files,sc.dirs]
						elif show_arch_min_size:
							data = [sc.sclassid,sc.sclassname,sc.get_admin_only_str(),sc.get_labels_mode_str(),sc.get_arch_mode_str(),sc.get_arch_delay_str(),humanize_number(sc.arch_min_size," "),sc.get_min_trashretention_str(),sc.files,sc.dirs]
						else:
							data = [sc.sclassid,sc.sclassname,sc.get_admin_only_str(),sc.get_labels_mode_str(),sc.get_arch_mode_str(),sc.get_arch_delay_str(),sc.get_min_trashretention_str(),sc.files,sc.dirs]
					else:
						data = ["","","","","","","","",""]
						if show_arch_min_size:
							data.append("")
						if show_export_group_and_priority:
							data.append("")
							data.append("")
					if st.defined:
						data.append(st.name)
					else:
						data.append((st.name,'8'))
					if show_copy_and_ec:
						if st.counters[0]!=None and st.counters[1]!=None and st.counters[2]!=None and st.counters[3]!=None and st.counters[4]!=None and st.counters[5]!=None and st.defined:
							data.append((st.counters[0],'3') if st.counters[0]>0 else "-")
							data.append((st.counters[1],'3') if st.counters[1]>0 else "-")
							if st.ec_level!=None and st.ec_level>0:
								data.append((st.counters[2],'5') if st.counters[2]>0 else "-")
								data.append((st.counters[3],'4'))
							else:
								data.append((st.counters[2],'4'))
								data.append((st.counters[3],'5') if st.counters[3]>0 else "-")
							data.append((st.counters[4],'6') if st.counters[4]>0 else "-")
							data.append((st.counters[5],'6') if st.counters[5]>0 else "-")
						else:
							data.extend(["-","-","-","-","-","-"])
					else:
						if st.counters[0]!=None and st.counters[1]!=None and st.counters[2]!=None and st.defined:
							data.append((st.counters[0],'3') if st.counters[0]>0 else "-")
							data.append((st.counters[1],'4'))
							data.append((st.counters[2],'6') if st.counters[2]>0 else "-")
						else:
							data.extend(["-","-","-"])
					if st.canbefulfilled==3:
						data.append(("YES",('4' if st.defined else '8')))
					elif st.canbefulfilled==2:
						data.append(("OVERLOADED",('3' if st.defined else '8')))
					elif st.canbefulfilled==1:
						data.append(("NO SPACE",('2' if st.defined else '8')))
					elif st.canbefulfilled==4:
						data.append(("EC ON HOLD",('2' if st.defined else '8')))
					else:
						data.append(("NO",('1' if st.defined else '8')))
					if show_labelmode_overrides:
						labels_mode_over_str = "LOOSE" if st.labelsmodeover==0 else "STD" if st.labelsmodeover==1 else "STRICT" if st.labelsmodeover==2 else sc.get_labels_mode_str()
						if (st.labelsmodeover>=0 and st.labelsmodeover<=2 and st.defined):
							if (st.labelsmodeover!=sc.labels_mode):
								data.append((labels_mode_over_str,'3'))
							else:
								data.append(labels_mode_over_str)
						else:
							data.append((labels_mode_over_str,'8'))
					if st.ec_level!=None and st.ec_level>0:
						rlstr = "EC %u+%u" % (ec_data_parts,ec_chksum_parts)
					else:
						rlstr = "COPIES: %u (1+%u)" % (len(st.labellist),len(st.labellist)-1)
					labstr = "%s" % (",".join([x for x,_,_ in labellist_fold(st.labellist)]))
					uniqstr = uniqmask_to_str(st.uniqmask)
					if st.defined:
						data.append(rlstr)
						data.append(labstr)
						data.append(uniqstr)
					else:
						data.append((rlstr,'8'))
						data.append((labstr,'8'))
						data.append((uniqstr,'8'))
					tab.append(*data)
			else:
				if show_copy_and_ec:
					if show_arch_min_size:
						if show_export_group_and_priority:
							data = ["COMMON",sc.sclassid,sc.sclassname,sc.priority,sc.export_group,sc.get_admin_only_str(),sc.get_labels_mode_str(),sc.get_arch_mode_str(),sc.get_arch_delay_str(),sc.arch_min_size,sc.get_min_trashretention_str(),sc.files,sc.dirs]
						else:
							data = ["COMMON",sc.sclassid,sc.sclassname,sc.get_admin_only_str(),sc.get_labels_mode_str(),sc.get_arch_mode_str(),sc.get_arch_delay_str(),sc.arch_min_size,sc.get_min_trashretention_str(),sc.files,sc.dirs,"",""]
					else:
						data = ["COMMON",sc.sclassid,sc.sclassname,sc.get_admin_only_str(),sc.get_labels_mode_str(),sc.get_arch_mode_str(),sc.get_arch_delay_str(),sc.get_min_trashretention_str(),sc.files,sc.dirs,"","",""]
				else:
					data = ["COMMON",sc.sclassid,sc.sclassname,sc.get_admin_only_str(),sc.get_labels_mode_str(),sc.get_arch_mode_str(),sc.get_arch_delay_str(),sc.get_min_trashretention_str(),sc.files,sc.dirs]
				tab.append(*data)
				# for defined,name,counters,ec_level,labellist,uniqmask,labelsmodeover,canbefulfilled in sc.states:
				for st in sc.states:
					ec_data_parts = 0
					ec_chksum_parts = 0
					if st.ec_level!=None and st.ec_level>0:
						ec_data_parts = st.ec_level >> 4
						ec_chksum_parts = st.ec_level & 0xF
						if ec_data_parts==0:
							ec_data_parts = 8
					if st.defined:
						data = [st.name,sc.sclassid]
						if show_copy_and_ec:
							if st.counters[0]!=None and st.counters[1]!=None and st.counters[2]!=None and st.counters[3]!=None and st.counters[4]!=None and st.counters[5]!=None and st.defined:
								data.append(st.counters[0])
								data.append(st.counters[1])
								data.append(st.counters[2])
								data.append(st.counters[3])
								data.append(st.counters[4])
								data.append(st.counters[5])
							else:
								data.extend(["-","-","-","-","-","-"])
						else:
							if st.counters[0]!=None and st.counters[1]!=None and st.counters[2]!=None and st.defined:
								data.append(st.counters[0])
								data.append(st.counters[1])
								data.append(st.counters[2])
							else:
								data.extend(["-","-","-"])
						if st.canbefulfilled==3:
							data.append("YES")
						elif st.canbefulfilled==2:
							data.append("OVERLOADED")
						elif st.canbefulfilled==1:
							data.append("NO SPACE")
						elif st.canbefulfilled==4:
							data.append("EC ON HOLD")
						else:
							data.append("NO")
						if show_labelmode_overrides:
							data.append("LOOSE" if st.labelsmodeover==0 else "STD" if st.labelsmodeover==1 else "STRICT" if st.labelsmodeover==2 else sc.get_labels_mode_str())
						if st.ec_level!=None and st.ec_level>0:
							rlstr = "EC %u+%u" % (ec_data_parts,ec_chksum_parts)
						else:
							rlstr = "COPIES: %u (1+%u)" % (len(st.labellist),len(st.labellist)-1)
						labstr = "%s" % (",".join([x for x,_,_ in labellist_fold(st.labellist)]))
						uniqstr = uniqmask_to_str(st.uniqmask)
						data.append(rlstr)
						data.append(labstr)
						data.append(uniqstr)
						if not show_labelmode_overrides:
							data.append("")
						tab.append(*data)

		if jsonmode:
			jcollect["dataset"]["storage_classes"] = json_sc_array
		else:
			print(myunicode(tab))
	except Exception:
		print_exception()

# Override patterns section
if org.shall_render("PA"):
	try:
		if jsonmode:
			json_pa_array = []
		elif ttymode:
			tab = Table("Override Patterns",7)
			tab.header("pattern","euid","egid","priority","storage class","trash retention","extra attributes")
			tab.defattr("r","r","r","r","r","r","r")
		else:
			tab = Table("override patterns",7)

		for op in dataprovider.get_opatterns(PAorder, PArev):
			if jsonmode:
				json_pa_dict = {}
				json_pa_dict["pattern"] = op.globname
				json_pa_dict["euid"] = op.euidstr
				json_pa_dict["egid"] = op.egidstr
				json_pa_dict["priority"] = op.priority
				json_pa_dict["storage_class_name"] = op.sclassname
				json_pa_dict["trash_retention"] = op.trashretention
				if op.trashretention==None:
					json_pa_dict["trash_retention_human"] = ""
				else:
					json_pa_dict["trash_retention_human"] = hours_to_str(op.trashretention)
				json_pa_dict["set_eattr"] = op.seteattr
				json_pa_dict["clear_eattr"] = op.clreattr
				if op.seteattr|op.clreattr:
					json_pa_dict["eattr_str"] = op.eattrstr
				else:
					json_pa_dict["eattr_str"] = None
				json_pa_array.append(json_pa_dict)
			else:
				if op.sclassname==None:
					op.sclassname = "-"
				dline = [op.globname,op.euidstr,op.egidstr,op.priority,op.sclassname]
				if op.trashretention==None:
					dline.append("-")
				elif ttymode:
					dline.append(hours_to_str(op.trashretention))
				else:
					dline.append(op.trashretention)
				if op.eattrstr=="-":
					dline.append("-")
				elif ttymode:
					dline.append(op.eattrstr)
				else:
					dline.append("%02X,%02X:%s" % (op.seteattr,op.clreattr,op.eattrstr))
				tab.append(*dline)
		if jsonmode:
			jcollect["dataset"]["patterns"] = json_pa_array
		else:
			print(myunicode(tab))
	except Exception:
		print_exception()

# Quotas
if org.shall_render("QU"):
	try:
		if jsonmode:
			json_qu_array = []
		elif ttymode:
			tab = Table("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 = Table("active quotas",16)

		maxperc,quotas = dataprovider.get_quotas(QUorder, QUrev)
		for qu in quotas:
			graceperiod_default = 0
			if cl.master().has_feature(FEATURE_DEFAULT_GRACEPERIOD):
				if qu.exceeded & 2:
					qu.exceeded &= 1
					graceperiod_default = 1
			if jsonmode:
				json_qu_dict = {}
				json_qu_dict["path"] = qu.path
				json_qu_dict["exceeded"] = True if qu.exceeded else False
				json_qu_dict["grace_period_default"] = True if graceperiod_default else False
				json_qu_dict["grace_period"] = qu.graceperiod
				if qu.graceperiod>0:
					json_qu_dict["grace_period_str"] = timeduration_to_shortstr(qu.graceperiod) + (" (default)" if graceperiod_default else "")
				else:
					json_qu_dict["grace_period_str"] = "default"
				if qu.timetoblock<0xFFFFFFFF:
					json_qu_dict["time_to_expire"] = qu.timetoblock
					if qu.timetoblock>0:
						json_qu_dict["time_to_expire_str"] = timeduration_to_shortstr(qu.timetoblock)
					else:
						json_qu_dict["time_to_expire_str"] = "expired"
				else:
					json_qu_dict["time_to_expire"] = None
					json_qu_dict["time_to_expire_str"] = ""
				json_qu_dict["flags"] = qu.qflags
				json_qu_dict["soft_quota_inodes"] = qu.sinodes if qu.qflags&1 else None
				json_qu_dict["soft_quota_length"] = qu.slength if qu.qflags&2 else None
				json_qu_dict["soft_quota_length_human"] = humanize_number(qu.slength," ") if qu.qflags&2 else None
				json_qu_dict["soft_quota_size"] = qu.ssize if qu.qflags&4 else None
				json_qu_dict["soft_quota_size_human"] = humanize_number(qu.ssize," ") if qu.qflags&4 else None
				json_qu_dict["soft_quota_realsize"] = qu.srealsize if qu.qflags&8 else None
				json_qu_dict["soft_quota_realsize_human"] = humanize_number(qu.srealsize," ") if qu.qflags&8 else None
				json_qu_dict["hard_quota_inodes"] = qu.hinodes if qu.qflags&16 else None
				json_qu_dict["hard_quota_length"] = qu.hlength if qu.qflags&32 else None
				json_qu_dict["hard_quota_length_human"] = humanize_number(qu.hlength," ") if qu.qflags&32 else None
				json_qu_dict["hard_quota_size"] = qu.hsize if qu.qflags&64 else None
				json_qu_dict["hard_quota_size_human"] = humanize_number(qu.hsize," ") if qu.qflags&64 else None
				json_qu_dict["hard_quota_realsize"] = qu.hrealsize if qu.qflags&128 else None
				json_qu_dict["hard_quota_realsize_human"] = humanize_number(qu.hrealsize," ") if qu.qflags&128 else None
				json_qu_dict["current_quota_inodes"] = qu.cinodes
				json_qu_dict["current_quota_length"] = qu.clength
				json_qu_dict["current_quota_length_human"] = humanize_number(qu.clength," ")
				json_qu_dict["current_quota_size"] = qu.csize
				json_qu_dict["current_quota_size_human"] = humanize_number(qu.csize," ")
				json_qu_dict["current_quota_realsize"] = qu.crealsize
				json_qu_dict["current_quota_realsize_human"] = humanize_number(qu.crealsize," ")
				json_qu_array.append(json_qu_dict)
			elif ttymode:
				dline = [qu.path] #,"yes" if qu.exceeded else "no"]
				if qu.graceperiod>0:
					dline.append(timeduration_to_shortstr(qu.graceperiod) + (" (default)" if graceperiod_default else ""))
				else:
					dline.append("default")
				if qu.timetoblock<0xFFFFFFFF:
					if qu.timetoblock>0:
						dline.append((timeduration_to_shortstr(qu.timetoblock),"2"))
					else:
						dline.append(("expired","1"))
				else:
					dline.append("-")
				if qu.qflags&1:
					dline.append(qu.sinodes)
				else:
					dline.append("-")
				if qu.qflags&2:
					dline.append(humanize_number(qu.slength," "))
				else:
					dline.append("-")
				if qu.qflags&4:
					dline.append(humanize_number(qu.ssize," "))
				else:
					dline.append("-")
				if qu.qflags&8:
					dline.append(humanize_number(qu.srealsize," "))
				else:
					dline.append("-")
				if qu.qflags&16:
					dline.append(qu.hinodes)
				else:
					dline.append("-")
				if qu.qflags&32:
					dline.append(humanize_number(qu.hlength," "))
				else:
					dline.append("-")
				if qu.qflags&64:
					dline.append(humanize_number(qu.hsize," "))
				else:
					dline.append("-")
				if qu.qflags&128:
					dline.append(humanize_number(qu.hrealsize," "))
				else:
					dline.append("-")
				dline.append(qu.cinodes)
				if qu.qflags&1:
					if qu.sinodes>0:
						dline.append(("%.2f" % ((100.0*qu.cinodes)/qu.sinodes),"4" if qu.sinodes>=qu.cinodes else "2" if qu.timetoblock>0 else "1"))
					else:
						dline.append(("inf","1"))
				else:
					dline.append("-")
				if qu.qflags&16:
					if qu.hinodes>0:
						dline.append(("%.2f" % ((100.0*qu.cinodes)/qu.hinodes),"4" if qu.hinodes>qu.cinodes else "1"))
					else:
						dline.append(("inf","1"))
				else:
					dline.append("-")
				dline.append(humanize_number(qu.clength," "))
				if qu.qflags&2:
					if qu.slength>0:
						dline.append(("%.2f" % ((100.0*qu.clength)/qu.slength),"4" if qu.slength>=qu.clength else "2" if qu.timetoblock>0 else "1"))
					else:
						dline.append(("inf","1"))
				else:
					dline.append("-")
				if qu.qflags&32:
					if qu.hlength>0:
						dline.append(("%.2f" % ((100.0*qu.clength)/qu.hlength),"4" if qu.hlength>qu.clength else "1"))
					else:
						dline.append(("inf","1"))
				else:
					dline.append("-")
				dline.append(humanize_number(qu.csize," "))
				if qu.qflags&4:
					if qu.ssize>0:
						dline.append(("%.2f" % ((100.0*qu.csize)/qu.ssize),"4" if qu.ssize>=qu.csize else "2" if qu.timetoblock>0 else "1"))
					else:
						dline.append(("inf","1"))
				else:
					dline.append("-")
				if qu.qflags&64:
					if qu.hsize>0:
						dline.append(("%.2f" % ((100.0*qu.csize)/qu.hsize),"4" if qu.hsize>qu.csize else "1"))
					else:
						dline.append(("inf","1"))
				else:
					dline.append("-")
				dline.append(humanize_number(qu.crealsize," "))
				if qu.qflags&8:
					if qu.srealsize>0:
						dline.append(("%.2f" % ((100.0*qu.crealsize)/qu.srealsize),"4" if qu.srealsize>=qu.crealsize else "2" if qu.timetoblock>0 else "1"))
					else:
						dline.append(("inf","1"))
				else:
					dline.append("-")
				if qu.qflags&128:
					if qu.hrealsize>0:
						dline.append(("%.2f" % ((100.0*qu.crealsize)/qu.hrealsize),"4" if qu.hrealsize>qu.crealsize else "1"))
					else:
						dline.append(("inf","1"))
				else:
					dline.append("-")
				tab.append(*dline)
			else:
				dline = [qu.path,"yes" if qu.exceeded else "no"]
				if qu.graceperiod>0:
					dline.append(qu.graceperiod)
				else:
					dline.append("default")
				if qu.timetoblock<0xFFFFFFFF:
					if qu.timetoblock>0:
						dline.append(qu.timetoblock)
					else:
						dline.append("expired")
				else:
					dline.append("-")
				dline.append(qu.sinodes if qu.qflags&1 else "-")
				dline.append(qu.slength if qu.qflags&2 else "-")
				dline.append(qu.ssize if qu.qflags&4 else "-")
				dline.append(qu.srealsize if qu.qflags&8 else "-")
				dline.append(qu.hinodes if qu.qflags&16 else "-")
				dline.append(qu.hlength if qu.qflags&32 else "-")
				dline.append(qu.hsize if qu.qflags&64 else "-")
				dline.append(qu.hrealsize if qu.qflags&128 else "-")
				dline.extend((qu.cinodes,qu.clength,qu.csize,qu.crealsize))
				tab.append(*dline)
		if jsonmode:
			jcollect["dataset"]["quotas"] = json_qu_array
		else:
			print(myunicode(tab))
	except Exception:
		print_exception()

# Master charts
if org.shall_render("MC"):
	out = []
	try:
		if jsonmode:
			json_mc_array = []
			if cl.master().version_at_least(4,31,0):
				chrange = MCrange
				if (chrange<0 or chrange>3) and chrange!=9:
					chrange = 0
				if MCcount<0 or MCcount>4095:
					MCcount = 4095
				for host,port,no,mode,desc,name,raw in MCchdata:
					json_mc_dict = {}
					if (host==None or port==None):
						json_mc_dict["master"] = "leader"
					else:
						json_mc_dict["master"] = "%s:%s" % (host,port)
					json_mc_dict["name"] = name
					json_mc_dict["description"] = desc
					json_mc_dict["raw_format"] = bool(raw)
					if host==None or port==None:
						perc,base,datadict = get_charts_multi_data(cl.master(),no*10+chrange,MCcount)
					else:
						try:
							conn = MFSConn(host,port)
							perc,base,datadict = get_charts_multi_data(conn,no*10+chrange,MCcount)
							del conn
						except Exception:
							perc,base,datadict = None,None,None
					if perc!=None and base!=None and datadict!=None:
						json_mc_dict["percent"] = bool(perc)
						json_mc_data = {}
						for chrng in datadict:
							ch1data,ch2data,ch3data,ts,mul,div = datadict[chrng]
							mul,div = adjust_muldiv(mul,div,base)
							json_mc_data_range = {}
							if ch1data!=None:
								json_mc_data_range["data_array_1"] = charts_convert_data(ch1data,mul,div,raw)
								if ch2data!=None:
									json_mc_data_range["data_array_2"] = charts_convert_data(ch2data,mul,div,raw)
									if ch3data!=None:
										json_mc_data_range["data_array_3"] = charts_convert_data(ch3data,mul,div,raw)
							json_mc_data_range["timestamp"] = shiftts(ts)
							json_mc_data_range["shifted_timestamp"] = ts
							timestring = time.strftime("%Y-%m-%d %H:%M",time.gmtime(ts))
							json_mc_data_range["timestamp_str"] = timestring
							json_mc_data_range["time_step"] = [60,360,1800,86400][chrng]
							if raw:
								json_mc_data_range["multiplier"] = mul
								json_mc_data_range["divisor"] = div
							json_mc_data[chrng] = json_mc_data_range
						json_mc_dict["data_ranges"] = json_mc_data
					else:
						json_mc_dict["percent"] = None
						json_mc_dict["data_ranges"] = None
					json_mc_array.append(json_mc_dict)
			else:
				jcollect["errors"].append("Master chart data is not supported in your version of MFS - please upgrade! Minimal required version is 4.31.")
		else:
			if ttymode:
				tab = Table("Master chart data",len(MCchdata)+1,"r")
				hdrstr = ["host/port ->"]
				for host,port,no,mode,desc,name,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,name,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 = Table("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,name,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 = cl.master().command(CLTOAN_CHART_DATA,ANTOCL_CHART_DATA,struct.pack(">LL",x*10+chrange,MCcount))
					else:
						try:
							conn = MFSConn(host,port)
							data,length = conn.command(CLTOAN_CHART_DATA,ANTOCL_CHART_DATA,struct.pack(">LL",x*10+chrange,MCcount))
							del conn
						except Exception:
							data,length = None,0
					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 range(entries):
				ts = timestamp-chrangestep*e
				timestring = time.strftime("%Y-%m-%d %H:%M",time.gmtime(ts))
				dline = [timestring]
				for host,port,no,mode,desc,name,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," "))
					elif mode==5:
						if raw:
							dline.append("%u" % data)
						else:
							data = float(data)/float(chrangestep)
							dline.append("%.3fMB/s" % (data/(1024.0*1024.0)))
					elif mode==6:
						dline.append("%u" % data)
					elif mode==7:
						dline.append("%us" % data)
					elif mode==8:
						diff = (data/1000.0)
						if raw: dline.append("%.8f%%" % (diff))
						else: dline.append("%.2f%%" % (diff))
				tab.append(*dline)
			else:
				tab = Table("Master chart data is not supported in your version of MFS - please upgrade! Minimal required version is 2.0.15.",1,"r")
		if jsonmode:
			jcollect["dataset"]["mastercharts"] = json_mc_array
		else:
			print(myunicode(tab))
	except Exception:
		print_exception()

# Chunkservers charts
if org.shall_render("CC"):
		out = []
		try:
			CCchdata_defined = []
			CCchdata_undefined = []
			for host,port,no,mode,desc,name,raw in CCchdata:
				if host==None or port==None:
					CCchdata_undefined.append((no,mode,desc,name,raw))
				else:
					CCchdata_defined.append((host,port,no,mode,desc,name,raw))
			CCchdata = []
			if len(CCchdata_undefined)>0:
				for cs in dataprovider.get_chunkservers(): # default sort by ip/port
					for no,mode,desc,name,raw in CCchdata_undefined:
						CCchdata.append((cs.host,cs.port,no,mode,desc,name,raw))
			for host,port,no,mode,desc,name,raw in CCchdata_defined:
				CCchdata.append((host,port,no,mode,desc,name,raw))
			if jsonmode:
				json_cc_array = []
				if cl.master().version_at_least(4,31,0):
					chrange = CCrange
					if (chrange<0 or chrange>3) and chrange!=9:
						chrange = 0
					if CCcount<0 or CCcount>4095:
						CCcount = 4095
					
					multiconn = MFSMultiConn(timeout=12)
					chartid_arr = []
					for host,port,no,_,_,_,_ in CCchdata:
						if not multiconn.is_registered(host,port):
							multiconn.register(host,port)
						chartid = no*10+chrange
						if not chartid in chartid_arr:
							chartid_arr.append(chartid)
					all_charts = get_charts_multi_data_async(multiconn,chartid_arr,CCcount)
					del multiconn

					for host,port,no,mode,desc,name,raw in CCchdata:
						json_cc_dict = {}
						json_cc_dict["chunkserver"] = "%s:%s" % (host,port)
						json_cc_dict["name"] = name
						json_cc_dict["description"] = desc
						json_cc_dict["raw_format"] = bool(raw)
						hostkey = "%s:%u" % (host,port)
						chartid = no*10+chrange
						chartkey = "%s:%u" % (hostkey,chartid)
						if not chartkey in all_charts:
							jcollect["errors"].append("Chunkserver's %s data for chart %s is not available. Probably this chunkserver is unreachable." % (hostkey,chartid))
							continue
						perc,base,datadict = all_charts[chartkey]
						if perc!=None and base!=None and datadict!=None:
							json_cc_dict["percent"] = bool(perc)
							json_cc_data = {}
							for chrng in datadict:
								ch1data,ch2data,ch3data,ts,mul,div = datadict[chrng]
								mul,div=adjust_muldiv(mul,div,base)
								json_cc_data_range = {}
								if ch1data!=None:
									json_cc_data_range["data_array_1"] = charts_convert_data(ch1data,mul,div,raw)
									if ch2data!=None:
										json_cc_data_range["data_array_2"] = charts_convert_data(ch2data,mul,div,raw)
										if ch3data!=None:
											json_cc_data_range["data_array_3"] = charts_convert_data(ch3data,mul,div,raw)
								json_cc_data_range["timestamp"] = shiftts(ts)
								json_cc_data_range["shifted_timestamp"] = ts
								timestring = time.strftime("%Y-%m-%d %H:%M",time.gmtime(ts))
								json_cc_data_range["timestamp_str"] = timestring
								json_cc_data_range["time_step"] = [60,360,1800,86400][chrng]
								if raw:
									json_cc_data_range["multiplier"] = mul
									json_cc_data_range["divisor"] = div
								json_cc_data[chrng] = json_cc_data_range
							json_cc_dict["data_ranges"] = json_cc_data
						else:
							json_cc_dict["percent"] = None
							json_cc_dict["data_ranges"] = None
						json_cc_array.append(json_cc_dict)
				else:
					jcollect["errors"].append("Chunkserver chart data is not supported in your version of MFS - please upgrade! Minimal required version is 4.31.")
			else:
				if ttymode:
					tab = Table("Chunkserver chart data",len(CCchdata)+1,"r")
					hdrstr = ["host/port ->"]
					for host,port,no,mode,desc,name,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,name,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 = Table("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,name,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:
						try:
							conn = MFSConn(host,port)
							data,length = conn.command(CLTOAN_CHART_DATA,ANTOCL_CHART_DATA,struct.pack(">LL",x*10+chrange,CCcount))
							del conn
						except Exception:
							length = 0
						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 range(entries):
					ts = timestamp-chrangestep*e
					timestring = time.strftime("%Y-%m-%d %H:%M",time.gmtime(ts))
					dline = [timestring]
					for host,port,no,mode,desc,name,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)))
						elif mode==6:
							dline.append("%u" % data)
						elif mode==8:
							diff = (data/1000.0)
							if raw: dline.append("%.8f%%" % (diff))
							else: dline.append("%.2f%%" % (diff))
					tab.append(*dline)
				else:
					tab = Table("Chunkserver chart data are not supported in your version of MFS - please upgrade. Minimal required version is 2.0.15.",1,"r")
			if jsonmode:
				jcollect["dataset"]["cscharts"] = json_cc_array
			else:
				print(myunicode(tab))
		except Exception:
			print_exception()

if jsonmode and cl.master()!=None:
	print(json.dumps(jcollect))
