def main(params):
cell = params["cell"]
bos_conn = cell.open_bos_server(params["server"], params)
if "dir" in params:
d = params["dir"]
else:
d = "/usr/afs/bin"
for f in params["file"]:
i = f.rfind('/')
if i > -1:
f = f[i + 1:]
f = d + "/" + f
verbose("Asking about ", f, "\n")
ret = kafs.BOZO_GetDates(bos_conn, f)
if ret.newtime == 0:
s = "File " + f + "does not exist, "
else:
s = "File {:s} dated {:s}, ".format(f, time2str(ret.newtime))
if ret.baktime == 0:
s += "no .BAK file, "
else:
s += ".BAK file dated " + time2str(ret.baktime) + ", "
if ret.oldtime == 0:
s += "no .OLD file."
else:
s += ".OLD file dated " + time2str(ret.oldtime) + "."
output(s, "\n")
def expand_from_stringlist(comp_words, comp_cword, names):
reply = ""
for i in names:
if i.startswith(comp_words[comp_cword]):
reply += " " + i
output(reply.lstrip(), "\n")
sys.exit(0)
def display_instance_long(params, bos_conn, name):
info, status = display_instance_normal(params, bos_conn, name)
outputf(" Process last started at {:s} ({:d} proc starts)",
time2str(info.status.porcStartTime), info.status.procStarts)
if info.status.lastAnyExit != 0:
output(" Last exit at ", time2str(info.status.lastAnyExit), "\n")
if info.status.lastErrorExit != 0:
output(" Last error exit ", info.status.lastErrorExit, "\n")
s = " Last error exit at " + time2str(
info.status.lastErrorExit) + ","
istr = kafs.BOZO_GetInstanceStrings(bos_conn, name)
if istr.errorname != "":
s += " by " + istr.errorname + ","
if info.status.errorSignal == signal.SIGTERM:
s += " due to shutdown request."
elif info.status.errorSignal != 0:
s += " due to signal {:d}.".format(info.status.errorSignal)
else:
s += " due to exit {:d}.".format(info.status.errorCode)
output(s, "\n")
try:
i = 0
while True:
ret = kafs.BOZO_GetInstanceParm(bos_conn, name, i)
i += 1
output(" Command ", i, " is '", ret.parm, "'\n")
except kafs.AbortBZDOM:
pass
output("\n")
def main(params):
exitcode = 0
cell = params["cell"]
prcache = cell.get_prcache(params)
names = params["name"]
if "id" in params:
ids = params["id"]
else:
ids = []
for i in range(0, len(names)):
try:
name = names[i]
verbose("Adding user ", name, "\n")
if i < len(ids):
new_id = int(ids[i])
ret = cell.call_pt_server(params, kafs.PR_NewEntry, name,
new_id, 0)
else:
ret = cell.call_pt_server(params, kafs.PR_NewEntry, name, 0, 0)
new_id = ret.id
output("User ", name, " has id ", new_id, "\n")
prcache.evict_name(name)
prcache.evict_id(new_id)
except kafs.AbortPREXIST:
error("Entry for name already exists ; unable to create user ",
name, "\n")
if "force" not in params:
break
except kafs.AbortPRIDEXIST:
error("Entry for id already exists ; unable to create user ", name,
" with id ", new_id, "\n")
if "force" not in params:
break
return exitcode
def main(params):
cell = params["cell"]
bos_conn = cell.open_bos_server(params["server"], params)
if "instance" not in params:
instances = []
try:
i = 0
while True:
verbose("Enum ", i, ": ")
ret = kafs.BOZO_EnumerateInstance(bos_conn, i)
i += 1
verbose_cont(ret.iname, "\n")
instances.append(ret.iname)
except kafs.AbortBZDOM:
verbose_cont("<empty slot>\n")
else:
instances = params["instance"]
for i in instances:
try:
verbose("Displaying ", i, "\n")
if "long" in params:
display_instance_long(params, bos_conn, i)
else:
display_instance_normal(params, bos_conn, i)
except kafs.AbortBZNOENT:
error("failed to get instance info for '", i,
"' (no such entity)\n")
if "_baddiraccess" in params and "long" in params:
output(
"Bosserver reports inappropriate access on server directories\n")
def main(params):
cell = params["cell"]
bos_conn = cell.open_bos_server(params["server"], params)
split = split_handler()
output("Fetching log file '", params["file"], "'...\n")
output_flush()
ret = kafs.BOZO_GetLog(bos_conn, params["file"], split)
def main(params):
cell = params["cell"]
bos_conn = cell.open_bos_server(params["server"], params)
ret = kafs.BOZO_GetRestricted(bos_conn)
if ret.isrestricted:
output("Restricted mode is on\n")
else:
output("Restricted mode is off\n")
def main(params):
matches = search_help(params["_prog"], params["_cmdsetmod"],
params["_commands"], params["topic"].casefold())
if not matches:
output("Sorry, no commands found\n")
else:
for i in sorted(matches.keys()):
output(i, ": ", matches[i], "\n")
def display_vldb(params, vldb):
if vldb.volumeId[kafs.RWVOL] != 0:
outputf(" RWrite: {:<10d}", vldb.volumeId[kafs.RWVOL])
if vldb.volumeId[kafs.ROVOL] != 0:
outputf(" ROnly: {:<10d}", vldb.volumeId[kafs.ROVOL])
if vldb.volumeId[kafs.BACKVOL] != 0:
outputf(" Backup: {:<10d}", vldb.volumeId[kafs.BACKVOL])
output("\n")
display_vldb_site_list(params, vldb, " ")
def main(params):
cell = params["cell"]
if "users" in params and "groups" in params:
flags = kafs.PRWANTUSERS | kafs.PRWANTGROUPS
elif "groups" in params:
flags = kafs.PRWANTGROUPS
else:
flags = kafs.PRWANTUSERS
ret = cell.call_pt_server(params, kafs.PR_ListEntries, flags, 0)
output("Name ID Owner Creator\n")
for i in ret.entries:
outputf("{:24s} {:7d} {:7d} {:7d}\n", i.name, i.id, i.owner, i.creator)
def display_command_list(prog, cmdsetmod, commands):
output(prog, ": Commands are:\n")
for i in sorted(commands):
if i == "help":
desc = "Get help on commands"
elif i == "apropos":
desc = "Search by help text"
else:
command = cmdsetmod.get_command(i)
if hasattr(command, "alias"):
desc = "Alias for '" + command.alias + "'"
elif not hasattr(command, "help"):
desc = "** no help **"
else:
desc = command.help
outputf("{:<15s} {:s}\n", i, desc)
def display_instance_normal(params, bos_conn, name):
info = kafs.BOZO_GetInstanceInfo(bos_conn, name)
status = kafs.BOZO_GetStatus(bos_conn, name)
if info.status.flags & kafs.BOZO_BADDIRACCESS:
params["_baddiraccess"] = True
s = "Instance " + name + ","
if "long" in params:
s += " (type is " + info.type + ")"
# The instance's permanent state is shown by the goals returned by
# GetInstanceInfo()
if info.status.fileGoal == kafs.BSTAT_SHUTDOWN:
if info.status.goal == kafs.BSTAT_SHUTDOWN:
s += " disabled,"
else:
s += " temporarily enabled,"
else:
if info.status.goal == kafs.BSTAT_SHUTDOWN:
s += " temporarily disabled,"
else:
pass
# Supplementary data is found in the flags
if info.status.flags & kafs.BOZO_HASCORE:
s += " has core file,"
if info.status.flags & kafs.BOZO_ERRORSTOP:
s += " stopped for too many errors,"
# The instance's actual state is returned by GetStatus()
if status.inStat == kafs.BSTAT_SHUTDOWN:
s += " currently shut down."
elif status.inStat == kafs.BSTAT_NORMAL:
s += " currently running normally."
elif status.inStat == kafs.BSTAT_SHUTTINGDOWN:
s += " currently shutting down."
elif status.inStat == kafs.BSTAT_STARTINGUP:
s += " currently starting up."
output(s, "\n")
if status.statdescr != "":
output(" Auxiliary status is: ", status.statdescr, "\n")
return (info, status)
def main(params):
cell = params["cell"]
bos_conn = cell.open_bos_server(params["server"], params)
users = ""
try:
i = 0
while True:
ret = kafs.BOZO_ListSUsers(bos_conn, i)
i += 1
users += " " + ret.name
except kafs.RemoteAbort as msg:
if str(msg) == "Aborted 1":
pass
else:
raise
output("SUsers are:", users, "\n")
output("\n")
def display_command_arguments(args):
for arg in args:
if arg[2] == "fn" or arg[2][0] == "o":
opt_o = "["
opt_c = "]"
else:
opt_o = ""
opt_c = ""
output(" ", opt_o, "-", arg[0])
if arg[2] != "fn":
output(" ", arg[3])
output(opt_c)
output(" [-help]")
def main(params):
cell = params["cell"]
prcache = cell.get_prcache(params)
for name in params["nameorid"]:
prcache.precache_name_or_id(name)
results = []
for name in params["nameorid"]:
uid = prcache.name_or_id_to_id(name)
if uid == None:
error("User or group doesn't exist so couldn't look up id for " +
name + "\n")
if "force" not in params:
break
continue
try:
verbose("Listing entries owned by user ", uid, " (", name, ")\n")
ret = cell.call_pt_server(params, kafs.PR_ListOwned, uid, 0)
elist = ret.elist
for entry in elist:
prcache.precache_id(entry)
results.append((uid, elist))
except kafs.AbortPRNOENT:
error("User or group doesn't exist deleting ", name, " (id ", uid,
")\n")
if "force" not in params:
break
except kafs.AbortPRPERM:
error("Permission denied deleting ", name, " (id: ", uid, ")\n")
if "force" not in params:
break
for (uid, elist) in results:
output("Groups owned by ", prcache.id_to_name(uid), " (id: ", uid,
") are:\n")
for entry in elist:
output(" ", prcache.id_to_name(entry), "\n")
def print_record(params, vldb):
"""Display a single VLDB record"""
output(vldb.name, "\n")
output(" ")
flags = vldb.serverFlags[0]
if flags & kafs.VLSF_RWVOL:
outputf(" RWrite: {:<12d}", vldb.volumeId[0])
if flags & kafs.VLSF_ROVOL:
outputf(" ROnly: {:<12d}", vldb.volumeId[1])
if flags & kafs.VLSF_BACKVOL:
outputf(" Backup: {:<12d}", vldb.volumeId[2])
output("\n")
display_vldb_site_list(params, vldb, " ")
output("\n")
def display_vol_mp_basic_information(params, vol):
server = params["server"]
output("BEGIN_OF_ENTRY\n")
outputf("name\t\t{:s}\n", vol.name)
outputf("id\t\t{:d}\n", vol.volid)
outputf("serv\t\t{:<15s}\t{:s}\n", str(server), server.addr())
outputf("part\t\t{:s}\n", params["_partname"])
outputf("status\t\t{:s}\n", vol_status(vol))
outputf("backupID\t{:d}\n", vol.backupID)
outputf("parentID\t{:d}\n", vol.parentID)
outputf("cloneID\t\t{:d}\n", vol.cloneID)
outputf("inUse\t\t{:s}\n", yes_or_no(vol.inUse))
try:
outputf("needsSalvaged\t{:s}\n", yes_or_no(vol.needsSalvaged))
outputf("destroyMe\t{:s}\n", yes_or_no(vol.destroyMe))
except AttributeError:
pass
outputf("type\t\t{:s}\n", vol_type(vol))
outputf("creationDate\t{:<10d}\t{:s}\n", vol.creationDate,
time2str(vol.creationDate))
outputf("accessDate\t{:<10d}\t{:s}\n", vol.accessDate,
time2str(vol.accessDate))
outputf("updateDate\t{:<10d}\t{:s}\n", vol.updateDate,
time2str(vol.updateDate))
outputf("backupData\t{:<10d}\t{:s}\n", vol.backupDate,
time2str(vol.backupDate))
outputf("copyDate\t{:<10d}\t{:s}\n", vol.copyDate, time2str(vol.copyDate))
try:
outputf("flags\t\t{:<7d}\t(Optional)\n", vol.flags)
except AttributeError:
pass
outputf("diskused\t{:d}\n", vol.size)
outputf("maxquota\t{:d}\n", vol.maxquota)
try:
outputf("minquota\t{:<7d}\t(Optional)\n", vol.spare0)
except AttributeError:
pass
outputf("filecount\t{:d}\n", vol.filecount)
outputf("dayUse\t\t{:d}\n", vol.dayUse)
def main(params):
# Get a list of VLDB servers to query
cell = params["cell"]
z_conn = cell.open_vl_server(params)
quiet = "quiet" in params
if "name" in params:
ret = kafs.VL_GetEntryByName(z_conn, params["name"])
vldb = ret.entry
print_record(params, vldb)
return
attributes = kafs.VldbListByAttributes()
attributes.Mask = 0
if "server" in params:
attributes.Mask |= kafs.VLLIST_SERVER
attributes.server = params["server"].integer_addr()
if "partition" in params:
attributes.Mask |= kafs.VLLIST_PARTITION
attributes.partition = params["partition"]
if "locked" in params:
attributes.Mask |= kafs.VLLIST_FLAG
attributes.flag = kafs.VLOP_MOVE | kafs.VLOP_RELEASE | kafs.VLOP_BACKUP | kafs.VLOP_DELETE | kafs.VLOP_DUMP
ret = kafs.VL_ListAttributes(z_conn, attributes)
blkentries = ret.blkentries
if not quiet and "server" in params:
output("VLDB entries for server ", params["server"], "\n")
if "nosort" not in params:
blkentries.sort(key=lambda vldb: vldb.name)
for vldb in blkentries:
print_record(params, vldb)
if not quiet:
output("Total entries: ", len(blkentries), "\n")
def main(params):
cell = params["cell"]
bos_conn = cell.open_bos_server(params["server"], params)
if "dir" in params:
d = params["dir"]
else:
d = "/usr/afs/bin"
for f in params["file"]:
stat = os.stat(f)
fd = open(f, "rb")
split = split_handler(f, fd, stat.st_size)
i = f.rfind('/')
if i > -1:
f = f[i + 1:]
remote_file = d + "/" + f
verbose("Installing file ", remote_file, "\n")
ret = kafs.BOZO_Install(bos_conn, remote_file, stat.st_size, 0,
int(stat.st_mtime), split)
output(program_name, ": installed file ", f, "\n")
def main(params):
cell = params["cell"]
vol_conn = cell.open_volume_server(params["server"], params)
if "partition" not in params:
ret = kafs.VOLSER_ListPartitions(vol_conn)
partitions = ret.partIDs.partIds
else:
partitions = [params["partition"]]
for i in partitions:
if i != 0xffffffff:
partname = partition.id2part(i)
try:
ret = kafs.VOLSER_PartitionInfo(vol_conn, partname)
part = ret.partition
output("Free space on partition ", part.name, ": ", part.free,
" K blocks out of total ", part.totalUsable, "\n")
except kafs.AbortVOLSERILLEGAL_PARTITION:
error("partition ", partname,
" does not exist on the server\n")
def display_restart_time(params, desc, time):
if time.mask & kafs.KTIME_NEVER:
t = "never"
elif time.mask & kafs.KTIME_NOW:
t = "never"
elif time.mask & (kafs.KTIME_DAY | kafs.KTIME_TIME) == 0:
t = "[unspecified time]"
else:
t = "[unspecified time]"
if time.mask & kafs.KTIME_DAY:
t = restart_days[time.day] + " "
else:
t = ""
if time.mask & kafs.KTIME_TIME:
if not (time.mask & kafs.KTIME_MIN):
time.min = 0
if time.mask & kafs.KTIME_HOUR:
h = time.hour
if h > 12:
h -= 12
if h == 0:
h = 12
t += "{:d}:{:02d}".format(h, time.min)
else:
t += "xx:{:02d}".format(time.min)
if time.mask & kafs.KTIME_SEC:
t += ":{:02d}".format(time.sec)
if time.mask & kafs.KTIME_HOUR:
if time.hour < 12:
t += " am"
else:
t += " pm"
else:
pass
output(desc, t, "\n")
def list_one(params, vl_conn, attributes):
ret = kafs.VL_GetAddrsU(vl_conn, attributes)
if "printuuid" in params:
output("UUID: ", uuid2str(ret.uuidp1), "\n")
addrs = ret.blkaddrs
for a in addrs:
output(addrcache.resolve(params, a), "\n")
if "printuuid" in params:
output("\n")
def main(params):
cell = params["cell"]
vol_conn = cell.open_volume_server(params["server"], params)
ret = kafs.VOLSER_ListPartitions(vol_conn)
partitions = ret.partIDs.partIds
output("The partitions on the server are:\n")
parts = ""
n = 0
for i in partitions:
if i != 0xffffffff:
n += 1
output(" ", partition.id2part(i))
output("\n")
output("Total: ", n, "\n")
def display_aliases(prog, cmdsetmod, commands, topic):
aliases = []
for i in commands:
if i == "help" or i == "apropos":
continue
command = cmdsetmod.get_command(i)
if hasattr(command, "alias"):
if command.alias == topic:
aliases.append(i)
if aliases:
output("aliases: ", aliases[0])
if len(aliases) > 1:
for i in range(1, len(aliases)):
output(", ", aliases[i])
output("\n")
def display_format_extended(params, vol):
if vol.status == kafs.VBUSY:
output("VOLUME_BUSY\t{:d}\n", vol.volid)
return
elif vol.status != kafs.VOK:
output("COULD_NOT_ATTACH_VOLUME\t{:d}\n", vol.volid)
return
display_vol_mp_basic_information(params, vol)
for i in range(0, 4):
outputf("{:s}\t{:8d}\n", reads_labels[i], vol.stat_reads[i])
for i in range(0, 4):
outputf("{:s}\t{:8d}\n", writes_labels[i], vol.stat_writes[i])
for i in range(0, 6):
outputf("file_same_author_idx_{:d}\t{:8d}\n", i, vol.stat_fileSameAuthor[i])
outputf("file_diff_author_idx_{:d}\t{:8d}\n", i, vol.stat_fileDiffAuthor[i])
outputf("dir_same_author_idx_{:d}\t{:8d}\n", i, vol.stat_dirSameAuthor[i])
outputf("dir_dif_author_idx_{:d}\t{:8d}\n", i, vol.stat_dirDiffAuthor[i])
output("END_OF_ENTRY")
def main(params):
cell = params["cell"]
ret = cell.call_pt_server(params, kafs.PR_ListMax)
output("Max user id is ", ret.uid, " and max group id is ", ret.gid, ".\n")
def display_format(params, vldb, vol):
display_vol_mp_information(params, vol)
output("\n")
display_vldb(params, vldb)
def main(params):
cell = params["cell"]
prcache = cell.get_prcache(params)
for name in params["nameorid"]:
prcache.precache_name_or_id(name)
requests = []
memberships = dict()
for name in params["nameorid"]:
gid = prcache.name_or_id_to_id(name)
if gid == None:
error("User or group doesn't exist so couldn't look up id for " +
name + "\n")
if "force" not in params:
break
continue
if gid not in requests:
try:
if gid < 0:
# Group
verbose("Listing membership of ", gid, " (", name, ")\n")
group = prcache.id_to_group(gid)
prcache.precache_ids(group)
else:
# User - ListElements returns the ancestry of a non-group
ret = cell.call_pt_server(params, kafs.PR_ListElements,
gid)
elist = ret.elist
memberships[gid] = elist
prcache.precache_ids(elist)
for i in elist:
if i < 0:
prcache.id_to_group(i)
requests.append(gid)
except kafs.AbortPRNOENT:
error("User or group doesn't exist ", name, " (id ", gid,
")\n")
prcache.id_is_unknown(gid)
if "force" not in params:
break
except kafs.AbortPRPERM:
error("Permission denied on ID ", name, " (id: ", gid, ")\n")
prcache.id_is_unknown(gid)
if "force" not in params:
break
if "expandgroups" in params:
groups_needing_expansion = set(prcache.known_groups())
verbose("Expand groups ", groups_needing_expansion, "\n")
while groups_needing_expansion:
gid = groups_needing_expansion.pop()
members = prcache.id_to_group(gid)
for m in members:
prcache.precache_id(m)
if m < 0 and not prcache.have_group(
m) and m not in groups_needing_expansion:
groups_needing_expansion.add(m)
if "supergroups" in params:
for r in requests:
if r < 0:
ret = cell.call_pt_server(params, kafs.PR_ListGroupsMemberOf,
r)
glist = ret.glist
memberships[r] = glist
for r in requests:
# Display members of a group
if r < 0:
if "expandgroups" in params:
output("Expanded Members of ", prcache.id_to_name(r), " (id: ",
r, ") are:\n")
for m in prcache.id_to_expanded_group(r):
if m > 0:
output(" ", prcache.id_to_name(m), "\n")
else:
output("Members of ", prcache.id_to_name(r), " (id: ", r,
") are:\n")
for m in prcache.id_to_group(r):
output(" ", prcache.id_to_name(m), "\n")
# Display membership of a user or a group
if r > 0 and "expandgroups" in params:
output("Expanded Groups ", prcache.id_to_name(r), " (id: ", r,
") is a member of:\n")
member_of = memberships[r]
expanded = set(member_of)
for gid in member_of:
expanded |= prcache.id_to_expanded_group(gid)
for m in expanded:
if m < 0:
output(" ", prcache.id_to_name(m), "\n")
elif r > 0 or "supergroups" in params:
output("Groups ", prcache.id_to_name(r), " (id: ", r,
") is a member of:\n")
for gid in memberships[r]:
output(" ", prcache.id_to_name(gid), "\n")
def display_help_on_topics(prog, cmdsetmod, commands, topics):
for topic in topics:
if topic == "help":
output("bos help: ", help, "\n")
display_command_arguments(command_arguments)
continue
if topic == "apropos":
command = __import__("afs.apropos", globals(), locals(), ['*'])
output("bos apropos: ", command.help, "\n")
display_command_arguments(command.command_arguments)
continue
# See if the command is in the set
try:
found = False
for i in commands:
if i == topic:
found = topic
break
if i.startswith(topic):
if found:
raise RuntimeError("Ambiguous topic '" + topic +
"'; use 'apropos' to list\n")
found = i
if not found:
raise RuntimeError("Unknown topic '" + topic + "'\n")
topic = found
except RuntimeError as e:
error(e)
set_exitcode(5)
continue
# Load the command module
command = cmdsetmod.get_command(topic)
# If it's an alias, then switch to the real module
if hasattr(command, "alias"):
alias = " (alias for " + command.alias + ")"
command = cmdsetmod.get_command(command.alias)
else:
alias = ""
output(prog, " ", topic, ": ", command.help, alias, "\n")
display_aliases(prog, cmdsetmod, commands, topic)
output("Usage: ", prog, " ", topic)
display_command_arguments(command.command_arguments)
output("\n")
desc = command.description
if desc[0] == "\n":
desc = desc[1:]
output(desc)
def helpflag(prog, cmdsetmod, topic, command):
output("Usage: ", prog, " ", topic)
display_command_arguments(command.command_arguments)
output("\n")
