#include "compiler.h"
#include "dirs.h"
#include "dynamic-string.h"
+#include "json.h"
#include "ovsdb-idl.h"
#include "poll-loop.h"
#include "svec.h"
/* --oneline: Write each command's output as a single line? */
static bool oneline;
+/* --dry-run: Do not commit any changes. */
+static bool dry_run;
+
+/* --no-wait: Wait for ovs-vswitchd to reload its configuration? */
+static bool wait_for_reload = true;
+
+/* --timeout: Time to wait for a connection to 'db'. */
+static int timeout = 5;
+
static void vsctl_fatal(const char *, ...) PRINTF_FORMAT(1, 2) NO_RETURN;
static char *default_db(void);
static void usage(void) NO_RETURN;
vlog_set_levels(VLM_reconnect, VLF_ANY_FACILITY, VLL_WARN);
parse_options(argc, argv);
+ if (timeout) {
+ time_alarm(timeout);
+ }
+
/* Log our arguments. This is often valuable for debugging systems. */
ds_init(&args);
for (i = 1; i < argc; i++) {
OPT_DB = UCHAR_MAX + 1,
OPT_ONELINE,
OPT_NO_SYSLOG,
- OPT_NO_WAIT
+ OPT_NO_WAIT,
+ OPT_DRY_RUN
};
static struct option long_options[] = {
{"db", required_argument, 0, OPT_DB},
{"no-syslog", no_argument, 0, OPT_NO_SYSLOG},
{"no-wait", no_argument, 0, OPT_NO_WAIT},
+ {"dry-run", no_argument, 0, OPT_DRY_RUN},
{"oneline", no_argument, 0, OPT_ONELINE},
+ {"timeout", required_argument, 0, 't'},
{"verbose", optional_argument, 0, 'v'},
{"help", no_argument, 0, 'h'},
{"version", no_argument, 0, 'V'},
{0, 0, 0, 0},
};
+
for (;;) {
+ unsigned long int timeout;
int c;
- c = getopt_long(argc, argv, "+v::hV", long_options, NULL);
+ c = getopt_long(argc, argv, "+v::hVt:", long_options, NULL);
if (c == -1) {
break;
}
break;
case OPT_NO_WAIT:
- /* XXX not yet implemented */
+ wait_for_reload = false;
+ break;
+
+ case OPT_DRY_RUN:
+ dry_run = true;
break;
case 'h':
OVS_PRINT_VERSION(0, 0);
exit(EXIT_SUCCESS);
+ case 't':
+ timeout = strtoul(optarg, NULL, 10);
+ if (timeout < 0) {
+ ovs_fatal(0, "value %s on -t or --timeout is invalid",
+ optarg);
+ }
+ break;
+
case 'v':
vlog_set_verbosity(optarg);
break;
" iface-get-external-id IFACE"
" list key-value pairs on IFACE\n"
);
+ printf("\nController commands:\n"
+ " get-controller [BRIDGE] "
+ "print the controller for BRIDGE\n"
+ " del-controller [BRIDGE] "
+ "delete the controller for BRIDGE\n"
+ " set-controller [BRIDGE] TARGET "
+ "set the controller for BRIDGE to TARGET\n"
+ " get-fail-mode [BRIDGE] "
+ "print the fail-mode for BRIDGE\n"
+ " del-fail-mode [BRIDGE] "
+ "delete the fail-mode for BRIDGE\n"
+ " set-fail-mode [BRIDGE] MODE "
+ "set the fail-mode for BRIDGE to MODE\n"
+ );
printf("\nOptions:\n"
" --db=DATABASE "
"connect to DATABASE\n"
struct vsctl_bridge {
struct ovsrec_bridge *br_cfg;
char *name;
+ struct ovsrec_controller *ctrl;
struct vsctl_bridge *parent;
int vlan;
};
struct shash bridges;
struct shash ports;
struct shash ifaces;
+ struct ovsrec_controller *ctrl;
};
static struct ovsdb_idl_txn *
br->name = xstrdup(name);
br->parent = parent;
br->vlan = vlan;
+ br->ctrl = parent ? parent->br_cfg->controller : br_cfg->controller;
shash_add(&b->bridges, br->name, br);
return br;
}
shash_init(&info->ports);
shash_init(&info->ifaces);
+ info->ctrl = ovs->controller;
+
shash_init(&bridges);
shash_init(&ports);
for (i = 0; i < ovs->n_bridges; i++) {
return br;
}
+static struct vsctl_bridge *
+find_real_bridge(struct vsctl_info *info, const char *name, bool must_exist)
+{
+ struct vsctl_bridge *br = find_bridge(info, name, must_exist);
+ if (br && br->parent) {
+ vsctl_fatal("%s is a fake bridge", name);
+ }
+ return br;
+}
+
static struct vsctl_port *
find_port(struct vsctl_info *info, const char *name, bool must_exist)
{
parent = find_bridge(&info, parent_name, false);
if (parent && parent->vlan) {
- vsctl_fatal("cannot create brdige with fake bridge as parent");
+ vsctl_fatal("cannot create bridge with fake bridge as parent");
}
if (!parent) {
vsctl_fatal("parent bridge %s does not exist", parent_name);
"", ctx->argc >= 3 ? ctx->argv[2] : NULL, &ctx->output);
free_info(&info);
}
+
+static void
+cmd_get_controller(struct vsctl_context *ctx)
+{
+ struct vsctl_info info;
+
+ get_info(ctx->ovs, &info);
+
+ if (ctx->argc == 1) {
+ /* Return the controller from the "Open_vSwitch" table */
+ if (info.ctrl) {
+ ds_put_format(&ctx->output, "%s\n", info.ctrl->target);
+ }
+ } else {
+ /* Return the controller for a particular bridge. */
+ struct vsctl_bridge *br = find_bridge(&info, ctx->argv[1], true);
+
+ /* If no controller is explicitly defined for the requested
+ * bridge, fallback to the "Open_vSwitch" table's controller. */
+ if (br->ctrl) {
+ ds_put_format(&ctx->output, "%s\n", br->ctrl->target);
+ } else if (info.ctrl) {
+ ds_put_format(&ctx->output, "%s\n", info.ctrl->target);
+ }
+ }
+
+ free_info(&info);
+}
+
+static void
+cmd_del_controller(struct vsctl_context *ctx)
+{
+ struct vsctl_info info;
+
+ get_info(ctx->ovs, &info);
+
+ if (ctx->argc == 1) {
+ if (info.ctrl) {
+ ovsrec_controller_delete(info.ctrl);
+ ovsrec_open_vswitch_set_controller(ctx->ovs, NULL);
+ }
+ } else {
+ struct vsctl_bridge *br = find_real_bridge(&info, ctx->argv[1], true);
+
+ if (br->ctrl) {
+ ovsrec_controller_delete(br->ctrl);
+ ovsrec_bridge_set_controller(br->br_cfg, NULL);
+ }
+ }
+
+ free_info(&info);
+}
+
+static void
+cmd_set_controller(struct vsctl_context *ctx)
+{
+ struct vsctl_info info;
+ struct ovsrec_controller *ctrl;
+
+ get_info(ctx->ovs, &info);
+
+ if (ctx->argc == 2) {
+ /* Set the controller in the "Open_vSwitch" table. */
+ if (info.ctrl) {
+ ovsrec_controller_delete(info.ctrl);
+ }
+ ctrl = ovsrec_controller_insert(txn_from_openvswitch(ctx->ovs));
+ ovsrec_controller_set_target(ctrl, ctx->argv[1]);
+ ovsrec_open_vswitch_set_controller(ctx->ovs, ctrl);
+ } else {
+ /* Set the controller for a particular bridge. */
+ struct vsctl_bridge *br = find_real_bridge(&info, ctx->argv[1], true);
+
+ if (br->ctrl) {
+ ovsrec_controller_delete(br->ctrl);
+ }
+ ctrl = ovsrec_controller_insert(txn_from_openvswitch(ctx->ovs));
+ ovsrec_controller_set_target(ctrl, ctx->argv[2]);
+ ovsrec_bridge_set_controller(br->br_cfg, ctrl);
+ }
+
+ free_info(&info);
+}
+
+static void
+cmd_get_fail_mode(struct vsctl_context *ctx)
+{
+ struct vsctl_info info;
+ const char *fail_mode = NULL;
+
+ get_info(ctx->ovs, &info);
+
+ if (ctx->argc == 1) {
+ /* Return the fail-mode from the "Open_vSwitch" table */
+ if (info.ctrl && info.ctrl->fail_mode) {
+ fail_mode = info.ctrl->fail_mode;
+ }
+ } else {
+ /* Return the fail-mode for a particular bridge. */
+ struct vsctl_bridge *br = find_bridge(&info, ctx->argv[1], true);
+
+ /* If no controller or fail-mode is explicitly defined for the
+ * requested bridge, fallback to the "Open_vSwitch" table's
+ * setting. */
+ if (br->ctrl && br->ctrl->fail_mode) {
+ fail_mode = br->ctrl->fail_mode;
+ } else if (info.ctrl && info.ctrl->fail_mode) {
+ fail_mode = info.ctrl->fail_mode;
+ }
+ }
+
+ if (fail_mode && strlen(fail_mode)) {
+ ds_put_format(&ctx->output, "%s\n", info.ctrl->fail_mode);
+ }
+
+ free_info(&info);
+}
+
+static void
+cmd_del_fail_mode(struct vsctl_context *ctx)
+{
+ struct vsctl_info info;
+
+ get_info(ctx->ovs, &info);
+
+ if (ctx->argc == 1) {
+ if (info.ctrl && info.ctrl->fail_mode) {
+ ovsrec_controller_set_fail_mode(info.ctrl, NULL);
+ }
+ } else {
+ struct vsctl_bridge *br = find_real_bridge(&info, ctx->argv[1], true);
+
+ if (br->ctrl && br->ctrl->fail_mode) {
+ ovsrec_controller_set_fail_mode(br->ctrl, NULL);
+ }
+ }
+
+ free_info(&info);
+}
+
+static void
+cmd_set_fail_mode(struct vsctl_context *ctx)
+{
+ struct vsctl_info info;
+ const char *fail_mode;
+
+ get_info(ctx->ovs, &info);
+
+ fail_mode = (ctx->argc == 2) ? ctx->argv[1] : ctx->argv[2];
+
+ if (strcmp(fail_mode, "standalone") && strcmp(fail_mode, "secure")) {
+ vsctl_fatal("fail-mode must be \"standalone\" or \"secure\"");
+ }
+
+ if (ctx->argc == 2) {
+ /* Set the fail-mode in the "Open_vSwitch" table. */
+ if (!info.ctrl) {
+ vsctl_fatal("no controller declared");
+ }
+ ovsrec_controller_set_fail_mode(info.ctrl, fail_mode);
+ } else {
+ struct vsctl_bridge *br = find_real_bridge(&info, ctx->argv[1], true);
+
+ if (!br->ctrl) {
+ vsctl_fatal("no controller declared for %s", br->name);
+ }
+ ovsrec_controller_set_fail_mode(br->ctrl, fail_mode);
+ }
+
+ free_info(&info);
+}
\f
typedef void vsctl_handler_func(struct vsctl_context *);
const struct ovsrec_open_vswitch *ovs,
struct ds *output);
+static struct json *
+where_uuid_equals(const struct uuid *uuid)
+{
+ return
+ json_array_create_1(
+ json_array_create_3(
+ json_string_create("_uuid"),
+ json_string_create("=="),
+ json_array_create_2(
+ json_string_create("uuid"),
+ json_string_create_nocopy(
+ xasprintf(UUID_FMT, UUID_ARGS(uuid))))));
+}
+
static void
do_vsctl(int argc, char *argv[], struct ovsdb_idl *idl)
{
struct ovsdb_idl_txn *txn;
const struct ovsrec_open_vswitch *ovs;
enum ovsdb_idl_txn_status status;
- struct ds *output;
+ struct ds comment, *output;
+ int64_t next_cfg;
int n_output;
int i, start;
txn = ovsdb_idl_txn_create(idl);
+ if (dry_run) {
+ ovsdb_idl_txn_set_dry_run(txn);
+ }
+
+ ds_init(&comment);
+ ds_put_cstr(&comment, "ovs-vsctl:");
+ for (i = 0; i < argc; i++) {
+ ds_put_format(&comment, " %s", argv[i]);
+ }
+ ovsdb_idl_txn_add_comment(txn, ds_cstr(&comment));
+ ds_destroy(&comment);
ovs = ovsrec_open_vswitch_first(idl);
if (!ovs) {
ovs = ovsrec_open_vswitch_insert(txn);
}
+ if (wait_for_reload) {
+ struct json *where = where_uuid_equals(&ovs->header_.uuid);
+ ovsdb_idl_txn_increment(txn, "Open_vSwitch", "next_cfg",
+ where);
+ json_destroy(where);
+ }
+
output = xmalloc(argc * sizeof *output);
n_output = 0;
for (start = i = 0; i <= argc; i++) {
ovsdb_idl_txn_wait(txn);
poll_block();
}
+ if (wait_for_reload && status == TXN_SUCCESS) {
+ next_cfg = ovsdb_idl_txn_get_increment_new_value(txn);
+ }
ovsdb_idl_txn_destroy(txn);
switch (status) {
/* Should not happen--we never call ovsdb_idl_txn_abort(). */
vsctl_fatal("transaction aborted");
+ case TXN_UNCHANGED:
case TXN_SUCCESS:
break;
fputs(ds_cstr(ds), stdout);
}
}
+
+ if (wait_for_reload && status != TXN_UNCHANGED) {
+ for (;;) {
+ const struct ovsrec_open_vswitch *ovs;
+
+ ovsdb_idl_run(idl);
+ OVSREC_OPEN_VSWITCH_FOR_EACH (ovs, idl) {
+ if (ovs->cur_cfg >= next_cfg) {
+ goto done;
+ }
+ }
+ ovsdb_idl_wait(idl);
+ poll_block();
+ }
+ done: ;
+ }
+
exit(EXIT_SUCCESS);
}
{"iface-to-br", 1, 1, cmd_iface_to_br, ""},
{"iface-set-external-id", 2, 3, cmd_iface_set_external_id, ""},
{"iface-get-external-id", 1, 2, cmd_iface_get_external_id, ""},
+
+ /* Controller commands. */
+ {"get-controller", 0, 1, cmd_get_controller, ""},
+ {"del-controller", 0, 1, cmd_del_controller, ""},
+ {"set-controller", 1, 2, cmd_set_controller, ""},
+ {"get-fail-mode", 0, 1, cmd_get_fail_mode, ""},
+ {"del-fail-mode", 0, 1, cmd_del_fail_mode, ""},
+ {"set-fail-mode", 1, 2, cmd_set_fail_mode, ""},
};
const struct vsctl_command *p;
projects / openvswitch / blobdiff