--- /dev/null
+include setup.py
+include kafs/*.c
+include kafs/*.h
+include rxgen/*.py
+include kafs/rpc-api/*.h
+include kafs/rpc-api/*.xg
-CFLAGS := $(shell python3-config --cflags)
-
-RXGEN := ./rxgen/rxgen.py $(wildcard ./rxgen/*.py)
-
-GENERATED := afs_xg.c afs_xg.h afs_py.c afs_py.h
-
-pykafs.so: $(GENERATED)
+build:
python3 setup.py build
-#AFS_API := rpc-api/afsuuid.h rpc-api/vldb.xg
-AFS_API := $(sort $(wildcard rpc-api/*.h)) $(sort $(wildcard rpc-api/*.xg))
+rpm:
+ python3 setup.py bdist_rpm
-.rxgen.check $(GENERATED): $(AFS_API) $(RXGEN)
- ./rxgen/rxgen.py $(AFS_API)
- touch .rxgen.check
+source_tarball:
+ python3 setup.py sdist
clean:
find \( -name "*~" -o -name "*.o" -o -name "*.so" \) -delete
- rm -rf build/
- rm -f $(GENERATED) .rxgen.check
+ rm -rf build/ dist/
+ rm -rf $(GENERATED) .rxgen.check
'site-packages')]
sys.path = local_path + sys.path
-from afs.main import main
+from kafs.main import main
if __name__ == '__main__':
main()
--- /dev/null
+These are the kAFS command line utilities.
--- /dev/null
+# -*- coding: utf-8 -*-
+
+__copyright__ = """
+Copyright (C) 2014 Red Hat, Inc. All Rights Reserved.
+Written by David Howells (dhowells@redhat.com)
+
+Derived from StGIT:
+
+Copyright (C) 2005, Catalin Marinas <catalin.marinas@gmail.com>
+Copyright (C) 2008, Karl Hasselström <kha@treskal.com>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public Licence version 2 as
+published by the Free Software Foundation.
+
+This program 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 Licence for more details.
+
+You should have received a copy of the GNU General Public Licence
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+"""
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs.exception import AFSException
-from afs.argparse import *
-from afs.lib.output import *
+from kafs.exception import AFSException
+from kafs.argparse import *
+from kafs.lib.output import *
help = "Search by help text"
matches = dict()
for i in commands:
if i == "help":
- command = __import__("afs.help", globals(), locals(), ['*'])
+ command = __import__("kafs.help", globals(), locals(), ['*'])
if topic in command.help.casefold():
matches["help"] = command.help
continue
2 of the Licence, or (at your option) any later version.
"""
-from exception import AFSArgumentError, AFSHelpFlag
-from afs.lib.output import set_verbosity
+from kafs.exception import AFSArgumentError, AFSHelpFlag
+from kafs.lib.output import set_verbosity
def get_cell(switch, params):
- from afs.lib.cell import cell
+ from kafs.lib.cell import cell
return cell(params[0])
def get_bosserver(switch, params):
- from afs.lib.bosserver import bosserver
+ from kafs.lib.bosserver import bosserver
return bosserver(params[0])
def get_fileserver(switch, params):
- from afs.lib.fileserver import fileserver
+ from kafs.lib.fileserver import fileserver
return fileserver(params[0])
def get_volserver(switch, params):
- from afs.lib.volserver import volserver
+ from kafs.lib.volserver import volserver
return volserver(params[0])
def get_vlservers(switch, params):
- from afs.lib.vlserver import vlserver
+ from kafs.lib.vlserver import vlserver
servers = []
for i in params:
servers.append(vlserver(params[0]))
return params
def get_partition_id(switch, params):
- from afs.lib.partition import part2id
+ from kafs.lib.partition import part2id
return part2id(params[0])
def get_auth(switch, params):
return params
def get_uuid(switch, params):
- from afs.lib.uuid import str2uuid
+ from kafs.lib.uuid import str2uuid
return str2uuid(params[0])
def get_string(switch, params):
import sys, os
-import afs.commands
-from afs.argparse import *
-from afs.lib.output import *
+import kafs.commands
+from kafs.argparse import *
+from kafs.lib.output import *
logfile = None
del s
# If we're starting from the "afs" program, we need to select the command set
- cmdsets = afs.commands.get_command_sets()
+ cmdsets = kafs.commands.get_command_sets()
#log("Command sets ", cmdsets, "\n")
if cmdset == "afs":
set_program_name("afs")
error("Unknown command set '", cmdset, "'\n")
sys.exit(1)
- cmdsetmod = afs.commands.import_command_set(cmdset)
+ cmdsetmod = kafs.commands.import_command_set(cmdset)
commands = cmdsetmod.get_command_list()
commands.append("help")
commands.append("apropos")
# Load the command
if cmd == "help":
- command = __import__("afs.help", globals(), locals(), ['*'])
+ command = __import__("kafs.help", globals(), locals(), ['*'])
elif cmd == "apropos":
- command = __import__("afs.apropos", globals(), locals(), ['*'])
+ command = __import__("kafs.apropos", globals(), locals(), ['*'])
else:
command = cmdsetmod.get_command(cmd)
# If it's an alias, then switch to the real module
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs.argparse import *
-from afs.lib.output import *
-import kafs
+from kafs.argparse import *
+from kafs.lib.output import *
+import kafs.rpc as rpc
help = "Add a database server machine to the CellServDB file"
]
argument_size_limits = {
- "host" : kafs.BOZO_BSSIZE,
+ "host" : rpc.BOZO_BSSIZE,
}
description = r"""
if "clone" in params:
name = "[" + name + "]"
verbose("Adding host ", name, "\n")
- ret = kafs.BOZO_AddCellHost(bos_conn, name)
+ ret = rpc.BOZO_AddCellHost(bos_conn, name)
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs.exception import AFSException
-from afs.argparse import *
-from afs.lib.output import *
-from afs.lib.time import *
-import kafs
+from kafs.exception import AFSException
+from kafs.argparse import *
+from kafs.lib.output import *
+from kafs.lib.time import *
+import kafs.rpc as rpc
from getpass import getpass
help = "Add a new server encryption key to the KeyFile file"
if passwd != passwd2:
raise RuntimeError("Input key mismatch")
- salted_passwd = kafs.afs_string_to_key(passwd, str(cell))
- key = kafs.bozo_key()
+ salted_passwd = rpc.afs_string_to_key(passwd, str(cell))
+ key = rpc.bozo_key()
key.data = salted_passwd
a = ""
verbose("Key: {:d}: ".format(len(key.data)), a, "\n")
try:
- ret = kafs.BOZO_AddKey(bos_conn, int(params["kvno"]), key)
- except kafs.AbortBZKVNOINUSE:
+ ret = rpc.BOZO_AddKey(bos_conn, int(params["kvno"]), key)
+ except rpc.AbortBZKVNOINUSE:
errorf("failed to set key {:s} (kvno already used - have to remove existing kvno's before reuse)\n", params["kvno"])
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs.argparse import *
-from afs.lib.output import *
-import kafs
+from kafs.argparse import *
+from kafs.lib.output import *
+import kafs.rpc as rpc
import sys
help = "Add a privileged user to the UserList file"
]
argument_size_limits = {
- "user" : kafs.BOZO_BSSIZE,
+ "user" : rpc.BOZO_BSSIZE,
}
description = r"""
for i in params["user"]:
try:
verbose("Adding user ", i, "\n")
- ret = kafs.BOZO_AddSUser(bos_conn, i)
- except kafs.RemoteAbort as e:
+ ret = rpc.BOZO_AddSUser(bos_conn, i)
+ except rpc.RemoteAbort as e:
if str(e) == "Aborted 17":
error("failed to add user ", i, " (File exists)\n")
exitcode = 1
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs.exception import AFSException, AFSArgumentError
-from afs.argparse import *
-from afs.lib.output import *
-import kafs
+from kafs.exception import AFSException, AFSArgumentError
+from kafs.argparse import *
+from kafs.lib.output import *
+import kafs.rpc as rpc
help = "Define a new process in the BosConfig file and start it"
]
argument_size_limits = {
- "instance" : kafs.BOZO_BSSIZE,
- "type" : kafs.BOZO_BSSIZE,
- "cmd" : kafs.BOZO_BSSIZE,
- "notifier" : kafs.BOZO_BSSIZE,
+ "instance" : rpc.BOZO_BSSIZE,
+ "type" : rpc.BOZO_BSSIZE,
+ "cmd" : rpc.BOZO_BSSIZE,
+ "notifier" : rpc.BOZO_BSSIZE,
}
description = r"""
bos_conn = cell.open_bos_server(params["server"], params)
try:
- ret = kafs.BOZO_CreateBnode(bos_conn, type, instance,
+ ret = rpc.BOZO_CreateBnode(bos_conn, type, instance,
cmd[0], cmd[1], cmd[2], cmd[3], cmd[4], cmd[5])
- except kafs.AbortBZEXISTS:
+ except rpc.AbortBZEXISTS:
error("failed to create new server instance ", instance,
" of type '", type, "' (entity already exists)\n")
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs.exception import AFSException
-from afs.argparse import *
-from afs.lib.output import *
-import kafs
+from kafs.exception import AFSException
+from kafs.argparse import *
+from kafs.lib.output import *
+import kafs.rpc as rpc
help = "Delete a server process from the BosConfig file"
]
argument_size_limits = {
- "instance" : kafs.BOZO_BSSIZE,
+ "instance" : rpc.BOZO_BSSIZE,
}
description = r"""
for i in params["instance"]:
verbose("Deleting instance ", i, "\n")
try:
- ret = kafs.BOZO_DeleteBnode(bos_conn, i)
- except kafs.AbortBZBUSY:
+ ret = rpc.BOZO_DeleteBnode(bos_conn, i)
+ except rpc.AbortBZBUSY:
error("can't delete running instance '", i, "'\n")
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs.exception import AFSArgumentError
-from afs.argparse import *
-from afs.lib.output import *
-import kafs
+from kafs.exception import AFSArgumentError
+from kafs.argparse import *
+from kafs.lib.output import *
+import kafs.rpc as rpc
help = "Execute a command on a remote server machine"
]
argument_size_limits = {
- "cmd" : kafs.BOZO_BSSIZE,
+ "cmd" : rpc.BOZO_BSSIZE,
}
description = r"""
bos_conn = cell.open_bos_server(params["server"], params)
try:
- ret = kafs.BOZO_Exec(bos_conn, params["cmd"])
- except kafs.RemoteAbort as e:
+ ret = rpc.BOZO_Exec(bos_conn, params["cmd"])
+ except rpc.RemoteAbort as e:
# If the command terminates with anything other than exit(0), the
# server aborts with the wait() status.
status = int(str(e)[8:])
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs.argparse import *
-from afs.lib.output import *
-from afs.lib.time import *
-import kafs
+from kafs.argparse import *
+from kafs.lib.output import *
+from kafs.lib.time import *
+import kafs.rpc as rpc
help = "Display the time stamps on an AFS binary file"
]
argument_size_limits = {
- "file" : kafs.BOZO_BSSIZE,
- "dir" : kafs.BOZO_BSSIZE,
+ "file" : rpc.BOZO_BSSIZE,
+ "dir" : rpc.BOZO_BSSIZE,
}
description = r"""
f = d + "/" + f
verbose("Asking about ", f, "\n")
- ret = kafs.BOZO_GetDates(bos_conn, f)
+ ret = rpc.BOZO_GetDates(bos_conn, f)
if ret.newtime == 0:
s = "File " + f + "does not exist, "
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs.exception import AFSException
-from afs.argparse import *
-from afs.lib.output import *
-import kafs
+from kafs.exception import AFSException
+from kafs.argparse import *
+from kafs.lib.output import *
+import kafs.rpc as rpc
import os
help = "Print a server process's log file"
]
argument_size_limits = {
- "file" : kafs.BOZO_BSSIZE,
+ "file" : rpc.BOZO_BSSIZE,
}
description = r"""
output("Fetching log file '", params["file"], "'...\n")
output_flush()
- ret = kafs.BOZO_GetLog(bos_conn, params["file"], split)
+ ret = rpc.BOZO_GetLog(bos_conn, params["file"], split)
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs.argparse import *
-from afs.lib.output import *
-import kafs
+from kafs.argparse import *
+from kafs.lib.output import *
+import kafs.rpc as rpc
help = "Display the automatic restart times for server processes"
restart_days = [ "sun", "mon", "tue", "wed", "thu", "fri", "sat" ]
def display_restart_time(params, desc, time):
- if time.mask & kafs.KTIME_NEVER:
+ if time.mask & rpc.KTIME_NEVER:
t = "never"
- elif time.mask & kafs.KTIME_NOW:
+ elif time.mask & rpc.KTIME_NOW:
t = "never"
- elif time.mask & (kafs.KTIME_DAY | kafs.KTIME_TIME) == 0:
+ elif time.mask & (rpc.KTIME_DAY | rpc.KTIME_TIME) == 0:
t = "[unspecified time]"
else:
t = "[unspecified time]"
- if time.mask & kafs.KTIME_DAY:
+ if time.mask & rpc.KTIME_DAY:
t = restart_days[time.day] + " ";
else:
t = ""
- if time.mask & kafs.KTIME_TIME:
- if not (time.mask & kafs.KTIME_MIN):
+ if time.mask & rpc.KTIME_TIME:
+ if not (time.mask & rpc.KTIME_MIN):
time.min = 0
- if time.mask & kafs.KTIME_HOUR:
+ if time.mask & rpc.KTIME_HOUR:
h = time.hour
if h > 12:
h -= 12
t += "{:d}:{:02d}".format(h, time.min)
else:
t += "xx:{:02d}".format(time.min)
- if time.mask & kafs.KTIME_SEC:
+ if time.mask & rpc.KTIME_SEC:
t += ":{:02d}".format(time.sec)
- if time.mask & kafs.KTIME_HOUR:
+ if time.mask & rpc.KTIME_HOUR:
if time.hour < 12:
t += " am"
else:
cell = params["cell"]
bos_conn = cell.open_bos_server(params["server"], params)
- gen = kafs.BOZO_GetRestartTime(bos_conn, kafs.BOZO_RESTARTTIME_GENERAL)
- newbin = kafs.BOZO_GetRestartTime(bos_conn, kafs.BOZO_RESTARTTIME_NEWBIN)
+ gen = rpc.BOZO_GetRestartTime(bos_conn, rpc.BOZO_RESTARTTIME_GENERAL)
+ newbin = rpc.BOZO_GetRestartTime(bos_conn, rpc.BOZO_RESTARTTIME_NEWBIN)
s = "Server " + params["server"].name() + " restarts "
display_restart_time(params, s + "at ", gen.restartTime)
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs.argparse import *
-from afs.lib.output import *
-import kafs
+from kafs.argparse import *
+from kafs.lib.output import *
+import kafs.rpc as rpc
help = "Display whether a bos server is restricted or not"
cell = params["cell"]
bos_conn = cell.open_bos_server(params["server"], params)
- ret = kafs.BOZO_GetRestricted(bos_conn)
+ ret = rpc.BOZO_GetRestricted(bos_conn)
if ret.isrestricted:
output("Restricted mode is on\n")
else:
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs.exception import AFSException
-from afs.argparse import *
-from afs.lib.output import *
-import kafs
+from kafs.exception import AFSException
+from kafs.argparse import *
+from kafs.lib.output import *
+import kafs.rpc as rpc
import os
help = "Revert to the former version of a process's binary file"
]
argument_size_limits = {
- "file" : kafs.BOZO_BSSIZE,
- "dir" : kafs.BOZO_BSSIZE,
+ "file" : rpc.BOZO_BSSIZE,
+ "dir" : rpc.BOZO_BSSIZE,
}
description = r"""
remote_file = d + "/" + f
verbose("Installing file ", remote_file, "\n")
- ret = kafs.BOZO_Install(bos_conn, remote_file, stat.st_size, 0,
+ ret = rpc.BOZO_Install(bos_conn, remote_file, stat.st_size, 0,
int(stat.st_mtime), split)
output(program_name, ": installed file ", f, "\n");
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs.argparse import *
-from afs.lib.output import *
-import kafs
+from kafs.argparse import *
+from kafs.lib.output import *
+import kafs.rpc as rpc
help = "Display the contents of the CellServDB file"
cell = params["cell"]
bos_conn = cell.open_bos_server(params["server"], params)
- ret = kafs.BOZO_GetCellName(bos_conn)
+ ret = rpc.BOZO_GetCellName(bos_conn)
cellname = ret.name
output("Cell name is ", cellname, "\n")
try:
i = 0
while True:
- ret = kafs.BOZO_GetCellHost(bos_conn, i)
+ ret = rpc.BOZO_GetCellHost(bos_conn, i)
i += 1
output("Host ", i, " is ", ret.name, "\n")
- except kafs.AbortBZDOM:
+ except rpc.AbortBZDOM:
pass
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs.exception import AFSException
-from afs.argparse import *
-from afs.lib.output import *
-from afs.lib.time import *
-import kafs
+from kafs.exception import AFSException
+from kafs.argparse import *
+from kafs.lib.output import *
+from kafs.lib.time import *
+import kafs.rpc as rpc
help = "Display the server encryption keys from the KeyFile file"
try:
i = 0
while True:
- ret = kafs.BOZO_ListKeys(bos_conn, i)
+ ret = rpc.BOZO_ListKeys(bos_conn, i)
i += 1
if mod_sec < ret.keinfo.mod_sec:
mod_sec = ret.keinfo.mod_sec
else:
output(" has cksum ", ret.keinfo.keyCheckSum, "\n")
- except kafs.AbortBZDOM:
+ except rpc.AbortBZDOM:
pass
output("Keys last changed on ", time2str(mod_sec), ".\n")
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs.argparse import *
-from afs.lib.output import *
-import kafs
+from kafs.argparse import *
+from kafs.lib.output import *
+import kafs.rpc as rpc
help = "List the privileged users from the UserList file"
try:
i = 0
while True:
- ret = kafs.BOZO_ListSUsers(bos_conn, i)
+ ret = rpc.BOZO_ListSUsers(bos_conn, i)
i += 1
users += " " + ret.name
- except kafs.RemoteAbort as msg:
+ except rpc.RemoteAbort as msg:
if str(msg) == "Aborted 1":
pass
else:
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs.exception import AFSArgumentError
-from afs.argparse import *
-from afs.lib.output import *
-import kafs
+from kafs.exception import AFSArgumentError
+from kafs.argparse import *
+from kafs.lib.output import *
+import kafs.rpc as rpc
help = "Remove obsolete files from /usr/afs/bin and /usr/afs/logs"
else:
flags = 0
if "bak" in params:
- flags |= kafs.BOZO_PRUNEBAK
+ flags |= rpc.BOZO_PRUNEBAK
if "old" in params:
- flags |= kafs.BOZO_PRUNEOLD
+ flags |= rpc.BOZO_PRUNEOLD
if "core" in params:
- flags |= kafs.BOZO_PRUNECORE
- ret = kafs.BOZO_Prune(bos_conn, flags)
+ flags |= rpc.BOZO_PRUNECORE
+ ret = rpc.BOZO_Prune(bos_conn, flags)
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs.argparse import *
-from afs.lib.output import *
-import kafs
+from kafs.argparse import *
+from kafs.lib.output import *
+import kafs.rpc as rpc
import sys
help = "Remove a database server machine from the CellServDB file"
for i in params["host"]:
try:
verbose("Deleting host ", i.name(), "\n")
- ret = kafs.BOZO_DeleteCellHost(bos_conn, i.name())
- except kafs.AbortBZNOENT:
+ ret = rpc.BOZO_DeleteCellHost(bos_conn, i.name())
+ except rpc.AbortBZNOENT:
error("failed to delete host ", i.name(), " (no such entity)\n")
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs.exception import AFSException
-from afs.argparse import *
-from afs.lib.output import *
-from afs.lib.time import *
-import kafs
+from kafs.exception import AFSException
+from kafs.argparse import *
+from kafs.lib.output import *
+from kafs.lib.time import *
+import kafs.rpc as rpc
help = "Remove server encryption keys from the KeyFile file"
try:
for i in params["kvno"]:
trying = i
- ret = kafs.BOZO_DeleteKey(bos_conn, int(i))
- except kafs.RemoteAbort as e:
+ ret = rpc.BOZO_DeleteKey(bos_conn, int(i))
+ except rpc.RemoteAbort as e:
if str(e) != "Aborted 70354689":
raise
errorf("failed to delete key {:s} (could not find entry)\n", trying)
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs.argparse import *
-from afs.lib.output import *
-import kafs
+from kafs.argparse import *
+from kafs.lib.output import *
+import kafs.rpc as rpc
import sys
help = "Remove a privileged user from the UserList file"
]
argument_size_limits = {
- "user" : kafs.BOZO_BSSIZE,
+ "user" : rpc.BOZO_BSSIZE,
}
description = r"""
for i in params["user"]:
try:
verbose("Deleting suser ", i, "\n")
- ret = kafs.BOZO_DeleteSUser(bos_conn, i)
- except kafs.RemoteAbort as e:
+ ret = rpc.BOZO_DeleteSUser(bos_conn, i)
+ except rpc.RemoteAbort as e:
if str(e) == "Aborted 2":
error("failed to delete user ", i, " (no such user)\n")
else:
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs.exception import AFSArgumentError
-from afs.argparse import *
-from afs.lib.output import *
-import kafs
+from kafs.exception import AFSArgumentError
+from kafs.argparse import *
+from kafs.lib.output import *
+import kafs.rpc as rpc
help = "Restart a server process"
]
argument_size_limits = {
- "instance" : kafs.BOZO_BSSIZE,
+ "instance" : rpc.BOZO_BSSIZE,
}
description = r"""
bos_conn = cell.open_bos_server(params["server"], params)
if "all" in params:
- ret = kafs.BOZO_RestartAll(bos_conn)
+ ret = rpc.BOZO_RestartAll(bos_conn)
elif "bosserver" in params:
- ret = kafs.BOZO_ReBozo(bos_conn)
+ ret = rpc.BOZO_ReBozo(bos_conn)
elif "instance" in params:
for i in params["instance"]:
try:
verbose("Restarting ", i, "\n")
- ret = kafs.BOZO_Restart(bos_conn, i)
- except kafs.AbortBZNOENT:
+ ret = rpc.BOZO_Restart(bos_conn, i)
+ except rpc.AbortBZNOENT:
error("failed to start instance '", i, "' (no such entity)\n")
else:
raise AFSArgumentError("One of -all, -bosserver or -instance must be supplied")
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs.exception import AFSArgumentError
-from afs.argparse import *
-from afs.lib.output import *
-import kafs
+from kafs.exception import AFSArgumentError
+from kafs.argparse import *
+from kafs.lib.output import *
+import kafs.rpc as rpc
help = "Set authorization checking requirements for all server processes"
bos_conn = cell.open_bos_server(params["server"], params)
try:
- ret = kafs.BOZO_SetNoAuthFlag(bos_conn, auth == "off")
- except kafs.AbortBZACCESS:
+ ret = rpc.BOZO_SetNoAuthFlag(bos_conn, auth == "off")
+ except rpc.AbortBZACCESS:
error("you are not authorized for this operation (failed to set authentication flag)\n")
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs.argparse import *
-from afs.lib.output import *
-import kafs
+from kafs.argparse import *
+from kafs.lib.output import *
+import kafs.rpc as rpc
help = "Display whether a bos server is restricted or not"
]
argument_size_limits = {
- "name" : kafs.BOZO_BSSIZE,
+ "name" : rpc.BOZO_BSSIZE,
}
description = r"""
cell = params["cell"]
bos_conn = cell.open_bos_server(params["server"], params)
- ret = kafs.BOZO_SetCellName(bos_conn, str(params["name"]))
+ ret = rpc.BOZO_SetCellName(bos_conn, str(params["name"]))
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from exception import AFSArgumentError
-from afs.argparse import *
-from afs.lib.output import *
-from afs.lib.parse_setrestart_time import *
-import kafs
+from kafs.exception import AFSArgumentError
+from kafs.argparse import *
+from kafs.lib.output import *
+from kafs.lib.parse_setrestart_time import *
+import kafs.rpc as rpc
help = "Set when the BOS Server restarts processes"
time = params["time"]
- t = kafs.BOZO_RESTARTTIME_GENERAL
+ t = rpc.BOZO_RESTARTTIME_GENERAL
if "newbinary" in params:
- t = kafs.BOZO_RESTARTTIME_NEWBIN
+ t = rpc.BOZO_RESTARTTIME_NEWBIN
- ret = kafs.BOZO_SetRestartTime(bos_conn, t, time)
+ ret = rpc.BOZO_SetRestartTime(bos_conn, t, time)
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs.argparse import *
-from afs.lib.output import *
-import kafs
+from kafs.argparse import *
+from kafs.lib.output import *
+import kafs.rpc as rpc
help = "Place a server into restricted mode"
raise AFSArgumentError("The -mode argument takes a numeric value")
try:
- ret = kafs.BOZO_SetRestricted(bos_conn, int(params["mode"]))
- except kafs.AbortBZACCESS:
+ ret = rpc.BOZO_SetRestricted(bos_conn, int(params["mode"]))
+ except rpc.AbortBZACCESS:
error("failed to set restricted mode (you are not authorized for this operation)\n")
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs.exception import AFSException
-from afs.argparse import *
-from afs.lib.output import *
-import kafs
+from kafs.exception import AFSException
+from kafs.argparse import *
+from kafs.lib.output import *
+import kafs.rpc as rpc
help = "Stop a process without changing its status flag"
]
argument_size_limits = {
- "instance" : kafs.BOZO_BSSIZE,
+ "instance" : rpc.BOZO_BSSIZE,
}
description = r"""
for i in params["instance"]:
try:
verbose("Shutting down ", i, "\n");
- ret = kafs.BOZO_SetTStatus(bos_conn, i, kafs.BSTAT_SHUTDOWN)
- except kafs.AbortBZNOENT:
+ ret = rpc.BOZO_SetTStatus(bos_conn, i, rpc.BSTAT_SHUTDOWN)
+ except rpc.AbortBZNOENT:
error("failed to shutdown instance '", i, "' (no such entity)\n")
error_occurred = True
else:
- ret = kafs.BOZO_ShutdownAll(bos_conn)
+ ret = rpc.BOZO_ShutdownAll(bos_conn)
if not error_occurred and "wait" in params:
verbose("Waiting\n")
- ret = kafs.BOZO_WaitAll(bos_conn)
+ ret = rpc.BOZO_WaitAll(bos_conn)
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs.exception import AFSException
-from afs.argparse import *
-from afs.lib.output import *
-import kafs
+from kafs.exception import AFSException
+from kafs.argparse import *
+from kafs.lib.output import *
+import kafs.rpc as rpc
help = "Start a process after setting its status flag"
]
argument_size_limits = {
- "instance" : kafs.BOZO_BSSIZE,
+ "instance" : rpc.BOZO_BSSIZE,
}
description = r"""
for i in params["instance"]:
try:
verbose("Starting ", i, "\n")
- ret = kafs.BOZO_SetStatus(bos_conn, i, kafs.BSTAT_NORMAL)
- except kafs.AbortBZNOENT:
+ ret = rpc.BOZO_SetStatus(bos_conn, i, rpc.BSTAT_NORMAL)
+ except rpc.AbortBZNOENT:
error("failed to start instance '", i, "' (no such entity)\n")
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs.exception import AFSException
-from afs.argparse import *
-from afs.lib.output import *
-import kafs
+from kafs.exception import AFSException
+from kafs.argparse import *
+from kafs.lib.output import *
+import kafs.rpc as rpc
help = "Start a process without changing its status flag"
]
argument_size_limits = {
- "instance" : kafs.BOZO_BSSIZE,
+ "instance" : rpc.BOZO_BSSIZE,
}
description = r"""
for i in params["instance"]:
try:
verbose("Starting ", i, "\n")
- ret = kafs.BOZO_SetTStatus(bos_conn, i, kafs.BSTAT_NORMAL)
- except kafs.AbortBZNOENT:
+ ret = rpc.BOZO_SetTStatus(bos_conn, i, rpc.BSTAT_NORMAL)
+ except rpc.AbortBZNOENT:
error("failed to start instance '", i, "' (no such entity)\n")
else:
- ret = kafs.BOZO_StartupAll(bos_conn)
+ ret = rpc.BOZO_StartupAll(bos_conn)
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs.argparse import *
-from afs.lib.output import *
-from afs.lib.time import *
-import kafs
+from kafs.argparse import *
+from kafs.lib.output import *
+from kafs.lib.time import *
+import kafs.rpc as rpc
import sys
import signal
]
argument_size_limits = {
- "instance" : kafs.BOZO_BSSIZE,
+ "instance" : rpc.BOZO_BSSIZE,
}
description = r"""
"""
def display_instance_normal(params, bos_conn, name):
- info = kafs.BOZO_GetInstanceInfo(bos_conn, name)
- status = kafs.BOZO_GetStatus(bos_conn, name)
+ info = rpc.BOZO_GetInstanceInfo(bos_conn, name)
+ status = rpc.BOZO_GetStatus(bos_conn, name)
- if info.status.flags & kafs.BOZO_BADDIRACCESS:
+ if info.status.flags & rpc.BOZO_BADDIRACCESS:
params["_baddiraccess"] = True
s = "Instance " + name + ","
# 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:
+ if info.status.fileGoal == rpc.BSTAT_SHUTDOWN:
+ if info.status.goal == rpc.BSTAT_SHUTDOWN:
s += " disabled,"
else:
s += " temporarily enabled,"
else:
- if info.status.goal == kafs.BSTAT_SHUTDOWN:
+ if info.status.goal == rpc.BSTAT_SHUTDOWN:
s += " temporarily disabled,"
else:
pass
# Supplementary data is found in the flags
- if info.status.flags & kafs.BOZO_HASCORE:
+ if info.status.flags & rpc.BOZO_HASCORE:
s += " has core file,"
- if info.status.flags & kafs.BOZO_ERRORSTOP:
+ if info.status.flags & rpc.BOZO_ERRORSTOP:
s += " stopped for too many errors,"
# The instance's actual state is returned by GetStatus()
- if status.inStat == kafs.BSTAT_SHUTDOWN:
+ if status.inStat == rpc.BSTAT_SHUTDOWN:
s += " currently shut down."
- elif status.inStat == kafs.BSTAT_NORMAL:
+ elif status.inStat == rpc.BSTAT_NORMAL:
s += " currently running normally."
- elif status.inStat == kafs.BSTAT_SHUTTINGDOWN:
+ elif status.inStat == rpc.BSTAT_SHUTTINGDOWN:
s += " currently shutting down."
- elif status.inStat == kafs.BSTAT_STARTINGUP:
+ elif status.inStat == rpc.BSTAT_STARTINGUP:
s += " currently starting up."
output(s, "\n")
if status.statdescr != "":
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)
+ istr = rpc.BOZO_GetInstanceStrings(bos_conn, name)
if istr.errorname != "":
s += " by " + istr.errorname + ","
if info.status.errorSignal == signal.SIGTERM:
try:
i = 0
while True:
- ret = kafs.BOZO_GetInstanceParm(bos_conn, name, i)
+ ret = rpc.BOZO_GetInstanceParm(bos_conn, name, i)
i += 1
output(" Command ", i, " is '", ret.parm, "'\n")
- except kafs.AbortBZDOM:
+ except rpc.AbortBZDOM:
pass
output("\n")
i = 0
while True:
verbose("Enum ", i, ": ")
- ret = kafs.BOZO_EnumerateInstance(bos_conn, i)
+ ret = rpc.BOZO_EnumerateInstance(bos_conn, i)
i += 1
verbose_cont(ret.iname, "\n")
instances.append(ret.iname)
- except kafs.AbortBZDOM:
+ except rpc.AbortBZDOM:
verbose_cont("<empty slot>\n")
else:
instances = params["instance"]
display_instance_long(params, bos_conn, i)
else:
display_instance_normal(params, bos_conn, i)
- except kafs.AbortBZNOENT:
+ except rpc.AbortBZNOENT:
error("failed to get instance info for '", i, "' (no such entity)\n")
if "_baddiraccess" in params and "long" in params:
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs.exception import AFSException
-from afs.argparse import *
-from afs.lib.output import *
-import kafs
+from kafs.exception import AFSException
+from kafs.argparse import *
+from kafs.lib.output import *
+import kafs.rpc as rpc
help = "Stop a process after changing its status flag"
]
argument_size_limits = {
- "instance" : kafs.BOZO_BSSIZE,
+ "instance" : rpc.BOZO_BSSIZE,
}
description = r"""
for i in params["instance"]:
try:
verbose("Stopping ", i, "\n")
- ret = kafs.BOZO_SetStatus(bos_conn, i, kafs.BSTAT_SHUTDOWN)
- except kafs.AbortBZNOENT:
+ ret = rpc.BOZO_SetStatus(bos_conn, i, rpc.BSTAT_SHUTDOWN)
+ except rpc.AbortBZNOENT:
error("failed to change stop instance '", i, "' (no such entity)")
error_occurred = True
if not error_occurred and "wait" in params:
verbose("Waiting\n")
- ret = kafs.BOZO_WaitAll(bos_conn)
+ ret = rpc.BOZO_WaitAll(bos_conn)
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs.exception import AFSException
-from afs.argparse import *
-from afs.lib.output import *
-import kafs
+from kafs.exception import AFSException
+from kafs.argparse import *
+from kafs.lib.output import *
+import kafs.rpc as rpc
help = "Revert to the former version of a process's binary file"
]
argument_size_limits = {
- "file" : kafs.BOZO_BSSIZE,
- "dir" : kafs.BOZO_BSSIZE,
+ "file" : rpc.BOZO_BSSIZE,
+ "dir" : rpc.BOZO_BSSIZE,
}
description = r"""
verbose("Reverting file ", f, "\n")
try:
- ret = kafs.BOZO_UnInstall(bos_conn, f)
- except kafs.AbortBZBUSY:
+ ret = rpc.BOZO_UnInstall(bos_conn, f)
+ except rpc.AbortBZBUSY:
error("can't revert running instance '", f, "'\n")
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs.argparse import *
-from afs.lib.output import *
-import kafs
+from kafs.argparse import *
+from kafs.lib.output import *
+import kafs.rpc as rpc
help = "Add a user or machine to a Protection Database group"
]
argument_size_limits = {
- "name" : kafs.PR_MAXNAMELEN,
+ "name" : rpc.PR_MAXNAMELEN,
}
description = r"""
continue
try:
- ret = cell.call_pt_server(params, kafs.PR_AddToGroup, uid, gid)
+ ret = cell.call_pt_server(params, rpc.PR_AddToGroup, uid, gid)
prcache.evict_groups()
- except kafs.AbortPRIDEXIST:
+ except rpc.AbortPRIDEXIST:
error("Entry for id already exists ; unable to add user ", user, " to group ", group, ignored, "\n")
if "force" not in params:
return
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs.argparse import *
-from afs.lib.output import *
-import kafs
+from kafs.argparse import *
+from kafs.lib.output import *
+import kafs.rpc as rpc
import sys
help = "Change the owner of a Protection Database entry"
]
argument_size_limits = {
- "oldname" : kafs.PR_MAXNAMELEN,
- "owner" : kafs.PR_MAXNAMELEN,
+ "oldname" : rpc.PR_MAXNAMELEN,
+ "owner" : rpc.PR_MAXNAMELEN,
}
description = r"""
try:
verbose("Chowning ", gid, " to ", owner, "\n")
- ret = cell.call_pt_server(params, kafs.PR_ChangeEntry, gid, "", owner, 0)
+ ret = cell.call_pt_server(params, rpc.PR_ChangeEntry, gid, "", owner, 0)
# The name is changed by the act of chowning (group names are prefixed
# by the owner user name and a colon, and the prefix gets changed)
prcache.evict_id(gid)
prcache.evict_groups()
- except kafs.AbortPRNOENT:
+ except rpc.AbortPRNOENT:
error("User or group doesn't exist ; unable to change name of ",
prcache.id_to_name(gid), " to ", params["owner"], "\n")
- except kafs.AbortPRPERM:
+ except rpc.AbortPRPERM:
error("Permission denied ; unable to change name of ",
prcache.id_to_name(gid), " to ", prcache.id_to_name(owner), "\n")
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs.argparse import *
-from afs.lib.output import *
-import kafs
+from kafs.argparse import *
+from kafs.lib.output import *
+import kafs.rpc as rpc
import sys
help = "Create an (empty) Protection Database group entry"
]
argument_size_limits = {
- "name" : kafs.PR_MAXNAMELEN,
+ "name" : rpc.PR_MAXNAMELEN,
}
description = r"""
verbose("Adding group ", name, "\n")
if i < len(ids):
new_id = int(ids[i])
- ret = cell.call_pt_server(params, kafs.PR_INewEntry, name, new_id, oid)
+ ret = cell.call_pt_server(params, rpc.PR_INewEntry, name, new_id, oid)
else:
- ret = cell.call_pt_server(params, kafs.PR_NewEntry, name, kafs.PRGRP, oid)
+ ret = cell.call_pt_server(params, rpc.PR_NewEntry, name, rpc.PRGRP, oid)
new_id = ret.id
output("Group ", name, " has id ", new_id, "\n")
prcache.evict_name(name)
prcache.evict_id(new_id)
- except kafs.AbortPREXIST:
+ except rpc.AbortPREXIST:
error("Entry for name already exists ; unable to create group ", name, "\n")
if "force" not in params:
break
- except kafs.AbortPRIDEXIST:
+ except rpc.AbortPRIDEXIST:
error("Entry for id already exists ; unable to create group ", name, " with id ", new_id, "\n")
if "force" not in params:
break
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs.argparse import *
-from afs.lib.output import *
-import kafs
+from kafs.argparse import *
+from kafs.lib.output import *
+import kafs.rpc as rpc
import sys
help = "Create a user or machine entry in the Protection Database"
]
argument_size_limits = {
- "name" : kafs.PR_MAXNAMELEN,
+ "name" : rpc.PR_MAXNAMELEN,
}
description = r"""
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)
+ ret = cell.call_pt_server(params, rpc.PR_NewEntry, name, new_id, 0)
else:
- ret = cell.call_pt_server(params, kafs.PR_NewEntry, name, 0, 0)
+ ret = cell.call_pt_server(params, rpc.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:
+ except rpc.AbortPREXIST:
error("Entry for name already exists ; unable to create user ", name, "\n")
if "force" not in params:
break
- except kafs.AbortPRIDEXIST:
+ except rpc.AbortPRIDEXIST:
error("Entry for id already exists ; unable to create user ", name, " with id ", new_id, "\n")
if "force" not in params:
break
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs.argparse import *
-from afs.lib.output import *
-import kafs
+from kafs.argparse import *
+from kafs.lib.output import *
+import kafs.rpc as rpc
import sys
help = "Delete a Protection Database entry"
]
argument_size_limits = {
- "nameorid" : kafs.PR_MAXNAMELEN,
+ "nameorid" : rpc.PR_MAXNAMELEN,
}
description = r"""
try:
verbose("Deleting user ", uid, " (", prcache.id_to_name(uid), ")\n")
- ret = cell.call_pt_server(params, kafs.PR_Delete, uid)
+ ret = cell.call_pt_server(params, rpc.PR_Delete, uid)
prcache.evict_id(uid)
prcache.evict_groups()
- except kafs.AbortPRNOENT:
+ except rpc.AbortPRNOENT:
error("User or group doesn't exist deleting ", name, " (id ", uid, ")\n")
if "force" not in params:
break
- except kafs.AbortPRPERM:
+ except rpc.AbortPRPERM:
error("Permission denied deleting ", name, " (id: ", uid, ")\n")
if "force" not in params:
break
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs.argparse import *
-from afs.lib.output import *
-import kafs
+from kafs.argparse import *
+from kafs.lib.output import *
+import kafs.rpc as rpc
import sys
help = "Display a Protection Database entry"
]
argument_size_limits = {
- "nameorid" : kafs.PR_MAXNAMELEN,
+ "nameorid" : rpc.PR_MAXNAMELEN,
}
description = r"""
if uid not in results:
try:
verbose("Listing entry for ", uid, " (", name, ")\n")
- ret = cell.call_pt_server(params, kafs.PR_ListEntry, uid)
+ ret = cell.call_pt_server(params, rpc.PR_ListEntry, uid)
entry = ret.entry
results[uid] = entry
requests.append(uid)
prcache.precache_id(entry.owner)
prcache.precache_id(entry.creator)
- except kafs.AbortPRNOENT:
+ except rpc.AbortPRNOENT:
error("User or group doesn't exist examining ", name, " (id ", uid, ")\n")
prcache.id_is_unknown(uid)
- except kafs.AbortPRPERM:
+ except rpc.AbortPRPERM:
error("Permission denied examining ", name, " (id: ", uid, ")\n")
# Display the results
eflags = entry.flags << 16
flags = ""
# Indicate who can use "pts examine"
- if eflags & kafs.PRP_STATUS_ANY:
+ if eflags & rpc.PRP_STATUS_ANY:
flags += "S" # Anyone
- elif eflags & kafs.PRP_STATUS_MEM:
+ elif eflags & rpc.PRP_STATUS_MEM:
flags += "s" # Members only
else:
flags += "-" # Should not exist
# Indicate who can use "pts listowned"
- if eflags & kafs.PRP_OWNED_ANY:
+ if eflags & rpc.PRP_OWNED_ANY:
flags += "O" # Anyone
else:
flags += "-" # Sysadmin & Group owner only
# Indicate who can use "pts membership"
- if eflags & kafs.PRP_MEMBER_ANY:
+ if eflags & rpc.PRP_MEMBER_ANY:
flags += "M" # Anyone
- elif eflags & kafs.PRP_MEMBER_MEM:
+ elif eflags & rpc.PRP_MEMBER_MEM:
flags += "m" # Members only
else:
flags += "-" # Sysadmin & User can list which groups they belong to
# Indicate who can use "pts adduser"
- if eflags & kafs.PRP_ADD_ANY:
+ if eflags & rpc.PRP_ADD_ANY:
flags += "A" # Anyone
- elif eflags & kafs.PRP_ADD_MEM:
+ elif eflags & rpc.PRP_ADD_MEM:
flags += "a" # Members only
else:
flags += "-" # Sysadmin & Group owner only
# Indicate who can use "pts removeuser"
- if eflags & kafs.PRP_REMOVE_MEM:
+ if eflags & rpc.PRP_REMOVE_MEM:
flags += "r" # Members can remove other members
else:
flags += "-" # Sysadmin & Group owner only
# The group quota being 'unlimited' seems to depend on being a member
# of the system:administrators group and/or having zero ngroups (or
# possibly something else)
- verbose("Is ", entry.id, " a member of ", kafs.PR_SYSADMINID, "?\n")
- ret = cell.call_pt_server(params, kafs.PR_IsAMemberOf, entry.id, kafs.PR_SYSADMINID)
+ verbose("Is ", entry.id, " a member of ", rpc.PR_SYSADMINID, "?\n")
+ ret = cell.call_pt_server(params, rpc.PR_IsAMemberOf, entry.id, rpc.PR_SYSADMINID)
group_quota = entry.ngroups
if ret.flag or entry.ngroups == 0:
group_quota = "unlimited"
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs.argparse import *
-from afs.lib.output import *
-import kafs
+from kafs.argparse import *
+from kafs.lib.output import *
+import kafs.rpc as rpc
import sys
help = "Display all users or groups in the Protection Database"
cell = params["cell"]
if "users" in params and "groups" in params:
- flags = kafs.PRWANTUSERS | kafs.PRWANTGROUPS
+ flags = rpc.PRWANTUSERS | rpc.PRWANTGROUPS
elif "groups" in params:
- flags = kafs.PRWANTGROUPS
+ flags = rpc.PRWANTGROUPS
else:
- flags = kafs.PRWANTUSERS
+ flags = rpc.PRWANTUSERS
- ret = cell.call_pt_server(params, kafs.PR_ListEntries, flags, 0)
+ ret = cell.call_pt_server(params, rpc.PR_ListEntries, flags, 0)
output("Name ID Owner Creator\n")
for i in ret.entries:
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs.argparse import *
-from afs.lib.output import *
-import kafs
+from kafs.argparse import *
+from kafs.lib.output import *
+import kafs.rpc as rpc
import sys
help = "Display the max user id and max group id counters"
def main(params):
cell = params["cell"]
- ret = cell.call_pt_server(params, kafs.PR_ListMax)
+ ret = cell.call_pt_server(params, rpc.PR_ListMax)
output("Max user id is ", ret.uid, " and max group id is ", ret.gid, ".\n")
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs.argparse import *
-from afs.lib.output import *
-import kafs
+from kafs.argparse import *
+from kafs.lib.output import *
+import kafs.rpc as rpc
import sys
help = "Show the Protection Database groups owned by a user or group"
]
argument_size_limits = {
- "nameorid" : kafs.PR_MAXNAMELEN,
+ "nameorid" : rpc.PR_MAXNAMELEN,
}
description = r"""
try:
verbose("Listing entries owned by user ", uid, " (", name, ")\n")
- ret = cell.call_pt_server(params, kafs.PR_ListOwned, uid, 0)
+ ret = cell.call_pt_server(params, rpc.PR_ListOwned, uid, 0)
elist = ret.elist
for entry in elist:
prcache.precache_id(entry)
results.append((uid, elist))
- except kafs.AbortPRNOENT:
+ except rpc.AbortPRNOENT:
error("User or group doesn't exist deleting ", name, " (id ", uid, ")\n")
if "force" not in params:
break
- except kafs.AbortPRPERM:
+ except rpc.AbortPRPERM:
error("Permission denied deleting ", name, " (id: ", uid, ")\n")
if "force" not in params:
break
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs.argparse import *
-from afs.lib.output import *
-import kafs
+from kafs.argparse import *
+from kafs.lib.output import *
+import kafs.rpc as rpc
import sys
help = "Show the Protection Database groups owned by a user or group"
]
argument_size_limits = {
- "nameorid" : kafs.PR_MAXNAMELEN,
+ "nameorid" : rpc.PR_MAXNAMELEN,
}
description = r"""
prcache.precache_ids(group)
else:
# User - ListElements returns the ancestry of a non-group
- ret = cell.call_pt_server(params, kafs.PR_ListElements, gid)
+ ret = cell.call_pt_server(params, rpc.PR_ListElements, gid)
elist = ret.elist
memberships[gid] = elist
prcache.precache_ids(elist)
prcache.id_to_group(i)
requests.append(gid)
- except kafs.AbortPRNOENT:
+ except rpc.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:
+ except rpc.AbortPRPERM:
error("Permission denied on ID ", name, " (id: ", gid, ")\n")
prcache.id_is_unknown(gid)
if "force" not in params:
if "supergroups" in params:
for r in requests:
if r < 0:
- ret = cell.call_pt_server(params, kafs.PR_ListGroupsMemberOf, r)
+ ret = cell.call_pt_server(params, rpc.PR_ListGroupsMemberOf, r)
glist = ret.glist
memberships[r] = glist
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs.argparse import *
-from afs.lib.output import *
-import kafs
+from kafs.argparse import *
+from kafs.lib.output import *
+import kafs.rpc as rpc
help = "Remove a user from a Protection Database group"
]
argument_size_limits = {
- "name" : kafs.PR_MAXNAMELEN,
+ "name" : rpc.PR_MAXNAMELEN,
}
description = r"""
continue
try:
- ret = cell.call_pt_server(params, kafs.PR_RemoveFromGroup, uid, gid)
+ ret = cell.call_pt_server(params, rpc.PR_RemoveFromGroup, uid, gid)
prcache.evict_groups()
- except kafs.AbortPRNOENT:
+ except rpc.AbortPRNOENT:
error("User or group doesn't exist ; unable to remove user ", user, " from group ", group, ignored, "\n")
if "force" not in params:
return
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs.argparse import *
-from afs.lib.output import *
-import kafs
+from kafs.argparse import *
+from kafs.lib.output import *
+import kafs.rpc as rpc
import sys
help = "Change the name of a Protection Database entry"
]
argument_size_limits = {
- "oldname" : kafs.PR_MAXNAMELEN,
- "newname" : kafs.PR_MAXNAMELEN,
+ "oldname" : rpc.PR_MAXNAMELEN,
+ "newname" : rpc.PR_MAXNAMELEN,
}
description = r"""
try:
verbose("Renaming ", uid, " to ", newname, "\n")
- ret = cell.call_pt_server(params, kafs.PR_ChangeEntry, uid, newname, 0, 0)
+ ret = cell.call_pt_server(params, rpc.PR_ChangeEntry, uid, newname, 0, 0)
prcache.evict_id(uid)
prcache.evict_groups()
- except kafs.AbortPREXIST:
+ except rpc.AbortPREXIST:
error("Entry for name already exists ; unable to change name of ",
prcache.id_to_name(uid), " to ", newname, "\n")
- except kafs.AbortPRNOENT:
+ except rpc.AbortPRNOENT:
error("User or group doesn't exist ; unable to change name of ",
uid, " to ", newname, "\n")
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs.argparse import *
-from afs.exception import AFSArgumentError
-from afs.lib.output import *
-import kafs
+from kafs.argparse import *
+from kafs.exception import AFSArgumentError
+from kafs.lib.output import *
+import kafs.rpc as rpc
import sys
help = "Set privacy flags or quota for a Protection Database entry"
# Indicate who can use "pts examine"
if s[0] == "S":
- flags |= kafs.PRP_STATUS_ANY # Anyone
+ flags |= rpc.PRP_STATUS_ANY # Anyone
elif s[0] == "s":
- flags |= kafs.PRP_STATUS_MEM # Members only
+ flags |= rpc.PRP_STATUS_MEM # Members only
else:
raise AFSArgumentError("Status-read privacy flags must be [Ss]")
# Indicate who can use "pts listowned"
if s[1] == "O":
- flags |= kafs.PRP_OWNED_ANY # Anyone
+ flags |= rpc.PRP_OWNED_ANY # Anyone
elif s[1] == "-":
pass # Sysadmin & Group owner only
else:
# Indicate who can use "pts membership"
if s[2] == "M":
- flags |= kafs.PRP_MEMBER_ANY # Anyone
+ flags |= rpc.PRP_MEMBER_ANY # Anyone
elif s[2] == "m":
- flags |= kafs.PRP_MEMBER_MEM # Members only
+ flags |= rpc.PRP_MEMBER_MEM # Members only
elif s[2] == "-":
pass # Sysadmin & User can list which groups they belong to
else:
# Indicate who can use "pts adduser"
if s[3] == "A":
- flags |= kafs.PRP_ADD_ANY # Anyone
+ flags |= rpc.PRP_ADD_ANY # Anyone
elif s[3] == "a":
- elflags |= kafs.PRP_ADD_MEM # Members only
+ elflags |= rpc.PRP_ADD_MEM # Members only
elif s[3] == "-":
pass # Sysadmin & Group owner only
else:
# Indicate who can use "pts removeuser"
if s[4] == "r":
- flags |= kafs.PRP_REMOVE_MEM # Members can remove other members
+ flags |= rpc.PRP_REMOVE_MEM # Members can remove other members
elif s[4] == "-":
pass # Sysadmin |= Group owner only
else:
]
argument_size_limits = {
- "nameorid" : kafs.PR_MAXNAMELEN,
+ "nameorid" : rpc.PR_MAXNAMELEN,
}
description = r"""
if "access" in params:
flags = params["access"]
- mask |= kafs.PR_SF_ALLBITS
+ mask |= rpc.PR_SF_ALLBITS
if "groupquota" in params:
ngroups = params["groupquota"]
if not ngroups.isnumeric():
raise AFSArgumentError("Group quota must be positive integer or zero")
ngroups = int(ngroups)
- mask |= kafs.PR_SF_NGROUPS
+ mask |= rpc.PR_SF_NGROUPS
for name in params["nameorid"]:
uid = prcache.name_or_id_to_id(name)
try:
verbose("Altering entry for ", uid, " (", name, ")\n")
- ret = cell.call_pt_server(params, kafs.PR_SetFieldsEntry,
+ ret = cell.call_pt_server(params, rpc.PR_SetFieldsEntry,
uid, mask, flags, ngroups, 0, 0, 0)
- except kafs.AbortPRNOENT:
+ except rpc.AbortPRNOENT:
error("User or group doesn't exist examining ", name, " (id ", uid, ")\n")
prcache.id_is_unknown(uid)
- except kafs.AbortPRPERM:
+ except rpc.AbortPRPERM:
error("Permission denied examining ", name, " (id: ", uid, ")\n")
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs.argparse import *
-from afs.lib.output import *
-import kafs
+from kafs.argparse import *
+from kafs.lib.output import *
+import kafs.rpc as rpc
import sys
help = "Set the value of the max group id or max user id counter"
try:
uid = params["user"]
verbose("Set max UID to ", uid, "\n")
- ret = cell.call_pt_server(params, kafs.PR_SetMax, uid, kafs.PRUSER)
- except kafs.AbortPRPERM:
+ ret = cell.call_pt_server(params, rpc.PR_SetMax, uid, rpc.PRUSER)
+ except rpc.AbortPRPERM:
error("Permission denied ; unable to change max user id\n")
if "force" not in params:
return
try:
gid = params["group"]
verbose("Set max GID to ", gid, "\n")
- ret = cell.call_pt_server(params, kafs.PR_SetMax, gid, kafs.PRGRP)
- except kafs.AbortPRPERM:
+ ret = cell.call_pt_server(params, rpc.PR_SetMax, gid, rpc.PRGRP)
+ except rpc.AbortPRPERM:
error("Permission denied ; unable to change max group id\n")
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs.argparse import *
-from afs.exception import AFSException
-from afs.lib.output import *
-from afs.lib.partition import id2part
-from afs.lib.time import *
-import kafs
+from kafs.argparse import *
+from kafs.exception import AFSException
+from kafs.lib.output import *
+from kafs.lib.partition import id2part
+from kafs.lib.time import *
+import kafs.rpc as rpc
help = "Create a read/write volume and associated VLDB entry"
vol_conn = cell.open_volume_server(params["server"], params)
vldb_conn = cell.open_vl_server(params)
- ret = kafs.VOLSER_XListPartitions(vol_conn)
+ ret = rpc.VOLSER_XListPartitions(vol_conn)
partitions = ret.ent
# The partition must exist on the server
# The volume mustn't exist in the VLDB
try:
- ret = kafs.VL_GetEntryByNameN(vldb_conn, params["name"])
+ ret = rpc.VL_GetEntryByNameN(vldb_conn, params["name"])
raise AFSException("Volume " + params["name"] + " already exists")
- except kafs.AbortVL_NOENT:
+ except rpc.AbortVL_NOENT:
pass
# We need three volume IDs for the R/W, R/O and backup volumes
volume_ids = [ 0, 0, 0 ]
- ret = kafs.VL_GetNewVolumeId(vldb_conn, 1)
- volume_ids[kafs.RWVOL] = ret.newvolumid
- ret = kafs.VL_GetNewVolumeId(vldb_conn, 1)
- volume_ids[kafs.ROVOL] = ret.newvolumid
- ret = kafs.VL_GetNewVolumeId(vldb_conn, 1)
- volume_ids[kafs.BACKVOL] = ret.newvolumid
+ ret = rpc.VL_GetNewVolumeId(vldb_conn, 1)
+ volume_ids[rpc.RWVOL] = ret.newvolumid
+ ret = rpc.VL_GetNewVolumeId(vldb_conn, 1)
+ volume_ids[rpc.ROVOL] = ret.newvolumid
+ ret = rpc.VL_GetNewVolumeId(vldb_conn, 1)
+ volume_ids[rpc.BACKVOL] = ret.newvolumid
# Begin a volume creation transaction and configure the volume
- ret = kafs.VOLSER_CreateVolume(vol_conn,
+ ret = rpc.VOLSER_CreateVolume(vol_conn,
part,
params["name"],
- kafs.RWVOL,
+ rpc.RWVOL,
0,
- volume_ids[kafs.RWVOL])
- if ret.volid != volume_ids[kafs.RWVOL]:
+ volume_ids[rpc.RWVOL])
+ if ret.volid != volume_ids[rpc.RWVOL]:
raise AFSException("Tried to create volume {:x} but got {:x}".format(
- ret.volid, volume_ids[kafs.RWVOL]))
+ ret.volid, volume_ids[rpc.RWVOL]))
transaction = ret.trans
try:
# Set the maximum quota
v = 0xffffffff
- info = kafs.volintInfo()
+ info = rpc.volintInfo()
info.creationDate = v
info.accessDate = v
info.updateDate = v
else:
info.maxquota = 5000
- ret = kafs.VOLSER_SetInfo(vol_conn, transaction, info)
+ ret = rpc.VOLSER_SetInfo(vol_conn, transaction, info)
# Set the flags
- ret = kafs.VOLSER_SetFlags(vol_conn, transaction, 0)
+ ret = rpc.VOLSER_SetFlags(vol_conn, transaction, 0)
# Create the VLDB entry
- vldb = kafs.nvldbentry()
+ vldb = rpc.nvldbentry()
vldb.name = params["name"]
vldb.nServers = 1
vldb.serverNumber[0] = int(params["server"].addr())
vldb.serverPartition[0] = part
- vldb.serverFlags[0] = kafs.VLSF_RWVOL
+ vldb.serverFlags[0] = rpc.VLSF_RWVOL
vldb.volumeId = volume_ids
vldb.cloneId = 0
- vldb.flags = kafs.VLF_RWEXISTS
+ vldb.flags = rpc.VLF_RWEXISTS
- ret = kafs.VL_CreateEntryN(vldb_conn, vldb)
+ ret = rpc.VL_CreateEntryN(vldb_conn, vldb)
except Exception as e:
# If we can't create a VLDB entry, we should probably clean up the
# volume we've just created, rather than leaving it lying around.
error("VLDB entry or volume creation failed; attempting to delete the volume.");
try:
- kafs.VOLSER_DeleteVolume(vol_conn, transaction)
+ rpc.VOLSER_DeleteVolume(vol_conn, transaction)
except:
error("Volume deletion failed");
try:
- ret = kafs.VOLSER_EndTrans(vol_conn, transaction)
+ ret = rpc.VOLSER_EndTrans(vol_conn, transaction)
except:
error("Couldn't end volume creation transaction on error\n")
raise e
# Polish off
try:
- ret = kafs.VOLSER_EndTrans(vol_conn, transaction)
+ ret = rpc.VOLSER_EndTrans(vol_conn, transaction)
except Exception as e:
error("Couldn't end volume creation transaction on error\n")
raise e
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs.argparse import *
-from afs.exception import AFSException
-from afs.lib.output import *
-from afs.lib.voldisplay import *
-from afs.lib.partition import id2part
-from afs.lib.volserver import volserver
-import kafs
+from kafs.argparse import *
+from kafs.exception import AFSException
+from kafs.lib.output import *
+from kafs.lib.voldisplay import *
+from kafs.lib.partition import id2part
+from kafs.lib.volserver import volserver
+import kafs.rpc as rpc
help = "Show volume header and VLDB entry information for a volume"
]
argument_size_limits = {
- "id" : kafs.VLDB_MAXNAMELEN,
+ "id" : rpc.VLDB_MAXNAMELEN,
}
description = r"""
"""
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])
+ if vldb.volumeId[rpc.RWVOL] != 0:
+ outputf(" RWrite: {:<10d}", vldb.volumeId[rpc.RWVOL])
+ if vldb.volumeId[rpc.ROVOL] != 0:
+ outputf(" ROnly: {:<10d}", vldb.volumeId[rpc.ROVOL])
+ if vldb.volumeId[rpc.BACKVOL] != 0:
+ outputf(" Backup: {:<10d}", vldb.volumeId[rpc.BACKVOL])
output("\n")
display_vldb_site_list(params, vldb, " ")
volname = params["id"]
if volname.isnumeric():
volid = int(volname)
- ret = kafs.VL_GetEntryByIDN(vl_conn, volid, 0xffffffff)
+ ret = rpc.VL_GetEntryByIDN(vl_conn, volid, 0xffffffff)
vldb = ret.entry
- if volid == vldb.volumeId[kafs.RWVOL]:
- servflag = kafs.VLSF_RWVOL
- elif volid == vldb.volumeId[kafs.ROVOL]:
- servflag = kafs.VLSF_ROVOL
- elif volid == vldb.volumeId[kafs.BACKVOL]:
- servflag = kafs.VLSF_BACKVOL
+ if volid == vldb.volumeId[rpc.RWVOL]:
+ servflag = rpc.VLSF_RWVOL
+ elif volid == vldb.volumeId[rpc.ROVOL]:
+ servflag = rpc.VLSF_ROVOL
+ elif volid == vldb.volumeId[rpc.BACKVOL]:
+ servflag = rpc.VLSF_BACKVOL
else:
raise AFSException("Requested volume ID not in record for volume ID")
else:
- ret = kafs.VL_GetEntryByNameN(vl_conn, volname)
+ ret = rpc.VL_GetEntryByNameN(vl_conn, volname)
vldb = ret.entry
servflag = 0
for i in range(0, vldb.nServers):
servflag |= vldb.serverFlags[i]
- if servflag & kafs.VLSF_RWVOL:
- servflag = kafs.VLSF_RWVOL
- volid = vldb.volumeId[kafs.RWVOL]
- elif servflag & kafs.VLSF_ROVOL:
- servflag = kafs.VLSF_ROVOL
- volid = vldb.volumeId[kafs.ROVOL]
- elif servflag & kafs.VLSF_BACKVOL:
- servflag = kafs.VLSF_BACKVOL
- volid = vldb.volumeId[kafs.BACKVOL]
+ if servflag & rpc.VLSF_RWVOL:
+ servflag = rpc.VLSF_RWVOL
+ volid = vldb.volumeId[rpc.RWVOL]
+ elif servflag & rpc.VLSF_ROVOL:
+ servflag = rpc.VLSF_ROVOL
+ volid = vldb.volumeId[rpc.ROVOL]
+ elif servflag & rpc.VLSF_BACKVOL:
+ servflag = rpc.VLSF_BACKVOL
+ volid = vldb.volumeId[rpc.BACKVOL]
else:
raise AFSException("Requested volume does not exist on any server")
vol_server = volserver(vldb.serverNumber[i])
vol_conn = cell.open_volume_server(vol_server, params)
if "extended" in params:
- ret = kafs.VOLSER_XListOneVolume(vol_conn, vldb.serverPartition[i], volid)
+ ret = rpc.VOLSER_XListOneVolume(vol_conn, vldb.serverPartition[i], volid)
else:
- ret = kafs.VOLSER_ListOneVolume(vol_conn, vldb.serverPartition[i], volid)
+ ret = rpc.VOLSER_ListOneVolume(vol_conn, vldb.serverPartition[i], volid)
params["server"] = vol_server
params["_partname"] = id2part(vldb.serverPartition[i])
vol = ret.resultEntries[0]
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs.argparse import *
-from afs.lib.output import *
-from afs.lib.uuid import uuid2str
-import afs.lib.addrcache as addrcache
-import kafs
+from kafs.argparse import *
+from kafs.lib.output import *
+from kafs.lib.uuid import uuid2str
+import kafs.lib.addrcache as addrcache
+import kafs.rpc as rpc
help = "Display all VLDB entries"
"""
def list_one(params, vl_conn, attributes):
- ret = kafs.VL_GetAddrsU(vl_conn, attributes)
+ ret = rpc.VL_GetAddrsU(vl_conn, attributes)
if "printuuid" in params:
output("UUID: ", uuid2str(ret.uuidp1), "\n")
output("\n")
def list_all(params, vl_conn):
- ret = kafs.VL_GetAddrs(vl_conn, 0, 0)
+ ret = rpc.VL_GetAddrs(vl_conn, 0, 0)
verbose("nentries ", ret.nentries, "\n")
found = ret.nentries
limit = ret.nentries * 2
- attributes = kafs.ListAddrByAttributes()
- attributes.Mask |= kafs.VLADDR_INDEX
+ attributes = rpc.ListAddrByAttributes()
+ attributes.Mask |= rpc.VLADDR_INDEX
for index in range(1, 65536):
verbose("Look up", index)
try:
list_one(params, vl_conn, attributes)
found -= 1
- except kafs.AbortVL_NOENT:
+ except rpc.AbortVL_NOENT:
continue
- except kafs.AbortVL_INDEXERANGE:
+ except rpc.AbortVL_INDEXERANGE:
break
if found <= 0:
break
if "uuid" not in params and "host" not in params:
return list_all(params, vl_conn)
- attributes = kafs.ListAddrByAttributes()
+ attributes = rpc.ListAddrByAttributes()
attributes.Mask = 0
if "uuid" in params:
- attributes.Mask |= kafs.VLADDR_UUID
+ attributes.Mask |= rpc.VLADDR_UUID
attributes.uuid = params["uuid"]
if "host" in params:
- attributes.Mask |= kafs.VLADDR_IPADDR
+ attributes.Mask |= rpc.VLADDR_IPADDR
attributes.ipaddr = params["host"].integer_addr()
list_one(params, vl_conn, attributes)
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs.argparse import *
-from afs.lib.output import *
-import afs.lib.partition as partition
-import kafs
+from kafs.argparse import *
+from kafs.lib.output import *
+import kafs.lib.partition as partition
+import kafs.rpc as rpc
help = "Display all AFS partitions on a file server machine"
cell = params["cell"]
vol_conn = cell.open_volume_server(params["server"], params)
- ret = kafs.VOLSER_ListPartitions(vol_conn)
+ ret = rpc.VOLSER_ListPartitions(vol_conn)
partitions = ret.partIDs.partIds
output("The partitions on the server are:\n");
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs.argparse import *
-from afs.lib.output import *
-from afs.lib.voldisplay import *
-import kafs
+from kafs.argparse import *
+from kafs.lib.output import *
+from kafs.lib.voldisplay import *
+import kafs.rpc as rpc
help = "Query the VLDB"
]
argument_size_limits = {
- "name" : kafs.VLDB_MAXNAMELEN,
+ "name" : rpc.VLDB_MAXNAMELEN,
}
description = r"""
output(vldb.name, "\n")
output(" ");
flags = vldb.serverFlags[0]
- if flags & kafs.VLSF_RWVOL:
+ if flags & rpc.VLSF_RWVOL:
outputf(" RWrite: {:<12d}", vldb.volumeId[0])
- if flags & kafs.VLSF_ROVOL:
+ if flags & rpc.VLSF_ROVOL:
outputf(" ROnly: {:<12d}", vldb.volumeId[1])
- if flags & kafs.VLSF_BACKVOL:
+ if flags & rpc.VLSF_BACKVOL:
outputf(" Backup: {:<12d}",vldb.volumeId[2])
output("\n")
display_vldb_site_list(params, vldb, " ")
quiet = "quiet" in params
if "name" in params:
- ret = kafs.VL_GetEntryByName(z_conn, params["name"])
+ ret = rpc.VL_GetEntryByName(z_conn, params["name"])
vldb = ret.entry
print_record(params, vldb)
return
- attributes = kafs.VldbListByAttributes()
+ attributes = rpc.VldbListByAttributes()
attributes.Mask = 0
if "server" in params:
- attributes.Mask |= kafs.VLLIST_SERVER
+ attributes.Mask |= rpc.VLLIST_SERVER
attributes.server = params["server"].integer_addr()
if "partition" in params:
- attributes.Mask |= kafs.VLLIST_PARTITION
+ attributes.Mask |= rpc.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
+ attributes.Mask |= rpc.VLLIST_FLAG
+ attributes.flag = rpc.VLOP_MOVE | rpc.VLOP_RELEASE | rpc.VLOP_BACKUP | rpc.VLOP_DELETE | rpc.VLOP_DUMP
- ret = kafs.VL_ListAttributes(z_conn, attributes)
+ ret = rpc.VL_ListAttributes(z_conn, attributes)
blkentries = ret.blkentries
if not quiet and "server" in params:
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs.argparse import *
-from afs.lib.output import *
-from afs.lib.partition import id2part
-from afs.lib.voldisplay import *
-import kafs
+from kafs.argparse import *
+from kafs.lib.output import *
+from kafs.lib.partition import id2part
+from kafs.lib.voldisplay import *
+import kafs.rpc as rpc
import sys
help = "Display information from a volume header"
"writes_diff_net", "writes_diff_net_auth" ]
def display_format_extended(params, vol):
- if vol.status == kafs.VBUSY:
+ if vol.status == rpc.VBUSY:
output("VOLUME_BUSY\t{:d}\n", vol.volid)
return
- elif vol.status != kafs.VOK:
+ elif vol.status != rpc.VOK:
output("COULD_NOT_ATTACH_VOLUME\t{:d}\n", vol.volid)
return
###############################################################################
def display_one_partition(params, vol_conn, partition):
if "extended" in params:
- ret = kafs.VOLSER_XListVolumes(vol_conn, partition, 1)
+ ret = rpc.VOLSER_XListVolumes(vol_conn, partition, 1)
else:
- ret = kafs.VOLSER_ListVolumes(vol_conn, partition, 1)
+ ret = rpc.VOLSER_ListVolumes(vol_conn, partition, 1)
params["_partname"] = partname = id2part(partition)
if "quiet" not in params:
for vol in volumes:
if vol.inUse:
n_online += 1
- if vol.status == kafs.VBUSY:
+ if vol.status == rpc.VBUSY:
n_busy += 1
display_func(params, vol)
if "partition" in params:
try:
display_one_partition(params, vol_conn, params["partition"])
- except kafs.AbortVOLSERILLEGAL_PARTITION:
+ except rpc.AbortVOLSERILLEGAL_PARTITION:
error("vos : partition ", params["raw.partition"][0],
" does not exist on the server")
else:
- ret = kafs.VOLSER_XListPartitions(vol_conn)
+ ret = rpc.VOLSER_XListPartitions(vol_conn)
for p in ret.ent:
one_partition(params, vol_conn, p)
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs.argparse import *
-from afs.lib.output import *
-import afs.lib.partition as partition
-import kafs
+from kafs.argparse import *
+from kafs.lib.output import *
+import kafs.lib.partition as partition
+import kafs.rpc as rpc
help = "Report the available and total space on a partition"
vol_conn = cell.open_volume_server(params["server"], params)
if "partition" not in params:
- ret = kafs.VOLSER_ListPartitions(vol_conn)
+ ret = rpc.VOLSER_ListPartitions(vol_conn)
partitions = ret.partIDs.partIds
else:
partitions = [ params["partition"] ]
partname = partition.id2part(i)
try:
- ret = kafs.VOLSER_PartitionInfo(vol_conn, partname)
+ ret = rpc.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:
+ except rpc.AbortVOLSERILLEGAL_PARTITION:
error("partition ", partname, " does not exist on the server\n")
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs.argparse import *
-from afs.lib.output import *
-import afs.lib.partition as partition
-from afs.lib.time import *
-import kafs
+from kafs.argparse import *
+from kafs.lib.output import *
+import kafs.lib.partition as partition
+from kafs.lib.time import *
+import kafs.rpc as rpc
help = "Report a volume server's status"
cell = params["cell"]
vol_conn = cell.open_volume_server(params["server"], params)
- ret = kafs.VOLSER_Monitor(vol_conn)
+ ret = rpc.VOLSER_Monitor(vol_conn)
results = ret.result
if len(results) == 0:
output("No active transactions on", params["server"].name(), "\n")
for trans in results:
outputf("transaction: {:d} created: {:s}\n", trans.tid, time2str(trans.creationTime))
output("lastActiveTime:", time2str(trans.time), "\n")
- if iflag & kafs.ITOffline:
+ if iflag & rpc.ITOffline:
attach_mode = "offline"
- elif iflag & kafs.ITBusy:
+ elif iflag & rpc.ITBusy:
attach_mode = "busy"
- elif iflag & kafs.ITReadOnly:
+ elif iflag & rpc.ITReadOnly:
attach_mode = "readonly"
- elif iflag & kafs.ITCreate:
+ elif iflag & rpc.ITCreate:
attach_mode = "create"
- elif iflag & kafs.ITCreateVolID:
+ elif iflag & rpc.ITCreateVolID:
attach_mode = "createvolid"
else:
attach_mode = "{:d}".format(trans.iflags)
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs.exception import AFSException
-from afs.argparse import *
-from afs.lib.output import *
+from kafs.exception import AFSException
+from kafs.argparse import *
+from kafs.lib.output import *
help = "Get help on commands"
continue
if topic == "apropos":
- command = __import__("afs.apropos", globals(), locals(), ['*'])
+ command = __import__("kafs.apropos", globals(), locals(), ['*'])
output("bos apropos: ", command.help, "\n")
display_command_arguments(command.command_arguments)
continue
#include <arpa/inet.h>
#include "structmember.h"
#include "kafs.h"
-#include "afs_py.h"
+#include "rxgen_afs_py.h"
#if 0
/*
#endif
/*
- * Initialise the module.
+ * Initialise the module. This function must be named for the last component
+ * of the module path (ie. rpc from kafs.rpc).
*/
#ifndef PyMODINIT_FUNC /* declarations for DLL import/export */
#define PyMODINIT_FUNC void
#endif
PyMODINIT_FUNC
-PyInit_kafs(void)
+PyInit_rpc(void)
{
PyObject *m;
--- /dev/null
+# -*- coding: utf-8 -*-
+
+__copyright__ = """
+Copyright (C) 2014 Red Hat, Inc. All Rights Reserved.
+Written by David Howells (dhowells@redhat.com)
+
+Derived from StGIT:
+
+Copyright (C) 2005, Catalin Marinas <catalin.marinas@gmail.com>
+Copyright (C) 2008, Karl Hasselström <kha@treskal.com>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public Licence version 2 as
+published by the Free Software Foundation.
+
+This program 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 Licence for more details.
+
+You should have received a copy of the GNU General Public Licence
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+"""
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs import exception
+from kafs.exception import AFSNetAddressError
from socket import gethostbyname_ex, gethostbyaddr, gaierror, herror
import sys
import ipaddress
try:
addr = ipaddress.ip_address(name)
if addr.version == 6:
- raise exception.AFSNetAddressError("IPv6 is not currently supported")
+ raise AFSNetAddressError("IPv6 is not currently supported")
return str(addr)
except ValueError:
pass
try:
result = gethostbyname_ex(name)
except gaierror as e:
- raise exception.AFSNetAddressError("Couldn't resolve '" + name + "'")
+ raise AFSNetAddressError("Couldn't resolve '" + name + "'")
add_ghb(name, None, result)
return cache_n2a[name]
try:
addr = ipaddress.ip_address(name)
if addr.version == 6:
- raise exception.AFSNetAddressError("IPv6 is not currently supported")
+ raise AFSNetAddressError("IPv6 is not currently supported")
return addr
except ValueError:
- raise exception.AFSNetAddressError("Can't translate '" + name + "' to integer")
+ raise AFSNetAddressError("Can't translate '" + name + "' to integer")
###############################################################################
#
try:
addr = ipaddress.ip_address(name)
if addr.version == 6:
- raise exception.AFSNetAddressError("IPv6 is not currently supported")
+ raise AFSNetAddressError("IPv6 is not currently supported")
return addr
except ValueError:
pass
if str(type(addr)) != "<class 'IPv4Address'>" and str(type(addr)) != "<class 'IPv6Address'>":
addr = ipaddress.ip_address(addr)
if addr.version == 6:
- raise exception.AFSNetAddressError("IPv6 is not currently supported")
+ raise AFSNetAddressError("IPv6 is not currently supported")
return addr
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs import exception
-from afs.lib.output import *
-from afs.lib.server import server
+from kafs.lib.output import *
+from kafs.lib.server import server
class bosserver(server):
"""Represents an AFS BOS server. We hold the server address here."""
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs import exception
-from afs.lib.vlserver import vlserver
-from afs.lib.server import ServerError
-from afs.lib.prcache import prcache
-from afs.lib.output import *
+from kafs.exception import AFSException
+from kafs.lib.vlserver import vlserver
+from kafs.lib.server import ServerError
+from kafs.lib.prcache import prcache
+from kafs.lib.output import *
import dns.resolver
import linecache
-import kafs
+import kafs.rpc as rpc
-class CellError(exception.AFSException):
+class CellError(AFSException):
"""Error raised by L{cell} objects."""
class cell:
security = 0
key = None
elif "encrypt" in params:
- security = kafs.RXRPC_SECURITY_ENCRYPT
+ security = rpc.RXRPC_SECURITY_ENCRYPT
else:
- security = kafs.RXRPC_SECURITY_PLAIN
+ security = rpc.RXRPC_SECURITY_PLAIN
return (key, security)
# Open a VL Server connection
for vladdr in self.query_vl_addrs():
verbose("Trying vlserver ", vladdr, "\n")
- z_conn = kafs.rx_new_connection(str(vladdr), kafs.VL_PORT, kafs.VL_SERVICE,
- key, security)
+ z_conn = rpc.rx_new_connection(str(vladdr), rpc.VL_PORT, rpc.VL_SERVICE,
+ key, security)
try:
- ret = kafs.VL_Probe(z_conn)
+ ret = rpc.VL_Probe(z_conn)
self.__vlconn = z_conn
break
except ConnectionRefusedError:
key, security = self.determine_security(params)
verbose("Trying volserver ", server.addr(), "\n")
- vol_conn = kafs.rx_new_connection(str(server.addr()),
- kafs.VOLSERVICE_PORT,
- kafs.VOLSERVICE_ID,
- key, security)
+ vol_conn = rpc.rx_new_connection(str(server.addr()),
+ rpc.VOLSERVICE_PORT,
+ rpc.VOLSERVICE_ID,
+ key, security)
return vol_conn
# Open a BOS Server connection
key, security = self.determine_security(params)
verbose("Trying bosserver ", server.addr(), "\n")
- bos_conn = kafs.rx_new_connection(str(server.addr()),
- kafs.BOSSERVICE_PORT,
- kafs.BOSSERVICE_ID,
- key, security)
+ bos_conn = rpc.rx_new_connection(str(server.addr()),
+ rpc.BOSSERVICE_PORT,
+ rpc.BOSSERVICE_ID,
+ key, security)
return bos_conn
# Open a Protection Server connection
verbose("Trying ptserver ", server, "\n")
- pt_conn = kafs.rx_new_connection(str(server),
- kafs.PR_PORT,
- kafs.PR_SERVICE,
- key, security)
+ pt_conn = rpc.rx_new_connection(str(server),
+ rpc.PR_PORT,
+ rpc.PR_SERVICE,
+ key, security)
return pt_conn
# Find and call out to a working protection server
except ConnectionRefusedError:
# Move on to the next server
verbose("Connection refused\n");
- except kafs.AbortUNOTSYNC:
+ except rpc.AbortUNOTSYNC:
verbose("Server is not synchronised\n");
except OSError as e:
verbose(e, "\n");
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs import exception
-from afs.lib.output import *
-from afs.lib.server import server
+from kafs.lib.output import *
+from kafs.lib.server import server
class fileserver(server):
"""Represents an AFS File server. We hold the server address here."""
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from exception import AFSArgumentError
-import kafs
+from kafs.exception import AFSArgumentError
+import kafs.rpc as rpc
days = [ "sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday" ]
#
###############################################################################
def parse_restart_time(switch, params):
- at = kafs.bozo_netKTime()
+ at = rpc.bozo_netKTime()
time = params[0].strip().lower()
if time == "":
raise AFSArgumentError("Empty time string")
if time == "never":
- at.mask = kafs.KTIME_NEVER
+ at.mask = rpc.KTIME_NEVER
return at
if time == "now":
- at.mask = kafs.KTIME_NOW
+ at.mask = rpc.KTIME_NOW
return at
if time.startswith("every "):
for i in range(0, 7):
if days[i].startswith(day):
at.day = i
- at.mask |= kafs.KTIME_DAY
+ at.mask |= rpc.KTIME_DAY
break
else:
raise AFSArgumentError("Unrecognised day name")
if at.min > 59:
raise AFSArgumentError("Minute out of range in time")
- at.mask |= kafs.KTIME_HOUR | kafs.KTIME_MIN
+ at.mask |= rpc.KTIME_HOUR | rpc.KTIME_MIN
return at
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from exception import AFSArgumentError
+from kafs.exception import AFSArgumentError
def part2id(name):
"""Convert a partition name or number string into a numeric ID"""
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs import exception
-from afs.lib.output import *
-import kafs
+from kafs.lib.output import *
+import kafs.rpc as rpc
class AFS_PR_Entry:
"""Protection Database Name/ID mapping entry"""
name_arg_list = []
for i in names_to_lookup:
verbose_cont(i, ",")
- prname = kafs.prname()
+ prname = rpc.prname()
prname.prname = i
name_arg_list.append(prname)
verbose_cont(")\n")
- ret = self.__cell.call_pt_server(self.__params, kafs.PR_NameToID, name_arg_list)
+ ret = self.__cell.call_pt_server(self.__params, rpc.PR_NameToID, name_arg_list)
for i in range(0, len(names_to_lookup)):
name = names_to_lookup[i]
ugid = ret.ilist[i]
# Convert the name to an ID for message purposes - note that if the
# entry does not exist, this will return the anonymous ID
- if ugid == kafs.PR_ANONYMOUSID and name != "anonymous":
+ if ugid == rpc.PR_ANONYMOUSID and name != "anonymous":
entry = AFS_PR_Entry(name, None)
else:
entry = AFS_PR_Entry(name, ugid)
verbose_cont(i, ",")
verbose_cont(")\n")
- ret = self.__cell.call_pt_server(self.__params, kafs.PR_IDToName, ids_to_lookup)
+ ret = self.__cell.call_pt_server(self.__params, rpc.PR_IDToName, ids_to_lookup)
nlist = ret.nlist
for i in range(0, len(ids_to_lookup)):
ugid = ids_to_lookup[i]
def do_look_up_group(self, gid):
verbose("Look up group ", gid, "\n")
assert(gid < 0)
- ret = self.__cell.call_pt_server(self.__params, kafs.PR_ListElements, gid)
+ ret = self.__cell.call_pt_server(self.__params, rpc.PR_ListElements, gid)
entries = ret.elist
self.__groups[gid] = pr_group(gid, entries)
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs import exception
-import afs.lib.addrcache as addrcache
-from afs.lib.output import *
+from kafs.exception import AFSException
+import kafs.lib.addrcache as addrcache
+from kafs.lib.output import *
-class ServerError(exception.AFSException):
+class ServerError(AFSException):
"""Error raised by L{volserver} objects."""
class server:
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from exception import AFSArgumentError
+from kafs.exception import AFSArgumentError
def uuid2str(uuid):
"""Convert an afsUUID-class object into a UUID string"""
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs import exception
-from afs.lib.output import *
-from afs.lib.server import server
+from kafs.lib.output import *
+from kafs.lib.server import server
class vlserver(server):
"""Represents an AFS Volume Location server. We hold the server address here."""
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs.lib.output import *
-import afs.lib.addrcache as addrcache
-import afs.lib.partition as partition
-from afs.lib.time import *
-import kafs
+from kafs.lib.output import *
+import kafs.lib.addrcache as addrcache
+import kafs.lib.partition as partition
+from kafs.lib.time import *
+import kafs.rpc as rpc
statistics_time_ranges = [
"0-60 sec ",
return s
def vol_status(vol):
- if vol.status == kafs.VOK:
+ if vol.status == rpc.VOK:
return "OK"
- if vol.status == kafs.VBUSY:
+ if vol.status == rpc.VBUSY:
return "BUSY"
return "UNATTACHABLE"
part = partition.id2part(vldb.serverPartition[i])
flags = vldb.serverFlags[i]
- if flags & kafs.VLSF_ROVOL:
+ if flags & rpc.VLSF_ROVOL:
ptype = "RO"
- elif flags & kafs.VLSF_RWVOL:
+ elif flags & rpc.VLSF_RWVOL:
ptype = "RW"
else:
ptype = "Back"
outputf("{:s} server {:s} partition {:s} {:s} Site\n",
indent, addr, part, ptype)
- if vldb.flags & (kafs.VLOP_MOVE |
- kafs.VLOP_RELEASE |
- kafs.VLOP_BACKUP |
- kafs.VLOP_DELETE |
- kafs.VLOP_DUMP):
+ if vldb.flags & (rpc.VLOP_MOVE |
+ rpc.VLOP_RELEASE |
+ rpc.VLOP_BACKUP |
+ rpc.VLOP_DELETE |
+ rpc.VLOP_DUMP):
output(indent, "Volume is currently LOCKED")
- if vldb.flags & kafs.VLOP_MOVE:
+ if vldb.flags & rpc.VLOP_MOVE:
output(indent, "Volume is locked for a move operation")
- if vldb.flags & kafs.VLOP_RELEASE:
+ if vldb.flags & rpc.VLOP_RELEASE:
output(indent, "Volume is locked for a release operation")
- if vldb.flags & kafs.VLOP_BACKUP:
+ if vldb.flags & rpc.VLOP_BACKUP:
output(indent, "Volume is locked for a backup operation")
- if vldb.flags & kafs.VLOP_DELETE:
+ if vldb.flags & rpc.VLOP_DELETE:
output(indent, "Volume is locked for a delete/misc operation")
- if vldb.flags & kafs.VLOP_DUMP:
+ if vldb.flags & rpc.VLOP_DUMP:
output(indent, "Volume is locked for a dump/restore operation")
###############################################################################
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from afs import exception
-from afs.lib.output import *
-from afs.lib.server import server
+from kafs.lib.output import *
+from kafs.lib.server import server
class volserver(server):
"""Represents an AFS Volume server. We hold the server address here."""
import sys, os, traceback
-import afs.commands
-from afs.lib.output import *
-from exception import AFSArgumentError, AFSHelpFlag
+import kafs.commands
+from kafs.lib.output import *
+from kafs.exception import AFSArgumentError, AFSHelpFlag
###############################################################################
#
prog = os.path.basename(sys.argv[0])
set_program_name(prog)
- cmdsets = afs.commands.get_command_sets()
+ cmdsets = kafs.commands.get_command_sets()
#print("CMDSETS:", cmdsets)
if prog == "afs":
raise RuntimeError("Unsupported command set '" + cmdset + "'")
if cmd in ['-v', '--version', 'version']:
- from afs.version import version
+ from kafs.version import version
print('AFS Toolkit %s' % version)
print('Python version %s' % sys.version)
sys.exit(0)
sys.exit(0)
# Import the command set
- cmdsetmod = afs.commands.import_command_set(cmdset)
+ cmdsetmod = kafs.commands.import_command_set(cmdset)
commands = cmdsetmod.get_command_list()
commands.append("help")
commands.append("apropos")
sys.argv[0] += ' {:s}'.format(cmd)
if cmd == "help":
- command = __import__("afs.help", globals(), locals(), ['*'])
+ command = __import__("kafs.help", globals(), locals(), ['*'])
elif cmd == "apropos":
- command = __import__("afs.apropos", globals(), locals(), ['*'])
+ command = __import__("kafs.apropos", globals(), locals(), ['*'])
else:
command = cmdsetmod.get_command(cmd)
# If it's an alias, then switch to the real module
# Parse the parameters
try:
- params = afs.argparse.parse_arguments(sys.argv[1:],
+ params = kafs.argparse.parse_arguments(sys.argv[1:],
command.command_arguments,
argument_size_limits,
cant_combine_arguments)
print(prog + ":", e, file=sys.stderr)
sys.exit(2)
except AFSHelpFlag:
- helper = __import__("afs.help", globals(), locals(), ['*'])
+ helper = __import__("kafs.help", globals(), locals(), ['*'])
helper.helpflag(prog, cmdsetmod, cmd, command)
sys.exit(0)
# Stick in the default cell if there isn't one
if "cell" not in params:
- from afs.lib.cell import cell
+ from kafs.lib.cell import cell
params["cell"] = cell()
params["_prog"] = prog
# These modules are only used from this point onwards and do not
# need to be imported earlier
- from afs.exception import AFSException
+ from kafs.exception import AFSException
try:
set_debugging_level(int(os.environ.get('AFS_DEBUG_LEVEL', 0)))
#include "structmember.h"
#include <arpa/inet.h>
#include "py_rxgen.h"
-#include "afs_py.h"
+#include "rxgen_afs_py.h"
#include "rxgen.h"
#define debug(fmt, ...) do { if (0) printf(fmt, ## __VA_ARGS__); } while (0)
#include <arpa/inet.h>
#include <assert.h>
#include "py_rxgen.h"
-#include "afs_py.h"
+#include "rxgen_afs_py.h"
#include "rxgen.h"
#define debug(fmt, ...) do { if (0) printf(fmt, ## __VA_ARGS__); } while (0)
--- /dev/null
+from rpc import *
+
+__all__ = ["rpc"]
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from rxgen_bits import *
+from rxgen.rxgen_bits import *
###############################################################################
#
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from rxgen_bits import *
+from rxgen.rxgen_bits import *
###############################################################################
#
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from rxgen_bits import *
+from rxgen.rxgen_bits import *
###############################################################################
#
o.pysrc("static PyModuleDef kafs_module = {\n")
o.pysrc("\t.m_base = PyModuleDef_HEAD_INIT,\n")
- o.pysrc("\t.m_name = \"kafs\",\n")
+ o.pysrc("\t.m_name = \"rpc\",\n")
o.pysrc("\t.m_doc = \"AFS stuff.\",\n")
o.pysrc("\t.m_size = -1,\n")
o.pysrc("\t.m_methods = module_methods,\n")
# Emit a base remote abort class that all others can be subclassed off
o.pysrc("\n")
- o.pysrc("\tkafs_remote_abort = PyErr_NewException(\"kafs.RemoteAbort\", NULL, NULL);\n")
+ o.pysrc("\tkafs_remote_abort = PyErr_NewException(\"rpc.RemoteAbort\", NULL, NULL);\n")
o.pysrc("\tif (!kafs_remote_abort)\n")
o.pysrc("\t\treturn NULL;\n")
o.pysrc("\tPy_INCREF(kafs_remote_abort);\n")
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from rxgen_bits import *
+from rxgen.rxgen_bits import *
class decode_phase:
def __init__(self, form="flat", size=0, xdr_size=0, name=None):
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
-from rxgen_bits import *
+from rxgen.rxgen_bits import *
###############################################################################
#
import keyword
import time
import os
-from rxgen_bits import *
-from emit_c_struct import *
-from emit_c_sync_funcs import *
-from emit_py_types import *
-from emit_py_sync_funcs import *
-from emit_py_module import *
+from rxgen.rxgen_bits import *
+from rxgen.emit_c_struct import *
+from rxgen.emit_c_sync_funcs import *
+from rxgen.emit_py_types import *
+from rxgen.emit_py_sync_funcs import *
+from rxgen.emit_py_module import *
xdr = None # Current context
xdr.source = infile
xdr.lineno = 0
- f = open(infile)
+ f = open(infile, encoding="utf-8")
data = f.read()
f.close()
#
# Section: main
#
-if __name__ == "__main__":
- if len(sys.argv) < 2:
- print("Usage: {:s} <filename>*".format(sys.argv[0]))
- sys.exit(1)
-
- for f in sys.argv[1:]:
+def run(files, out_file_prefix):
+ for f in files:
if not parse(f):
break
xdr.finished_parsing()
- o = file_generator(xdr)
+ o = file_generator(xdr, out_file_prefix)
o.rxhdr("/* AUTOGENERATED */\n")
#o.rxhdr("#define _XOPEN_SOURCE\n";
o.rxhdr("#include <stdint.h>\n")
o.rxhdr("#include \"rxgen.h\"\n")
o.rxsrc("/* AUTOGENERATED */\n")
- o.rxsrc("#include \"afs_xg.h\"\n")
+ o.rxsrc("#include \"rxgen_afs_xg.h\"\n")
o.rxsrc("#include <stdio.h>\n")
o.rxsrc("#include <stdlib.h>\n")
o.rxsrc("#include <string.h>\n")
o.pyhdr("/* AUTOGENERATED */\n")
o.pyhdr("#include <Python.h>\n")
- o.pyhdr("#include \"afs_xg.h\"\n")
+ o.pyhdr("#include \"rxgen_afs_xg.h\"\n")
o.pyhdr("#include \"py_rxgen.h\"\n")
o.pysrc("/* AUTOGENERATED */\n")
o.pysrc("#include <Python.h>\n")
o.pysrc("#include \"structmember.h\"\n")
- o.pysrc("#include \"afs_py.h\"\n")
+ o.pysrc("#include \"rxgen_afs_py.h\"\n")
o.pysrc("#include <arpa/inet.h>\n")
o.pysrc("\n")
emit_py_func_simple_sync_call(o, f)
emit_py_module(o);
+
+#
+# Drive the program if executed as a standalone process
+#
+if __name__ == "__main__":
+ if len(sys.argv) < 2:
+ print("Usage: {:s} <filename>*".format(sys.argv[0]))
+ sys.exit(1)
+
+ run(sys.argv[1:], "")
###############################################################################
class file_generator:
"""File generator class"""
- def __init__(self, xdr):
+ def __init__(self, xdr, prefix):
self.xdr = xdr
- self._rxhdr = open("afs_xg.h", "w", encoding="utf-8")
- self._rxsrc = open("afs_xg.c", "w", encoding="utf-8")
- self._pyhdr = open("afs_py.h", "w", encoding="utf-8")
- self._pysrc = open("afs_py.c", "w", encoding="utf-8")
+ self._rxhdr = open(prefix + "afs_xg.h", "w", encoding="utf-8")
+ self._rxsrc = open(prefix + "afs_xg.c", "w", encoding="utf-8")
+ self._pyhdr = open(prefix + "afs_py.h", "w", encoding="utf-8")
+ self._pysrc = open(prefix + "afs_py.c", "w", encoding="utf-8")
def rxhdr(self, *va):
for i in va:
from distutils.core import setup, Extension
+from distutils.command.build_py import build_py as _build_py
+import os
+from glob import glob
+import rxgen.rxgen as rxgen
# Example that has an rpcgen implementation that is run from setup.py
#
# http://git.linux-nfs.org/?p=iisaman/pynfs.git;a=tree;h=14b3085dcce30d941a7839241779639b80e6298b;hb=14b3085dcce30d941a7839241779639b80e6298b
+class build_py(_build_py):
+ """Specialized Python source builder that scans for .xg files"""
+ def build_packages(self):
+ # A copy from _build_py, with a call to expand_xdr added
+ for package in self.packages:
+ print("PKG", package)
+ package_dir = self.get_package_dir(package)
+ self.check_package(package, package_dir)
+ if package == "kafs":
+ self.expand_xdr(os.path.join(package_dir, "rpc-api"),
+ package_dir)
+ modules = self.find_package_modules(package, package_dir)
+ for (package_, module, module_file) in modules:
+ assert package == package_
+ self.build_module(module, module_file, package)
+
+ def expand_xdr(self, src, dst):
+ print("SRC", os.getcwd())
+ xdr_files = glob(os.path.join(src, "*.h")) + glob(os.path.join(src, "*.xg"))
+ print("Run rxgen", " ".join(xdr_files))
+ assert(xdr_files)
+ rxgen.run(xdr_files, os.path.join(dst, "rxgen_"))
+
setup(name = "kafs",
version = "0.1",
+ packages = [ "kafs",
+ "kafs.lib",
+ "kafs.commands",
+ "kafs.commands.bos",
+ "kafs.commands.pts",
+ "kafs.commands.vos",
+ ],
+ scripts = [ "afs" ],
description = "AFS filesystem management scripting and commands",
+ cmdclass = { "build_py": build_py },
+ ext_modules = [Extension("kafs.rpc",
+ sources = [ "kafs/kafs.c",
+ "kafs/rxgen_afs_xg.c",
+ "kafs/rxgen_afs_py.c",
+ "kafs/py_passwd.c",
+ "kafs/py_rxgen.c",
+ "kafs/py_rxconn.c",
+ "kafs/py_rxsplit.c",
+ "kafs/af_rxrpc.c"
+ ],
+ extra_compile_args = [
+ "-O0",
+ "-Wp,-U_FORTIFY_SOURCE",
+ ],
+ include_dirs = [
+ "."
+ ],
+ libraries = [
+ "k5crypto",
+ "krb5"
+ ]
+ )],
+
author = "David Howells",
author_email = "dhowells@redhat.com",
license = "GPLv2",
- ext_modules = [Extension("kafs",
- sources = [ "afs_xg.c",
- "kafs.c",
- "afs_py.c",
- "py_passwd.c",
- "py_rxgen.c",
- "py_rxconn.c",
- "py_rxsplit.c",
- "af_rxrpc.c"
- ],
- extra_compile_args = [
- "-O0",
- "-Wp,-U_FORTIFY_SOURCE",
- ],
- libraries = [
- "k5crypto",
- "krb5"
- ]
- )])
+ url = "http://git.infradead.org/users/dhowells/kafs-utils.git",
+ )
import sys;
import getopt;
import dns.resolver;
-import kafs;
+import kafs.rpc as rpc;
cell = "grand.central.org";
volumes = [ "root.cell" ];
for vlserver in vladdrs:
print("Trying", vlserver);
- z_conn = kafs.rx_new_connection(vlserver, kafs.VL_PORT, kafs.VL_SERVICE);
+ z_conn = rpc.rx_new_connection(vlserver, rpc.VL_PORT, rpc.VL_SERVICE);
try:
- ret = kafs.VL_Probe(z_conn);
+ ret = rpc.VL_Probe(z_conn);
break;
except ConnectionRefusedError:
pass;
# Look up each of the volumes in the list
print("-- Look up the named volumes --");
for vol in volumes:
- ret = kafs.VL_GetEntryByName(z_conn, vol);
+ ret = rpc.VL_GetEntryByName(z_conn, vol);
vldb = ret.entry;
servers = set();
# Pick an arbitrary server serving that volume and find out what volumes
# that server serves
- attributes = kafs.VldbListByAttributes();
- attributes.Mask = kafs.VLLIST_SERVER;
+ attributes = rpc.VldbListByAttributes();
+ attributes.Mask = rpc.VLLIST_SERVER;
attributes.server = servers.pop();
- ret = kafs.VL_ListAttributes(z_conn, attributes)
+ ret = rpc.VL_ListAttributes(z_conn, attributes)
blkentries = ret.blkentries;
for i in blkentries:
projects / users / dhowells / kafs-utils.git / commitdiff