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", "", 0, 0, ovsdb_server_exit
, &exiting
);
139 unixctl_command_register("ovsdb-server/compact", "", 0, 0,
140 ovsdb_server_compact
, file
);
141 unixctl_command_register("ovsdb-server/reconnect", "", 0, 0,
142 ovsdb_server_reconnect
, jsonrpc
);
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(target
);
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 /* This function is used to read the string-string key-values from a map.
323 * Returns the true if the 'key' is found and returns the "value" associated
324 * with the 'key' in 'stringp', else returns false. */
326 read_map_string_column(const struct ovsdb_row
*row
, const char *column_name
,
327 const char **stringp
, const char *key
)
329 const struct ovsdb_datum
*datum
;
330 union ovsdb_atom
*atom_key
= NULL
, *atom_value
= NULL
;
333 datum
= get_datum((struct ovsdb_row
*) row
, column_name
, OVSDB_TYPE_STRING
,
334 OVSDB_TYPE_STRING
, UINT_MAX
);
341 for (i
= 0; i
< datum
->n
; i
++) {
342 atom_key
= &datum
->keys
[i
];
343 if (!strcmp(atom_key
->string
, key
)){
344 atom_value
= &datum
->values
[i
];
349 *stringp
= atom_value
? atom_value
->string
: NULL
;
350 return atom_value
!= NULL
;
353 static const union ovsdb_atom
*
354 read_column(const struct ovsdb_row
*row
, const char *column_name
,
355 enum ovsdb_atomic_type type
)
357 const struct ovsdb_datum
*datum
;
359 datum
= get_datum((struct ovsdb_row
*) row
, column_name
, type
, OVSDB_TYPE_VOID
,
361 return datum
&& datum
->n
? datum
->keys
: NULL
;
365 read_integer_column(const struct ovsdb_row
*row
, const char *column_name
,
366 long long int *integerp
)
368 const union ovsdb_atom
*atom
;
370 atom
= read_column(row
, column_name
, OVSDB_TYPE_INTEGER
);
371 *integerp
= atom
? atom
->integer
: 0;
376 read_string_column(const struct ovsdb_row
*row
, const char *column_name
,
377 const char **stringp
)
379 const union ovsdb_atom
*atom
;
381 atom
= read_column(row
, column_name
, OVSDB_TYPE_STRING
);
382 *stringp
= atom
? atom
->string
: NULL
;
387 write_bool_column(struct ovsdb_row
*row
, const char *column_name
, bool value
)
389 struct ovsdb_datum
*datum
= get_datum(row
, column_name
, OVSDB_TYPE_BOOLEAN
,
395 datum
->keys
[0].boolean
= value
;
399 write_string_string_column(struct ovsdb_row
*row
, const char *column_name
,
400 char **keys
, char **values
, size_t n
)
402 const struct ovsdb_column
*column
;
403 struct ovsdb_datum
*datum
;
406 column
= ovsdb_table_schema_get_column(row
->table
->schema
, column_name
);
407 datum
= get_datum(row
, column_name
, OVSDB_TYPE_STRING
, OVSDB_TYPE_STRING
,
413 /* Free existing data. */
414 ovsdb_datum_destroy(datum
, &column
->type
);
416 /* Allocate space for new values. */
418 datum
->keys
= xmalloc(n
* sizeof *datum
->keys
);
419 datum
->values
= xmalloc(n
* sizeof *datum
->values
);
421 for (i
= 0; i
< n
; ++i
) {
422 datum
->keys
[i
].string
= keys
[i
];
423 datum
->values
[i
].string
= values
[i
];
426 /* Sort and check constraints. */
427 ovsdb_datum_sort_assert(datum
, column
->type
.key
.type
);
430 /* Get the other config for the manager from the database. */
432 manager_get_other_config(const struct ovsdb_row
*row
,
433 struct ovsdb_jsonrpc_options
*options
)
435 const char *temp_string
;
437 /* Retrieve the configs and store in the options. */
438 if (read_map_string_column(row
, "other_config", &temp_string
, "dscp")) {
439 options
->dscp
= atoi(temp_string
);
441 options
->dscp
= DSCP_DEFAULT
;
445 /* Adds a remote and options to 'remotes', based on the Manager table row in
448 add_manager_options(struct shash
*remotes
, const struct ovsdb_row
*row
)
450 static struct vlog_rate_limit rl
= VLOG_RATE_LIMIT_INIT(1, 1);
451 struct ovsdb_jsonrpc_options
*options
;
452 long long int max_backoff
, probe_interval
;
455 if (!read_string_column(row
, "target", &target
) || !target
) {
456 VLOG_INFO_RL(&rl
, "Table `%s' has missing or invalid `target' column",
457 row
->table
->schema
->name
);
461 options
= add_remote(remotes
, target
);
462 if (read_integer_column(row
, "max_backoff", &max_backoff
)) {
463 options
->max_backoff
= max_backoff
;
465 if (read_integer_column(row
, "inactivity_probe", &probe_interval
)) {
466 options
->probe_interval
= probe_interval
;
469 manager_get_other_config(row
, options
);
473 query_db_remotes(const char *name
, const struct ovsdb
*db
,
474 struct shash
*remotes
)
476 const struct ovsdb_column
*column
;
477 const struct ovsdb_table
*table
;
478 const struct ovsdb_row
*row
;
480 parse_db_column(db
, name
, &table
, &column
);
482 if (column
->type
.key
.type
== OVSDB_TYPE_STRING
483 && column
->type
.value
.type
== OVSDB_TYPE_VOID
) {
484 HMAP_FOR_EACH (row
, hmap_node
, &table
->rows
) {
485 const struct ovsdb_datum
*datum
;
488 datum
= &row
->fields
[column
->index
];
489 for (i
= 0; i
< datum
->n
; i
++) {
490 add_remote(remotes
, datum
->keys
[i
].string
);
493 } else if (column
->type
.key
.type
== OVSDB_TYPE_UUID
494 && column
->type
.key
.u
.uuid
.refTable
495 && column
->type
.value
.type
== OVSDB_TYPE_VOID
) {
496 const struct ovsdb_table
*ref_table
= column
->type
.key
.u
.uuid
.refTable
;
497 HMAP_FOR_EACH (row
, hmap_node
, &table
->rows
) {
498 const struct ovsdb_datum
*datum
;
501 datum
= &row
->fields
[column
->index
];
502 for (i
= 0; i
< datum
->n
; i
++) {
503 const struct ovsdb_row
*ref_row
;
505 ref_row
= ovsdb_table_get_row(ref_table
, &datum
->keys
[i
].uuid
);
507 add_manager_options(remotes
, ref_row
);
515 update_remote_row(const struct ovsdb_row
*row
, struct ovsdb_txn
*txn
,
516 const struct ovsdb_jsonrpc_server
*jsonrpc
)
518 struct ovsdb_jsonrpc_remote_status status
;
519 struct ovsdb_row
*rw_row
;
521 char *keys
[8], *values
[8];
524 /* Get the "target" (protocol/host/port) spec. */
525 if (!read_string_column(row
, "target", &target
)) {
526 /* Bad remote spec or incorrect schema. */
529 rw_row
= ovsdb_txn_row_modify(txn
, row
);
530 ovsdb_jsonrpc_server_get_remote_status(jsonrpc
, target
, &status
);
532 /* Update status information columns. */
533 write_bool_column(rw_row
, "is_connected", status
.is_connected
);
536 keys
[n
] = xstrdup("state");
537 values
[n
++] = xstrdup(status
.state
);
539 if (status
.sec_since_connect
!= UINT_MAX
) {
540 keys
[n
] = xstrdup("sec_since_connect");
541 values
[n
++] = xasprintf("%u", status
.sec_since_connect
);
543 if (status
.sec_since_disconnect
!= UINT_MAX
) {
544 keys
[n
] = xstrdup("sec_since_disconnect");
545 values
[n
++] = xasprintf("%u", status
.sec_since_disconnect
);
547 if (status
.last_error
) {
548 keys
[n
] = xstrdup("last_error");
550 xstrdup(ovs_retval_to_string(status
.last_error
));
552 if (status
.locks_held
&& status
.locks_held
[0]) {
553 keys
[n
] = xstrdup("locks_held");
554 values
[n
++] = xstrdup(status
.locks_held
);
556 if (status
.locks_waiting
&& status
.locks_waiting
[0]) {
557 keys
[n
] = xstrdup("locks_waiting");
558 values
[n
++] = xstrdup(status
.locks_waiting
);
560 if (status
.locks_lost
&& status
.locks_lost
[0]) {
561 keys
[n
] = xstrdup("locks_lost");
562 values
[n
++] = xstrdup(status
.locks_lost
);
564 if (status
.n_connections
> 1) {
565 keys
[n
] = xstrdup("n_connections");
566 values
[n
++] = xasprintf("%d", status
.n_connections
);
568 write_string_string_column(rw_row
, "status", keys
, values
, n
);
570 ovsdb_jsonrpc_server_free_remote_status(&status
);
574 update_remote_rows(const struct ovsdb
*db
, struct ovsdb_txn
*txn
,
575 const char *remote_name
,
576 const struct ovsdb_jsonrpc_server
*jsonrpc
)
578 const struct ovsdb_table
*table
, *ref_table
;
579 const struct ovsdb_column
*column
;
580 const struct ovsdb_row
*row
;
582 if (strncmp("db:", remote_name
, 3)) {
586 parse_db_column(db
, remote_name
, &table
, &column
);
588 if (column
->type
.key
.type
!= OVSDB_TYPE_UUID
589 || !column
->type
.key
.u
.uuid
.refTable
590 || column
->type
.value
.type
!= OVSDB_TYPE_VOID
) {
594 ref_table
= column
->type
.key
.u
.uuid
.refTable
;
596 HMAP_FOR_EACH (row
, hmap_node
, &table
->rows
) {
597 const struct ovsdb_datum
*datum
;
600 datum
= &row
->fields
[column
->index
];
601 for (i
= 0; i
< datum
->n
; i
++) {
602 const struct ovsdb_row
*ref_row
;
604 ref_row
= ovsdb_table_get_row(ref_table
, &datum
->keys
[i
].uuid
);
606 update_remote_row(ref_row
, txn
, jsonrpc
);
613 update_remote_status(const struct ovsdb_jsonrpc_server
*jsonrpc
,
614 const struct sset
*remotes
, struct ovsdb
*db
)
616 static struct vlog_rate_limit rl
= VLOG_RATE_LIMIT_INIT(1, 1);
617 struct ovsdb_txn
*txn
;
618 const bool durable_txn
= false;
619 struct ovsdb_error
*error
;
622 txn
= ovsdb_txn_create(db
);
624 /* Iterate over --remote arguments given on command line. */
625 SSET_FOR_EACH (remote
, remotes
) {
626 update_remote_rows(db
, txn
, remote
, jsonrpc
);
629 error
= ovsdb_txn_commit(txn
, durable_txn
);
631 VLOG_ERR_RL(&rl
, "Failed to update remote status: %s",
632 ovsdb_error_to_string(error
));
636 /* Reconfigures ovsdb-server based on information in the database. */
638 reconfigure_from_db(struct ovsdb_jsonrpc_server
*jsonrpc
,
639 const struct ovsdb
*db
, struct sset
*remotes
)
641 struct shash resolved_remotes
;
644 /* Configure remotes. */
645 shash_init(&resolved_remotes
);
646 SSET_FOR_EACH (name
, remotes
) {
647 if (!strncmp(name
, "db:", 3)) {
648 query_db_remotes(name
, db
, &resolved_remotes
);
650 add_remote(&resolved_remotes
, name
);
653 ovsdb_jsonrpc_server_set_remotes(jsonrpc
, &resolved_remotes
);
654 shash_destroy_free_data(&resolved_remotes
);
657 stream_ssl_set_key_and_cert(query_db_string(db
, private_key_file
),
658 query_db_string(db
, certificate_file
));
659 stream_ssl_set_ca_cert_file(query_db_string(db
, ca_cert_file
),
664 ovsdb_server_exit(struct unixctl_conn
*conn
, int argc OVS_UNUSED
,
665 const char *argv
[] OVS_UNUSED
,
668 bool *exiting
= exiting_
;
670 unixctl_command_reply(conn
, NULL
);
674 ovsdb_server_compact(struct unixctl_conn
*conn
, int argc OVS_UNUSED
,
675 const char *argv
[] OVS_UNUSED
, void *file_
)
677 struct ovsdb_file
*file
= file_
;
678 struct ovsdb_error
*error
;
680 VLOG_INFO("compacting database by user request");
681 error
= ovsdb_file_compact(file
);
683 unixctl_command_reply(conn
, NULL
);
685 char *s
= ovsdb_error_to_string(error
);
686 ovsdb_error_destroy(error
);
687 unixctl_command_reply_error(conn
, s
);
692 /* "ovsdb-server/reconnect": makes ovsdb-server drop all of its JSON-RPC
693 * connections and reconnect. */
695 ovsdb_server_reconnect(struct unixctl_conn
*conn
, int argc OVS_UNUSED
,
696 const char *argv
[] OVS_UNUSED
, void *jsonrpc_
)
698 struct ovsdb_jsonrpc_server
*jsonrpc
= jsonrpc_
;
700 ovsdb_jsonrpc_server_reconnect(jsonrpc
);
701 unixctl_command_reply(conn
, NULL
);
705 parse_options(int argc
, char *argv
[], char **file_namep
,
706 struct sset
*remotes
, char **unixctl_pathp
,
710 OPT_DUMMY
= UCHAR_MAX
+ 1,
714 OPT_BOOTSTRAP_CA_CERT
,
716 LEAK_CHECKER_OPTION_ENUMS
,
719 static struct option long_options
[] = {
720 {"remote", required_argument
, NULL
, OPT_REMOTE
},
721 {"unixctl", required_argument
, NULL
, OPT_UNIXCTL
},
722 {"run", required_argument
, NULL
, OPT_RUN
},
723 {"help", no_argument
, NULL
, 'h'},
724 {"version", no_argument
, NULL
, 'V'},
727 LEAK_CHECKER_LONG_OPTIONS
,
728 {"bootstrap-ca-cert", required_argument
, NULL
, OPT_BOOTSTRAP_CA_CERT
},
729 {"private-key", required_argument
, NULL
, 'p'},
730 {"certificate", required_argument
, NULL
, 'c'},
731 {"ca-cert", required_argument
, NULL
, 'C'},
734 char *short_options
= long_options_to_short_options(long_options
);
740 c
= getopt_long(argc
, argv
, short_options
, long_options
, NULL
);
747 sset_add(remotes
, optarg
);
751 *unixctl_pathp
= optarg
;
755 *run_command
= optarg
;
762 ovs_print_version(0, 0);
766 DAEMON_OPTION_HANDLERS
767 LEAK_CHECKER_OPTION_HANDLERS
770 private_key_file
= optarg
;
774 certificate_file
= optarg
;
778 ca_cert_file
= optarg
;
779 bootstrap_ca_cert
= false;
782 case OPT_BOOTSTRAP_CA_CERT
:
783 ca_cert_file
= optarg
;
784 bootstrap_ca_cert
= true;
801 *file_namep
= xasprintf("%s/openvswitch/conf.db", ovs_sysconfdir());
805 *file_namep
= xstrdup(argv
[0]);
809 ovs_fatal(0, "database file is only non-option argument; "
810 "use --help for usage");
817 printf("%s: Open vSwitch database server\n"
818 "usage: %s [OPTIONS] DATABASE\n"
819 "where DATABASE is a database file in ovsdb format.\n",
820 program_name
, program_name
);
821 printf("\nJSON-RPC options (may be specified any number of times):\n"
822 " --remote=REMOTE connect or listen to REMOTE\n");
823 stream_usage("JSON-RPC", true, true, true);
826 printf("\nOther options:\n"
827 " --run COMMAND run COMMAND as subprocess then exit\n"
828 " --unixctl=SOCKET override default control socket name\n"
829 " -h, --help display this help message\n"
830 " -V, --version display version information\n");
831 leak_checker_usage();