2 * Copyright (c) 2009, 2010, 2011, 2012, 2013 Nicira, Inc.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at:
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
26 #include "command-line.h"
27 #include "dynamic-string.h"
30 #include "ovsdb-data.h"
31 #include "ovsdb-error.h"
32 #include "ovsdb-idl.h"
33 #include "ovsdb-types.h"
34 #include "ovsdb/column.h"
35 #include "ovsdb/condition.h"
36 #include "ovsdb/file.h"
37 #include "ovsdb/log.h"
38 #include "ovsdb/mutation.h"
39 #include "ovsdb/ovsdb.h"
40 #include "ovsdb/query.h"
41 #include "ovsdb/row.h"
42 #include "ovsdb/server.h"
43 #include "ovsdb/table.h"
44 #include "ovsdb/transaction.h"
45 #include "ovsdb/trigger.h"
46 #include "poll-loop.h"
49 #include "tests/idltest.h"
54 NO_RETURN
static void usage(void);
55 static void parse_options(int argc
, char *argv
[]);
56 static struct command
*get_all_commands(void);
59 main(int argc
, char *argv
[])
61 set_program_name(argv
[0]);
62 parse_options(argc
, argv
);
63 run_command(argc
- optind
, argv
+ optind
, get_all_commands());
68 parse_options(int argc
, char *argv
[])
70 static const struct option long_options
[] = {
71 {"timeout", required_argument
, NULL
, 't'},
72 {"verbose", optional_argument
, NULL
, 'v'},
73 {"help", no_argument
, NULL
, 'h'},
76 char *short_options
= long_options_to_short_options(long_options
);
79 unsigned long int timeout
;
82 c
= getopt_long(argc
, argv
, short_options
, long_options
, NULL
);
89 timeout
= strtoul(optarg
, NULL
, 10);
91 ovs_fatal(0, "value %s on -t or --timeout is not at least 1",
102 vlog_set_verbosity(optarg
);
118 printf("%s: Open vSwitch database test utility\n"
119 "usage: %s [OPTIONS] COMMAND [ARG...]\n\n"
120 " log-io FILE FLAGS COMMAND...\n"
121 " open FILE with FLAGS, run COMMANDs\n"
123 " test ovsdb_atom_default()\n"
125 " test ovsdb_datum_default()\n"
126 " parse-atomic-type TYPE\n"
127 " parse TYPE as OVSDB atomic type, and re-serialize\n"
128 " parse-base-type TYPE\n"
129 " parse TYPE as OVSDB base type, and re-serialize\n"
131 " parse JSON as OVSDB type, and re-serialize\n"
132 " parse-atoms TYPE ATOM...\n"
133 " parse JSON ATOMs as atoms of TYPE, and re-serialize\n"
134 " parse-atom-strings TYPE ATOM...\n"
135 " parse string ATOMs as atoms of given TYPE, and re-serialize\n"
136 " sort-atoms TYPE ATOM...\n"
137 " print JSON ATOMs in sorted order\n"
138 " parse-data TYPE DATUM...\n"
139 " parse JSON DATUMs as data of given TYPE, and re-serialize\n"
140 " parse-data-strings TYPE DATUM...\n"
141 " parse string DATUMs as data of given TYPE, and re-serialize\n"
142 " parse-column NAME OBJECT\n"
143 " parse column NAME with info OBJECT, and re-serialize\n"
144 " parse-table NAME OBJECT [DEFAULT-IS-ROOT]\n"
145 " parse table NAME with info OBJECT\n"
146 " parse-row TABLE ROW..., and re-serialize\n"
147 " parse each ROW of defined TABLE\n"
148 " compare-row TABLE ROW...\n"
149 " mutually compare all of the ROWs, print those that are equal\n"
150 " parse-conditions TABLE CONDITION...\n"
151 " parse each CONDITION on TABLE, and re-serialize\n"
152 " evaluate-conditions TABLE [CONDITION,...] [ROW,...]\n"
153 " test CONDITIONS on TABLE against each ROW, print results\n"
154 " parse-mutations TABLE MUTATION...\n"
155 " parse each MUTATION on TABLE, and re-serialize\n"
156 " execute-mutations TABLE [MUTATION,...] [ROW,...]\n"
157 " execute MUTATIONS on TABLE on each ROW, print results\n"
158 " query TABLE [ROW,...] [CONDITION,...]\n"
159 " add each ROW to TABLE, then query and print the rows that\n"
160 " satisfy each CONDITION.\n"
161 " query-distinct TABLE [ROW,...] [CONDITION,...] COLUMNS\n"
162 " add each ROW to TABLE, then query and print the rows that\n"
163 " satisfy each CONDITION and have distinct COLUMNS.\n"
164 " parse-schema JSON\n"
165 " parse JSON as an OVSDB schema, and re-serialize\n"
166 " transact COMMAND\n"
167 " execute each specified transactional COMMAND:\n"
174 " execute SCHEMA TRANSACTION...\n"
175 " executes each TRANSACTION on an initially empty database\n"
176 " the specified SCHEMA\n"
177 " trigger SCHEMA TRANSACTION...\n"
178 " executes each TRANSACTION on an initially empty database\n"
179 " the specified SCHEMA. A TRANSACTION of the form\n"
180 " [\"advance\", NUMBER] advances NUMBER milliseconds in\n"
181 " simulated time, for causing triggers to time out.\n"
182 " idl SERVER [TRANSACTION...]\n"
183 " connect to SERVER and dump the contents of the database\n"
184 " as seen initially by the IDL implementation and after\n"
185 " executing each TRANSACTION. (Each TRANSACTION must modify\n"
186 " the database or this command will hang.)\n",
187 program_name
, program_name
);
189 printf("\nOther options:\n"
190 " -t, --timeout=SECS give up after SECS seconds\n"
191 " -h, --help display this help message\n");
195 /* Command helper functions. */
198 parse_json(const char *s
)
200 struct json
*json
= json_from_string(s
);
201 if (json
->type
== JSON_STRING
) {
202 ovs_fatal(0, "\"%s\": %s", s
, json
->u
.string
);
208 unbox_json(struct json
*json
)
210 if (json
->type
== JSON_ARRAY
&& json
->u
.array
.n
== 1) {
211 struct json
*inner
= json
->u
.array
.elems
[0];
212 json
->u
.array
.elems
[0] = NULL
;
221 print_and_free_json(struct json
*json
)
223 char *string
= json_to_string(json
, JSSF_SORT
);
230 print_and_free_ovsdb_error(struct ovsdb_error
*error
)
232 char *string
= ovsdb_error_to_string(error
);
233 ovsdb_error_destroy(error
);
239 check_ovsdb_error(struct ovsdb_error
*error
)
242 char *s
= ovsdb_error_to_string(error
);
243 ovsdb_error_destroy(error
);
244 ovs_fatal(0, "%s", s
);
249 die_if_error(char *error
)
252 ovs_fatal(0, "%s", error
);
256 /* Command implementations. */
259 do_log_io(int argc
, char *argv
[])
261 const char *name
= argv
[1];
262 char *mode_string
= argv
[2];
264 struct ovsdb_error
*error
;
265 enum ovsdb_log_open_mode mode
;
266 struct ovsdb_log
*log
;
269 if (!strcmp(mode_string
, "read-only")) {
270 mode
= OVSDB_LOG_READ_ONLY
;
271 } else if (!strcmp(mode_string
, "read/write")) {
272 mode
= OVSDB_LOG_READ_WRITE
;
273 } else if (!strcmp(mode_string
, "create")) {
274 mode
= OVSDB_LOG_CREATE
;
276 ovs_fatal(0, "unknown log-io open mode \"%s\"", mode_string
);
279 check_ovsdb_error(ovsdb_log_open(name
, mode
, -1, &log
));
280 printf("%s: open successful\n", name
);
282 for (i
= 3; i
< argc
; i
++) {
283 const char *command
= argv
[i
];
284 if (!strcmp(command
, "read")) {
287 error
= ovsdb_log_read(log
, &json
);
289 printf("%s: read: ", name
);
291 print_and_free_json(json
);
293 printf("end of log\n");
297 } else if (!strncmp(command
, "write:", 6)) {
298 struct json
*json
= parse_json(command
+ 6);
299 error
= ovsdb_log_write(log
, json
);
301 } else if (!strcmp(command
, "commit")) {
302 error
= ovsdb_log_commit(log
);
304 ovs_fatal(0, "unknown log-io command \"%s\"", command
);
307 char *s
= ovsdb_error_to_string(error
);
308 printf("%s: %s failed: %s\n", name
, command
, s
);
310 ovsdb_error_destroy(error
);
312 printf("%s: %s successful\n", name
, command
);
316 ovsdb_log_close(log
);
320 do_default_atoms(int argc OVS_UNUSED
, char *argv
[] OVS_UNUSED
)
324 for (type
= 0; type
< OVSDB_N_TYPES
; type
++) {
325 union ovsdb_atom atom
;
327 if (type
== OVSDB_TYPE_VOID
) {
331 printf("%s: ", ovsdb_atomic_type_to_string(type
));
333 ovsdb_atom_init_default(&atom
, type
);
334 if (!ovsdb_atom_equals(&atom
, ovsdb_atom_default(type
), type
)) {
338 ovsdb_atom_destroy(&atom
, type
);
345 do_default_data(int argc OVS_UNUSED
, char *argv
[] OVS_UNUSED
)
350 for (n_min
= 0; n_min
<= 1; n_min
++) {
351 for (key
= 0; key
< OVSDB_N_TYPES
; key
++) {
352 if (key
== OVSDB_TYPE_VOID
) {
355 for (value
= 0; value
< OVSDB_N_TYPES
; value
++) {
356 struct ovsdb_datum datum
;
357 struct ovsdb_type type
;
359 ovsdb_base_type_init(&type
.key
, key
);
360 ovsdb_base_type_init(&type
.value
, value
);
363 assert(ovsdb_type_is_valid(&type
));
365 printf("key %s, value %s, n_min %u: ",
366 ovsdb_atomic_type_to_string(key
),
367 ovsdb_atomic_type_to_string(value
), n_min
);
369 ovsdb_datum_init_default(&datum
, &type
);
370 if (!ovsdb_datum_equals(&datum
, ovsdb_datum_default(&type
),
375 ovsdb_datum_destroy(&datum
, &type
);
376 ovsdb_type_destroy(&type
);
385 do_parse_atomic_type(int argc OVS_UNUSED
, char *argv
[])
387 enum ovsdb_atomic_type type
;
390 json
= unbox_json(parse_json(argv
[1]));
391 check_ovsdb_error(ovsdb_atomic_type_from_json(&type
, json
));
393 print_and_free_json(ovsdb_atomic_type_to_json(type
));
397 do_parse_base_type(int argc OVS_UNUSED
, char *argv
[])
399 struct ovsdb_base_type base
;
402 json
= unbox_json(parse_json(argv
[1]));
403 check_ovsdb_error(ovsdb_base_type_from_json(&base
, json
));
405 print_and_free_json(ovsdb_base_type_to_json(&base
));
406 ovsdb_base_type_destroy(&base
);
410 do_parse_type(int argc OVS_UNUSED
, char *argv
[])
412 struct ovsdb_type type
;
415 json
= unbox_json(parse_json(argv
[1]));
416 check_ovsdb_error(ovsdb_type_from_json(&type
, json
));
418 print_and_free_json(ovsdb_type_to_json(&type
));
419 ovsdb_type_destroy(&type
);
423 do_parse_atoms(int argc
, char *argv
[])
425 struct ovsdb_base_type base
;
429 json
= unbox_json(parse_json(argv
[1]));
430 check_ovsdb_error(ovsdb_base_type_from_json(&base
, json
));
433 for (i
= 2; i
< argc
; i
++) {
434 struct ovsdb_error
*error
;
435 union ovsdb_atom atom
;
437 json
= unbox_json(parse_json(argv
[i
]));
438 error
= ovsdb_atom_from_json(&atom
, &base
, json
, NULL
);
442 print_and_free_ovsdb_error(error
);
444 print_and_free_json(ovsdb_atom_to_json(&atom
, base
.type
));
445 ovsdb_atom_destroy(&atom
, base
.type
);
448 ovsdb_base_type_destroy(&base
);
452 do_parse_atom_strings(int argc
, char *argv
[])
454 struct ovsdb_base_type base
;
458 json
= unbox_json(parse_json(argv
[1]));
459 check_ovsdb_error(ovsdb_base_type_from_json(&base
, json
));
462 for (i
= 2; i
< argc
; i
++) {
463 union ovsdb_atom atom
;
466 die_if_error(ovsdb_atom_from_string(&atom
, &base
, argv
[i
], NULL
));
469 ovsdb_atom_to_string(&atom
, base
.type
, &out
);
473 ovsdb_atom_destroy(&atom
, base
.type
);
475 ovsdb_base_type_destroy(&base
);
479 do_parse_data__(int argc
, char *argv
[],
481 (*parse
)(struct ovsdb_datum
*datum
,
482 const struct ovsdb_type
*type
,
483 const struct json
*json
,
484 struct ovsdb_symbol_table
*symtab
))
486 struct ovsdb_type type
;
490 json
= unbox_json(parse_json(argv
[1]));
491 check_ovsdb_error(ovsdb_type_from_json(&type
, json
));
494 for (i
= 2; i
< argc
; i
++) {
495 struct ovsdb_datum datum
;
497 json
= unbox_json(parse_json(argv
[i
]));
498 check_ovsdb_error(parse(&datum
, &type
, json
, NULL
));
501 print_and_free_json(ovsdb_datum_to_json(&datum
, &type
));
503 ovsdb_datum_destroy(&datum
, &type
);
505 ovsdb_type_destroy(&type
);
509 do_parse_data(int argc
, char *argv
[])
511 do_parse_data__(argc
, argv
, ovsdb_datum_from_json
);
515 do_parse_data_strings(int argc
, char *argv
[])
517 struct ovsdb_type type
;
521 json
= unbox_json(parse_json(argv
[1]));
522 check_ovsdb_error(ovsdb_type_from_json(&type
, json
));
525 for (i
= 2; i
< argc
; i
++) {
526 struct ovsdb_datum datum
;
529 die_if_error(ovsdb_datum_from_string(&datum
, &type
, argv
[i
], NULL
));
532 ovsdb_datum_to_string(&datum
, &type
, &out
);
536 ovsdb_datum_destroy(&datum
, &type
);
538 ovsdb_type_destroy(&type
);
541 static enum ovsdb_atomic_type compare_atoms_atomic_type
;
544 compare_atoms(const void *a_
, const void *b_
)
546 const union ovsdb_atom
*a
= a_
;
547 const union ovsdb_atom
*b
= b_
;
549 return ovsdb_atom_compare_3way(a
, b
, compare_atoms_atomic_type
);
553 do_sort_atoms(int argc OVS_UNUSED
, char *argv
[])
555 struct ovsdb_base_type base
;
556 union ovsdb_atom
*atoms
;
557 struct json
*json
, **json_atoms
;
561 json
= unbox_json(parse_json(argv
[1]));
562 check_ovsdb_error(ovsdb_base_type_from_json(&base
, json
));
565 json
= unbox_json(parse_json(argv
[2]));
566 if (json
->type
!= JSON_ARRAY
) {
567 ovs_fatal(0, "second argument must be array");
570 /* Convert JSON atoms to internal representation. */
571 n_atoms
= json
->u
.array
.n
;
572 atoms
= xmalloc(n_atoms
* sizeof *atoms
);
573 for (i
= 0; i
< n_atoms
; i
++) {
574 check_ovsdb_error(ovsdb_atom_from_json(&atoms
[i
], &base
,
575 json
->u
.array
.elems
[i
], NULL
));
580 compare_atoms_atomic_type
= base
.type
;
581 qsort(atoms
, n_atoms
, sizeof *atoms
, compare_atoms
);
583 /* Convert internal representation back to JSON. */
584 json_atoms
= xmalloc(n_atoms
* sizeof *json_atoms
);
585 for (i
= 0; i
< n_atoms
; i
++) {
586 json_atoms
[i
] = ovsdb_atom_to_json(&atoms
[i
], base
.type
);
587 ovsdb_atom_destroy(&atoms
[i
], base
.type
);
589 print_and_free_json(json_array_create(json_atoms
, n_atoms
));
591 ovsdb_base_type_destroy(&base
);
595 do_parse_column(int argc OVS_UNUSED
, char *argv
[])
597 struct ovsdb_column
*column
;
600 json
= parse_json(argv
[2]);
601 check_ovsdb_error(ovsdb_column_from_json(json
, argv
[1], &column
));
603 print_and_free_json(ovsdb_column_to_json(column
));
604 ovsdb_column_destroy(column
);
608 do_parse_table(int argc OVS_UNUSED
, char *argv
[])
610 struct ovsdb_table_schema
*ts
;
611 bool default_is_root
;
614 default_is_root
= argc
> 3 && !strcmp(argv
[3], "true");
616 json
= parse_json(argv
[2]);
617 check_ovsdb_error(ovsdb_table_schema_from_json(json
, argv
[1], &ts
));
619 print_and_free_json(ovsdb_table_schema_to_json(ts
, default_is_root
));
620 ovsdb_table_schema_destroy(ts
);
624 do_parse_rows(int argc
, char *argv
[])
626 struct ovsdb_column_set all_columns
;
627 struct ovsdb_table_schema
*ts
;
628 struct ovsdb_table
*table
;
632 json
= unbox_json(parse_json(argv
[1]));
633 check_ovsdb_error(ovsdb_table_schema_from_json(json
, "mytable", &ts
));
636 table
= ovsdb_table_create(ts
);
637 ovsdb_column_set_init(&all_columns
);
638 ovsdb_column_set_add_all(&all_columns
, table
);
640 for (i
= 2; i
< argc
; i
++) {
641 struct ovsdb_column_set columns
;
642 struct ovsdb_row
*row
;
644 ovsdb_column_set_init(&columns
);
645 row
= ovsdb_row_create(table
);
647 json
= unbox_json(parse_json(argv
[i
]));
648 check_ovsdb_error(ovsdb_row_from_json(row
, json
, NULL
, &columns
));
651 print_and_free_json(ovsdb_row_to_json(row
, &all_columns
));
653 if (columns
.n_columns
) {
659 for (j
= 0; j
< columns
.n_columns
; j
++) {
660 svec_add(&names
, columns
.columns
[j
]->name
);
663 s
= svec_join(&names
, ", ", "");
666 svec_destroy(&names
);
671 ovsdb_column_set_destroy(&columns
);
672 ovsdb_row_destroy(row
);
675 ovsdb_column_set_destroy(&all_columns
);
676 ovsdb_table_destroy(table
); /* Also destroys 'ts'. */
680 do_compare_rows(int argc
, char *argv
[])
682 struct ovsdb_column_set all_columns
;
683 struct ovsdb_table_schema
*ts
;
684 struct ovsdb_table
*table
;
685 struct ovsdb_row
**rows
;
691 json
= unbox_json(parse_json(argv
[1]));
692 check_ovsdb_error(ovsdb_table_schema_from_json(json
, "mytable", &ts
));
695 table
= ovsdb_table_create(ts
);
696 ovsdb_column_set_init(&all_columns
);
697 ovsdb_column_set_add_all(&all_columns
, table
);
700 rows
= xmalloc(sizeof *rows
* n_rows
);
701 names
= xmalloc(sizeof *names
* n_rows
);
702 for (i
= 0; i
< n_rows
; i
++) {
703 rows
[i
] = ovsdb_row_create(table
);
705 json
= parse_json(argv
[i
+ 2]);
706 if (json
->type
!= JSON_ARRAY
|| json
->u
.array
.n
!= 2
707 || json
->u
.array
.elems
[0]->type
!= JSON_STRING
) {
708 ovs_fatal(0, "\"%s\" does not have expected form "
709 "[\"name\", {data}]", argv
[i
]);
711 names
[i
] = xstrdup(json
->u
.array
.elems
[0]->u
.string
);
712 check_ovsdb_error(ovsdb_row_from_json(rows
[i
], json
->u
.array
.elems
[1],
716 for (i
= 0; i
< n_rows
; i
++) {
717 uint32_t i_hash
= ovsdb_row_hash_columns(rows
[i
], &all_columns
, 0);
718 for (j
= i
+ 1; j
< n_rows
; j
++) {
719 uint32_t j_hash
= ovsdb_row_hash_columns(rows
[j
], &all_columns
, 0);
720 if (ovsdb_row_equal_columns(rows
[i
], rows
[j
], &all_columns
)) {
721 printf("%s == %s\n", names
[i
], names
[j
]);
722 if (i_hash
!= j_hash
) {
723 printf("but hash(%s) != hash(%s)\n", names
[i
], names
[j
]);
726 } else if (i_hash
== j_hash
) {
727 printf("hash(%s) == hash(%s)\n", names
[i
], names
[j
]);
731 for (i
= 0; i
< n_rows
; i
++) {
732 ovsdb_row_destroy(rows
[i
]);
738 ovsdb_column_set_destroy(&all_columns
);
739 ovsdb_table_destroy(table
); /* Also destroys 'ts'. */
743 do_parse_conditions(int argc
, char *argv
[])
745 struct ovsdb_table_schema
*ts
;
750 json
= unbox_json(parse_json(argv
[1]));
751 check_ovsdb_error(ovsdb_table_schema_from_json(json
, "mytable", &ts
));
754 for (i
= 2; i
< argc
; i
++) {
755 struct ovsdb_condition cnd
;
756 struct ovsdb_error
*error
;
758 json
= parse_json(argv
[i
]);
759 error
= ovsdb_condition_from_json(ts
, json
, NULL
, &cnd
);
761 print_and_free_json(ovsdb_condition_to_json(&cnd
));
763 char *s
= ovsdb_error_to_string(error
);
764 ovs_error(0, "%s", s
);
766 ovsdb_error_destroy(error
);
771 ovsdb_condition_destroy(&cnd
);
773 ovsdb_table_schema_destroy(ts
);
779 do_evaluate_conditions(int argc OVS_UNUSED
, char *argv
[])
781 struct ovsdb_table_schema
*ts
;
782 struct ovsdb_table
*table
;
783 struct ovsdb_condition
*conditions
;
785 struct ovsdb_row
**rows
;
790 /* Parse table schema, create table. */
791 json
= unbox_json(parse_json(argv
[1]));
792 check_ovsdb_error(ovsdb_table_schema_from_json(json
, "mytable", &ts
));
795 table
= ovsdb_table_create(ts
);
797 /* Parse conditions. */
798 json
= parse_json(argv
[2]);
799 if (json
->type
!= JSON_ARRAY
) {
800 ovs_fatal(0, "CONDITION argument is not JSON array");
802 n_conditions
= json
->u
.array
.n
;
803 conditions
= xmalloc(n_conditions
* sizeof *conditions
);
804 for (i
= 0; i
< n_conditions
; i
++) {
805 check_ovsdb_error(ovsdb_condition_from_json(ts
, json
->u
.array
.elems
[i
],
806 NULL
, &conditions
[i
]));
811 json
= parse_json(argv
[3]);
812 if (json
->type
!= JSON_ARRAY
) {
813 ovs_fatal(0, "ROW argument is not JSON array");
815 n_rows
= json
->u
.array
.n
;
816 rows
= xmalloc(n_rows
* sizeof *rows
);
817 for (i
= 0; i
< n_rows
; i
++) {
818 rows
[i
] = ovsdb_row_create(table
);
819 check_ovsdb_error(ovsdb_row_from_json(rows
[i
], json
->u
.array
.elems
[i
],
824 for (i
= 0; i
< n_conditions
; i
++) {
825 printf("condition %2"PRIuSIZE
":", i
);
826 for (j
= 0; j
< n_rows
; j
++) {
827 bool result
= ovsdb_condition_evaluate(rows
[j
], &conditions
[i
]);
831 putchar(result
? 'T' : '-');
836 for (i
= 0; i
< n_conditions
; i
++) {
837 ovsdb_condition_destroy(&conditions
[i
]);
840 for (i
= 0; i
< n_rows
; i
++) {
841 ovsdb_row_destroy(rows
[i
]);
844 ovsdb_table_destroy(table
); /* Also destroys 'ts'. */
848 do_parse_mutations(int argc
, char *argv
[])
850 struct ovsdb_table_schema
*ts
;
855 json
= unbox_json(parse_json(argv
[1]));
856 check_ovsdb_error(ovsdb_table_schema_from_json(json
, "mytable", &ts
));
859 for (i
= 2; i
< argc
; i
++) {
860 struct ovsdb_mutation_set set
;
861 struct ovsdb_error
*error
;
863 json
= parse_json(argv
[i
]);
864 error
= ovsdb_mutation_set_from_json(ts
, json
, NULL
, &set
);
866 print_and_free_json(ovsdb_mutation_set_to_json(&set
));
868 char *s
= ovsdb_error_to_string(error
);
869 ovs_error(0, "%s", s
);
871 ovsdb_error_destroy(error
);
876 ovsdb_mutation_set_destroy(&set
);
878 ovsdb_table_schema_destroy(ts
);
884 do_execute_mutations(int argc OVS_UNUSED
, char *argv
[])
886 struct ovsdb_table_schema
*ts
;
887 struct ovsdb_table
*table
;
888 struct ovsdb_mutation_set
*sets
;
890 struct ovsdb_row
**rows
;
895 /* Parse table schema, create table. */
896 json
= unbox_json(parse_json(argv
[1]));
897 check_ovsdb_error(ovsdb_table_schema_from_json(json
, "mytable", &ts
));
900 table
= ovsdb_table_create(ts
);
902 /* Parse mutations. */
903 json
= parse_json(argv
[2]);
904 if (json
->type
!= JSON_ARRAY
) {
905 ovs_fatal(0, "MUTATION argument is not JSON array");
907 n_sets
= json
->u
.array
.n
;
908 sets
= xmalloc(n_sets
* sizeof *sets
);
909 for (i
= 0; i
< n_sets
; i
++) {
910 check_ovsdb_error(ovsdb_mutation_set_from_json(ts
,
911 json
->u
.array
.elems
[i
],
917 json
= parse_json(argv
[3]);
918 if (json
->type
!= JSON_ARRAY
) {
919 ovs_fatal(0, "ROW argument is not JSON array");
921 n_rows
= json
->u
.array
.n
;
922 rows
= xmalloc(n_rows
* sizeof *rows
);
923 for (i
= 0; i
< n_rows
; i
++) {
924 rows
[i
] = ovsdb_row_create(table
);
925 check_ovsdb_error(ovsdb_row_from_json(rows
[i
], json
->u
.array
.elems
[i
],
930 for (i
= 0; i
< n_sets
; i
++) {
931 printf("mutation %2"PRIuSIZE
":\n", i
);
932 for (j
= 0; j
< n_rows
; j
++) {
933 struct ovsdb_error
*error
;
934 struct ovsdb_row
*row
;
936 row
= ovsdb_row_clone(rows
[j
]);
937 error
= ovsdb_mutation_set_execute(row
, &sets
[i
]);
939 printf("row %"PRIuSIZE
": ", j
);
941 print_and_free_ovsdb_error(error
);
943 struct ovsdb_column_set columns
;
944 struct shash_node
*node
;
946 ovsdb_column_set_init(&columns
);
947 SHASH_FOR_EACH (node
, &ts
->columns
) {
948 struct ovsdb_column
*c
= node
->data
;
949 if (!ovsdb_datum_equals(&row
->fields
[c
->index
],
950 &rows
[j
]->fields
[c
->index
],
952 ovsdb_column_set_add(&columns
, c
);
955 if (columns
.n_columns
) {
956 print_and_free_json(ovsdb_row_to_json(row
, &columns
));
958 printf("no change\n");
960 ovsdb_column_set_destroy(&columns
);
962 ovsdb_row_destroy(row
);
967 for (i
= 0; i
< n_sets
; i
++) {
968 ovsdb_mutation_set_destroy(&sets
[i
]);
971 for (i
= 0; i
< n_rows
; i
++) {
972 ovsdb_row_destroy(rows
[i
]);
975 ovsdb_table_destroy(table
); /* Also destroys 'ts'. */
978 /* Inserts a row, without bothering to update metadata such as refcounts. */
980 put_row(struct ovsdb_table
*table
, struct ovsdb_row
*row
)
982 const struct uuid
*uuid
= ovsdb_row_get_uuid(row
);
983 if (!ovsdb_table_get_row(table
, uuid
)) {
984 hmap_insert(&table
->rows
, &row
->hmap_node
, uuid_hash(uuid
));
988 struct do_query_cbdata
{
989 struct uuid
*row_uuids
;
995 do_query_cb(const struct ovsdb_row
*row
, void *cbdata_
)
997 struct do_query_cbdata
*cbdata
= cbdata_
;
1000 for (i
= 0; i
< cbdata
->n_rows
; i
++) {
1001 if (uuid_equals(ovsdb_row_get_uuid(row
), &cbdata
->row_uuids
[i
])) {
1002 cbdata
->counts
[i
]++;
1010 do_query(int argc OVS_UNUSED
, char *argv
[])
1012 struct do_query_cbdata cbdata
;
1013 struct ovsdb_table_schema
*ts
;
1014 struct ovsdb_table
*table
;
1019 /* Parse table schema, create table. */
1020 json
= unbox_json(parse_json(argv
[1]));
1021 check_ovsdb_error(ovsdb_table_schema_from_json(json
, "mytable", &ts
));
1024 table
= ovsdb_table_create(ts
);
1026 /* Parse rows, add to table. */
1027 json
= parse_json(argv
[2]);
1028 if (json
->type
!= JSON_ARRAY
) {
1029 ovs_fatal(0, "ROW argument is not JSON array");
1031 cbdata
.n_rows
= json
->u
.array
.n
;
1032 cbdata
.row_uuids
= xmalloc(cbdata
.n_rows
* sizeof *cbdata
.row_uuids
);
1033 cbdata
.counts
= xmalloc(cbdata
.n_rows
* sizeof *cbdata
.counts
);
1034 for (i
= 0; i
< cbdata
.n_rows
; i
++) {
1035 struct ovsdb_row
*row
= ovsdb_row_create(table
);
1036 uuid_generate(ovsdb_row_get_uuid_rw(row
));
1037 check_ovsdb_error(ovsdb_row_from_json(row
, json
->u
.array
.elems
[i
],
1039 if (ovsdb_table_get_row(table
, ovsdb_row_get_uuid(row
))) {
1040 ovs_fatal(0, "duplicate UUID "UUID_FMT
" in table",
1041 UUID_ARGS(ovsdb_row_get_uuid(row
)));
1043 cbdata
.row_uuids
[i
] = *ovsdb_row_get_uuid(row
);
1044 put_row(table
, row
);
1048 /* Parse conditions and execute queries. */
1049 json
= parse_json(argv
[3]);
1050 if (json
->type
!= JSON_ARRAY
) {
1051 ovs_fatal(0, "CONDITION argument is not JSON array");
1053 for (i
= 0; i
< json
->u
.array
.n
; i
++) {
1054 struct ovsdb_condition cnd
;
1057 check_ovsdb_error(ovsdb_condition_from_json(ts
, json
->u
.array
.elems
[i
],
1060 memset(cbdata
.counts
, 0, cbdata
.n_rows
* sizeof *cbdata
.counts
);
1061 ovsdb_query(table
, &cnd
, do_query_cb
, &cbdata
);
1063 printf("query %2"PRIuSIZE
":", i
);
1064 for (j
= 0; j
< cbdata
.n_rows
; j
++) {
1068 if (cbdata
.counts
[j
]) {
1069 printf("%d", cbdata
.counts
[j
]);
1070 if (cbdata
.counts
[j
] > 1) {
1080 ovsdb_condition_destroy(&cnd
);
1084 ovsdb_table_destroy(table
); /* Also destroys 'ts'. */
1089 struct do_query_distinct_class
{
1090 struct ovsdb_row
*example
;
1094 struct do_query_distinct_row
{
1096 struct do_query_distinct_class
*class;
1100 do_query_distinct(int argc OVS_UNUSED
, char *argv
[])
1102 struct ovsdb_column_set columns
;
1103 struct ovsdb_table_schema
*ts
;
1104 struct ovsdb_table
*table
;
1105 struct do_query_distinct_row
*rows
;
1107 struct do_query_distinct_class
*classes
;
1113 /* Parse table schema, create table. */
1114 json
= unbox_json(parse_json(argv
[1]));
1115 check_ovsdb_error(ovsdb_table_schema_from_json(json
, "mytable", &ts
));
1118 table
= ovsdb_table_create(ts
);
1120 /* Parse column set. */
1121 json
= parse_json(argv
[4]);
1122 check_ovsdb_error(ovsdb_column_set_from_json(json
, table
->schema
,
1126 /* Parse rows, add to table. */
1127 json
= parse_json(argv
[2]);
1128 if (json
->type
!= JSON_ARRAY
) {
1129 ovs_fatal(0, "ROW argument is not JSON array");
1131 n_rows
= json
->u
.array
.n
;
1132 rows
= xmalloc(n_rows
* sizeof *rows
);
1133 classes
= xmalloc(n_rows
* sizeof *classes
);
1135 for (i
= 0; i
< n_rows
; i
++) {
1136 struct ovsdb_row
*row
;
1140 row
= ovsdb_row_create(table
);
1141 uuid_generate(ovsdb_row_get_uuid_rw(row
));
1142 check_ovsdb_error(ovsdb_row_from_json(row
, json
->u
.array
.elems
[i
],
1145 /* Initialize row and find equivalence class. */
1146 rows
[i
].uuid
= *ovsdb_row_get_uuid(row
);
1147 rows
[i
].class = NULL
;
1148 for (j
= 0; j
< n_classes
; j
++) {
1149 if (ovsdb_row_equal_columns(row
, classes
[j
].example
, &columns
)) {
1150 rows
[i
].class = &classes
[j
];
1154 if (!rows
[i
].class) {
1155 rows
[i
].class = &classes
[n_classes
];
1156 classes
[n_classes
].example
= ovsdb_row_clone(row
);
1160 /* Add row to table. */
1161 if (ovsdb_table_get_row(table
, ovsdb_row_get_uuid(row
))) {
1162 ovs_fatal(0, "duplicate UUID "UUID_FMT
" in table",
1163 UUID_ARGS(ovsdb_row_get_uuid(row
)));
1165 put_row(table
, row
);
1170 /* Parse conditions and execute queries. */
1171 json
= parse_json(argv
[3]);
1172 if (json
->type
!= JSON_ARRAY
) {
1173 ovs_fatal(0, "CONDITION argument is not JSON array");
1175 for (i
= 0; i
< json
->u
.array
.n
; i
++) {
1176 struct ovsdb_row_set results
;
1177 struct ovsdb_condition cnd
;
1180 check_ovsdb_error(ovsdb_condition_from_json(ts
, json
->u
.array
.elems
[i
],
1183 for (j
= 0; j
< n_classes
; j
++) {
1184 classes
[j
].count
= 0;
1186 ovsdb_row_set_init(&results
);
1187 ovsdb_query_distinct(table
, &cnd
, &columns
, &results
);
1188 for (j
= 0; j
< results
.n_rows
; j
++) {
1191 for (k
= 0; k
< n_rows
; k
++) {
1192 if (uuid_equals(ovsdb_row_get_uuid(results
.rows
[j
]),
1194 rows
[k
].class->count
++;
1198 ovsdb_row_set_destroy(&results
);
1200 printf("query %2"PRIuSIZE
":", i
);
1201 for (j
= 0; j
< n_rows
; j
++) {
1202 int count
= rows
[j
].class->count
;
1209 printf("%d", count
);
1211 } else if (count
== 1) {
1212 putchar("abcdefghijklmnopqrstuvwxyz"[rows
[j
].class - classes
]);
1219 ovsdb_condition_destroy(&cnd
);
1223 ovsdb_table_destroy(table
); /* Also destroys 'ts'. */
1229 do_parse_schema(int argc OVS_UNUSED
, char *argv
[])
1231 struct ovsdb_schema
*schema
;
1234 json
= parse_json(argv
[1]);
1235 check_ovsdb_error(ovsdb_schema_from_json(json
, &schema
));
1237 print_and_free_json(ovsdb_schema_to_json(schema
));
1238 ovsdb_schema_destroy(schema
);
1242 do_execute(int argc OVS_UNUSED
, char *argv
[])
1244 struct ovsdb_schema
*schema
;
1249 /* Create database. */
1250 json
= parse_json(argv
[1]);
1251 check_ovsdb_error(ovsdb_schema_from_json(json
, &schema
));
1253 db
= ovsdb_create(schema
);
1255 for (i
= 2; i
< argc
; i
++) {
1256 struct json
*params
, *result
;
1259 params
= parse_json(argv
[i
]);
1260 result
= ovsdb_execute(db
, NULL
, params
, 0, NULL
);
1261 s
= json_to_string(result
, JSSF_SORT
);
1264 json_destroy(params
);
1265 json_destroy(result
);
1271 struct test_trigger
{
1272 struct ovsdb_trigger trigger
;
1277 do_trigger_dump(struct test_trigger
*t
, long long int now
, const char *title
)
1279 struct json
*result
;
1282 result
= ovsdb_trigger_steal_result(&t
->trigger
);
1283 s
= json_to_string(result
, JSSF_SORT
);
1284 printf("t=%lld: trigger %d (%s): %s\n", now
, t
->number
, title
, s
);
1286 json_destroy(result
);
1287 ovsdb_trigger_destroy(&t
->trigger
);
1292 do_trigger(int argc OVS_UNUSED
, char *argv
[])
1294 struct ovsdb_schema
*schema
;
1295 struct ovsdb_session session
;
1296 struct ovsdb_server server
;
1303 /* Create database. */
1304 json
= parse_json(argv
[1]);
1305 check_ovsdb_error(ovsdb_schema_from_json(json
, &schema
));
1307 db
= ovsdb_create(schema
);
1309 ovsdb_server_init(&server
);
1310 ovsdb_server_add_db(&server
, db
);
1311 ovsdb_session_init(&session
, &server
);
1315 for (i
= 2; i
< argc
; i
++) {
1316 struct json
*params
= parse_json(argv
[i
]);
1317 if (params
->type
== JSON_ARRAY
1318 && json_array(params
)->n
== 2
1319 && json_array(params
)->elems
[0]->type
== JSON_STRING
1320 && !strcmp(json_string(json_array(params
)->elems
[0]), "advance")
1321 && json_array(params
)->elems
[1]->type
== JSON_INTEGER
) {
1322 now
+= json_integer(json_array(params
)->elems
[1]);
1323 json_destroy(params
);
1325 struct test_trigger
*t
= xmalloc(sizeof *t
);
1326 ovsdb_trigger_init(&session
, db
, &t
->trigger
, params
, now
);
1327 t
->number
= number
++;
1328 if (ovsdb_trigger_is_complete(&t
->trigger
)) {
1329 do_trigger_dump(t
, now
, "immediate");
1331 printf("t=%lld: new trigger %d\n", now
, t
->number
);
1335 ovsdb_trigger_run(db
, now
);
1336 while (!list_is_empty(&session
.completions
)) {
1337 do_trigger_dump(CONTAINER_OF(list_pop_front(&session
.completions
),
1338 struct test_trigger
, trigger
.node
),
1342 ovsdb_trigger_wait(db
, now
);
1343 poll_immediate_wake();
1347 ovsdb_server_destroy(&server
);
1352 do_help(int argc OVS_UNUSED
, char *argv
[] OVS_UNUSED
)
1357 /* "transact" command. */
1359 static struct ovsdb
*do_transact_db
;
1360 static struct ovsdb_txn
*do_transact_txn
;
1361 static struct ovsdb_table
*do_transact_table
;
1364 do_transact_commit(int argc OVS_UNUSED
, char *argv
[] OVS_UNUSED
)
1366 ovsdb_error_destroy(ovsdb_txn_commit(do_transact_txn
, false));
1367 do_transact_txn
= NULL
;
1371 do_transact_abort(int argc OVS_UNUSED
, char *argv
[] OVS_UNUSED
)
1373 ovsdb_txn_abort(do_transact_txn
);
1374 do_transact_txn
= NULL
;
1378 uuid_from_integer(int integer
, struct uuid
*uuid
)
1381 uuid
->parts
[3] = integer
;
1384 static const struct ovsdb_row
*
1385 do_transact_find_row(const char *uuid_string
)
1387 const struct ovsdb_row
*row
;
1390 uuid_from_integer(atoi(uuid_string
), &uuid
);
1391 row
= ovsdb_table_get_row(do_transact_table
, &uuid
);
1393 ovs_fatal(0, "table does not contain row with UUID "UUID_FMT
,
1400 do_transact_set_integer(struct ovsdb_row
*row
, const char *column_name
,
1403 if (integer
!= -1) {
1404 const struct ovsdb_column
*column
;
1406 column
= ovsdb_table_schema_get_column(do_transact_table
->schema
,
1408 row
->fields
[column
->index
].keys
[0].integer
= integer
;
1413 do_transact_get_integer(const struct ovsdb_row
*row
, const char *column_name
)
1415 const struct ovsdb_column
*column
;
1417 column
= ovsdb_table_schema_get_column(do_transact_table
->schema
,
1419 return row
->fields
[column
->index
].keys
[0].integer
;
1423 do_transact_set_i_j(struct ovsdb_row
*row
,
1424 const char *i_string
, const char *j_string
)
1426 do_transact_set_integer(row
, "i", atoi(i_string
));
1427 do_transact_set_integer(row
, "j", atoi(j_string
));
1431 do_transact_insert(int argc OVS_UNUSED
, char *argv
[] OVS_UNUSED
)
1433 struct ovsdb_row
*row
;
1436 row
= ovsdb_row_create(do_transact_table
);
1439 uuid
= ovsdb_row_get_uuid_rw(row
);
1440 uuid_from_integer(atoi(argv
[1]), uuid
);
1441 if (ovsdb_table_get_row(do_transact_table
, uuid
)) {
1442 ovs_fatal(0, "table already contains row with UUID "UUID_FMT
,
1446 do_transact_set_i_j(row
, argv
[2], argv
[3]);
1449 ovsdb_txn_row_insert(do_transact_txn
, row
);
1453 do_transact_delete(int argc OVS_UNUSED
, char *argv
[] OVS_UNUSED
)
1455 const struct ovsdb_row
*row
= do_transact_find_row(argv
[1]);
1456 ovsdb_txn_row_delete(do_transact_txn
, row
);
1460 do_transact_modify(int argc OVS_UNUSED
, char *argv
[] OVS_UNUSED
)
1462 const struct ovsdb_row
*row_ro
;
1463 struct ovsdb_row
*row_rw
;
1465 row_ro
= do_transact_find_row(argv
[1]);
1466 row_rw
= ovsdb_txn_row_modify(do_transact_txn
, row_ro
);
1467 do_transact_set_i_j(row_rw
, argv
[2], argv
[3]);
1471 compare_rows_by_uuid(const void *a_
, const void *b_
)
1473 struct ovsdb_row
*const *ap
= a_
;
1474 struct ovsdb_row
*const *bp
= b_
;
1476 return uuid_compare_3way(ovsdb_row_get_uuid(*ap
), ovsdb_row_get_uuid(*bp
));
1480 do_transact_print(int argc OVS_UNUSED
, char *argv
[] OVS_UNUSED
)
1482 const struct ovsdb_row
**rows
;
1483 const struct ovsdb_row
*row
;
1487 n_rows
= hmap_count(&do_transact_table
->rows
);
1488 rows
= xmalloc(n_rows
* sizeof *rows
);
1490 HMAP_FOR_EACH (row
, hmap_node
, &do_transact_table
->rows
) {
1493 assert(i
== n_rows
);
1495 qsort(rows
, n_rows
, sizeof *rows
, compare_rows_by_uuid
);
1497 for (i
= 0; i
< n_rows
; i
++) {
1498 printf("\n%"PRId32
": i=%d, j=%d",
1499 ovsdb_row_get_uuid(rows
[i
])->parts
[3],
1500 do_transact_get_integer(rows
[i
], "i"),
1501 do_transact_get_integer(rows
[i
], "j"));
1508 do_transact(int argc
, char *argv
[])
1510 static const struct command do_transact_commands
[] = {
1511 { "commit", NULL
, 0, 0, do_transact_commit
},
1512 { "abort", NULL
, 0, 0, do_transact_abort
},
1513 { "insert", NULL
, 2, 3, do_transact_insert
},
1514 { "delete", NULL
, 1, 1, do_transact_delete
},
1515 { "modify", NULL
, 2, 3, do_transact_modify
},
1516 { "print", NULL
, 0, 0, do_transact_print
},
1517 { NULL
, NULL
, 0, 0, NULL
},
1520 struct ovsdb_schema
*schema
;
1525 json
= parse_json("{\"name\": \"testdb\", "
1529 " {\"i\": {\"type\": \"integer\"}, "
1530 " \"j\": {\"type\": \"integer\"}}}}}");
1531 check_ovsdb_error(ovsdb_schema_from_json(json
, &schema
));
1533 do_transact_db
= ovsdb_create(schema
);
1534 do_transact_table
= ovsdb_get_table(do_transact_db
, "mytable");
1535 assert(do_transact_table
!= NULL
);
1537 for (i
= 1; i
< argc
; i
++) {
1538 struct json
*command
;
1543 command
= parse_json(argv
[i
]);
1544 if (command
->type
!= JSON_ARRAY
) {
1545 ovs_fatal(0, "transaction %d must be JSON array "
1546 "with at least 1 element", i
);
1549 n_args
= command
->u
.array
.n
;
1550 args
= xmalloc((n_args
+ 1) * sizeof *args
);
1551 for (j
= 0; j
< n_args
; j
++) {
1552 struct json
*s
= command
->u
.array
.elems
[j
];
1553 if (s
->type
!= JSON_STRING
) {
1554 ovs_fatal(0, "transaction %d argument %d must be JSON string",
1557 args
[j
] = xstrdup(json_string(s
));
1559 args
[n_args
] = NULL
;
1561 if (!do_transact_txn
) {
1562 do_transact_txn
= ovsdb_txn_create(do_transact_db
);
1565 for (j
= 0; j
< n_args
; j
++) {
1569 fputs(args
[j
], stdout
);
1572 run_command(n_args
, args
, do_transact_commands
);
1575 for (j
= 0; j
< n_args
; j
++) {
1579 json_destroy(command
);
1581 ovsdb_txn_abort(do_transact_txn
);
1582 ovsdb_destroy(do_transact_db
); /* Also destroys 'schema'. */
1586 compare_link1(const void *a_
, const void *b_
)
1588 const struct idltest_link1
*const *ap
= a_
;
1589 const struct idltest_link1
*const *bp
= b_
;
1590 const struct idltest_link1
*a
= *ap
;
1591 const struct idltest_link1
*b
= *bp
;
1593 return a
->i
< b
->i
? -1 : a
->i
> b
->i
;
1597 print_idl(struct ovsdb_idl
*idl
, int step
)
1599 const struct idltest_simple
*s
;
1600 const struct idltest_link1
*l1
;
1601 const struct idltest_link2
*l2
;
1604 IDLTEST_SIMPLE_FOR_EACH (s
, idl
) {
1607 printf("%03d: i=%"PRId64
" r=%g b=%s s=%s u="UUID_FMT
" ia=[",
1608 step
, s
->i
, s
->r
, s
->b
? "true" : "false",
1609 s
->s
, UUID_ARGS(&s
->u
));
1610 for (i
= 0; i
< s
->n_ia
; i
++) {
1611 printf("%s%"PRId64
, i
? " " : "", s
->ia
[i
]);
1614 for (i
= 0; i
< s
->n_ra
; i
++) {
1615 printf("%s%g", i
? " " : "", s
->ra
[i
]);
1618 for (i
= 0; i
< s
->n_ba
; i
++) {
1619 printf("%s%s", i
? " " : "", s
->ba
[i
] ? "true" : "false");
1622 for (i
= 0; i
< s
->n_sa
; i
++) {
1623 printf("%s%s", i
? " " : "", s
->sa
[i
]);
1626 for (i
= 0; i
< s
->n_ua
; i
++) {
1627 printf("%s"UUID_FMT
, i
? " " : "", UUID_ARGS(&s
->ua
[i
]));
1629 printf("] uuid="UUID_FMT
"\n", UUID_ARGS(&s
->header_
.uuid
));
1632 IDLTEST_LINK1_FOR_EACH (l1
, idl
) {
1633 struct idltest_link1
**links
;
1636 printf("%03d: i=%"PRId64
" k=", step
, l1
->i
);
1638 printf("%"PRId64
, l1
->k
->i
);
1641 links
= xmemdup(l1
->ka
, l1
->n_ka
* sizeof *l1
->ka
);
1642 qsort(links
, l1
->n_ka
, sizeof *links
, compare_link1
);
1643 for (i
= 0; i
< l1
->n_ka
; i
++) {
1644 printf("%s%"PRId64
, i
? " " : "", links
[i
]->i
);
1649 printf("%"PRId64
, l1
->l2
->i
);
1651 printf(" uuid="UUID_FMT
"\n", UUID_ARGS(&l1
->header_
.uuid
));
1654 IDLTEST_LINK2_FOR_EACH (l2
, idl
) {
1655 printf("%03d: i=%"PRId64
" l1=", step
, l2
->i
);
1657 printf("%"PRId64
, l2
->l1
->i
);
1659 printf(" uuid="UUID_FMT
"\n", UUID_ARGS(&l2
->header_
.uuid
));
1663 printf("%03d: empty\n", step
);
1668 parse_uuids(const struct json
*json
, struct ovsdb_symbol_table
*symtab
,
1673 if (json
->type
== JSON_STRING
&& uuid_from_string(&uuid
, json
->u
.string
)) {
1674 char *name
= xasprintf("#%"PRIuSIZE
"#", *n
);
1675 fprintf(stderr
, "%s = "UUID_FMT
"\n", name
, UUID_ARGS(&uuid
));
1676 ovsdb_symbol_table_put(symtab
, name
, &uuid
, false);
1679 } else if (json
->type
== JSON_ARRAY
) {
1682 for (i
= 0; i
< json
->u
.array
.n
; i
++) {
1683 parse_uuids(json
->u
.array
.elems
[i
], symtab
, n
);
1685 } else if (json
->type
== JSON_OBJECT
) {
1686 const struct shash_node
*node
;
1688 SHASH_FOR_EACH (node
, json_object(json
)) {
1689 parse_uuids(node
->data
, symtab
, n
);
1695 substitute_uuids(struct json
*json
, const struct ovsdb_symbol_table
*symtab
)
1697 if (json
->type
== JSON_STRING
) {
1698 const struct ovsdb_symbol
*symbol
;
1700 symbol
= ovsdb_symbol_table_get(symtab
, json
->u
.string
);
1702 free(json
->u
.string
);
1703 json
->u
.string
= xasprintf(UUID_FMT
, UUID_ARGS(&symbol
->uuid
));
1705 } else if (json
->type
== JSON_ARRAY
) {
1708 for (i
= 0; i
< json
->u
.array
.n
; i
++) {
1709 substitute_uuids(json
->u
.array
.elems
[i
], symtab
);
1711 } else if (json
->type
== JSON_OBJECT
) {
1712 const struct shash_node
*node
;
1714 SHASH_FOR_EACH (node
, json_object(json
)) {
1715 substitute_uuids(node
->data
, symtab
);
1720 static const struct idltest_simple
*
1721 idltest_find_simple(struct ovsdb_idl
*idl
, int i
)
1723 const struct idltest_simple
*s
;
1725 IDLTEST_SIMPLE_FOR_EACH (s
, idl
) {
1734 idl_set(struct ovsdb_idl
*idl
, char *commands
, int step
)
1736 char *cmd
, *save_ptr1
= NULL
;
1737 struct ovsdb_idl_txn
*txn
;
1738 enum ovsdb_idl_txn_status status
;
1739 bool increment
= false;
1741 txn
= ovsdb_idl_txn_create(idl
);
1742 for (cmd
= strtok_r(commands
, ",", &save_ptr1
); cmd
;
1743 cmd
= strtok_r(NULL
, ",", &save_ptr1
)) {
1744 char *save_ptr2
= NULL
;
1745 char *name
, *arg1
, *arg2
, *arg3
;
1747 name
= strtok_r(cmd
, " ", &save_ptr2
);
1748 arg1
= strtok_r(NULL
, " ", &save_ptr2
);
1749 arg2
= strtok_r(NULL
, " ", &save_ptr2
);
1750 arg3
= strtok_r(NULL
, " ", &save_ptr2
);
1752 if (!strcmp(name
, "set")) {
1753 const struct idltest_simple
*s
;
1756 ovs_fatal(0, "\"set\" command requires 3 arguments");
1759 s
= idltest_find_simple(idl
, atoi(arg1
));
1761 ovs_fatal(0, "\"set\" command asks for nonexistent "
1762 "i=%d", atoi(arg1
));
1765 if (!strcmp(arg2
, "b")) {
1766 idltest_simple_set_b(s
, atoi(arg3
));
1767 } else if (!strcmp(arg2
, "s")) {
1768 idltest_simple_set_s(s
, arg3
);
1769 } else if (!strcmp(arg2
, "u")) {
1771 if (!uuid_from_string(&uuid
, arg3
)) {
1772 ovs_fatal(0, "\"%s\" is not a valid UUID", arg3
);
1774 idltest_simple_set_u(s
, uuid
);
1775 } else if (!strcmp(arg2
, "r")) {
1776 idltest_simple_set_r(s
, atof(arg3
));
1778 ovs_fatal(0, "\"set\" command asks for unknown column %s",
1781 } else if (!strcmp(name
, "insert")) {
1782 struct idltest_simple
*s
;
1784 if (!arg1
|| arg2
) {
1785 ovs_fatal(0, "\"insert\" command requires 1 argument");
1788 s
= idltest_simple_insert(txn
);
1789 idltest_simple_set_i(s
, atoi(arg1
));
1790 } else if (!strcmp(name
, "delete")) {
1791 const struct idltest_simple
*s
;
1793 if (!arg1
|| arg2
) {
1794 ovs_fatal(0, "\"delete\" command requires 1 argument");
1797 s
= idltest_find_simple(idl
, atoi(arg1
));
1799 ovs_fatal(0, "\"delete\" command asks for nonexistent "
1800 "i=%d", atoi(arg1
));
1802 idltest_simple_delete(s
);
1803 } else if (!strcmp(name
, "verify")) {
1804 const struct idltest_simple
*s
;
1806 if (!arg2
|| arg3
) {
1807 ovs_fatal(0, "\"verify\" command requires 2 arguments");
1810 s
= idltest_find_simple(idl
, atoi(arg1
));
1812 ovs_fatal(0, "\"verify\" command asks for nonexistent "
1813 "i=%d", atoi(arg1
));
1816 if (!strcmp(arg2
, "i")) {
1817 idltest_simple_verify_i(s
);
1818 } else if (!strcmp(arg2
, "b")) {
1819 idltest_simple_verify_b(s
);
1820 } else if (!strcmp(arg2
, "s")) {
1821 idltest_simple_verify_s(s
);
1822 } else if (!strcmp(arg2
, "u")) {
1823 idltest_simple_verify_s(s
);
1824 } else if (!strcmp(arg2
, "r")) {
1825 idltest_simple_verify_r(s
);
1827 ovs_fatal(0, "\"verify\" command asks for unknown column %s",
1830 } else if (!strcmp(name
, "increment")) {
1831 const struct idltest_simple
*s
;
1833 if (!arg1
|| arg2
) {
1834 ovs_fatal(0, "\"increment\" command requires 1 argument");
1837 s
= idltest_find_simple(idl
, atoi(arg1
));
1839 ovs_fatal(0, "\"set\" command asks for nonexistent "
1840 "i=%d", atoi(arg1
));
1843 ovsdb_idl_txn_increment(txn
, &s
->header_
, &idltest_simple_col_i
);
1845 } else if (!strcmp(name
, "abort")) {
1846 ovsdb_idl_txn_abort(txn
);
1848 } else if (!strcmp(name
, "destroy")) {
1849 printf("%03d: destroy\n", step
);
1850 ovsdb_idl_txn_destroy(txn
);
1853 ovs_fatal(0, "unknown command %s", name
);
1857 status
= ovsdb_idl_txn_commit_block(txn
);
1858 printf("%03d: commit, status=%s",
1859 step
, ovsdb_idl_txn_status_to_string(status
));
1861 printf(", increment=%"PRId64
,
1862 ovsdb_idl_txn_get_increment_new_value(txn
));
1865 ovsdb_idl_txn_destroy(txn
);
1869 do_idl(int argc
, char *argv
[])
1871 struct jsonrpc
*rpc
;
1872 struct ovsdb_idl
*idl
;
1873 unsigned int seqno
= 0;
1874 struct ovsdb_symbol_table
*symtab
;
1882 idl
= ovsdb_idl_create(argv
[1], &idltest_idl_class
, true, true);
1884 struct stream
*stream
;
1886 error
= stream_open_block(jsonrpc_stream_open(argv
[1], &stream
,
1887 DSCP_DEFAULT
), &stream
);
1889 ovs_fatal(error
, "failed to connect to \"%s\"", argv
[1]);
1891 rpc
= jsonrpc_open(stream
);
1896 setvbuf(stdout
, NULL
, _IONBF
, 0);
1898 symtab
= ovsdb_symbol_table_create();
1899 for (i
= 2; i
< argc
; i
++) {
1900 char *arg
= argv
[i
];
1901 struct jsonrpc_msg
*request
, *reply
;
1904 /* The previous transaction didn't change anything. */
1907 /* Wait for update. */
1910 if (ovsdb_idl_get_seqno(idl
) != seqno
) {
1915 ovsdb_idl_wait(idl
);
1921 print_idl(idl
, step
++);
1923 seqno
= ovsdb_idl_get_seqno(idl
);
1925 if (!strcmp(arg
, "reconnect")) {
1926 printf("%03d: reconnect\n", step
++);
1927 ovsdb_idl_force_reconnect(idl
);
1928 } else if (arg
[0] != '[') {
1929 idl_set(idl
, arg
, step
++);
1931 struct json
*json
= parse_json(arg
);
1932 substitute_uuids(json
, symtab
);
1933 request
= jsonrpc_create_request("transact", json
, NULL
);
1934 error
= jsonrpc_transact_block(rpc
, request
, &reply
);
1935 if (error
|| reply
->error
) {
1936 ovs_fatal(error
, "jsonrpc transaction failed");
1938 printf("%03d: ", step
++);
1939 if (reply
->result
) {
1940 parse_uuids(reply
->result
, symtab
, &n_uuids
);
1942 json_destroy(reply
->id
);
1944 print_and_free_json(jsonrpc_msg_to_json(reply
));
1947 ovsdb_symbol_table_destroy(symtab
);
1954 if (ovsdb_idl_get_seqno(idl
) != seqno
) {
1957 ovsdb_idl_wait(idl
);
1960 print_idl(idl
, step
++);
1961 ovsdb_idl_destroy(idl
);
1962 printf("%03d: done\n", step
);
1965 static struct command all_commands
[] = {
1966 { "log-io", NULL
, 2, INT_MAX
, do_log_io
},
1967 { "default-atoms", NULL
, 0, 0, do_default_atoms
},
1968 { "default-data", NULL
, 0, 0, do_default_data
},
1969 { "parse-atomic-type", NULL
, 1, 1, do_parse_atomic_type
},
1970 { "parse-base-type", NULL
, 1, 1, do_parse_base_type
},
1971 { "parse-type", NULL
, 1, 1, do_parse_type
},
1972 { "parse-atoms", NULL
, 2, INT_MAX
, do_parse_atoms
},
1973 { "parse-atom-strings", NULL
, 2, INT_MAX
, do_parse_atom_strings
},
1974 { "parse-data", NULL
, 2, INT_MAX
, do_parse_data
},
1975 { "parse-data-strings", NULL
, 2, INT_MAX
, do_parse_data_strings
},
1976 { "sort-atoms", NULL
, 2, 2, do_sort_atoms
},
1977 { "parse-column", NULL
, 2, 2, do_parse_column
},
1978 { "parse-table", NULL
, 2, 3, do_parse_table
},
1979 { "parse-rows", NULL
, 2, INT_MAX
, do_parse_rows
},
1980 { "compare-rows", NULL
, 2, INT_MAX
, do_compare_rows
},
1981 { "parse-conditions", NULL
, 2, INT_MAX
, do_parse_conditions
},
1982 { "evaluate-conditions", NULL
, 3, 3, do_evaluate_conditions
},
1983 { "parse-mutations", NULL
, 2, INT_MAX
, do_parse_mutations
},
1984 { "execute-mutations", NULL
, 3, 3, do_execute_mutations
},
1985 { "query", NULL
, 3, 3, do_query
},
1986 { "query-distinct", NULL
, 4, 4, do_query_distinct
},
1987 { "transact", NULL
, 1, INT_MAX
, do_transact
},
1988 { "parse-schema", NULL
, 1, 1, do_parse_schema
},
1989 { "execute", NULL
, 2, INT_MAX
, do_execute
},
1990 { "trigger", NULL
, 2, INT_MAX
, do_trigger
},
1991 { "idl", NULL
, 1, INT_MAX
, do_idl
},
1992 { "help", NULL
, 0, INT_MAX
, do_help
},
1993 { NULL
, NULL
, 0, 0, NULL
},
1996 static struct command
*
1997 get_all_commands(void)
1999 return all_commands
;