def main():
parser = argparse.ArgumentParser(description="Python Implementation of"
" ovs-appctl.")
parser.add_argument("-t", "--target", default="ovs-vswitchd",
help="pidfile or socket to contact")
parser.add_argument("command", metavar="COMMAND",
help="Command to run.")
parser.add_argument("argv", metavar="ARG", nargs="*",
help="Arguments to the command.")
parser.add_argument("-T", "--timeout", metavar="SECS",
help="wait at most SECS seconds for a response")
args = parser.parse_args()
signal_alarm(int(args.timeout) if args.timeout else None)
ovs.vlog.Vlog.init()
target = args.target
client = connect_to_target(target)
err_no, error, result = client.transact(args.command, args.argv)
client.close()
if err_no:
ovs.util.ovs_fatal(err_no, "%s: transaction error" % target)
elif error is not None:
sys.stderr.write(error)
ovs.util.ovs_error(0, "%s: server returned an error" % target)
sys.exit(2)
else:
assert result is not None
sys.stdout.write(result)
def main(argv):
if len(argv) not in (2, 3):
sys.stderr.write("usage: %s SOCKETNAME1 [SOCKETNAME2]", argv[0])
sys.exit(1)
sockname1 = argv[1]
if len(argv) > 2:
sockname2 = argv[2]
else:
sockname2 = sockname1
signal.signal(signal.SIGALRM, signal.SIG_DFL)
signal_alarm(5)
# Create a listening socket under name 'sockname1'.
error, sock1 = ovs.socket_util.make_unix_socket(socket.SOCK_STREAM, False,
sockname1, None)
if error:
sys.stderr.write("%s: bind failed (%s)" %
(sockname1, os.strerror(error)))
sys.exit(1)
sock1.listen(1)
# Connect to 'sockname2' (which should be the same file, perhaps under a
# different name).
error, sock2 = ovs.socket_util.make_unix_socket(socket.SOCK_STREAM, False,
None, sockname2)
if error:
sys.stderr.write("%s: connect failed (%s)" %
(sockname2, os.strerror(error)))
sys.exit(1)
def main(argv):
if len(argv) not in (2, 3):
sys.stderr.write("usage: %s SOCKETNAME1 [SOCKETNAME2]", argv[0])
sys.exit(1)
sockname1 = argv[1]
if len(argv) > 2:
sockname2 = argv[2]
else:
sockname2 = sockname1
signal.signal(signal.SIGALRM, signal.SIG_DFL)
signal_alarm(5)
# Create a listening socket under name 'sockname1'.
error, sock1 = ovs.socket_util.make_unix_socket(socket.SOCK_STREAM, False, sockname1, None)
if error:
sys.stderr.write("%s: bind failed (%s)" % (sockname1, os.strerror(error)))
sys.exit(1)
sock1.listen(1)
# Connect to 'sockname2' (which should be the same file, perhaps under a
# different name).
error, sock2 = ovs.socket_util.make_unix_socket(socket.SOCK_STREAM, False, None, sockname2)
if error:
sys.stderr.write("%s: connect failed (%s)" % (sockname2, os.strerror(error)))
sys.exit(1)
def main():
parser = argparse.ArgumentParser(description="Python Implementation of"
" ovs-appctl.")
parser.add_argument("-t",
"--target",
default="ovs-vswitchd",
help="pidfile or socket to contact")
parser.add_argument("command", metavar="COMMAND", help="Command to run.")
parser.add_argument("argv",
metavar="ARG",
nargs="*",
help="Arguments to the command.")
parser.add_argument("-T",
"--timeout",
metavar="SECS",
help="wait at most SECS seconds for a response")
args = parser.parse_args()
if args.timeout:
signal_alarm(int(args.timeout))
ovs.vlog.Vlog.init()
target = args.target
client = connect_to_target(target)
err_no, error, result = client.transact(args.command, args.argv)
client.close()
if err_no:
ovs.util.ovs_fatal(err_no, "%s: transaction error" % target)
elif error is not None:
sys.stderr.write(error)
ovs.util.ovs_error(0, "%s: server returned an error" % target)
sys.exit(2)
else:
assert result is not None
sys.stdout.write(result)
def main(argv):
try:
options, args = getopt.gnu_getopt(argv[1:], 't:h', ['timeout', 'help'])
except getopt.GetoptError as geo:
sys.stderr.write("%s: %s\n" % (ovs.util.PROGRAM_NAME, geo.msg))
sys.exit(1)
timeout = None
for key, value in options:
if key in ['-h', '--help']:
usage()
elif key in ['-t', '--timeout']:
try:
timeout = int(value)
if timeout < 1:
raise TypeError
except TypeError:
raise error.Error("value %s on -t or --timeout is not at "
"least 1" % value)
else:
sys.exit(0)
signal_alarm(timeout)
if not args:
sys.stderr.write("%s: missing command argument "
"(use --help for help)\n" % ovs.util.PROGRAM_NAME)
sys.exit(1)
commands = {
"default-atoms": (do_default_atoms, 0),
"default-data": (do_default_data, 0),
"parse-atomic-type": (do_parse_atomic_type, 1),
"parse-base-type": (do_parse_base_type, 1),
"parse-type": (do_parse_type, 1),
"parse-atoms": (do_parse_atoms, (2, )),
"parse-data": (do_parse_data, (2, )),
"sort-atoms": (do_sort_atoms, 2),
"parse-column": (do_parse_column, 2),
"parse-table": (do_parse_table, (2, 3)),
"parse-schema": (do_parse_schema, 1),
"idl": (do_idl, (2, )),
"idl_passive": (do_idl_passive, (2, ))
}
command_name = args[0]
args = args[1:]
if command_name not in commands:
sys.stderr.write("%s: unknown command \"%s\" "
"(use --help for help)\n" %
(ovs.util.PROGRAM_NAME, command_name))
sys.exit(1)
func, n_args = commands[command_name]
if type(n_args) == tuple:
if len(args) < n_args[0]:
sys.stderr.write(
"%s: \"%s\" requires at least %d arguments but "
"only %d provided\n" %
(ovs.util.PROGRAM_NAME, command_name, n_args[0], len(args)))
sys.exit(1)
elif type(n_args) == int:
if len(args) != n_args:
sys.stderr.write(
"%s: \"%s\" requires %d arguments but %d "
"provided\n" %
(ovs.util.PROGRAM_NAME, command_name, n_args, len(args)))
sys.exit(1)
else:
assert False
func(*args)
def main(argv):
try:
options, args = getopt.gnu_getopt(argv[1:], 't:h',
['timeout',
'help'])
except getopt.GetoptError as geo:
sys.stderr.write("%s: %s\n" % (ovs.util.PROGRAM_NAME, geo.msg))
sys.exit(1)
for key, value in options:
if key in ['-h', '--help']:
usage()
elif key in ['-t', '--timeout']:
try:
timeout = int(value)
if timeout < 1:
raise TypeError
except TypeError:
raise error.Error("value %s on -t or --timeout is not at "
"least 1" % value)
signal_alarm(timeout)
else:
sys.exit(0)
if not args:
sys.stderr.write("%s: missing command argument "
"(use --help for help)\n" % ovs.util.PROGRAM_NAME)
sys.exit(1)
commands = {"default-atoms": (do_default_atoms, 0),
"default-data": (do_default_data, 0),
"parse-atomic-type": (do_parse_atomic_type, 1),
"parse-base-type": (do_parse_base_type, 1),
"parse-type": (do_parse_type, 1),
"parse-atoms": (do_parse_atoms, (2,)),
"parse-data": (do_parse_data, (2,)),
"sort-atoms": (do_sort_atoms, 2),
"parse-column": (do_parse_column, 2),
"parse-table": (do_parse_table, (2, 3)),
"parse-schema": (do_parse_schema, 1),
"idl": (do_idl, (2,)),
"idl_passive": (do_idl_passive, (2,))}
command_name = args[0]
args = args[1:]
if command_name not in commands:
sys.stderr.write("%s: unknown command \"%s\" "
"(use --help for help)\n" % (ovs.util.PROGRAM_NAME,
command_name))
sys.exit(1)
func, n_args = commands[command_name]
if type(n_args) == tuple:
if len(args) < n_args[0]:
sys.stderr.write("%s: \"%s\" requires at least %d arguments but "
"only %d provided\n"
% (ovs.util.PROGRAM_NAME, command_name,
n_args, len(args)))
sys.exit(1)
elif type(n_args) == int:
if len(args) != n_args:
sys.stderr.write("%s: \"%s\" requires %d arguments but %d "
"provided\n"
% (ovs.util.PROGRAM_NAME, command_name,
n_args, len(args)))
sys.exit(1)
else:
assert False
func(*args)
def main(argv):
try:
options, args = getopt.gnu_getopt(argv[1:], 't:h:j:',
['timeout', 'help', 'json-parser'])
except getopt.GetoptError as geo:
sys.stderr.write("%s: %s\n" % (ovs.util.PROGRAM_NAME, geo.msg))
sys.exit(1)
timeout = None
# Save the old version to detect whether we support the C Parser
# but then override to the Python parser because it is always available
# and is the historical default
ORIG_PARSER = ovs.json.PARSER
ovs.json.PARSER = ovs.json.PARSER_PY
for key, value in options:
if key in ['-h', '--help']:
usage()
elif key in ['-t', '--timeout']:
try:
timeout = int(value)
if timeout < 1:
raise TypeError
except TypeError:
raise error.Error("value %s on -t or --timeout is not at "
"least 1" % value)
elif key in ['-j', '--json-parser']:
if value == "python":
ovs.json.PARSER = ovs.json.PARSER_PY
elif value in ('C', 'c'):
if ORIG_PARSER != ovs.json.PARSER_C:
raise error.Error("C parser selected, but not compiled")
else:
ovs.json.PARSER = ovs.json.PARSER_C
else:
raise error.Error(
"invalid option: %s, json-parser must be 'C' or json")
else:
sys.exit(0)
signal_alarm(timeout)
if not args:
sys.stderr.write("%s: missing command argument "
"(use --help for help)\n" % ovs.util.PROGRAM_NAME)
sys.exit(1)
commands = {
"default-atoms": (do_default_atoms, 0),
"default-data": (do_default_data, 0),
"parse-atomic-type": (do_parse_atomic_type, 1),
"parse-base-type": (do_parse_base_type, 1),
"parse-type": (do_parse_type, 1),
"parse-atoms": (do_parse_atoms, (2, )),
"parse-data": (do_parse_data, (2, )),
"sort-atoms": (do_sort_atoms, 2),
"parse-column": (do_parse_column, 2),
"parse-table": (do_parse_table, (2, 3)),
"parse-schema": (do_parse_schema, 1),
"idl": (do_idl, (2, )),
"idl_passive": (do_idl_passive, (2, ))
}
command_name = args[0]
args = args[1:]
if command_name not in commands:
sys.stderr.write("%s: unknown command \"%s\" "
"(use --help for help)\n" %
(ovs.util.PROGRAM_NAME, command_name))
sys.exit(1)
func, n_args = commands[command_name]
if type(n_args) == tuple:
if len(args) < n_args[0]:
sys.stderr.write(
"%s: \"%s\" requires at least %d arguments but "
"only %d provided\n" %
(ovs.util.PROGRAM_NAME, command_name, n_args[0], len(args)))
sys.exit(1)
elif type(n_args) == int:
if len(args) != n_args:
sys.stderr.write(
"%s: \"%s\" requires %d arguments but %d "
"provided\n" %
(ovs.util.PROGRAM_NAME, command_name, n_args, len(args)))
sys.exit(1)
else:
assert False
func(*args)
