1 /* Copyright (c) 2009, 2010, 2011 Nicira Networks
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at:
7 * http://www.apache.org/licenses/LICENSE-2.0
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
25 #include "command-line.h"
32 #include "jsonrpc-server.h"
33 #include "leak-checker.h"
36 #include "ovsdb-data.h"
37 #include "ovsdb-types.h"
38 #include "ovsdb-error.h"
39 #include "poll-loop.h"
42 #include "stream-ssl.h"
48 #include "transaction.h"
54 VLOG_DEFINE_THIS_MODULE(ovsdb_server
);
56 /* SSL configuration. */
57 static char *private_key_file
;
58 static char *certificate_file
;
59 static char *ca_cert_file
;
60 static bool bootstrap_ca_cert
;
62 static unixctl_cb_func ovsdb_server_exit
;
63 static unixctl_cb_func ovsdb_server_compact
;
64 static unixctl_cb_func ovsdb_server_reconnect
;
66 static void parse_options(int argc
, char *argv
[], char **file_namep
,
67 struct sset
*remotes
, char **unixctl_pathp
,
69 static void usage(void) NO_RETURN
;
71 static void reconfigure_from_db(struct ovsdb_jsonrpc_server
*jsonrpc
,
72 const struct ovsdb
*db
, struct sset
*remotes
);
74 static void update_remote_status(const struct ovsdb_jsonrpc_server
*jsonrpc
,
75 const struct sset
*remotes
,
79 main(int argc
, char *argv
[])
81 char *unixctl_path
= NULL
;
82 char *run_command
= NULL
;
83 struct unixctl_server
*unixctl
;
84 struct ovsdb_jsonrpc_server
*jsonrpc
;
86 struct ovsdb_error
*error
;
87 struct ovsdb_file
*file
;
89 struct process
*run_process
;
93 long long int status_timer
= LLONG_MIN
;
95 proctitle_init(argc
, argv
);
96 set_program_name(argv
[0]);
97 stress_init_command();
98 signal(SIGPIPE
, SIG_IGN
);
101 parse_options(argc
, argv
, &file_name
, &remotes
, &unixctl_path
,
106 error
= ovsdb_file_open(file_name
, false, &db
, &file
);
108 ovs_fatal(0, "%s", ovsdb_error_to_string(error
));
112 jsonrpc
= ovsdb_jsonrpc_server_create(db
);
113 reconfigure_from_db(jsonrpc
, db
, &remotes
);
115 retval
= unixctl_server_create(unixctl_path
, &unixctl
);
123 run_argv
[0] = "/bin/sh";
125 run_argv
[2] = run_command
;
128 retval
= process_start(run_argv
, NULL
, 0, NULL
, 0, &run_process
);
130 ovs_fatal(retval
, "%s: process failed to start", run_command
);
136 daemonize_complete();
138 unixctl_command_register("exit", ovsdb_server_exit
, &exiting
);
139 unixctl_command_register("ovsdb-server/compact", ovsdb_server_compact
,
141 unixctl_command_register("ovsdb-server/reconnect", ovsdb_server_reconnect
,
146 reconfigure_from_db(jsonrpc
, db
, &remotes
);
147 ovsdb_jsonrpc_server_run(jsonrpc
);
148 unixctl_server_run(unixctl
);
149 ovsdb_trigger_run(db
, time_msec());
150 if (run_process
&& process_exited(run_process
)) {
154 /* update Manager status(es) every 5 seconds */
155 if (time_msec() >= status_timer
) {
156 status_timer
= time_msec() + 5000;
157 update_remote_status(jsonrpc
, &remotes
, db
);
160 ovsdb_jsonrpc_server_wait(jsonrpc
);
161 unixctl_server_wait(unixctl
);
162 ovsdb_trigger_wait(db
, time_msec());
164 process_wait(run_process
);
167 poll_immediate_wake();
169 poll_timer_wait_until(status_timer
);
172 ovsdb_jsonrpc_server_destroy(jsonrpc
);
174 sset_destroy(&remotes
);
175 unixctl_server_destroy(unixctl
);
177 if (run_process
&& process_exited(run_process
)) {
178 int status
= process_status(run_process
);
180 ovs_fatal(0, "%s: child exited, %s",
181 run_command
, process_status_msg(status
));
189 parse_db_column(const struct ovsdb
*db
,
191 const struct ovsdb_table
**tablep
,
192 const struct ovsdb_column
**columnp
)
194 char *name
, *table_name
, *column_name
;
195 const struct ovsdb_column
*column
;
196 const struct ovsdb_table
*table
;
197 char *save_ptr
= NULL
;
199 name
= xstrdup(name_
);
200 strtok_r(name
, ":", &save_ptr
); /* "db:" */
201 table_name
= strtok_r(NULL
, ",", &save_ptr
);
202 column_name
= strtok_r(NULL
, ",", &save_ptr
);
203 if (!table_name
|| !column_name
) {
204 ovs_fatal(0, "\"%s\": invalid syntax", name_
);
207 table
= ovsdb_get_table(db
, table_name
);
209 ovs_fatal(0, "\"%s\": no table named %s", name_
, table_name
);
212 column
= ovsdb_table_schema_get_column(table
->schema
, column_name
);
214 ovs_fatal(0, "\"%s\": table \"%s\" has no column \"%s\"",
215 name_
, table_name
, column_name
);
224 parse_db_string_column(const struct ovsdb
*db
,
226 const struct ovsdb_table
**tablep
,
227 const struct ovsdb_column
**columnp
)
229 const struct ovsdb_column
*column
;
230 const struct ovsdb_table
*table
;
232 parse_db_column(db
, name
, &table
, &column
);
234 if (column
->type
.key
.type
!= OVSDB_TYPE_STRING
235 || column
->type
.value
.type
!= OVSDB_TYPE_VOID
) {
236 ovs_fatal(0, "\"%s\": table \"%s\" column \"%s\" is "
237 "not string or set of strings",
238 name
, table
->schema
->name
, column
->name
);
245 static OVS_UNUSED
const char *
246 query_db_string(const struct ovsdb
*db
, const char *name
)
248 if (!name
|| strncmp(name
, "db:", 3)) {
251 const struct ovsdb_column
*column
;
252 const struct ovsdb_table
*table
;
253 const struct ovsdb_row
*row
;
255 parse_db_string_column(db
, name
, &table
, &column
);
257 HMAP_FOR_EACH (row
, hmap_node
, &table
->rows
) {
258 const struct ovsdb_datum
*datum
;
261 datum
= &row
->fields
[column
->index
];
262 for (i
= 0; i
< datum
->n
; i
++) {
263 if (datum
->keys
[i
].string
[0]) {
264 return datum
->keys
[i
].string
;
272 static struct ovsdb_jsonrpc_options
*
273 add_remote(struct shash
*remotes
, const char *target
)
275 struct ovsdb_jsonrpc_options
*options
;
277 options
= shash_find_data(remotes
, target
);
279 options
= ovsdb_jsonrpc_default_options();
280 shash_add(remotes
, target
, options
);
286 static struct ovsdb_datum
*
287 get_datum(struct ovsdb_row
*row
, const char *column_name
,
288 const enum ovsdb_atomic_type key_type
,
289 const enum ovsdb_atomic_type value_type
,
292 static struct vlog_rate_limit rl
= VLOG_RATE_LIMIT_INIT(1, 1);
293 const struct ovsdb_table_schema
*schema
= row
->table
->schema
;
294 const struct ovsdb_column
*column
;
296 column
= ovsdb_table_schema_get_column(schema
, column_name
);
298 VLOG_DBG_RL(&rl
, "Table `%s' has no `%s' column",
299 schema
->name
, column_name
);
303 if (column
->type
.key
.type
!= key_type
304 || column
->type
.value
.type
!= value_type
305 || column
->type
.n_max
!= n_max
) {
306 if (!VLOG_DROP_DBG(&rl
)) {
307 char *type_name
= ovsdb_type_to_english(&column
->type
);
308 VLOG_DBG("Table `%s' column `%s' has type %s, not expected "
309 "key type %s, value type %s, max elements %zd.",
310 schema
->name
, column_name
, type_name
,
311 ovsdb_atomic_type_to_string(key_type
),
312 ovsdb_atomic_type_to_string(value_type
),
319 return &row
->fields
[column
->index
];
322 static const union ovsdb_atom
*
323 read_column(const struct ovsdb_row
*row
, const char *column_name
,
324 enum ovsdb_atomic_type type
)
326 const struct ovsdb_datum
*datum
;
328 datum
= get_datum((struct ovsdb_row
*) row
, column_name
, type
, OVSDB_TYPE_VOID
, 1);
329 return datum
&& datum
->n
? datum
->keys
: NULL
;
333 read_integer_column(const struct ovsdb_row
*row
, const char *column_name
,
334 long long int *integerp
)
336 const union ovsdb_atom
*atom
;
338 atom
= read_column(row
, column_name
, OVSDB_TYPE_INTEGER
);
339 *integerp
= atom
? atom
->integer
: 0;
344 read_string_column(const struct ovsdb_row
*row
, const char *column_name
,
345 const char **stringp
)
347 const union ovsdb_atom
*atom
;
349 atom
= read_column(row
, column_name
, OVSDB_TYPE_STRING
);
350 *stringp
= atom
? atom
->string
: NULL
;
355 write_bool_column(struct ovsdb_row
*row
, const char *column_name
, bool value
)
357 struct ovsdb_datum
*datum
= get_datum(row
, column_name
, OVSDB_TYPE_BOOLEAN
,
363 datum
->keys
[0].boolean
= value
;
367 write_string_string_column(struct ovsdb_row
*row
, const char *column_name
,
368 char **keys
, char **values
, size_t n
)
370 const struct ovsdb_column
*column
;
371 struct ovsdb_datum
*datum
;
374 column
= ovsdb_table_schema_get_column(row
->table
->schema
, column_name
);
375 datum
= get_datum(row
, column_name
, OVSDB_TYPE_STRING
, OVSDB_TYPE_STRING
,
381 /* Free existing data. */
382 ovsdb_datum_destroy(datum
, &column
->type
);
384 /* Allocate space for new values. */
386 datum
->keys
= xmalloc(n
* sizeof *datum
->keys
);
387 datum
->values
= xmalloc(n
* sizeof *datum
->values
);
389 for (i
= 0; i
< n
; ++i
) {
390 datum
->keys
[i
].string
= keys
[i
];
391 datum
->values
[i
].string
= values
[i
];
394 /* Sort and check constraints. */
395 ovsdb_datum_sort_assert(datum
, column
->type
.key
.type
);
398 /* Adds a remote and options to 'remotes', based on the Manager table row in
401 add_manager_options(struct shash
*remotes
, const struct ovsdb_row
*row
)
403 static struct vlog_rate_limit rl
= VLOG_RATE_LIMIT_INIT(1, 1);
404 struct ovsdb_jsonrpc_options
*options
;
405 long long int max_backoff
, probe_interval
;
408 if (!read_string_column(row
, "target", &target
) || !target
) {
409 VLOG_INFO_RL(&rl
, "Table `%s' has missing or invalid `target' column",
410 row
->table
->schema
->name
);
414 options
= add_remote(remotes
, target
);
415 if (read_integer_column(row
, "max_backoff", &max_backoff
)) {
416 options
->max_backoff
= max_backoff
;
418 if (read_integer_column(row
, "inactivity_probe", &probe_interval
)) {
419 options
->probe_interval
= probe_interval
;
424 query_db_remotes(const char *name
, const struct ovsdb
*db
,
425 struct shash
*remotes
)
427 const struct ovsdb_column
*column
;
428 const struct ovsdb_table
*table
;
429 const struct ovsdb_row
*row
;
431 parse_db_column(db
, name
, &table
, &column
);
433 if (column
->type
.key
.type
== OVSDB_TYPE_STRING
434 && column
->type
.value
.type
== OVSDB_TYPE_VOID
) {
435 HMAP_FOR_EACH (row
, hmap_node
, &table
->rows
) {
436 const struct ovsdb_datum
*datum
;
439 datum
= &row
->fields
[column
->index
];
440 for (i
= 0; i
< datum
->n
; i
++) {
441 add_remote(remotes
, datum
->keys
[i
].string
);
444 } else if (column
->type
.key
.type
== OVSDB_TYPE_UUID
445 && column
->type
.key
.u
.uuid
.refTable
446 && column
->type
.value
.type
== OVSDB_TYPE_VOID
) {
447 const struct ovsdb_table
*ref_table
= column
->type
.key
.u
.uuid
.refTable
;
448 HMAP_FOR_EACH (row
, hmap_node
, &table
->rows
) {
449 const struct ovsdb_datum
*datum
;
452 datum
= &row
->fields
[column
->index
];
453 for (i
= 0; i
< datum
->n
; i
++) {
454 const struct ovsdb_row
*ref_row
;
456 ref_row
= ovsdb_table_get_row(ref_table
, &datum
->keys
[i
].uuid
);
458 add_manager_options(remotes
, ref_row
);
466 update_remote_row(const struct ovsdb_row
*row
, struct ovsdb_txn
*txn
,
467 const struct ovsdb_jsonrpc_server
*jsonrpc
)
469 struct ovsdb_jsonrpc_remote_status status
;
470 struct ovsdb_row
*rw_row
;
472 char *keys
[8], *values
[8];
475 /* Get the "target" (protocol/host/port) spec. */
476 if (!read_string_column(row
, "target", &target
)) {
477 /* Bad remote spec or incorrect schema. */
480 rw_row
= ovsdb_txn_row_modify(txn
, row
);
481 ovsdb_jsonrpc_server_get_remote_status(jsonrpc
, target
, &status
);
483 /* Update status information columns. */
484 write_bool_column(rw_row
, "is_connected", status
.is_connected
);
487 keys
[n
] = xstrdup("state");
488 values
[n
++] = xstrdup(status
.state
);
490 if (status
.sec_since_connect
!= UINT_MAX
) {
491 keys
[n
] = xstrdup("sec_since_connect");
492 values
[n
++] = xasprintf("%u", status
.sec_since_connect
);
494 if (status
.sec_since_disconnect
!= UINT_MAX
) {
495 keys
[n
] = xstrdup("sec_since_disconnect");
496 values
[n
++] = xasprintf("%u", status
.sec_since_disconnect
);
498 if (status
.last_error
) {
499 keys
[n
] = xstrdup("last_error");
501 xstrdup(ovs_retval_to_string(status
.last_error
));
503 if (status
.locks_held
&& status
.locks_held
[0]) {
504 keys
[n
] = xstrdup("locks_held");
505 values
[n
++] = xstrdup(status
.locks_held
);
507 if (status
.locks_waiting
&& status
.locks_waiting
[0]) {
508 keys
[n
] = xstrdup("locks_waiting");
509 values
[n
++] = xstrdup(status
.locks_waiting
);
511 if (status
.locks_lost
&& status
.locks_lost
[0]) {
512 keys
[n
] = xstrdup("locks_lost");
513 values
[n
++] = xstrdup(status
.locks_lost
);
515 if (status
.n_connections
> 1) {
516 keys
[n
] = xstrdup("n_connections");
517 values
[n
++] = xasprintf("%d", status
.n_connections
);
519 write_string_string_column(rw_row
, "status", keys
, values
, n
);
521 ovsdb_jsonrpc_server_free_remote_status(&status
);
525 update_remote_rows(const struct ovsdb
*db
, struct ovsdb_txn
*txn
,
526 const char *remote_name
,
527 const struct ovsdb_jsonrpc_server
*jsonrpc
)
529 const struct ovsdb_table
*table
, *ref_table
;
530 const struct ovsdb_column
*column
;
531 const struct ovsdb_row
*row
;
533 if (strncmp("db:", remote_name
, 3)) {
537 parse_db_column(db
, remote_name
, &table
, &column
);
539 if (column
->type
.key
.type
!= OVSDB_TYPE_UUID
540 || !column
->type
.key
.u
.uuid
.refTable
541 || column
->type
.value
.type
!= OVSDB_TYPE_VOID
) {
545 ref_table
= column
->type
.key
.u
.uuid
.refTable
;
547 HMAP_FOR_EACH (row
, hmap_node
, &table
->rows
) {
548 const struct ovsdb_datum
*datum
;
551 datum
= &row
->fields
[column
->index
];
552 for (i
= 0; i
< datum
->n
; i
++) {
553 const struct ovsdb_row
*ref_row
;
555 ref_row
= ovsdb_table_get_row(ref_table
, &datum
->keys
[i
].uuid
);
557 update_remote_row(ref_row
, txn
, jsonrpc
);
564 update_remote_status(const struct ovsdb_jsonrpc_server
*jsonrpc
,
565 const struct sset
*remotes
, struct ovsdb
*db
)
567 static struct vlog_rate_limit rl
= VLOG_RATE_LIMIT_INIT(1, 1);
568 struct ovsdb_txn
*txn
;
569 const bool durable_txn
= false;
570 struct ovsdb_error
*error
;
573 txn
= ovsdb_txn_create(db
);
575 /* Iterate over --remote arguments given on command line. */
576 SSET_FOR_EACH (remote
, remotes
) {
577 update_remote_rows(db
, txn
, remote
, jsonrpc
);
580 error
= ovsdb_txn_commit(txn
, durable_txn
);
582 VLOG_ERR_RL(&rl
, "Failed to update remote status: %s",
583 ovsdb_error_to_string(error
));
587 /* Reconfigures ovsdb-server based on information in the database. */
589 reconfigure_from_db(struct ovsdb_jsonrpc_server
*jsonrpc
,
590 const struct ovsdb
*db
, struct sset
*remotes
)
592 struct shash resolved_remotes
;
595 /* Configure remotes. */
596 shash_init(&resolved_remotes
);
597 SSET_FOR_EACH (name
, remotes
) {
598 if (!strncmp(name
, "db:", 3)) {
599 query_db_remotes(name
, db
, &resolved_remotes
);
601 add_remote(&resolved_remotes
, name
);
604 ovsdb_jsonrpc_server_set_remotes(jsonrpc
, &resolved_remotes
);
605 shash_destroy_free_data(&resolved_remotes
);
608 stream_ssl_set_key_and_cert(query_db_string(db
, private_key_file
),
609 query_db_string(db
, certificate_file
));
610 stream_ssl_set_ca_cert_file(query_db_string(db
, ca_cert_file
),
615 ovsdb_server_exit(struct unixctl_conn
*conn
, const char *args OVS_UNUSED
,
618 bool *exiting
= exiting_
;
620 unixctl_command_reply(conn
, 200, NULL
);
624 ovsdb_server_compact(struct unixctl_conn
*conn
, const char *args OVS_UNUSED
,
627 struct ovsdb_file
*file
= file_
;
628 struct ovsdb_error
*error
;
630 VLOG_INFO("compacting database by user request");
631 error
= ovsdb_file_compact(file
);
633 unixctl_command_reply(conn
, 200, NULL
);
635 char *s
= ovsdb_error_to_string(error
);
636 ovsdb_error_destroy(error
);
637 unixctl_command_reply(conn
, 503, s
);
642 /* "ovsdb-server/reconnect": makes ovsdb-server drop all of its JSON-RPC
643 * connections and reconnect. */
645 ovsdb_server_reconnect(struct unixctl_conn
*conn
, const char *args OVS_UNUSED
,
648 struct ovsdb_jsonrpc_server
*jsonrpc
= jsonrpc_
;
650 ovsdb_jsonrpc_server_reconnect(jsonrpc
);
651 unixctl_command_reply(conn
, 200, NULL
);
655 parse_options(int argc
, char *argv
[], char **file_namep
,
656 struct sset
*remotes
, char **unixctl_pathp
,
660 OPT_DUMMY
= UCHAR_MAX
+ 1,
664 OPT_BOOTSTRAP_CA_CERT
,
666 LEAK_CHECKER_OPTION_ENUMS
,
669 static struct option long_options
[] = {
670 {"remote", required_argument
, NULL
, OPT_REMOTE
},
671 {"unixctl", required_argument
, NULL
, OPT_UNIXCTL
},
672 {"run", required_argument
, NULL
, OPT_RUN
},
673 {"help", no_argument
, NULL
, 'h'},
674 {"version", no_argument
, NULL
, 'V'},
677 LEAK_CHECKER_LONG_OPTIONS
,
678 {"bootstrap-ca-cert", required_argument
, NULL
, OPT_BOOTSTRAP_CA_CERT
},
679 {"private-key", required_argument
, NULL
, 'p'},
680 {"certificate", required_argument
, NULL
, 'c'},
681 {"ca-cert", required_argument
, NULL
, 'C'},
684 char *short_options
= long_options_to_short_options(long_options
);
690 c
= getopt_long(argc
, argv
, short_options
, long_options
, NULL
);
697 sset_add(remotes
, optarg
);
701 *unixctl_pathp
= optarg
;
705 *run_command
= optarg
;
712 ovs_print_version(0, 0);
716 DAEMON_OPTION_HANDLERS
717 LEAK_CHECKER_OPTION_HANDLERS
720 private_key_file
= optarg
;
724 certificate_file
= optarg
;
728 ca_cert_file
= optarg
;
729 bootstrap_ca_cert
= false;
732 case OPT_BOOTSTRAP_CA_CERT
:
733 ca_cert_file
= optarg
;
734 bootstrap_ca_cert
= true;
751 *file_namep
= xasprintf("%s/openvswitch/conf.db", ovs_sysconfdir());
755 *file_namep
= xstrdup(argv
[0]);
759 ovs_fatal(0, "database file is only non-option argument; "
760 "use --help for usage");
767 printf("%s: Open vSwitch database server\n"
768 "usage: %s [OPTIONS] DATABASE\n"
769 "where DATABASE is a database file in ovsdb format.\n",
770 program_name
, program_name
);
771 printf("\nJSON-RPC options (may be specified any number of times):\n"
772 " --remote=REMOTE connect or listen to REMOTE\n");
773 stream_usage("JSON-RPC", true, true, true);
776 printf("\nOther options:\n"
777 " --run COMMAND run COMMAND as subprocess then exit\n"
778 " --unixctl=SOCKET override default control socket name\n"
779 " -h, --help display this help message\n"
780 " -V, --version display version information\n");
781 leak_checker_usage();