1#!/usr/bin/env python3
2import argparse
3import json
4import os
5from collections import OrderedDict
6
7import requests
8
9PRAGMA_ONCE = """#pragma once
10"""
11
12WARNING = """/****************************************************************
13 *                 READ THIS WARNING FIRST
14 * This is an auto-generated header which contains definitions
15 * for Redfish DMTF defined messages.
16 * DO NOT modify this registry outside of running the
17 * parse_registries.py script.  The definitions contained within
18 * this file are owned by DMTF.  Any modifications to these files
19 * should be first pushed to the relevant registry in the DMTF
20 * github organization.
21 ***************************************************************/"""
22
23REGISTRY_HEADER = (
24    PRAGMA_ONCE
25    + WARNING
26    + """
27#include "registries.hpp"
28
29#include <array>
30
31// clang-format off
32
33namespace redfish::registries::{}
34{{
35"""
36)
37
38SCRIPT_DIR = os.path.dirname(os.path.realpath(__file__))
39
40include_path = os.path.realpath(
41    os.path.join(SCRIPT_DIR, "..", "redfish-core", "include", "registries")
42)
43
44proxies = {"https": os.environ.get("https_proxy", None)}
45
46
47def make_getter(dmtf_name, header_name, type_name):
48    url = "https://redfish.dmtf.org/registries/{}".format(dmtf_name)
49    dmtf = requests.get(url, proxies=proxies)
50    dmtf.raise_for_status()
51    json_file = json.loads(dmtf.text, object_pairs_hook=OrderedDict)
52    path = os.path.join(include_path, header_name)
53    return (path, json_file, type_name, url)
54
55
56def openbmc_local_getter():
57    url = "https://github.com/openbmc/bmcweb/blob/master/redfish-core/include/registries/openbmc.json"
58    with open(
59        os.path.join(
60            SCRIPT_DIR,
61            "..",
62            "redfish-core",
63            "include",
64            "registries",
65            "openbmc.json",
66        ),
67        "rb",
68    ) as json_file:
69        json_file = json.load(json_file)
70
71    path = os.path.join(include_path, "openbmc_message_registry.hpp")
72    return (path, json_file, "openbmc", url)
73
74
75def update_registries(files):
76    # Remove the old files
77    for file, json_dict, namespace, url in files:
78        try:
79            os.remove(file)
80        except BaseException:
81            print("{} not found".format(file))
82
83        with open(file, "w") as registry:
84
85            version_split = json_dict["RegistryVersion"].split(".")
86
87            registry.write(REGISTRY_HEADER.format(namespace))
88            # Parse the Registry header info
89            registry.write(
90                "const Header header = {{\n"
91                '    "{json_dict[@Redfish.Copyright]}",\n'
92                '    "{json_dict[@odata.type]}",\n'
93                "    {version_split[0]},\n"
94                "    {version_split[1]},\n"
95                "    {version_split[2]},\n"
96                '    "{json_dict[Name]}",\n'
97                '    "{json_dict[Language]}",\n'
98                '    "{json_dict[Description]}",\n'
99                '    "{json_dict[RegistryPrefix]}",\n'
100                '    "{json_dict[OwningEntity]}",\n'
101                "}};\n"
102                "constexpr const char* url =\n"
103                '    "{url}";\n'
104                "\n"
105                "constexpr std::array registry =\n"
106                "{{\n".format(
107                    json_dict=json_dict,
108                    url=url,
109                    version_split=version_split,
110                )
111            )
112
113            messages_sorted = sorted(json_dict["Messages"].items())
114            for messageId, message in messages_sorted:
115                registry.write(
116                    "    MessageEntry{{\n"
117                    '        "{messageId}",\n'
118                    "        {{\n"
119                    '            "{message[Description]}",\n'
120                    '            "{message[Message]}",\n'
121                    '            "{message[MessageSeverity]}",\n'
122                    "            {message[NumberOfArgs]},\n"
123                    "            {{".format(
124                        messageId=messageId, message=message
125                    )
126                )
127                paramTypes = message.get("ParamTypes")
128                if paramTypes:
129                    for paramType in paramTypes:
130                        registry.write(
131                            '\n                "{}",'.format(paramType)
132                        )
133                    registry.write("\n            },\n")
134                else:
135                    registry.write("},\n")
136                registry.write(
137                    '            "{message[Resolution]}",\n'
138                    "        }}}},\n".format(message=message)
139                )
140
141            registry.write("\n};\n\nenum class Index\n{\n")
142            for index, (messageId, message) in enumerate(messages_sorted):
143                messageId = messageId[0].lower() + messageId[1:]
144                registry.write("    {} = {},\n".format(messageId, index))
145            registry.write(
146                "}};\n}} // namespace redfish::registries::{}\n".format(
147                    namespace
148                )
149            )
150
151
152def get_privilege_string_from_list(privilege_list):
153    privilege_string = "{{\n"
154    for privilege_json in privilege_list:
155        privileges = privilege_json["Privilege"]
156        privilege_string += "    {"
157        for privilege in privileges:
158            if privilege == "NoAuth":
159                continue
160            privilege_string += '"'
161            privilege_string += privilege
162            privilege_string += '",\n'
163        if privilege != "NoAuth":
164            privilege_string = privilege_string[:-2]
165        privilege_string += "}"
166        privilege_string += ",\n"
167    privilege_string = privilege_string[:-2]
168    privilege_string += "\n}}"
169    return privilege_string
170
171
172def get_variable_name_for_privilege_set(privilege_list):
173    names = []
174    for privilege_json in privilege_list:
175        privileges = privilege_json["Privilege"]
176        names.append("And".join(privileges))
177    return "Or".join(names)
178
179
180PRIVILEGE_HEADER = (
181    PRAGMA_ONCE
182    + WARNING
183    + """
184#include "privileges.hpp"
185
186#include <array>
187
188// clang-format off
189
190namespace redfish::privileges
191{
192"""
193)
194
195
196def get_response_code(entry_id, entry):
197    codes = {
198        "InternalError": "internal_server_error",
199        "OperationTimeout": "internal_server_error",
200        "PropertyValueResourceConflict": "conflict",
201        "ResourceInUse": "service_unavailable",
202        "ServiceTemporarilyUnavailable": "service_unavailable",
203        "ResourceCannotBeDeleted": "method_not_allowed",
204        "PropertyValueModified": "ok",
205        "InsufficientPrivilege": "forbidden",
206        "AccountForSessionNoLongerExists": "forbidden",
207        "ServiceDisabled": "service_unavailable",
208        "ServiceInUnknownState": "service_unavailable",
209        "EventSubscriptionLimitExceeded": "service_unavailable",
210        "ResourceAtUriUnauthorized": "unauthorized",
211        "SessionTerminated": "ok",
212        "SubscriptionTerminated": "ok",
213        "PropertyNotWritable": "forbidden",
214        "MaximumErrorsExceeded": "internal_server_error",
215        "GeneralError": "internal_server_error",
216        "PreconditionFailed": "precondition_failed",
217        "OperationFailed": "bad_gateway",
218        "ServiceShuttingDown": "service_unavailable",
219        "AccountRemoved": "ok",
220        "PropertyValueExternalConflict": "conflict",
221        "InsufficientStorage": "insufficient_storage",
222        "OperationNotAllowed": "method_not_allowed",
223        "ResourceNotFound": "not_found",
224        "CouldNotEstablishConnection": "not_found",
225        "AccessDenied": "forbidden",
226        "Success": None,
227        "Created": "created",
228        "NoValidSession": "forbidden",
229        "SessionLimitExceeded": "service_unavailable",
230        "ResourceExhaustion": "service_unavailable",
231        "AccountModified": "ok",
232        "PasswordChangeRequired": None,
233        "ResourceInStandby": "service_unavailable",
234        "GenerateSecretKeyRequired": "forbidden",
235    }
236
237    code = codes.get(entry_id, "NOCODE")
238    if code != "NOCODE":
239        return code
240
241    return "bad_request"
242
243
244def make_error_function(
245    entry_id, entry, is_header, registry_name, namespace_name
246):
247    arg_nonstring_types = {
248        "const boost::urls::url_view_base&": {
249            "AccessDenied": [1],
250            "CouldNotEstablishConnection": [1],
251            "GenerateSecretKeyRequired": [1],
252            "InvalidObject": [1],
253            "PasswordChangeRequired": [1],
254            "PropertyValueResourceConflict": [3],
255            "ResetRequired": [1],
256            "ResourceAtUriInUnknownFormat": [1],
257            "ResourceAtUriUnauthorized": [1],
258            "ResourceCreationConflict": [1],
259            "ResourceMissingAtURI": [1],
260            "SourceDoesNotSupportProtocol": [1],
261        },
262        "const nlohmann::json&": {
263            "ActionParameterValueError": [1],
264            "ActionParameterValueFormatError": [1],
265            "ActionParameterValueTypeError": [1],
266            "PropertyValueExternalConflict": [2],
267            "PropertyValueFormatError": [1],
268            "PropertyValueIncorrect": [2],
269            "PropertyValueModified": [2],
270            "PropertyValueNotInList": [1],
271            "PropertyValueOutOfRange": [1],
272            "PropertyValueResourceConflict": [2],
273            "PropertyValueTypeError": [1],
274            "QueryParameterValueFormatError": [1],
275            "QueryParameterValueTypeError": [1],
276        },
277        "uint64_t": {
278            "ArraySizeTooLong": [2],
279            "InvalidIndex": [1],
280            "StringValueTooLong": [2],
281            "TaskProgressChanged": [2],
282        },
283    }
284
285    out = ""
286    args = []
287    argtypes = []
288    for arg_index, arg in enumerate(entry.get("ParamTypes", [])):
289        arg_index += 1
290        typename = "std::string_view"
291        for typestring, entries in arg_nonstring_types.items():
292            if arg_index in entries.get(entry_id, []):
293                typename = typestring
294
295        argtypes.append(typename)
296        args.append(f"{typename} arg{arg_index}")
297    function_name = entry_id[0].lower() + entry_id[1:]
298    arg = ", ".join(args)
299    out += f"nlohmann::json {function_name}({arg})"
300
301    if is_header:
302        out += ";\n\n"
303    else:
304        out += "\n{\n"
305        to_array_type = ""
306        if argtypes:
307            outargs = []
308            for index, typename in enumerate(argtypes):
309                index += 1
310                if typename == "const nlohmann::json&":
311                    out += f"std::string arg{index}Str = arg{index}.dump(-1, ' ', true, nlohmann::json::error_handler_t::replace);\n"
312                elif typename == "uint64_t":
313                    out += f"std::string arg{index}Str = std::to_string(arg{index});\n"
314
315            for index, typename in enumerate(argtypes):
316                index += 1
317                if typename == "const boost::urls::url_view_base&":
318                    outargs.append(f"arg{index}.buffer()")
319                    to_array_type = "<std::string_view>"
320                elif typename == "const nlohmann::json&":
321                    outargs.append(f"arg{index}Str")
322                    to_array_type = "<std::string_view>"
323                elif typename == "uint64_t":
324                    outargs.append(f"arg{index}Str")
325                    to_array_type = "<std::string_view>"
326                else:
327                    outargs.append(f"arg{index}")
328            argstring = ", ".join(outargs)
329
330        if argtypes:
331            arg_param = f"std::to_array{to_array_type}({{{argstring}}})"
332        else:
333            arg_param = "{}"
334        out += f"    return getLog(redfish::registries::{namespace_name}::Index::{function_name}, {arg_param});"
335        out += "\n}\n\n"
336    if registry_name == "Base":
337        args.insert(0, "crow::Response& res")
338        if entry_id == "InternalError":
339            if is_header:
340                args.append(
341                    "std::source_location location = std::source_location::current()"
342                )
343            else:
344                args.append("const std::source_location location")
345        arg = ", ".join(args)
346        out += f"void {function_name}({arg})"
347        if is_header:
348            out += ";\n"
349        else:
350            out += "\n{\n"
351            if entry_id == "InternalError":
352                out += """BMCWEB_LOG_CRITICAL("Internal Error {}({}:{}) `{}`: ", location.file_name(),
353                            location.line(), location.column(),
354                            location.function_name());\n"""
355
356            if entry_id == "ServiceTemporarilyUnavailable":
357                out += "res.addHeader(boost::beast::http::field::retry_after, arg1);"
358
359            res = get_response_code(entry_id, entry)
360            if res:
361                out += f"    res.result(boost::beast::http::status::{res});\n"
362            args_out = ", ".join([f"arg{x+1}" for x in range(len(argtypes))])
363
364            addMessageToJson = {
365                "PropertyDuplicate": 1,
366                "ResourceAlreadyExists": 2,
367                "CreateFailedMissingReqProperties": 1,
368                "PropertyValueFormatError": 2,
369                "PropertyValueNotInList": 2,
370                "PropertyValueTypeError": 2,
371                "PropertyValueError": 1,
372                "PropertyNotWritable": 1,
373                "PropertyValueModified": 1,
374                "PropertyMissing": 1,
375            }
376
377            addMessageToRoot = [
378                "SessionTerminated",
379                "SubscriptionTerminated",
380                "AccountRemoved",
381                "Created",
382                "Success",
383                "PasswordChangeRequired",
384            ]
385
386            if entry_id in addMessageToJson:
387                out += f"    addMessageToJson(res.jsonValue, {function_name}({args_out}), arg{addMessageToJson[entry_id]});\n"
388            elif entry_id in addMessageToRoot:
389                out += f"    addMessageToJsonRoot(res.jsonValue, {function_name}({args_out}));\n"
390            else:
391                out += f"    addMessageToErrorJson(res.jsonValue, {function_name}({args_out}));\n"
392            out += "}\n"
393    out += "\n"
394    return out
395
396
397def create_error_registry(
398    entry, registry_version, registry_name, namespace_name, filename
399):
400    file, json_dict, namespace, url = entry
401    base_filename = filename + "_messages"
402
403    error_messages_hpp = os.path.join(
404        SCRIPT_DIR, "..", "redfish-core", "include", f"{base_filename}.hpp"
405    )
406    messages = json_dict["Messages"]
407
408    with open(
409        error_messages_hpp,
410        "w",
411    ) as out:
412        out.write(PRAGMA_ONCE)
413        out.write(WARNING)
414        out.write(
415            """
416
417#include "http_response.hpp"
418
419#include <boost/url/url_view_base.hpp>
420#include <nlohmann/json.hpp>
421
422#include <cstdint>
423#include <source_location>
424#include <string>
425#include <string_view>
426
427// IWYU pragma: no_forward_declare crow::Response
428
429namespace redfish
430{
431
432namespace messages
433{
434"""
435        )
436        if registry_name == "Base":
437            out.write(
438                f'constexpr const char* messageVersionPrefix = "{registry_name}.{registry_version}.";'
439            )
440            out.write(
441                """
442            constexpr const char* messageAnnotation = "@Message.ExtendedInfo";
443
444            /**
445            * @brief Moves all error messages from the |source| JSON to |target|
446            */
447            void moveErrorsToErrorJson(nlohmann::json& target, nlohmann::json& source);
448
449        """
450            )
451        for entry_id, entry in messages.items():
452            message = entry["Message"]
453            for index in range(1, 10):
454                message = message.replace(f"'%{index}'", f"<arg{index}>")
455                message = message.replace(f"%{index}", f"<arg{index}>")
456
457            if registry_name == "Base":
458                out.write("/**\n")
459                out.write(f"* @brief Formats {entry_id} message into JSON\n")
460                out.write(f'* Message body: "{message}"\n')
461                out.write("*\n")
462                arg_index = 0
463                for arg_index, arg in enumerate(entry.get("ParamTypes", [])):
464                    arg_index += 1
465
466                    out.write(
467                        f"* @param[in] arg{arg_index} Parameter of message that will replace %{arg_index} in its body.\n"
468                    )
469                out.write("*\n")
470                out.write(
471                    f"* @returns Message {entry_id} formatted to JSON */\n"
472                )
473
474            out.write(
475                make_error_function(
476                    entry_id, entry, True, registry_name, namespace_name
477                )
478            )
479        out.write("    }\n")
480        out.write("}\n")
481
482    error_messages_cpp = os.path.join(
483        SCRIPT_DIR, "..", "redfish-core", "src", f"{base_filename}.cpp"
484    )
485    with open(
486        error_messages_cpp,
487        "w",
488    ) as out:
489        out.write(WARNING)
490        out.write(f'\n#include "{base_filename}.hpp"\n')
491        if registry_name == "Base":
492            out.write(
493                """
494
495#include "http_response.hpp"
496#include "logging.hpp"
497"""
498            )
499        out.write(
500            """
501#include "registries.hpp"
502"""
503        )
504        if registry_name == "Base":
505            reg_name_lower = "base"
506        else:
507            reg_name_lower = namespace_name.lower()
508        out.write(
509            f'#include "registries/{reg_name_lower}_message_registry.hpp"'
510        )
511        if registry_name == "Base":
512            out.write(
513                """
514
515    #include <boost/beast/http/field.hpp>
516    #include <boost/beast/http/status.hpp>
517    #include <boost/url/url_view_base.hpp>
518"""
519            )
520        out.write(
521            """
522#include <nlohmann/json.hpp>
523
524#include <array>
525#include <cstddef>
526#include <cstdint>
527"""
528        )
529        if registry_name == "Base":
530            out.write(
531                """
532#include <source_location>
533"""
534            )
535        out.write(
536            """
537#include <span>
538#include <string>
539#include <string_view>
540
541// Clang can't seem to decide whether this header needs to be included or not,
542// and is inconsistent.  Include it for now
543// NOLINTNEXTLINE(misc-include-cleaner)
544#include <utility>
545
546namespace redfish
547{
548
549namespace messages
550{
551"""
552        )
553
554        if registry_name == "Base":
555            out.write(
556                """
557static void addMessageToErrorJson(nlohmann::json& target,
558                                  const nlohmann::json& message)
559{
560    auto& error = target["error"];
561
562    // If this is the first error message, fill in the information from the
563    // first error message to the top level struct
564    if (!error.is_object())
565    {
566        auto messageIdIterator = message.find("MessageId");
567        if (messageIdIterator == message.end())
568        {
569            BMCWEB_LOG_CRITICAL(
570                "Attempt to add error message without MessageId");
571            return;
572        }
573
574        auto messageFieldIterator = message.find("Message");
575        if (messageFieldIterator == message.end())
576        {
577            BMCWEB_LOG_CRITICAL("Attempt to add error message without Message");
578            return;
579        }
580        error["code"] = *messageIdIterator;
581        error["message"] = *messageFieldIterator;
582    }
583    else
584    {
585        // More than 1 error occurred, so the message has to be generic
586        error["code"] = std::string(messageVersionPrefix) + "GeneralError";
587        error["message"] = "A general error has occurred. See Resolution for "
588                           "information on how to resolve the error.";
589    }
590
591    // This check could technically be done in the default construction
592    // branch above, but because we need the pointer to the extended info field
593    // anyway, it's more efficient to do it here.
594    auto& extendedInfo = error[messages::messageAnnotation];
595    if (!extendedInfo.is_array())
596    {
597        extendedInfo = nlohmann::json::array();
598    }
599
600    extendedInfo.push_back(message);
601}
602
603void moveErrorsToErrorJson(nlohmann::json& target, nlohmann::json& source)
604{
605    if (!source.is_object())
606    {
607        return;
608    }
609    auto errorIt = source.find("error");
610    if (errorIt == source.end())
611    {
612        // caller puts error message in root
613        messages::addMessageToErrorJson(target, source);
614        source.clear();
615        return;
616    }
617    auto extendedInfoIt = errorIt->find(messages::messageAnnotation);
618    if (extendedInfoIt == errorIt->end())
619    {
620        return;
621    }
622    const nlohmann::json::array_t* extendedInfo =
623        (*extendedInfoIt).get_ptr<const nlohmann::json::array_t*>();
624    if (extendedInfo == nullptr)
625    {
626        source.erase(errorIt);
627        return;
628    }
629    for (const nlohmann::json& message : *extendedInfo)
630    {
631        addMessageToErrorJson(target, message);
632    }
633    source.erase(errorIt);
634}
635
636static void addMessageToJsonRoot(nlohmann::json& target,
637                                 const nlohmann::json& message)
638{
639    if (!target[messages::messageAnnotation].is_array())
640    {
641        // Force object to be an array
642        target[messages::messageAnnotation] = nlohmann::json::array();
643    }
644
645    target[messages::messageAnnotation].push_back(message);
646}
647
648static void addMessageToJson(nlohmann::json& target,
649                             const nlohmann::json& message,
650                             std::string_view fieldPath)
651{
652    std::string extendedInfo(fieldPath);
653    extendedInfo += messages::messageAnnotation;
654
655    nlohmann::json& field = target[extendedInfo];
656    if (!field.is_array())
657    {
658        // Force object to be an array
659        field = nlohmann::json::array();
660    }
661
662    // Object exists and it is an array so we can just push in the message
663    field.push_back(message);
664}
665"""
666            )
667        out.write(
668            """
669static nlohmann::json getLog(redfish::registries::{namespace_name}::Index name,
670                             std::span<const std::string_view> args)
671{{
672    size_t index = static_cast<size_t>(name);
673    if (index >= redfish::registries::{namespace_name}::registry.size())
674    {{
675        return {{}};
676    }}
677    return getLogFromRegistry(redfish::registries::{namespace_name}::header,
678                              redfish::registries::{namespace_name}::registry, index, args);
679}}
680
681""".format(
682                namespace_name=namespace_name
683            )
684        )
685        for entry_id, entry in messages.items():
686            out.write(
687                f"""/**
688 * @internal
689 * @brief Formats {entry_id} message into JSON
690 *
691 * See header file for more information
692 * @endinternal
693 */
694"""
695            )
696            message = entry["Message"]
697            out.write(
698                make_error_function(
699                    entry_id, entry, False, registry_name, namespace_name
700                )
701            )
702
703        out.write("    }\n")
704        out.write("}\n")
705    os.system(f"clang-format -i {error_messages_hpp} {error_messages_cpp}")
706
707
708def make_privilege_registry():
709    path, json_file, type_name, url = make_getter(
710        "Redfish_1.5.0_PrivilegeRegistry.json",
711        "privilege_registry.hpp",
712        "privilege",
713    )
714    with open(path, "w") as registry:
715        registry.write(PRIVILEGE_HEADER)
716
717        privilege_dict = {}
718        for mapping in json_file["Mappings"]:
719            # first pass, identify all the unique privilege sets
720            for operation, privilege_list in mapping["OperationMap"].items():
721                privilege_dict[
722                    get_privilege_string_from_list(privilege_list)
723                ] = (privilege_list,)
724        for index, key in enumerate(privilege_dict):
725            (privilege_list,) = privilege_dict[key]
726            name = get_variable_name_for_privilege_set(privilege_list)
727            registry.write(
728                "const std::array<Privileges, {length}> "
729                "privilegeSet{name} = {key};\n".format(
730                    length=len(privilege_list), name=name, key=key
731                )
732            )
733            privilege_dict[key] = (privilege_list, name)
734
735        for mapping in json_file["Mappings"]:
736            entity = mapping["Entity"]
737            registry.write("// {}\n".format(entity))
738            for operation, privilege_list in mapping["OperationMap"].items():
739                privilege_string = get_privilege_string_from_list(
740                    privilege_list
741                )
742                operation = operation.lower()
743
744                registry.write(
745                    "const static auto& {}{} = privilegeSet{};\n".format(
746                        operation, entity, privilege_dict[privilege_string][1]
747                    )
748                )
749            registry.write("\n")
750        registry.write(
751            "} // namespace redfish::privileges\n// clang-format on\n"
752        )
753
754
755def to_pascal_case(text):
756    s = text.replace("_", " ")
757    s = s.split()
758    if len(text) == 0:
759        return text
760    return "".join(i.capitalize() for i in s[0:])
761
762
763def main():
764    dmtf_registries = (
765        ("base", "1.19.0"),
766        ("composition", "1.1.2"),
767        ("environmental", "1.0.1"),
768        ("ethernet_fabric", "1.0.1"),
769        ("fabric", "1.0.2"),
770        ("heartbeat_event", "1.0.1"),
771        ("job_event", "1.0.1"),
772        ("license", "1.0.3"),
773        ("log_service", "1.0.1"),
774        ("network_device", "1.0.3"),
775        ("platform", "1.0.1"),
776        ("power", "1.0.1"),
777        ("resource_event", "1.3.0"),
778        ("sensor_event", "1.0.1"),
779        ("storage_device", "1.2.1"),
780        ("task_event", "1.0.3"),
781        ("telemetry", "1.0.0"),
782        ("update", "1.0.2"),
783    )
784
785    parser = argparse.ArgumentParser()
786    parser.add_argument(
787        "--registries",
788        type=str,
789        default="privilege,openbmc,"
790        + ",".join([dmtf[0] for dmtf in dmtf_registries]),
791        help="Comma delimited list of registries to update",
792    )
793
794    args = parser.parse_args()
795
796    registries = set(args.registries.split(","))
797    files = []
798
799    for registry, version in dmtf_registries:
800        if registry in registries:
801            registry_pascal_case = to_pascal_case(registry)
802            files.append(
803                make_getter(
804                    f"{registry_pascal_case}.{version}.json",
805                    f"{registry}_message_registry.hpp",
806                    registry,
807                )
808            )
809    if "openbmc" in registries:
810        files.append(openbmc_local_getter())
811
812    update_registries(files)
813
814    create_error_registry(
815        files[0], dmtf_registries[0][1], "Base", "base", "error"
816    )
817    create_error_registry(
818        files[15], dmtf_registries[15][1], "TaskEvent", "task_event", "task"
819    )
820
821    if "privilege" in registries:
822        make_privilege_registry()
823
824
825if __name__ == "__main__":
826    main()
827