T6732: added same as vyos 1x

6 files changed, 720 insertions, 0 deletions

diff --git a/src/services/api/graphql/generate/composite_function.py b/src/services/api/graphql/generate/composite_function.py
new file mode 100644
index 0000000..d6626fd
--- /dev/null
+++ b/src/services/api/graphql/generate/composite_function.py
@@ -0,0 +1,7 @@
+# typing information for composite functions: those that invoke several
+# elementary requests, and return the result as a single dict
+def system_status():
+    pass
+
+queries = {'system_status': system_status}
+mutations = {}
diff --git a/src/services/api/graphql/generate/config_session_function.py b/src/services/api/graphql/generate/config_session_function.py
new file mode 100644
index 0000000..4ebb47a
--- /dev/null
+++ b/src/services/api/graphql/generate/config_session_function.py
@@ -0,0 +1,30 @@
+# typing information for native configsession functions; used to generate
+# schema definition files
+import typing
+
+def show_config(path: list[str], configFormat: typing.Optional[str]):
+    pass
+
+def show(path: list[str]):
+    pass
+
+def show_user_info(user: str):
+    pass
+
+queries = {'show_config': show_config,
+           'show': show,
+           'show_user_info': show_user_info}
+
+def save_config_file(fileName: typing.Optional[str]):
+    pass
+def load_config_file(fileName: str):
+    pass
+def add_system_image(location: str):
+    pass
+def delete_system_image(name: str):
+    pass
+
+mutations = {'save_config_file': save_config_file,
+             'load_config_file': load_config_file,
+             'add_system_image': add_system_image,
+             'delete_system_image': delete_system_image}
diff --git a/src/services/api/graphql/generate/generate_schema.py b/src/services/api/graphql/generate/generate_schema.py
new file mode 100644
index 0000000..dd5e7ea
--- /dev/null
+++ b/src/services/api/graphql/generate/generate_schema.py
@@ -0,0 +1,26 @@
+#!/usr/bin/env python3
+#
+# Copyright (C) 2023 VyOS maintainers and contributors
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 or later as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+#
+
+from schema_from_op_mode import generate_op_mode_definitions
+from schema_from_config_session import generate_config_session_definitions
+from schema_from_composite import generate_composite_definitions
+
+if __name__ == '__main__':
+    generate_op_mode_definitions()
+    generate_config_session_definitions()
+    generate_composite_definitions()
diff --git a/src/services/api/graphql/generate/schema_from_composite.py b/src/services/api/graphql/generate/schema_from_composite.py
new file mode 100644
index 0000000..06e7403
--- /dev/null
+++ b/src/services/api/graphql/generate/schema_from_composite.py
@@ -0,0 +1,178 @@
+#!/usr/bin/env python3
+#
+# Copyright (C) 2022-2023 VyOS maintainers and contributors
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 or later as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+#
+# A utility to generate GraphQL schema defintions from typing information of
+# composite functions comprising several requests.
+
+import os
+import sys
+from inspect import signature
+from jinja2 import Template
+
+from vyos.defaults import directories
+if __package__ is None or __package__ == '':
+    sys.path.append(os.path.join(directories['services'], 'api'))
+    from graphql.libs.op_mode import snake_to_pascal_case, map_type_name
+    from composite_function import queries, mutations
+else:
+    from .. libs.op_mode import snake_to_pascal_case, map_type_name
+    from . composite_function import queries, mutations
+
+SCHEMA_PATH = directories['api_schema']
+CLIENT_OP_PATH = directories['api_client_op']
+
+schema_data: dict = {'schema_name': '',
+                     'schema_fields': []}
+
+query_template  = """
+input {{ schema_name }}Input {
+    key: String
+    {%- for field_entry in schema_fields %}
+    {{ field_entry }}
+    {%- endfor %}
+}
+
+type {{ schema_name }} {
+    result: Generic
+}
+
+type {{ schema_name }}Result {
+    data: {{ schema_name }}
+    success: Boolean!
+    errors: [String]
+}
+
+extend type Query {
+    {{ schema_name }}(data: {{ schema_name }}Input) : {{ schema_name }}Result @compositequery
+}
+"""
+
+mutation_template  = """
+input {{ schema_name }}Input {
+    key: String
+    {%- for field_entry in schema_fields %}
+    {{ field_entry }}
+    {%- endfor %}
+}
+
+type {{ schema_name }} {
+    result: Generic
+}
+
+type {{ schema_name }}Result {
+    data: {{ schema_name }}
+    success: Boolean!
+    errors: [String]
+}
+
+extend type Mutation {
+    {{ schema_name }}(data: {{ schema_name }}Input) : {{ schema_name }}Result @compositemutation
+}
+"""
+
+op_query_template = """
+query {{ op_name }} ({{ op_sig }}) {
+  {{ op_name }} (data: { {{ op_arg }} }) {
+    success
+    errors
+    data {
+      result
+    }
+  }
+}
+"""
+
+op_mutation_template = """
+mutation {{ op_name }} ({{ op_sig }}) {
+  {{ op_name }} (data: { {{ op_arg }} }) {
+    success
+    errors
+    data {
+      result
+    }
+  }
+}
+"""
+
+def create_schema(func_name: str, func: callable, template: str) -> str:
+    sig = signature(func)
+
+    field_dict = {}
+    for k in sig.parameters:
+        field_dict[sig.parameters[k].name] = map_type_name(sig.parameters[k].annotation)
+
+    schema_fields = []
+    for k,v in field_dict.items():
+        schema_fields.append(k+': '+v)
+
+    schema_data['schema_name'] = snake_to_pascal_case(func_name)
+    schema_data['schema_fields'] = schema_fields
+
+    j2_template = Template(template)
+    res = j2_template.render(schema_data)
+
+    return res
+
+def create_client_op(func_name: str, func: callable, template: str) -> str:
+    sig = signature(func)
+
+    field_dict = {}
+    for k in sig.parameters:
+        field_dict[sig.parameters[k].name] = map_type_name(sig.parameters[k].annotation)
+
+    op_sig = ['$key: String']
+    op_arg = ['key: $key']
+    for k,v in field_dict.items():
+        op_sig.append('$'+k+': '+v)
+        op_arg.append(k+': $'+k)
+
+    op_data = {}
+    op_data['op_name'] = snake_to_pascal_case(func_name)
+    op_data['op_sig'] = ', '.join(op_sig)
+    op_data['op_arg'] = ', '.join(op_arg)
+
+    j2_template = Template(template)
+
+    res = j2_template.render(op_data)
+
+    return res
+
+def generate_composite_definitions():
+    schema = []
+    client_op = []
+    for name,func in queries.items():
+        res = create_schema(name, func, query_template)
+        schema.append(res)
+        res = create_client_op(name, func, op_query_template)
+        client_op.append(res)
+
+    for name,func in mutations.items():
+        res = create_schema(name, func, mutation_template)
+        schema.append(res)
+        res = create_client_op(name, func, op_mutation_template)
+        client_op.append(res)
+
+    out = '\n'.join(schema)
+    with open(f'{SCHEMA_PATH}/composite.graphql', 'w') as f:
+        f.write(out)
+
+    out = '\n'.join(client_op)
+    with open(f'{CLIENT_OP_PATH}/composite.graphql', 'w') as f:
+        f.write(out)
+
+if __name__ == '__main__':
+    generate_composite_definitions()
diff --git a/src/services/api/graphql/generate/schema_from_config_session.py b/src/services/api/graphql/generate/schema_from_config_session.py
new file mode 100644
index 0000000..1d5ff1e
--- /dev/null
+++ b/src/services/api/graphql/generate/schema_from_config_session.py
@@ -0,0 +1,178 @@
+#!/usr/bin/env python3
+#
+# Copyright (C) 2022-2023 VyOS maintainers and contributors
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 or later as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+#
+# A utility to generate GraphQL schema defintions from typing information of
+# (wrappers of) native configsession functions.
+
+import os
+import sys
+from inspect import signature
+from jinja2 import Template
+
+from vyos.defaults import directories
+if __package__ is None or __package__ == '':
+    sys.path.append(os.path.join(directories['services'], 'api'))
+    from graphql.libs.op_mode import snake_to_pascal_case, map_type_name
+    from config_session_function import queries, mutations
+else:
+    from .. libs.op_mode import snake_to_pascal_case, map_type_name
+    from . config_session_function import queries, mutations
+
+SCHEMA_PATH = directories['api_schema']
+CLIENT_OP_PATH = directories['api_client_op']
+
+schema_data: dict = {'schema_name': '',
+                     'schema_fields': []}
+
+query_template  = """
+input {{ schema_name }}Input {
+    key: String
+    {%- for field_entry in schema_fields %}
+    {{ field_entry }}
+    {%- endfor %}
+}
+
+type {{ schema_name }} {
+    result: Generic
+}
+
+type {{ schema_name }}Result {
+    data: {{ schema_name }}
+    success: Boolean!
+    errors: [String]
+}
+
+extend type Query {
+    {{ schema_name }}(data: {{ schema_name }}Input) : {{ schema_name }}Result @configsessionquery
+}
+"""
+
+mutation_template  = """
+input {{ schema_name }}Input {
+    key: String
+    {%- for field_entry in schema_fields %}
+    {{ field_entry }}
+    {%- endfor %}
+}
+
+type {{ schema_name }} {
+    result: Generic
+}
+
+type {{ schema_name }}Result {
+    data: {{ schema_name }}
+    success: Boolean!
+    errors: [String]
+}
+
+extend type Mutation {
+    {{ schema_name }}(data: {{ schema_name }}Input) : {{ schema_name }}Result @configsessionmutation
+}
+"""
+
+op_query_template = """
+query {{ op_name }} ({{ op_sig }}) {
+  {{ op_name }} (data: { {{ op_arg }} }) {
+    success
+    errors
+    data {
+      result
+    }
+  }
+}
+"""
+
+op_mutation_template = """
+mutation {{ op_name }} ({{ op_sig }}) {
+  {{ op_name }} (data: { {{ op_arg }} }) {
+    success
+    errors
+    data {
+      result
+    }
+  }
+}
+"""
+
+def create_schema(func_name: str, func: callable, template: str) -> str:
+    sig = signature(func)
+
+    field_dict = {}
+    for k in sig.parameters:
+        field_dict[sig.parameters[k].name] = map_type_name(sig.parameters[k].annotation)
+
+    schema_fields = []
+    for k,v in field_dict.items():
+        schema_fields.append(k+': '+v)
+
+    schema_data['schema_name'] = snake_to_pascal_case(func_name)
+    schema_data['schema_fields'] = schema_fields
+
+    j2_template = Template(template)
+    res = j2_template.render(schema_data)
+
+    return res
+
+def create_client_op(func_name: str, func: callable, template: str) -> str:
+    sig = signature(func)
+
+    field_dict = {}
+    for k in sig.parameters:
+        field_dict[sig.parameters[k].name] = map_type_name(sig.parameters[k].annotation)
+
+    op_sig = ['$key: String']
+    op_arg = ['key: $key']
+    for k,v in field_dict.items():
+        op_sig.append('$'+k+': '+v)
+        op_arg.append(k+': $'+k)
+
+    op_data = {}
+    op_data['op_name'] = snake_to_pascal_case(func_name)
+    op_data['op_sig'] = ', '.join(op_sig)
+    op_data['op_arg'] = ', '.join(op_arg)
+
+    j2_template = Template(template)
+
+    res = j2_template.render(op_data)
+
+    return res
+
+def generate_config_session_definitions():
+    schema = []
+    client_op = []
+    for name,func in queries.items():
+        res = create_schema(name, func, query_template)
+        schema.append(res)
+        res = create_client_op(name, func, op_query_template)
+        client_op.append(res)
+
+    for name,func in mutations.items():
+        res = create_schema(name, func, mutation_template)
+        schema.append(res)
+        res = create_client_op(name, func, op_mutation_template)
+        client_op.append(res)
+
+    out = '\n'.join(schema)
+    with open(f'{SCHEMA_PATH}/configsession.graphql', 'w') as f:
+        f.write(out)
+
+    out = '\n'.join(client_op)
+    with open(f'{CLIENT_OP_PATH}/configsession.graphql', 'w') as f:
+        f.write(out)
+
+if __name__ == '__main__':
+    generate_config_session_definitions()
diff --git a/src/services/api/graphql/generate/schema_from_op_mode.py b/src/services/api/graphql/generate/schema_from_op_mode.py
new file mode 100644
index 0000000..ab7cb69
--- /dev/null
+++ b/src/services/api/graphql/generate/schema_from_op_mode.py
@@ -0,0 +1,301 @@
+#!/usr/bin/env python3
+#
+# Copyright (C) 2022-2023 VyOS maintainers and contributors
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 or later as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+#
+# A utility to generate GraphQL schema defintions from standardized op-mode
+# scripts.
+
+import os
+import sys
+import json
+from inspect import signature, getmembers, isfunction, isclass, getmro
+from jinja2 import Template
+
+from vyos.defaults import directories
+from vyos.opmode import _is_op_mode_function_name as is_op_mode_function_name
+from vyos.opmode import _get_literal_values as get_literal_values
+from vyos.utils.system import load_as_module
+if __package__ is None or __package__ == '':
+    sys.path.append(os.path.join(directories['services'], 'api'))
+    from graphql.libs.op_mode import is_show_function_name
+    from graphql.libs.op_mode import snake_to_pascal_case, map_type_name
+else:
+    from .. libs.op_mode import is_show_function_name
+    from .. libs.op_mode import snake_to_pascal_case, map_type_name
+
+OP_MODE_PATH = directories['op_mode']
+SCHEMA_PATH = directories['api_schema']
+CLIENT_OP_PATH = directories['api_client_op']
+DATA_DIR = directories['data']
+
+
+op_mode_include_file = os.path.join(DATA_DIR, 'op-mode-standardized.json')
+op_mode_error_schema = 'op_mode_error.graphql'
+
+schema_data: dict = {'schema_name': '',
+                     'schema_fields': []}
+
+query_template  = """
+input {{ schema_name }}Input {
+    key: String
+    {%- for field_entry in schema_fields %}
+    {{ field_entry }}
+    {%- endfor %}
+}
+
+type {{ schema_name }} {
+    result: Generic
+}
+
+type {{ schema_name }}Result {
+    data: {{ schema_name }}
+    op_mode_error: OpModeError
+    success: Boolean!
+    errors: [String]
+}
+
+extend type Query {
+    {{ schema_name }}(data: {{ schema_name }}Input) : {{ schema_name }}Result @genopquery
+}
+"""
+
+mutation_template  = """
+input {{ schema_name }}Input {
+    key: String
+    {%- for field_entry in schema_fields %}
+    {{ field_entry }}
+    {%- endfor %}
+}
+
+type {{ schema_name }} {
+    result: Generic
+}
+
+type {{ schema_name }}Result {
+    data: {{ schema_name }}
+    op_mode_error: OpModeError
+    success: Boolean!
+    errors: [String]
+}
+
+extend type Mutation {
+    {{ schema_name }}(data: {{ schema_name }}Input) : {{ schema_name }}Result @genopmutation
+}
+"""
+
+enum_template = """
+enum {{ enum_name }} {
+    {%- for field_entry in enum_fields %}
+    {{ field_entry }}
+    {%- endfor %}
+}
+"""
+
+error_template = """
+interface OpModeError {
+    name: String!
+    message: String!
+    vyos_code: Int!
+}
+{% for name in error_names %}
+type {{ name }} implements OpModeError {
+    name: String!
+    message: String!
+    vyos_code: Int!
+}
+{%- endfor %}
+"""
+
+op_query_template = """
+query {{ op_name }} ({{ op_sig }}) {
+  {{ op_name }} (data: { {{ op_arg }} }) {
+    success
+    errors
+    op_mode_error {
+      name
+      message
+      vyos_code
+    }
+    data {
+      result
+    }
+  }
+}
+"""
+
+op_mutation_template = """
+mutation {{ op_name }} ({{ op_sig }}) {
+  {{ op_name }} (data: { {{ op_arg }} }) {
+    success
+    errors
+    op_mode_error {
+      name
+      message
+      vyos_code
+    }
+    data {
+      result
+    }
+  }
+}
+"""
+
+def create_schema(func_name: str, base_name: str, func: callable,
+                  enums: dict) -> str:
+    sig = signature(func)
+
+    for k in sig.parameters:
+        t = get_literal_values(sig.parameters[k].annotation)
+        if t:
+            enums[t] = snake_to_pascal_case(sig.parameters[k].name + '_' + base_name)
+
+    field_dict = {}
+    for k in sig.parameters:
+        field_dict[sig.parameters[k].name] = map_type_name(sig.parameters[k].annotation, enums)
+
+    # It is assumed that if one is generating a schema for a 'show_*'
+    # function, that 'get_raw_data' is present and 'raw' is desired.
+    if 'raw' in list(field_dict):
+        del field_dict['raw']
+
+    schema_fields = []
+    for k,v in field_dict.items():
+        schema_fields.append(k+': '+v)
+
+    schema_data['schema_name'] = snake_to_pascal_case(func_name + '_' + base_name)
+    schema_data['schema_fields'] = schema_fields
+
+    if is_show_function_name(func_name):
+        j2_template = Template(query_template)
+    else:
+        j2_template = Template(mutation_template)
+
+    res = j2_template.render(schema_data)
+
+    return res
+
+def create_client_op(func_name: str, base_name: str, func: callable,
+                     enums: dict) -> str:
+    sig = signature(func)
+
+    for k in sig.parameters:
+        t = get_literal_values(sig.parameters[k].annotation)
+        if t:
+            enums[t] = snake_to_pascal_case(sig.parameters[k].name + '_' + base_name)
+
+    field_dict = {}
+    for k in sig.parameters:
+        field_dict[sig.parameters[k].name] = map_type_name(sig.parameters[k].annotation, enums)
+
+    # It is assumed that if one is generating a schema for a 'show_*'
+    # function, that 'get_raw_data' is present and 'raw' is desired.
+    if 'raw' in list(field_dict):
+        del field_dict['raw']
+
+    op_sig = ['$key: String']
+    op_arg = ['key: $key']
+    for k,v in field_dict.items():
+        op_sig.append('$'+k+': '+v)
+        op_arg.append(k+': $'+k)
+
+    op_data = {}
+    op_data['op_name'] = snake_to_pascal_case(func_name + '_' + base_name)
+    op_data['op_sig'] = ', '.join(op_sig)
+    op_data['op_arg'] = ', '.join(op_arg)
+
+    if is_show_function_name(func_name):
+        j2_template = Template(op_query_template)
+    else:
+        j2_template = Template(op_mutation_template)
+
+    res = j2_template.render(op_data)
+
+    return res
+
+def create_enums(enums: dict) -> str:
+    enum_data = []
+    for k, v in enums.items():
+        enum = {'enum_name': v, 'enum_fields': list(k)}
+        enum_data.append(enum)
+
+    out = ''
+    j2_template = Template(enum_template)
+    for el in enum_data:
+        out += j2_template.render(el)
+        out += '\n'
+
+    return out
+
+def create_error_schema():
+    from vyos import opmode
+
+    e = Exception
+    err_types = getmembers(opmode, isclass)
+    err_types = [k for k in err_types if issubclass(k[1], e)]
+    # drop base class, to be replaced by interface type. Find the class
+    # programmatically, in case the base class name changes.
+    for i in range(len(err_types)):
+        if err_types[i][1] in getmro(err_types[i-1][1]):
+            del err_types[i]
+            break
+    err_names = [k[0] for k in err_types]
+    error_data = {'error_names': err_names}
+    j2_template = Template(error_template)
+    res = j2_template.render(error_data)
+
+    return res
+
+def generate_op_mode_definitions():
+    os.makedirs(CLIENT_OP_PATH, exist_ok=True)
+
+    out = create_error_schema()
+    with open(f'{SCHEMA_PATH}/{op_mode_error_schema}', 'w') as f:
+        f.write(out)
+
+    with open(op_mode_include_file) as f:
+        op_mode_files = json.load(f)
+
+    for file in op_mode_files:
+        basename = os.path.splitext(file)[0].replace('-', '_')
+        module = load_as_module(basename, os.path.join(OP_MODE_PATH, file))
+
+        funcs = getmembers(module, isfunction)
+        funcs = list(filter(lambda ft: is_op_mode_function_name(ft[0]), funcs))
+
+        funcs_dict = {}
+        for (name, thunk) in funcs:
+            funcs_dict[name] = thunk
+
+        schema = []
+        client_op = []
+        enums = {} # gather enums from function Literal type args
+        for name,func in funcs_dict.items():
+            res = create_schema(name, basename, func, enums)
+            schema.append(res)
+            res = create_client_op(name, basename, func, enums)
+            client_op.append(res)
+
+        out = create_enums(enums)
+        out += '\n'.join(schema)
+        with open(f'{SCHEMA_PATH}/{basename}.graphql', 'w') as f:
+            f.write(out)
+
+        out = '\n'.join(client_op)
+        with open(f'{CLIENT_OP_PATH}/{basename}.graphql', 'w') as f:
+            f.write(out)
+
+if __name__ == '__main__':
+    generate_op_mode_definitions()