1 /* Copyright (c) 2009, 2010 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.
26 #include "command-line.h"
31 #include "jsonrpc-server.h"
32 #include "leak-checker.h"
34 #include "ovsdb-data.h"
35 #include "ovsdb-types.h"
36 #include "ovsdb-error.h"
37 #include "poll-loop.h"
40 #include "stream-ssl.h"
46 #include "transaction.h"
52 VLOG_DEFINE_THIS_MODULE(ovsdb_server
);
55 /* SSL configuration. */
56 static char *private_key_file
;
57 static char *certificate_file
;
58 static char *ca_cert_file
;
59 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 shash
*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 shash
*remotes
);
74 static void update_remote_status(const struct ovsdb_jsonrpc_server
*jsonrpc
,
75 const struct shash
*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
,
104 die_if_already_running();
107 error
= ovsdb_file_open(file_name
, false, &db
, &file
);
109 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 shash_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
);
247 query_db_string(const struct ovsdb
*db
, const char *name
)
249 if (!name
|| strncmp(name
, "db:", 3)) {
252 const struct ovsdb_column
*column
;
253 const struct ovsdb_table
*table
;
254 const struct ovsdb_row
*row
;
256 parse_db_string_column(db
, name
, &table
, &column
);
258 HMAP_FOR_EACH (row
, hmap_node
, &table
->rows
) {
259 const struct ovsdb_datum
*datum
;
262 datum
= &row
->fields
[column
->index
];
263 for (i
= 0; i
< datum
->n
; i
++) {
264 if (datum
->keys
[i
].string
[0]) {
265 return datum
->keys
[i
].string
;
272 #endif /* HAVE_OPENSSL */
274 static struct ovsdb_jsonrpc_options
*
275 add_remote(struct shash
*remotes
, const char *target
)
277 struct ovsdb_jsonrpc_options
*options
;
279 options
= shash_find_data(remotes
, target
);
281 options
= ovsdb_jsonrpc_default_options();
282 shash_add(remotes
, target
, options
);
288 static struct ovsdb_datum
*
289 get_datum(struct ovsdb_row
*row
, const char *column_name
,
290 const enum ovsdb_atomic_type key_type
,
291 const enum ovsdb_atomic_type value_type
,
294 static struct vlog_rate_limit rl
= VLOG_RATE_LIMIT_INIT(1, 1);
295 const struct ovsdb_table_schema
*schema
= row
->table
->schema
;
296 const struct ovsdb_column
*column
;
298 column
= ovsdb_table_schema_get_column(schema
, column_name
);
300 VLOG_DBG_RL(&rl
, "Table `%s' has no `%s' column",
301 schema
->name
, column_name
);
305 if (column
->type
.key
.type
!= key_type
306 || column
->type
.value
.type
!= value_type
307 || column
->type
.n_max
!= n_max
) {
308 if (!VLOG_DROP_DBG(&rl
)) {
309 char *type_name
= ovsdb_type_to_english(&column
->type
);
310 VLOG_DBG("Table `%s' column `%s' has type %s, not expected "
311 "key type %s, value type %s, max elements %zd.",
312 schema
->name
, column_name
, type_name
,
313 ovsdb_atomic_type_to_string(key_type
),
314 ovsdb_atomic_type_to_string(value_type
),
321 return &row
->fields
[column
->index
];
324 static const union ovsdb_atom
*
325 read_column(const struct ovsdb_row
*row
, const char *column_name
,
326 enum ovsdb_atomic_type type
)
328 const struct ovsdb_datum
*datum
;
330 datum
= get_datum((struct ovsdb_row
*) row
, column_name
, type
, OVSDB_TYPE_VOID
, 1);
331 return datum
&& datum
->n
? datum
->keys
: NULL
;
335 read_integer_column(const struct ovsdb_row
*row
, const char *column_name
,
336 long long int *integerp
)
338 const union ovsdb_atom
*atom
;
340 atom
= read_column(row
, column_name
, OVSDB_TYPE_INTEGER
);
341 *integerp
= atom
? atom
->integer
: 0;
346 read_string_column(const struct ovsdb_row
*row
, const char *column_name
,
347 const char **stringp
)
349 const union ovsdb_atom
*atom
;
351 atom
= read_column(row
, column_name
, OVSDB_TYPE_STRING
);
352 *stringp
= atom
? atom
->string
: 0;
357 write_bool_column(struct ovsdb_row
*row
, const char *column_name
, bool value
)
359 struct ovsdb_datum
*datum
= get_datum(row
, column_name
, OVSDB_TYPE_BOOLEAN
,
365 datum
->keys
[0].boolean
= value
;
369 write_string_string_column(struct ovsdb_row
*row
, const char *column_name
,
370 char **keys
, char **values
, size_t n
)
372 const struct ovsdb_column
*column
;
373 struct ovsdb_datum
*datum
;
376 column
= ovsdb_table_schema_get_column(row
->table
->schema
, column_name
);
377 datum
= get_datum(row
, column_name
, OVSDB_TYPE_STRING
, OVSDB_TYPE_STRING
,
383 /* Free existing data. */
384 ovsdb_datum_destroy(datum
, &column
->type
);
386 /* Allocate space for new values. */
388 datum
->keys
= xmalloc(n
* sizeof *datum
->keys
);
389 datum
->values
= xmalloc(n
* sizeof *datum
->values
);
391 for (i
= 0; i
< n
; ++i
) {
392 datum
->keys
[i
].string
= keys
[i
];
393 datum
->values
[i
].string
= values
[i
];
396 /* Sort and check constraints. */
397 ovsdb_datum_sort_assert(datum
, column
->type
.key
.type
);
400 /* Adds a remote and options to 'remotes', based on the Manager table row in
403 add_manager_options(struct shash
*remotes
, const struct ovsdb_row
*row
)
405 static struct vlog_rate_limit rl
= VLOG_RATE_LIMIT_INIT(1, 1);
406 struct ovsdb_jsonrpc_options
*options
;
407 long long int max_backoff
, probe_interval
;
410 if (!read_string_column(row
, "target", &target
) || !target
) {
411 VLOG_INFO_RL(&rl
, "Table `%s' has missing or invalid `target' column",
412 row
->table
->schema
->name
);
416 options
= add_remote(remotes
, target
);
417 if (read_integer_column(row
, "max_backoff", &max_backoff
)) {
418 options
->max_backoff
= max_backoff
;
420 if (read_integer_column(row
, "inactivity_probe", &probe_interval
)) {
421 options
->probe_interval
= probe_interval
;
426 query_db_remotes(const char *name
, const struct ovsdb
*db
,
427 struct shash
*remotes
)
429 const struct ovsdb_column
*column
;
430 const struct ovsdb_table
*table
;
431 const struct ovsdb_row
*row
;
433 parse_db_column(db
, name
, &table
, &column
);
435 if (column
->type
.key
.type
== OVSDB_TYPE_STRING
436 && column
->type
.value
.type
== OVSDB_TYPE_VOID
) {
437 HMAP_FOR_EACH (row
, hmap_node
, &table
->rows
) {
438 const struct ovsdb_datum
*datum
;
441 datum
= &row
->fields
[column
->index
];
442 for (i
= 0; i
< datum
->n
; i
++) {
443 add_remote(remotes
, datum
->keys
[i
].string
);
446 } else if (column
->type
.key
.type
== OVSDB_TYPE_UUID
447 && column
->type
.key
.u
.uuid
.refTable
448 && column
->type
.value
.type
== OVSDB_TYPE_VOID
) {
449 const struct ovsdb_table
*ref_table
= column
->type
.key
.u
.uuid
.refTable
;
450 HMAP_FOR_EACH (row
, hmap_node
, &table
->rows
) {
451 const struct ovsdb_datum
*datum
;
454 datum
= &row
->fields
[column
->index
];
455 for (i
= 0; i
< datum
->n
; i
++) {
456 const struct ovsdb_row
*ref_row
;
458 ref_row
= ovsdb_table_get_row(ref_table
, &datum
->keys
[i
].uuid
);
460 add_manager_options(remotes
, ref_row
);
468 update_remote_row(const struct ovsdb_row
*row
, struct ovsdb_txn
*txn
,
469 const struct shash
*statuses
)
471 struct ovsdb_row
*rw_row
;
473 const struct ovsdb_jsonrpc_remote_status
*status
;
474 char *keys
[3], *values
[3];
477 /* Get the "target" (protocol/host/port) spec. */
478 if (!read_string_column(row
, "target", &target
)) {
479 /* Bad remote spec or incorrect schema. */
483 /* Prepare to modify this row. */
484 rw_row
= ovsdb_txn_row_modify(txn
, row
);
486 /* Find status information for this target. */
487 status
= shash_find_data(statuses
, target
);
489 /* Should never happen, but just in case... */
493 /* Update status information columns. */
495 write_bool_column(rw_row
, "is_connected",
496 status
->is_connected
);
498 keys
[n
] = xstrdup("state");
499 values
[n
++] = xstrdup(status
->state
);
500 keys
[n
] = xstrdup("time_in_state");
501 values
[n
++] = xasprintf("%u", status
->state_elapsed
);
502 if (status
->last_error
) {
503 keys
[n
] = xstrdup("last_error");
505 xstrdup(ovs_retval_to_string(status
->last_error
));
507 write_string_string_column(rw_row
, "status", keys
, values
, n
);
511 update_remote_rows(const struct ovsdb
*db
, struct ovsdb_txn
*txn
,
512 const char *remote_name
, const struct shash
*statuses
)
514 const struct ovsdb_table
*table
, *ref_table
;
515 const struct ovsdb_column
*column
;
516 const struct ovsdb_row
*row
;
518 if (strncmp("db:", remote_name
, 3)) {
522 parse_db_column(db
, remote_name
, &table
, &column
);
524 if (column
->type
.key
.type
!= OVSDB_TYPE_UUID
525 || !column
->type
.key
.u
.uuid
.refTable
526 || column
->type
.value
.type
!= OVSDB_TYPE_VOID
) {
530 ref_table
= column
->type
.key
.u
.uuid
.refTable
;
532 HMAP_FOR_EACH (row
, hmap_node
, &table
->rows
) {
533 const struct ovsdb_datum
*datum
;
536 datum
= &row
->fields
[column
->index
];
537 for (i
= 0; i
< datum
->n
; i
++) {
538 const struct ovsdb_row
*ref_row
;
540 ref_row
= ovsdb_table_get_row(ref_table
, &datum
->keys
[i
].uuid
);
542 update_remote_row(ref_row
, txn
, statuses
);
549 update_remote_status(const struct ovsdb_jsonrpc_server
*jsonrpc
,
550 const struct shash
*remotes
, struct ovsdb
*db
)
552 static struct vlog_rate_limit rl
= VLOG_RATE_LIMIT_INIT(1, 1);
553 struct shash_node
*remote
;
554 struct shash statuses
;
555 struct ovsdb_txn
*txn
;
556 const bool durable_txn
= false;
557 struct ovsdb_error
*error
;
559 /* Get status of current connections. */
560 ovsdb_jsonrpc_server_get_remote_status(jsonrpc
, &statuses
);
562 txn
= ovsdb_txn_create(db
);
564 /* Iterate over --remote arguments given on command line. */
565 SHASH_FOR_EACH (remote
, remotes
) {
566 update_remote_rows(db
, txn
, remote
->name
, &statuses
);
569 error
= ovsdb_txn_commit(txn
, durable_txn
);
571 VLOG_ERR_RL(&rl
, "Failed to update remote status: %s",
572 ovsdb_error_to_string(error
));
575 shash_destroy_free_data(&statuses
);
578 /* Reconfigures ovsdb-server based on information in the database. */
580 reconfigure_from_db(struct ovsdb_jsonrpc_server
*jsonrpc
,
581 const struct ovsdb
*db
, struct shash
*remotes
)
583 struct shash resolved_remotes
;
584 struct shash_node
*node
;
586 /* Configure remotes. */
587 shash_init(&resolved_remotes
);
588 SHASH_FOR_EACH (node
, remotes
) {
589 const char *name
= node
->name
;
591 if (!strncmp(name
, "db:", 3)) {
592 query_db_remotes(name
, db
, &resolved_remotes
);
594 add_remote(&resolved_remotes
, name
);
597 ovsdb_jsonrpc_server_set_remotes(jsonrpc
, &resolved_remotes
);
598 shash_destroy(&resolved_remotes
);
602 stream_ssl_set_key_and_cert(query_db_string(db
, private_key_file
),
603 query_db_string(db
, certificate_file
));
604 stream_ssl_set_ca_cert_file(query_db_string(db
, ca_cert_file
),
610 ovsdb_server_exit(struct unixctl_conn
*conn
, const char *args OVS_UNUSED
,
613 bool *exiting
= exiting_
;
615 unixctl_command_reply(conn
, 200, NULL
);
619 ovsdb_server_compact(struct unixctl_conn
*conn
, const char *args OVS_UNUSED
,
622 struct ovsdb_file
*file
= file_
;
623 struct ovsdb_error
*error
;
625 VLOG_INFO("compacting database by user request");
626 error
= ovsdb_file_compact(file
);
628 unixctl_command_reply(conn
, 200, NULL
);
630 char *s
= ovsdb_error_to_string(error
);
631 ovsdb_error_destroy(error
);
632 unixctl_command_reply(conn
, 503, s
);
637 /* "ovsdb-server/reconnect": makes ovsdb-server drop all of its JSON-RPC
638 * connections and reconnect. */
640 ovsdb_server_reconnect(struct unixctl_conn
*conn
, const char *args OVS_UNUSED
,
643 struct ovsdb_jsonrpc_server
*jsonrpc
= jsonrpc_
;
645 ovsdb_jsonrpc_server_reconnect(jsonrpc
);
646 unixctl_command_reply(conn
, 200, NULL
);
650 parse_options(int argc
, char *argv
[], char **file_namep
,
651 struct shash
*remotes
, char **unixctl_pathp
,
655 OPT_DUMMY
= UCHAR_MAX
+ 1,
659 OPT_BOOTSTRAP_CA_CERT
,
661 LEAK_CHECKER_OPTION_ENUMS
663 static struct option long_options
[] = {
664 {"remote", required_argument
, 0, OPT_REMOTE
},
665 {"unixctl", required_argument
, 0, OPT_UNIXCTL
},
666 {"run", required_argument
, 0, OPT_RUN
},
667 {"help", no_argument
, 0, 'h'},
668 {"version", no_argument
, 0, 'V'},
671 LEAK_CHECKER_LONG_OPTIONS
,
673 {"bootstrap-ca-cert", required_argument
, 0, OPT_BOOTSTRAP_CA_CERT
},
674 {"private-key", required_argument
, 0, 'p'},
675 {"certificate", required_argument
, 0, 'c'},
676 {"ca-cert", required_argument
, 0, 'C'},
680 char *short_options
= long_options_to_short_options(long_options
);
686 c
= getopt_long(argc
, argv
, short_options
, long_options
, NULL
);
693 shash_add_once(remotes
, optarg
, NULL
);
697 *unixctl_pathp
= optarg
;
701 *run_command
= optarg
;
708 OVS_PRINT_VERSION(0, 0);
712 DAEMON_OPTION_HANDLERS
713 LEAK_CHECKER_OPTION_HANDLERS
717 private_key_file
= optarg
;
721 certificate_file
= optarg
;
725 ca_cert_file
= optarg
;
726 bootstrap_ca_cert
= false;
729 case OPT_BOOTSTRAP_CA_CERT
:
730 ca_cert_file
= optarg
;
731 bootstrap_ca_cert
= true;
748 ovs_fatal(0, "database file is only non-option argument; "
749 "use --help for usage");
750 } else if (argc
< 1) {
751 ovs_fatal(0, "missing database file argument; use --help for usage");
754 *file_namep
= argv
[0];
760 printf("%s: Open vSwitch database server\n"
761 "usage: %s [OPTIONS] DATABASE\n"
762 "where DATABASE is a database file in ovsdb format.\n",
763 program_name
, program_name
);
764 printf("\nJSON-RPC options (may be specified any number of times):\n"
765 " --remote=REMOTE connect or listen to REMOTE\n");
766 stream_usage("JSON-RPC", true, true, true);
769 printf("\nOther options:\n"
770 " --run COMMAND run COMMAND as subprocess then exit\n"
771 " --unixctl=SOCKET override default control socket name\n"
772 " -h, --help display this help message\n"
773 " -V, --version display version information\n");
774 leak_checker_usage();