console_yaml.c

Go to the documentation of this file.

/* -*- C -*- */
/*
 * Copyright (c) 2011-2020 Seagate Technology LLC and/or its Affiliates
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * For any questions about this software or licensing,
 * please email opensource@seagate.com or cortx-questions@seagate.com.
 *
 */


#define M0_TRACE_SUBSYSTEM M0_TRACE_SUBSYS_OTHER
#include "lib/trace.h"

#include "lib/errno.h"
#include "lib/memory.h"
#include "lib/string.h"  /* m0_streq */

#include "console/console_yaml.h"

static void yaml_parser_error_detect(const yaml_parser_t * parser)
{
        M0_PRE(parser != NULL);

        switch (parser->error) {
        case YAML_MEMORY_ERROR:
            fprintf(stderr, "Memory error: Not enough memory for parsing\n");
            break;
        case YAML_READER_ERROR:
            if (parser->problem_value != -1)
                fprintf(stderr, "Reader error: %s: #%X at %lu\n",
                        parser->problem, parser->problem_value,
                        parser->problem_offset);
            else
                fprintf(stderr, "Reader error: %s at %lu\n",
                        parser->problem, parser->problem_offset);
            break;
        case YAML_SCANNER_ERROR:
            if (parser->context)
                fprintf(stderr, "Scanner error: %s at line %lu, column %lu"
                        " %s at line %lu, column %lu\n",
                        parser->context, parser->context_mark.line+1,
                        parser->context_mark.column+1, parser->problem,
                        parser->problem_mark.line+1,
                        parser->problem_mark.column+1);
            else
                fprintf(stderr, "Scanner error: %s at line %lu, column %lu\n",
                        parser->problem, parser->problem_mark.line+1,
                        parser->problem_mark.column+1);
            break;
        case YAML_PARSER_ERROR:
            if (parser->context)
                fprintf(stderr, "Parser error: %s at line %lu, column %lu"
                        " %s at line %lu, column %lu\n",
                        parser->context, parser->context_mark.line+1,
                        parser->context_mark.column+1,parser->problem,
                        parser->problem_mark.line+1,
                        parser->problem_mark.column+1);
            else
                fprintf(stderr, "Parser error: %s at line %lu, column %lu\n",
                        parser->problem, parser->problem_mark.line+1,
                        parser->problem_mark.column+1);
            break;
        case YAML_COMPOSER_ERROR:
        case YAML_WRITER_ERROR:
        case YAML_EMITTER_ERROR:
        case YAML_NO_ERROR:
            break;
        default:
                M0_IMPOSSIBLE("Invalid error");
        }
}

static struct m0_cons_yaml_info yaml_info;
M0_INTERNAL bool yaml_support;

M0_INTERNAL int m0_cons_yaml_init(const char *file_path)
{
        int          rc;
        yaml_node_t *root_node;

        M0_ENTRY("file_path=`%s'", file_path);
        M0_PRE(file_path != NULL);

        yaml_info.cyi_file = fopen(file_path, "r");

        if (yaml_info.cyi_file == NULL) {
                perror("Failed to open file ");
                printf("%s, errno = %d\n", file_path, errno);
                goto error;
        }
        /* Initialize parser */
        rc = yaml_parser_initialize(&yaml_info.cyi_parser);
        if (rc != 1) {
                fprintf(stderr, "Failed to initialize parser!\n");
                fclose(yaml_info.cyi_file);
                goto error;
        }

        /* Set input file */
        yaml_parser_set_input_file(&yaml_info.cyi_parser, yaml_info.cyi_file);

        /* Load document */
        rc = yaml_parser_load(&yaml_info.cyi_parser, &yaml_info.cyi_document);
        if (rc != 1) {
                yaml_parser_delete(&yaml_info.cyi_parser);
                fclose(yaml_info.cyi_file);
                fprintf(stderr, "yaml parser load failed!!\n");
                goto error;
        }

        root_node = yaml_document_get_root_node(&yaml_info.cyi_document);
        if (root_node == NULL) {
                yaml_document_delete(&yaml_info.cyi_document);
                yaml_parser_delete(&yaml_info.cyi_parser);
                fclose(yaml_info.cyi_file);
                fprintf(stderr, "document get root node failed\n");
                goto error;
        }

        yaml_info.cyi_current = yaml_info.cyi_document.nodes.start;
        yaml_support = true;

        return M0_RC(0);
error:
        yaml_parser_error_detect(&yaml_info.cyi_parser);
        return M0_RC(-EINVAL);
}

M0_INTERNAL void m0_cons_yaml_fini(void)
{
        yaml_support = false;
        yaml_document_delete(&yaml_info.cyi_document);
        yaml_parser_delete(&yaml_info.cyi_parser);
        fclose(yaml_info.cyi_file);
}

static yaml_node_t *search_node(const char *name)
{
        yaml_document_t *doc  = &yaml_info.cyi_document;
        yaml_node_t     *node = yaml_info.cyi_current;
        unsigned char   *data_value;

        M0_ENTRY("name=`%s'", name);
        for ( ; node < doc->nodes.top; node++) {
                if (node->type == YAML_SCALAR_NODE) {
                        data_value = node->data.scalar.value;
                        if (m0_streq((const char *)data_value, name)) {
                                node++;
                                yaml_info.cyi_current = node;
                                M0_LEAVE("found");
                                return node;
                        }
                }
        }
        M0_LEAVE("not found");
        return NULL;
}

M0_INTERNAL void *m0_cons_yaml_get_value(const char *name)
{
        yaml_node_t *node = search_node(name);
        return node == NULL ? NULL : node->data.scalar.value;
}

M0_INTERNAL int m0_cons_yaml_set_value(const char *name, void *data)
{
        return M0_ERR(-ENOTSUP);
}

#undef M0_TRACE_SUBSYSTEM

/*
 *  Local variables:
 *  c-indentation-style: "K&R"
 *  c-basic-offset: 8
 *  tab-width: 8
 *  fill-column: 80
 *  scroll-step: 1
 *  End:
 */