From patchwork Thu Mar 10 18:59:47 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: 8559421 Return-Path: X-Original-To: patchwork-qemu-devel@patchwork.kernel.org Delivered-To: patchwork-parsemail@patchwork2.web.kernel.org Received: from mail.kernel.org (mail.kernel.org [198.145.29.136]) by patchwork2.web.kernel.org (Postfix) with ESMTP id 52DE4C0553 for ; Thu, 10 Mar 2016 19:00:35 +0000 (UTC) Received: from mail.kernel.org (localhost [127.0.0.1]) by mail.kernel.org (Postfix) with ESMTP id 235112034E for ; Thu, 10 Mar 2016 19:00:34 +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 BD6152034B for ; Thu, 10 Mar 2016 19:00:32 +0000 (UTC) Received: from localhost ([::1]:50680 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1ae5p2-0003zX-6r for patchwork-qemu-devel@patchwork.kernel.org; Thu, 10 Mar 2016 14:00:32 -0500 Received: from eggs.gnu.org ([2001:4830:134:3::10]:46218) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1ae5on-0003v4-Kl for qemu-devel@nongnu.org; Thu, 10 Mar 2016 14:00:19 -0500 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1ae5ok-0003QW-NO for qemu-devel@nongnu.org; Thu, 10 Mar 2016 14:00:17 -0500 Received: from mx1.redhat.com ([209.132.183.28]:33545) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1ae5oa-0003Kr-K6; Thu, 10 Mar 2016 14:00:04 -0500 Received: from int-mx11.intmail.prod.int.phx2.redhat.com (int-mx11.intmail.prod.int.phx2.redhat.com [10.5.11.24]) by mx1.redhat.com (Postfix) with ESMTPS id 0578664D26; Thu, 10 Mar 2016 19:00:04 +0000 (UTC) Received: from t530wlan.home.berrange.com.com (vpn1-4-172.ams2.redhat.com [10.36.4.172]) by int-mx11.intmail.prod.int.phx2.redhat.com (8.14.4/8.14.4) with ESMTP id u2AJ01Mp002433; Thu, 10 Mar 2016 14:00:02 -0500 From: "Daniel P. Berrange" To: qemu-devel@nongnu.org Date: Thu, 10 Mar 2016 18:59:47 +0000 Message-Id: <1457636396-24983-1-git-send-email-berrange@redhat.com> In-Reply-To: <1457635927-23045-1-git-send-email-berrange@redhat.com> References: <1457635927-23045-1-git-send-email-berrange@redhat.com> X-Scanned-By: MIMEDefang 2.68 on 10.5.11.24 X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.39]); Thu, 10 Mar 2016 19:00:04 +0000 (UTC) X-detected-operating-system: by eggs.gnu.org: GNU/Linux 2.2.x-3.x [generic] X-Received-From: 209.132.183.28 Cc: qemu-block@nongnu.org, Markus Armbruster , Max Reitz , Paolo Bonzini , =?UTF-8?q?Andreas=20F=C3=A4rber?= Subject: [Qemu-devel] [PATCH v3 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 | 267 +++++++++++++++++++++++++++++++++++++++++++++++ tests/check-qdict.c | 143 +++++++++++++++++++++++++ 3 files changed, 411 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..3a01fcc 100644 --- a/qobject/qdict.c +++ b/qobject/qdict.c @@ -682,6 +682,273 @@ 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_list_size: + * @maybe_List: dict that may be only list elements + * + * Determine whether all keys in @maybe_list are + * valid list elements. They they are all valid, + * then this returns the number of elements. If + * they all look like non-numeric keys, then returns + * zero. If there is a mix of numeric and non-numeric + * keys, then an error is set as it is both a list + * and a dict at once. + * + * Returns: number of list elemets, 0 if a dict, -1 on error + */ +static ssize_t qdict_list_size(QDict *maybe_list, Error **errp) +{ + const QDictEntry *entry, *next; + ssize_t len = 0; + ssize_t max = -1; + int is_list = -1; + int64_t val; + + entry = qdict_first(maybe_list); + while (entry != NULL) { + next = qdict_next(maybe_list, entry); + + if (qemu_strtoll(entry->key, NULL, 10, &val) == 0) { + if (is_list == -1) { + is_list = 1; + } else if (!is_list) { + error_setg(errp, + "Key '%s' is for a list, but previous key is " + "for a dict", entry->key); + return -1; + } + len++; + if (val > max) { + max = val; + } + } else { + if (is_list == -1) { + is_list = 0; + } else if (is_list) { + error_setg(errp, + "Key '%s' is for a dict, but previous key is " + "for a list", entry->key); + return -1; + } + } + + entry = next; + } + + if (is_list == -1) { + is_list = 0; + } + + if (len != (max + 1)) { + error_setg(errp, "List indexes are not continuous, " + "saw %zd elements but %zd largest index", + len, max); + return -1; + } + + return is_list ? len : 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 merely 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; + ssize_t list_len; + size_t i; + char *prefix = NULL, *suffix = NULL; + + 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 */ + list_len = qdict_list_size(multi_level, errp); + if (list_len < 0) { + goto error; + } + + if (list_len) { + dst = QOBJECT(qlist_new()); + + 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(qobject_to_qlist(dst), child); + } + QDECREF(multi_level); + } else { + dst = QOBJECT(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..ea67544 100644 --- a/tests/check-qdict.c +++ b/tests/check-qdict.c @@ -596,6 +596,140 @@ static void qdict_join_test(void) QDECREF(dict2); } + +static void qdict_crumple_test_nonrecursive(void) +{ + QDict *src, *dst, *rules; + QObject *child, *res; + + 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")); + + res = qdict_crumple(src, false, &error_abort); + + g_assert_cmpint(qobject_type(res), ==, QTYPE_QDICT); + + dst = qobject_to_qdict(res); + + 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_cmpint(qdict_size(rules), ==, 4); + + 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, *res; + 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")); + + res = qdict_crumple(src, true, &error_abort); + + g_assert_cmpint(qobject_type(res), ==, QTYPE_QDICT); + + dst = qobject_to_qdict(res); + + 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_cmpint(qdict_size(rule), ==, 2); + 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_cmpint(qdict_size(rule), ==, 2); + 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_empty(void) +{ + QDict *src, *dst; + + src = qdict_new(); + + dst = (QDict *)qdict_crumple(src, true, &error_abort); + + g_assert_cmpint(qdict_size(dst), ==, 0); + + 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 +877,15 @@ 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/empty", + qdict_crumple_test_empty); + 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);