From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: From: Vladislav Shpilevoy Subject: [PATCH v2 03/10] yaml: introduce yaml.decode_tag Date: Fri, 20 Apr 2018 16:24:28 +0300 Message-Id: <0bce785538bba5d81f6c813732a7e309a941e175.1524228894.git.v.shpilevoy@tarantool.org> In-Reply-To: References: In-Reply-To: References: To: tarantool-patches@freelists.org Cc: vdavydov.dev@gmail.com List-ID: Yaml.decode_tag allows to decode a single tag of a YAML document. For #2677 it is needed to detect different push types in text console: print pushes via console.print, and actual pushes via box.session.push. To distinguish them YAML tags will be used. A client console for each message will try to find a tag. If a tag is absent, then the message is a simple response on a request. If a tag is !print!, then the document consists of a single string, that must be printed. Such a document must be decoded to get the printed string. So the calls sequence is yaml.decode_tag + yaml.decode. The reason why a print message must be decoded is that a print() result on a server side can be not well-formatted YAML, and must be encoded into it to be correctly send. For example, when I do on a server side something like this: console.print('very bad YAML string') The result of a print() is not a YAML document, and to be sent it must be encoded into YAML on a server side. If a tag is !push!, then the document is sent via box.session.push, and must not be decoded. It can be just printed or ignored or something. Needed for #2677 --- test/app-tap/yaml.test.lua | 30 ++++++++++++++++++- third_party/lua-yaml/lyaml.cc | 67 +++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 96 insertions(+), 1 deletion(-) diff --git a/test/app-tap/yaml.test.lua b/test/app-tap/yaml.test.lua index b81402cc0..ef64509fe 100755 --- a/test/app-tap/yaml.test.lua +++ b/test/app-tap/yaml.test.lua @@ -70,7 +70,10 @@ local function test_output(test, s) end local function test_tagged(test, s) - test:plan(7) + test:plan(15) + -- + -- Test encoding tags. + -- local must_be_err = 'Usage: encode_tagged({prefix = , handle = }, object)' local prefix = 'tag:tarantool.io/push,2018' local ok, err = pcall(s.encode_tagged) @@ -87,6 +90,31 @@ local function test_tagged(test, s) test:is(ret, "%TAG !push! "..prefix.."\n--- 300\n...\n", "encode_tagged usage") ret = s.encode_tagged({handle = '!print!', prefix = prefix}, {a = 100, b = 200}) test:is(ret, "%TAG !print! tag:tarantool.io/push,2018\n---\na: 100\nb: 200\n...\n", 'encode_tagged usage') + -- + -- Test decoding tags. + -- + must_be_err = "Usage: decode_tag()" + ok, err = pcall(s.decode_tag) + test:is(err, must_be_err, "decode_tag usage") + ok, err = pcall(s.decode_tag, false) + test:is(err, must_be_err, "decode_tag usage") + local handle, prefix = s.decode_tag(ret) + test:is(handle, "!print!", "handle is decoded ok") + test:is(prefix, "tag:tarantool.io/push,2018", "prefix is decoded ok") + local several_tags = +[[%TAG !tag1! tag:tarantool.io/tag1,2018 +%TAG !tag2! tag:tarantool.io/tag2,2018 +--- +- 100 +... +]] + ok, err = s.decode_tag(several_tags) + test:is(ok, nil, "can not decode multiple tags") + test:is(err, "can not decode multiple tags", "same") + local no_tags = s.encode(100) + handle, prefix = s.decode_tag(no_tags) + test:is(handle, nil, "no tag - no handle") + test:is(prefix, nil, "no tag - no prefix") end tap.test("yaml", function(test) diff --git a/third_party/lua-yaml/lyaml.cc b/third_party/lua-yaml/lyaml.cc index 8329f84e9..d24715edd 100644 --- a/third_party/lua-yaml/lyaml.cc +++ b/third_party/lua-yaml/lyaml.cc @@ -361,6 +361,72 @@ static int l_load(lua_State *L) { return loader.document_count; } +/** + * Decode a global tag of document. Multiple tags can not be + * decoded. In a case of multiple documents only first is + * processed. + * @param YAML document in string. + * @retval nil, err Error occured during decoding. In the second + * value is error description. + * @retval nil, nil A document does not contain tags. + * @retval handle, prefix Handle and prefix of a tag. + */ +static int +l_load_tag(struct lua_State *L) +{ + if (lua_gettop(L) != 1 || !lua_isstring(L, 1)) + return luaL_error(L, "Usage: decode_tag()"); + size_t len; + const char *str = lua_tolstring(L, 1, &len); + struct lua_yaml_loader loader; + memset(&loader, 0, sizeof(loader)); + loader.L = L; + loader.cfg = luaL_checkserializer(L); + if (yaml_parser_initialize(&loader.parser) == 0) + luaL_error(L, OOM_ERRMSG); + yaml_tag_directive_t *start, *end; + yaml_parser_set_input_string(&loader.parser, (const unsigned char *) str, + len); + /* Initial parser step. Detect the documents start position. */ + if (do_parse(&loader) == 0) + goto parse_error; + if (loader.event.type != YAML_STREAM_START_EVENT) { + lua_pushnil(L); + lua_pushstring(L, "expected STREAM_START_EVENT"); + return 2; + } + /* Parse a document start. */ + if (do_parse(&loader) == 0) + goto parse_error; + if (loader.event.type == YAML_STREAM_END_EVENT) + goto no_tags; + assert(loader.event.type == YAML_DOCUMENT_START_EVENT); + start = loader.event.data.document_start.tag_directives.start; + end = loader.event.data.document_start.tag_directives.end; + if (start == end) + goto no_tags; + if (end - start > 1) { + lua_pushnil(L); + lua_pushstring(L, "can not decode multiple tags"); + return 2; + } + lua_pushstring(L, (const char *) start->handle); + lua_pushstring(L, (const char *) start->prefix); + delete_event(&loader); + yaml_parser_delete(&loader.parser); + return 2; + +parse_error: + lua_pushnil(L); + /* Make nil be before an error message. */ + lua_insert(L, -2); + return 2; + +no_tags: + lua_pushnil(L); + return 1; +} + static int dump_node(struct lua_yaml_dumper *dumper); static yaml_char_t *get_yaml_anchor(struct lua_yaml_dumper *dumper) { @@ -753,6 +819,7 @@ static const luaL_Reg yamllib[] = { { "encode", l_dump }, { "encode_tagged", l_dump_tagged }, { "decode", l_load }, + { "decode_tag", l_load_tag }, { "new", l_new }, { NULL, NULL} }; -- 2.15.1 (Apple Git-101)