redfish-core/include/redfish.hpp

/*
// Copyright (c) 2018-2019 Intel Corporation
//
// 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.
*/
#pragma once

#include "bmcweb_config.h"

#include "account_service.hpp"
#include "aggregation_service.hpp"
#include "assembly.hpp"
#include "bios.hpp"
#include "cable.hpp"
#include "certificate_service.hpp"
#include "chassis.hpp"
#include "component_integrity.hpp"
#include "environment_metrics.hpp"
#include "ethernet.hpp"
#include "event_service.hpp"
#include "external_storer.hpp"
#include "fabric_adapters.hpp"
#include "fan.hpp"
#include "hypervisor_system.hpp"
#include "log_services.hpp"
#include "managed_store_http.hpp"
#include "manager_diagnostic_data.hpp"
#include "managers.hpp"
#include "memory.hpp"
#include "message_registries.hpp"
#include "metric_report.hpp"
#include "metric_report_definition.hpp"
#include "network_adapter.hpp"
#include "network_protocol.hpp"
#include "pcie.hpp"
#include "pcie_slots.hpp"
#include "port_metrics.hpp"
#include "ports.hpp"
#include "power.hpp"
#include "power_subsystem.hpp"
#include "power_supply.hpp"
#include "power_supply_metrics.hpp"
#include "processor.hpp"
#include "redfish_sessions.hpp"
#include "redfish_v1.hpp"
#include "request_stats_store_http.hpp"
#include "roles.hpp"
#include "sensors.hpp"
#include "service_root.hpp"
#include "storage.hpp"
#include "systems.hpp"
#include "task.hpp"
#include "telemetry_service.hpp"
#include "thermal.hpp"
#include "thermal_subsystem.hpp"
#include "trigger.hpp"
#include "trusted_component.hpp"
#include "update_service.hpp"
#include "virtual_media.hpp"

