From patchwork Mon Mar 7 15:43:20 2016 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: =?utf-8?q?Daniel_P=2E_Berrang=C3=A9?= X-Patchwork-Id: 8520451 Return-Path: X-Original-To: patchwork-qemu-devel@patchwork.kernel.org Delivered-To: patchwork-parsemail@patchwork1.web.kernel.org Received: from mail.kernel.org (mail.kernel.org [198.145.29.136]) by patchwork1.web.kernel.org (Postfix) with ESMTP id A01D19F46A for ; Mon, 7 Mar 2016 15:44:01 +0000 (UTC) Received: from mail.kernel.org (localhost [127.0.0.1]) by mail.kernel.org (Postfix) with ESMTP id 865B52025A for ; Mon, 7 Mar 2016 15:44:00 +0000 (UTC) Received: from lists.gnu.org (lists.gnu.org [208.118.235.17]) (using TLSv1 with cipher AES256-SHA (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 40265201EC for ; Mon, 7 Mar 2016 15:43:59 +0000 (UTC) Received: from localhost ([::1]:56523 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1acxKA-00053W-Ir for patchwork-qemu-devel@patchwork.kernel.org; Mon, 07 Mar 2016 10:43:58 -0500 Received: from eggs.gnu.org ([2001:4830:134:3::10]:41456) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1acxJy-0004zH-PY for qemu-devel@nongnu.org; Mon, 07 Mar 2016 10:43:48 -0500 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1acxJv-0004Ii-42 for qemu-devel@nongnu.org; Mon, 07 Mar 2016 10:43:46 -0500 Received: from mx1.redhat.com ([209.132.183.28]:45798) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1acxJu-0004Id-Qa for qemu-devel@nongnu.org; Mon, 07 Mar 2016 10:43:43 -0500 Received: from int-mx09.intmail.prod.int.phx2.redhat.com (int-mx09.intmail.prod.int.phx2.redhat.com [10.5.11.22]) by mx1.redhat.com (Postfix) with ESMTPS id 6F6BE7EBB3; Mon, 7 Mar 2016 15:43:42 +0000 (UTC) Received: from t530wlan.home.berrange.com.com (vpn1-5-56.ams2.redhat.com [10.36.5.56]) by int-mx09.intmail.prod.int.phx2.redhat.com (8.14.4/8.14.4) with ESMTP id u27Fhcwi004748; Mon, 7 Mar 2016 10:43:40 -0500 From: "Daniel P. Berrange" To: qemu-devel@nongnu.org Date: Mon, 7 Mar 2016 15:43:20 +0000 Message-Id: <1457365409-2905-2-git-send-email-berrange@redhat.com> In-Reply-To: <1457365409-2905-1-git-send-email-berrange@redhat.com> References: <1457365409-2905-1-git-send-email-berrange@redhat.com> X-Scanned-By: MIMEDefang 2.68 on 10.5.11.22 X-detected-operating-system: by eggs.gnu.org: GNU/Linux 3.x X-Received-From: 209.132.183.28 Cc: Markus Armbruster , Max Reitz , Paolo Bonzini , =?UTF-8?q?Andreas=20F=C3=A4rber?= Subject: [Qemu-devel] [PATCH v2 01/10] qdict: implement a qdict_crumple method for un-flattening a dict X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.14 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+patchwork-qemu-devel=patchwork.kernel.org@nongnu.org Sender: qemu-devel-bounces+patchwork-qemu-devel=patchwork.kernel.org@nongnu.org X-Spam-Status: No, score=-6.9 required=5.0 tests=BAYES_00, RCVD_IN_DNSWL_HI, UNPARSEABLE_RELAY autolearn=unavailable version=3.3.1 X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on mail.kernel.org X-Virus-Scanned: ClamAV using ClamSMTP The qdict_flatten() method will take a dict whose elements are further nested dicts/lists and flatten them by concatenating keys. The qdict_crumple() method aims to do the reverse, taking a flat qdict, and turning it into a set of nested dicts/lists. It will apply nesting based on the key name, with a '.' indicating a new level in the hierarchy. If the keys in the nested structure are all numeric, it will create a list, otherwise it will create a dict. If the keys are a mixture of numeric and non-numeric, or the numeric keys are not in strictly ascending order, an error will be reported. As an example, a flat dict containing { 'foo.0.bar': 'one', 'foo.0.wizz': '1', 'foo.1.bar': 'two', 'foo.1.wizz': '2' } will get turned into a dict with one element 'foo' whose value is a list. The list elements will each in turn be dicts. { 'foo' => [ { 'bar': 'one', 'wizz': '1' } { 'bar': 'two', 'wizz': '2' } ], } If the key is intended to contain a literal '.', then it must be escaped as '..'. ie a flat dict { 'foo..bar': 'wizz', 'bar.foo..bar': 'eek', 'bar.hello': 'world' } Will end up as { 'foo.bar': 'wizz', 'bar': { 'foo.bar': 'eek', 'hello': 'world' } } The intent of this function is that it allows a set of QemuOpts to be turned into a nested data structure that mirrors the nested used when the same object is defined over QMP. Signed-off-by: Daniel P. Berrange --- include/qapi/qmp/qdict.h | 1 + qobject/qdict.c | 237 +++++++++++++++++++++++++++++++++++++++++++++++ tests/check-qdict.c | 114 +++++++++++++++++++++++ 3 files changed, 352 insertions(+) diff --git a/include/qapi/qmp/qdict.h b/include/qapi/qmp/qdict.h index 71b8eb0..8a3ac13 100644 --- a/include/qapi/qmp/qdict.h +++ b/include/qapi/qmp/qdict.h @@ -73,6 +73,7 @@ void qdict_flatten(QDict *qdict); void qdict_extract_subqdict(QDict *src, QDict **dst, const char *start); void qdict_array_split(QDict *src, QList **dst); int qdict_array_entries(QDict *src, const char *subqdict); +QObject *qdict_crumple(QDict *src, bool recursive, Error **errp); void qdict_join(QDict *dest, QDict *src, bool overwrite); diff --git a/qobject/qdict.c b/qobject/qdict.c index 9833bd0..b0f3447 100644 --- a/qobject/qdict.c +++ b/qobject/qdict.c @@ -682,6 +682,243 @@ void qdict_array_split(QDict *src, QList **dst) } } + +/** + * qdict_split_flat_key: + * + * Given a flattened key such as 'foo.0.bar', split it + * into two parts at the first '.' separator. Allows + * double dot ('..') to escape the normal separator. + * + * eg + * 'foo.0.bar' -> prefix='foo' and suffix='0.bar' + * 'foo..0.bar' -> prefix='foo.0' and suffix='bar' + * + * The '..' sequence will be unescaped in the returned + * 'prefix' string. The 'suffix' string will be left + * in escaped format, so it can be fed back into the + * qdict_split_flat_key() key as the input later. + */ +static void qdict_split_flat_key(const char *key, char **prefix, char **suffix) +{ + const char *separator; + size_t i, j; + + /* Find first '.' separator, but if there is a pair '..' + * that acts as an escape, so skip over '..' */ + separator = NULL; + do { + if (separator) { + separator += 2; + } else { + separator = key; + } + separator = strchr(separator, '.'); + } while (separator && *(separator + 1) == '.'); + + if (separator) { + *prefix = g_strndup(key, + separator - key); + *suffix = g_strdup(separator + 1); + } else { + *prefix = g_strdup(key); + *suffix = NULL; + } + + /* Unescape the '..' sequence into '.' */ + for (i = 0, j = 0; (*prefix)[i] != '\0'; i++, j++) { + if ((*prefix)[i] == '.' && + (*prefix)[i + 1] == '.') { + i++; + } + (*prefix)[j] = (*prefix)[i]; + } + (*prefix)[j] = '\0'; +} + + +/** + * qdict_crumple: + * + * Reverses the flattening done by qdict_flatten by + * crumpling the dicts into a nested structure. Similar + * qdict_array_split, but copes with arbitrary nesting + * of dicts & arrays, not meely one level of arrays + * + * { 'foo.0.bar': 'one', 'foo.0.wizz': '1', + * 'foo.1.bar': 'two', 'foo.1.wizz': '2' } + * + * => + * + * { + * 'foo' => [ + * { 'bar': 'one', 'wizz': '1' } + * { 'bar': 'two', 'wizz': '2' } + * ], + * } + * + */ +QObject *qdict_crumple(QDict *src, bool recursive, Error **errp) +{ + const QDictEntry *entry, *next; + QDict *two_level, *multi_level = NULL; + QObject *dst = NULL, *child; + bool isList = false; + ssize_t list_max = -1; + size_t list_len = 0; + size_t i; + int64_t val; + char *prefix, *suffix; + + two_level = qdict_new(); + entry = qdict_first(src); + + /* Step 1: split our totally flat dict into a two level dict */ + while (entry != NULL) { + next = qdict_next(src, entry); + + if (qobject_type(entry->value) == QTYPE_QDICT || + qobject_type(entry->value) == QTYPE_QLIST) { + error_setg(errp, "Value %s is not a scalar", + entry->key); + goto error; + } + + qdict_split_flat_key(entry->key, &prefix, &suffix); + + child = qdict_get(two_level, prefix); + if (suffix) { + if (child) { + if (qobject_type(child) != QTYPE_QDICT) { + error_setg(errp, "Key %s prefix is already set as a scalar", + prefix); + goto error; + } + } else { + child = (QObject *)qdict_new(); + qdict_put_obj(two_level, prefix, child); + } + qobject_incref(entry->value); + qdict_put_obj(qobject_to_qdict(child), suffix, entry->value); + } else { + if (child) { + error_setg(errp, "Key %s prefix is already set as a dict", + prefix); + goto error; + } + qobject_incref(entry->value); + qdict_put_obj(two_level, prefix, entry->value); + } + + g_free(suffix); + g_free(prefix); + suffix = prefix = NULL; + + entry = next; + } + + /* Step 2: optionally process the two level dict recursively + * into a multi-level dict */ + if (recursive) { + multi_level = qdict_new(); + entry = qdict_first(two_level); + while (entry != NULL) { + next = qdict_next(two_level, entry); + + if (qobject_type(entry->value) == QTYPE_QDICT) { + child = qdict_crumple(qobject_to_qdict(entry->value), + recursive, errp); + if (!child) { + goto error; + } + + qdict_put_obj(multi_level, entry->key, child); + } else { + qobject_incref(entry->value); + qdict_put_obj(multi_level, entry->key, entry->value); + } + + entry = next; + } + QDECREF(two_level); + } else { + multi_level = two_level; + } + two_level = NULL; + + /* Step 3: detect if we need to turn our dict into list */ + entry = qdict_first(multi_level); + while (entry != NULL) { + next = qdict_next(multi_level, entry); + + errno = 0; + if (qemu_strtoll(entry->key, NULL, 10, &val) == 0) { + if (!dst) { + dst = (QObject *)qlist_new(); + isList = true; + } else if (!isList) { + error_setg(errp, + "Key '%s' is for a list, but previous key is " + "for a dict", entry->key); + goto error; + } + list_len++; + if (val > list_max) { + list_max = val; + } + } else { + if (!dst) { + dst = (QObject *)multi_level; + qobject_incref(dst); + isList = false; + } else if (isList) { + error_setg(errp, + "Key '%s' is for a dict, but previous key is " + "for a list", entry->key); + goto error; + } + } + + entry = next; + } + + /* Step 4: Turn the dict into a list */ + if (isList) { + if (list_len != (list_max + 1)) { + error_setg(errp, "List indexes are not continuous, " + "saw %zu elements but %zu largest index", + list_len, list_max); + goto error; + } + + for (i = 0; i < list_len; i++) { + char *key = g_strdup_printf("%zu", i); + + child = qdict_get(multi_level, key); + g_free(key); + if (!child) { + error_setg(errp, "Unexpected missing list entry %zu", i); + goto error; + } + + qobject_incref(child); + qlist_append_obj((QList *)dst, child); + } + } + QDECREF(multi_level); + + return dst; + + error: + g_free(suffix); + g_free(prefix); + QDECREF(multi_level); + QDECREF(two_level); + qobject_decref(dst); + return NULL; +} + + /** * qdict_array_entries(): Returns the number of direct array entries if the * sub-QDict of src specified by the prefix in subqdict (or src itself for diff --git a/tests/check-qdict.c b/tests/check-qdict.c index a43056c..20aa1af 100644 --- a/tests/check-qdict.c +++ b/tests/check-qdict.c @@ -596,6 +596,113 @@ static void qdict_join_test(void) QDECREF(dict2); } + +static void qdict_crumple_test_nonrecursive(void) +{ + QDict *src, *dst, *rules; + QObject *child; + + src = qdict_new(); + qdict_put(src, "rule.0.match", qstring_from_str("fred")); + qdict_put(src, "rule.0.policy", qstring_from_str("allow")); + qdict_put(src, "rule.1.match", qstring_from_str("bob")); + qdict_put(src, "rule.1.policy", qstring_from_str("deny")); + + dst = (QDict *)qdict_crumple(src, false, &error_abort); + + g_assert_cmpint(qdict_size(dst), ==, 1); + + child = qdict_get(dst, "rule"); + g_assert_cmpint(qobject_type(child), ==, QTYPE_QDICT); + + rules = qdict_get_qdict(dst, "rule"); + + g_assert_cmpstr("fred", ==, qdict_get_str(rules, "0.match")); + g_assert_cmpstr("allow", ==, qdict_get_str(rules, "0.policy")); + g_assert_cmpstr("bob", ==, qdict_get_str(rules, "1.match")); + g_assert_cmpstr("deny", ==, qdict_get_str(rules, "1.policy")); + + QDECREF(src); + QDECREF(dst); +} + + +static void qdict_crumple_test_recursive(void) +{ + QDict *src, *dst, *rule; + QObject *child; + QList *rules; + + src = qdict_new(); + qdict_put(src, "rule.0.match", qstring_from_str("fred")); + qdict_put(src, "rule.0.policy", qstring_from_str("allow")); + qdict_put(src, "rule.1.match", qstring_from_str("bob")); + qdict_put(src, "rule.1.policy", qstring_from_str("deny")); + + dst = (QDict *)qdict_crumple(src, true, &error_abort); + + g_assert_cmpint(qdict_size(dst), ==, 1); + + child = qdict_get(dst, "rule"); + g_assert_cmpint(qobject_type(child), ==, QTYPE_QLIST); + + rules = qdict_get_qlist(dst, "rule"); + g_assert_cmpint(qlist_size(rules), ==, 2); + + rule = qobject_to_qdict(qlist_pop(rules)); + g_assert_cmpstr("fred", ==, qdict_get_str(rule, "match")); + g_assert_cmpstr("allow", ==, qdict_get_str(rule, "policy")); + QDECREF(rule); + + rule = qobject_to_qdict(qlist_pop(rules)); + g_assert_cmpstr("bob", ==, qdict_get_str(rule, "match")); + g_assert_cmpstr("deny", ==, qdict_get_str(rule, "policy")); + QDECREF(rule); + + QDECREF(src); + QDECREF(dst); +} + + +static void qdict_crumple_test_bad_inputs(void) +{ + QDict *src; + Error *error = NULL; + + src = qdict_new(); + /* rule.0 can't be both a string and a dict */ + qdict_put(src, "rule.0", qstring_from_str("fred")); + qdict_put(src, "rule.0.policy", qstring_from_str("allow")); + + g_assert(qdict_crumple(src, true, &error) == NULL); + g_assert(error != NULL); + error_free(error); + error = NULL; + QDECREF(src); + + src = qdict_new(); + /* rule can't be both a list and a dict */ + qdict_put(src, "rule.0", qstring_from_str("fred")); + qdict_put(src, "rule.a", qstring_from_str("allow")); + + g_assert(qdict_crumple(src, true, &error) == NULL); + g_assert(error != NULL); + error_free(error); + error = NULL; + QDECREF(src); + + src = qdict_new(); + /* The input should be flat, ie no dicts or lists */ + qdict_put(src, "rule.0", qdict_new()); + qdict_put(src, "rule.a", qstring_from_str("allow")); + + g_assert(qdict_crumple(src, true, &error) == NULL); + g_assert(error != NULL); + error_free(error); + error = NULL; + QDECREF(src); +} + /* * Errors test-cases */ @@ -743,6 +850,13 @@ int main(int argc, char **argv) g_test_add_func("/errors/put_exists", qdict_put_exists_test); g_test_add_func("/errors/get_not_exists", qdict_get_not_exists_test); + g_test_add_func("/public/crumple/nonrecursive", + qdict_crumple_test_nonrecursive); + g_test_add_func("/public/crumple/recursive", + qdict_crumple_test_recursive); + g_test_add_func("/public/crumple/bad_inputs", + qdict_crumple_test_bad_inputs); + /* The Big one */ if (g_test_slow()) { g_test_add_func("/stress/test", qdict_stress_test);