namespace redfish
{
/*
 * @brief Top level class installing and providing Redfish services
 */
class RedfishService
{
  public:
    /*
     * @brief Redfish service constructor
     *
     * Loads Redfish configuration and installs schema resources
     *
     * @param[in] app   Crow app on which Redfish will initialize
     */
    explicit RedfishService(App& app)
    {
        requestAccountServiceRoutes(app);
#ifdef BMCWEB_ENABLE_REDFISH_AGGREGATION
        requestRoutesAggregationService(app);
        requestRoutesAggregationSourceCollection(app);
        requestRoutesAggregationSource(app);
#endif
        requestRoutesRoles(app);
        requestRoutesRoleCollection(app);
        requestRoutesServiceRoot(app);
        requestRoutesNetworkProtocol(app);
        requestRoutesSession(app);
        requestEthernetInterfacesRoutes(app);
        requestPortsRoutes(app);
        requestPortMetricsRoutes(app);
#ifdef BMCWEB_ALLOW_DEPRECATED_POWER_THERMAL
        requestRoutesThermal(app);
        requestRoutesPower(app);
#endif
#ifdef BMCWEB_NEW_POWERSUBSYSTEM_THERMALSUBSYSTEM
        requestRoutesEnvironmentMetrics(app);
        requestRoutesPowerSubsystem(app);
        requestRoutesPowerSupply(app);
        requestRoutesPowerSupplyCollection(app);
        requestRoutesPowerSupplyMetrics(app);
        requestRoutesThermalSubsystem(app);
        requestRoutesFan(app);
        requestRoutesFanCollection(app);
#endif
        requestRoutesComponentIntegrityCollection(app);
        requestRoutesComponentIntegrity(app);
        requestRoutesComponentIntegritySPDMGetSignedMeasurementsAction(app);
        requestRoutesComponentIntegritySPDMGetSignedMeasurementsActionInfo(app);
        requestRoutesManagerCollection(app);
        requestRoutesManager(app);
        requestRoutesManagerResetAction(app);
        requestRoutesManagerResetActionInfo(app);
        requestRoutesManagerResetToDefaultsAction(app);
        requestRoutesManagerDiagnosticData(app);
        requestRoutesPCIeSlots(app);
        requestRoutesChassisCollection(app);
        requestRoutesChassis(app);
        requestRoutesChassisResetAction(app);
        requestRoutesChassisResetActionInfo(app);
        requestRoutesChassisAssembly(app);
        requestRoutesChassisNetworkAdapterCollection(app);
        requestRoutesChassisNetworkAdapter(app);
        requestRoutesNetworkPortCollection(app);
        requestRoutesNetworkPort(app);
        requestRoutesNetworkPortMetrics(app);
        requestRoutesChassisDrive(app);
        requestRoutesChassisDriveName(app);
        requestRoutesTrustedComponentCollection(app);
        requestRoutesTrustedComponent(app);
        requestRoutesUpdateService(app);
        requestRoutesStorageCollection(app);
        requestRoutesStorage(app);
        requestRoutesStorageControllerCollection(app);
        requestRoutesStorageController(app);
        requestRoutesStorageControllerActions(app);
        requestRoutesStorageVolumeCollection(app);
        requestRoutesStorageVolume(app);
        requestRoutesCable(app);
        requestRoutesCableCollection(app);
        requestDriveResetAction(app);
        requestRoutesDriveResetActionInfo(app);
        requestRoutesStorageControllerMetric(app);
#ifdef BMCWEB_INSECURE_ENABLE_REDFISH_FW_TFTP_UPDATE
        requestRoutesUpdateServiceActionsSimpleUpdate(app);
#endif
        requestRoutesSoftwareInventoryCollection(app);
        requestRoutesSoftwareInventory(app);

        requestRoutesSystemLogServiceCollection(app);
        requestRoutesEventLogService(app);
        requestRoutesPostCodesEntryAdditionalData(app);

        requestRoutesPostCodesLogService(app);
        requestRoutesPostCodesClear(app);
        requestRoutesPostCodesEntry(app);
        requestRoutesPostCodesEntryCollection(app);

#ifdef BMCWEB_ENABLE_REDFISH_BOOT_TIME_LOG
        requestRoutesBootTimeLogService(app);
        requestRoutesBootTimeLogEntryCollection(app);
        requestRoutesBootTimeLogEntry(app);
#endif

#ifdef BMCWEB_ENABLE_REDFISH_DUMP_LOG
        requestRoutesSystemDumpService(app);
        requestRoutesSystemDumpEntryCollection(app);
        requestRoutesSystemDumpEntry(app);
        requestRoutesSystemDumpCreate(app);
        requestRoutesSystemDumpClear(app);

        requestRoutesBMCDumpService(app);
        requestRoutesBMCDumpEntryCollection(app);
        requestRoutesBMCDumpEntry(app);
        requestRoutesBMCDumpEntryDownload(app);
        requestRoutesBMCDumpCreate(app);
        requestRoutesBMCDumpClear(app);

        requestRoutesFaultLogDumpService(app);
        requestRoutesFaultLogDumpEntryCollection(app);
        requestRoutesFaultLogDumpEntry(app);
        requestRoutesFaultLogDumpClear(app);
#endif

#ifndef BMCWEB_ENABLE_REDFISH_DBUS_LOG_ENTRIES
        requestRoutesJournalEventLogEntryCollection(app);
        requestRoutesJournalEventLogEntry(app);
        requestRoutesJournalEventLogClear(app);
#endif

        requestRoutesBMCLogServiceCollection(app);
#ifdef BMCWEB_ENABLE_REDFISH_BMC_JOURNAL
        requestRoutesBMCJournalLogService(app);
        requestRoutesBMCJournalLogEntryCollection(app);
        requestRoutesBMCJournalLogEntry(app);
#endif

#ifdef BMCWEB_ENABLE_RASMANAGER_EVENT_LOG
        requestRoutesRasManagerLogService(app);
        requestRoutesRasManagerLogEntryCollection(app);
        requestRoutesRasManagerLogEntry(app);
        requestRoutesRasManagerLogClear(app);
#endif

#ifdef BMCWEB_ENABLE_REDFISH_CPU_LOG
        requestRoutesCrashdumpService(app);
        requestRoutesCrashdumpEntryCollection(app);
        requestRoutesCrashdumpEntry(app);
        requestRoutesCrashdumpFile(app);
        requestRoutesCrashdumpClear(app);
        requestRoutesCrashdumpCollect(app);
#endif // BMCWEB_ENABLE_REDFISH_CPU_LOG

#ifdef BMCWEB_ENABLE_PPR
        requestRoutesPPRService(app);
        requestRoutesPPRStatus(app);
        requestRoutesPPRFile(app);
        requestRoutesPPRConfig(app);
#endif // BMCWEB_ENABLE_PPR

        requestRoutesProcessorCollection(app);
        requestRoutesProcessor(app);
        requestRoutesOperatingConfigCollection(app);
        requestRoutesOperatingConfig(app);
        requestRoutesMemoryCollection(app);
        requestRoutesMemory(app);
        requestRoutesSubProcessorCoreCollection(app);
        requestRoutesSubProcessorCore(app);
        requestRoutesSubProcessorThreadCollection(app);
        requestRoutesSubProcessorThread(app);

        requestRoutesSystemsCollection(app);
        requestRoutesSystems(app);
        requestRoutesSystemActionsReset(app);
        requestRoutesSystemResetActionInfo(app);
        if constexpr (enableGoogleBaremetal)
        {
            requestRoutesSystemBootGuestOS(app);
            requestRoutesSystemBootGuestOSInfo(app);
        }
        requestRoutesBiosService(app);
        requestRoutesBiosReset(app);

#ifdef BMCWEB_ENABLE_VM_NBDPROXY
        requestNBDVirtualMediaRoutes(app);
#endif // BMCWEB_ENABLE_VM_NBDPROXY

#ifdef BMCWEB_ENABLE_REDFISH_DBUS_LOG_ENTRIES
        requestRoutesDBusLogServiceActionsClear(app);
        requestRoutesDBusEventLogEntryCollection(app);
        requestRoutesDBusEventLogEntry(app);
        requestRoutesDBusEventLogEntryDownload(app);
#endif

#ifdef BMCWEB_ENABLE_REDFISH_HOST_LOGGER
        requestRoutesSystemHostLogger(app);
        requestRoutesSystemHostLoggerCollection(app);
        requestRoutesSystemHostLoggerLogEntry(app);
#endif

        requestRoutesMessageRegistryFileCollection(app);
        requestRoutesMessageRegistryFile(app);
        requestRoutesMessageRegistry(app);

        requestRoutesCertificateService(app);
        requestRoutesHTTPSCertificate(app);
        requestRoutesLDAPCertificate(app);
        requestRoutesTrustStoreCertificate(app);
        requestRoutesChassisCertificate(app);

        requestRoutesSystemPCIeFunctionCollection(app);
        requestRoutesSystemPCIeFunction(app);
        requestRoutesSystemPCIeDeviceCollection(app);
        requestRoutesSystemPCIeDevice(app);

        requestRoutesSensorCollection(app);
        requestRoutesSensor(app);

        requestRoutesTaskMonitor(app);
        requestRoutesTaskService(app);
        requestRoutesTaskCollection(app);
        requestRoutesTask(app);
        requestRoutesEventService(app);
        requestRoutesEventDestinationCollection(app);
        requestRoutesEventDestination(app);
        requestRoutesFabricAdapters(app);
        requestRoutesFabricAdapterCollection(app);
        requestRoutesSubmitTestEvent(app);

        requestRoutesHypervisorSystems(app);

        requestRoutesTelemetryService(app);
        requestRoutesMetricReportDefinitionCollection(app);
        requestRoutesMetricReportDefinition(app);
        requestRoutesMetricReportCollection(app);
        requestRoutesMetricReport(app);
        requestRoutesTriggerCollection(app);
        requestRoutesTrigger(app);

        requestRoutesManagerFanModeChangeActionInfo(app);
        requestRoutesManagerFanModeChangeAction(app);

#ifdef BMCWEB_ENABLE_REDFISH_EXTERNAL_STORER
        requestRoutesExternalStorer(app);
        requestRoutesMemoryMetricsViaExternalStorer(app);
        requestRoutesProcessorMetricsViaExternalStorer(app);
#endif

#ifdef BMCWEB_ENABLE_REDFISH_BOOT_TIME
        requestRoutesHostBootTime(app);
        requestRoutesBmcBootTime(app);
#endif
        // Stateful BMC - managed store:
        managedStore::requestRoutesManagedStore(app);
        // request stats exporting
        managedStore::requestRoutesRequestStatsStore(app);

        // Note, this must be the last route registered
        requestRoutesRedfish(app);
    }
};

} // namespace redfish