xref: /openbmc/bmcweb/features/redfish/lib/chassis.hpp (revision 5b9e95a17fae7aaf9f8716b65345bb64ade5f403)

/*
// Copyright (c) 2018 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 "health.hpp"
#include "led.hpp"

#include <app.hpp>
#include <dbus_utility.hpp>
#include <query.hpp>
#include <registries/privilege_registry.hpp>
#include <sdbusplus/asio/property.hpp>
#include <utils/collection.hpp>

namespace redfish
{

/**
 * @brief Retrieves chassis state properties over dbus
 *
 * @param[in] aResp - Shared pointer for completing asynchronous calls.
 *
 * @return None.
 */
inline void getChassisState(std::shared_ptr<bmcweb::AsyncResp> aResp)
{
    // crow::connections::systemBus->async_method_call(
    sdbusplus::asio::getProperty<std::string>(
        *crow::connections::systemBus, "xyz.openbmc_project.State.Chassis",
        "/xyz/openbmc_project/state/chassis0",
        "xyz.openbmc_project.State.Chassis", "CurrentPowerState",
        [aResp{std::move(aResp)}](const boost::system::error_code ec,
                                  const std::string& chassisState) {
        if (ec)
        {
            if (ec == boost::system::errc::host_unreachable)
            {
                // Service not available, no error, just don't return
                // chassis state info
                BMCWEB_LOG_DEBUG << "Service not available " << ec;
                return;
            }
            BMCWEB_LOG_DEBUG << "DBUS response error " << ec;
            messages::internalError(aResp->res);
            return;
        }

        BMCWEB_LOG_DEBUG << "Chassis state: " << chassisState;
        // Verify Chassis State
        if (chassisState == "xyz.openbmc_project.State.Chassis.PowerState.On")
        {
            aResp->res.jsonValue["PowerState"] = "On";
            aResp->res.jsonValue["Status"]["State"] = "Enabled";
        }
        else if (chassisState ==
                 "xyz.openbmc_project.State.Chassis.PowerState.Off")
        {
            aResp->res.jsonValue["PowerState"] = "Off";
            aResp->res.jsonValue["Status"]["State"] = "StandbyOffline";
        }
        });
}

inline void getIntrusionByService(std::shared_ptr<bmcweb::AsyncResp> aResp,
                                  const std::string& service,
                                  const std::string& objPath)
{
    BMCWEB_LOG_DEBUG << "Get intrusion status by service \n";

    sdbusplus::asio::getProperty<std::string>(
        *crow::connections::systemBus, service, objPath,
        "xyz.openbmc_project.Chassis.Intrusion", "Status",
        [aResp{std::move(aResp)}](const boost::system::error_code ec,
                                  const std::string& value) {
        if (ec)
        {
            // do not add err msg in redfish response, because this is not
            //     mandatory property
            BMCWEB_LOG_ERROR << "DBUS response error " << ec << "\n";
            return;
        }

        aResp->res.jsonValue["PhysicalSecurity"]["IntrusionSensorNumber"] = 1;
        aResp->res.jsonValue["PhysicalSecurity"]["IntrusionSensor"] = value;
        });
}

/**
 * Retrieves physical security properties over dbus
 */
inline void getPhysicalSecurityData(std::shared_ptr<bmcweb::AsyncResp> aResp)
{
    crow::connections::systemBus->async_method_call(
        [aResp{std::move(aResp)}](
            const boost::system::error_code ec,
            const dbus::utility::MapperGetSubTreeResponse& subtree) {
        if (ec)
        {
            // do not add err msg in redfish response, because this is not
            //     mandatory property
            BMCWEB_LOG_INFO << "DBUS error: no matched iface " << ec << "\n";
            return;
        }
        // Iterate over all retrieved ObjectPaths.
        for (const auto& object : subtree)
        {
            for (const auto& service : object.second)
            {
                getIntrusionByService(aResp, service.first, object.first);
                return;
            }
        }
        },
        "xyz.openbmc_project.ObjectMapper",
        "/xyz/openbmc_project/object_mapper",
        "xyz.openbmc_project.ObjectMapper", "GetSubTree",
        "/xyz/openbmc_project/Intrusion", 1,
        std::array<const char*, 1>{"xyz.openbmc_project.Chassis.Intrusion"});
}

/**
 * ChassisCollection derived class for delivering Chassis Collection Schema
 *  Functions triggers appropriate requests on DBus
 */
inline void requestRoutesChassisCollection(App& app)
{
    BMCWEB_ROUTE(app, "/redfish/v1/Chassis/")
        .privileges(redfish::privileges::getChassisCollection)
        .methods(boost::beast::http::verb::get)(
            [&app](const crow::Request& req,
                   const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
        if (!redfish::setUpRedfishRoute(app, req, asyncResp->res))
        {
            return;
        }
        asyncResp->res.jsonValue["@odata.type"] =
            "#ChassisCollection.ChassisCollection";
        asyncResp->res.jsonValue["@odata.id"] = "/redfish/v1/Chassis";
        asyncResp->res.jsonValue["Name"] = "Chassis Collection";

        collection_util::getCollectionMembers(
            asyncResp, "/redfish/v1/Chassis",
            {"xyz.openbmc_project.Inventory.Item.Board",
             "xyz.openbmc_project.Inventory.Item.Chassis"});
        });
}

inline void
    getChassisLocationCode(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
                           const std::string& connectionName,
                           const std::string& path)
{
    sdbusplus::asio::getProperty<std::string>(
        *crow::connections::systemBus, connectionName, path,
        "xyz.openbmc_project.Inventory.Decorator.LocationCode", "LocationCode",
        [asyncResp](const boost::system::error_code ec,
                    const std::string& property) {
        if (ec)
        {
            BMCWEB_LOG_DEBUG << "DBUS response error for Location";
            messages::internalError(asyncResp->res);
            return;
        }

        asyncResp->res.jsonValue["Location"]["PartLocation"]["ServiceLabel"] =
            property;
        });
}

inline void getChassisUUID(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
                           const std::string& connectionName,
                           const std::string& path)
{
    sdbusplus::asio::getProperty<std::string>(
        *crow::connections::systemBus, connectionName, path,
        "xyz.openbmc_project.Common.UUID", "UUID",
        [asyncResp](const boost::system::error_code ec,
                    const std::string& chassisUUID) {
        if (ec)
        {
            BMCWEB_LOG_DEBUG << "DBUS response error for UUID";
            messages::internalError(asyncResp->res);
            return;
        }
        asyncResp->res.jsonValue["UUID"] = chassisUUID;
        });
}

/**
 * Chassis override class for delivering Chassis Schema
 * Functions triggers appropriate requests on DBus
 */
inline void requestRoutesChassis(App& app)
{
    BMCWEB_ROUTE(app, "/redfish/v1/Chassis/<str>/")
        .privileges(redfish::privileges::getChassis)
        .methods(boost::beast::http::verb::get)(
            [&app](const crow::Request& req,
                   const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
                   const std::string& chassisId) {
        if (!redfish::setUpRedfishRoute(app, req, asyncResp->res))
        {
            return;
        }
        const std::array<const char*, 2> interfaces = {
            "xyz.openbmc_project.Inventory.Item.Board",
            "xyz.openbmc_project.Inventory.Item.Chassis"};

        crow::connections::systemBus->async_method_call(
            [asyncResp, chassisId(std::string(chassisId))](
                const boost::system::error_code ec,
                const dbus::utility::MapperGetSubTreeResponse& subtree) {
            if (ec)
            {
                messages::internalError(asyncResp->res);
                return;
            }
            // Iterate over all retrieved ObjectPaths.
            for (const std::pair<std::string,
                                 std::vector<std::pair<
                                     std::string, std::vector<std::string>>>>&
                     object : subtree)
            {
                const std::string& path = object.first;
                const std::vector<
                    std::pair<std::string, std::vector<std::string>>>&
                    connectionNames = object.second;

                sdbusplus::message::object_path objPath(path);
                if (objPath.filename() != chassisId)
                {
                    continue;
                }

                auto health = std::make_shared<HealthPopulate>(asyncResp);

                sdbusplus::asio::getProperty<std::vector<std::string>>(
                    *crow::connections::systemBus,
                    "xyz.openbmc_project.ObjectMapper", path + "/all_sensors",
                    "xyz.openbmc_project.Association", "endpoints",
                    [health](const boost::system::error_code ec2,
                             const std::vector<std::string>& resp) {
                    if (ec2)
                    {
                        return; // no sensors = no failures
                    }
                    health->inventory = resp;
                    });

                health->populate();

                if (connectionNames.empty())
                {
                    BMCWEB_LOG_ERROR << "Got 0 Connection names";
                    continue;
                }

                asyncResp->res.jsonValue["@odata.type"] =
                    "#Chassis.v1_16_0.Chassis";
                asyncResp->res.jsonValue["@odata.id"] =
                    "/redfish/v1/Chassis/" + chassisId;
                asyncResp->res.jsonValue["Name"] = "Chassis Collection";
                asyncResp->res.jsonValue["ChassisType"] = "RackMount";
                asyncResp->res
                    .jsonValue["Actions"]["#Chassis.Reset"]["target"] =
                    "/redfish/v1/Chassis/" + chassisId +
                    "/Actions/Chassis.Reset";
                asyncResp->res.jsonValue["Actions"]["#Chassis.Reset"]
                                        ["@Redfish.ActionInfo"] =
                    "/redfish/v1/Chassis/" + chassisId + "/ResetActionInfo";
                asyncResp->res.jsonValue["PCIeDevices"]["@odata.id"] =
                    "/redfish/v1/Systems/system/PCIeDevices";

                sdbusplus::asio::getProperty<std::vector<std::string>>(
                    *crow::connections::systemBus,
                    "xyz.openbmc_project.ObjectMapper", path + "/drive",
                    "xyz.openbmc_project.Association", "endpoints",
                    [asyncResp,
                     chassisId](const boost::system::error_code ec3,
                                const std::vector<std::string>& resp) {
                    if (ec3 || resp.empty())
                    {
                        return; // no drives = no failures
                    }

                    nlohmann::json reference;
                    reference["odata.id"] = crow::utility::urlFromPieces(
                        "redfish", "v1", "Chassis", chassisId, "Drives");
                    asyncResp->res.jsonValue["Drives"] = std::move(reference);
                    });

                const std::string& connectionName = connectionNames[0].first;

                const std::vector<std::string>& interfaces2 =
                    connectionNames[0].second;
                const std::array<const char*, 2> hasIndicatorLed = {
                    "xyz.openbmc_project.Inventory.Item.Panel",
                    "xyz.openbmc_project.Inventory.Item.Board.Motherboard"};

                const std::string assetTagInterface =
                    "xyz.openbmc_project.Inventory.Decorator.AssetTag";
                if (std::find(interfaces2.begin(), interfaces2.end(),
                              assetTagInterface) != interfaces2.end())
                {
                    sdbusplus::asio::getProperty<std::string>(
                        *crow::connections::systemBus, connectionName, path,
                        assetTagInterface, "AssetTag",
                        [asyncResp, chassisId(std::string(chassisId))](
                            const boost::system::error_code ec,
                            const std::string& property) {
                        if (ec)
                        {
                            BMCWEB_LOG_DEBUG
                                << "DBus response error for AssetTag";
                            messages::internalError(asyncResp->res);
                            return;
                        }
                        asyncResp->res.jsonValue["AssetTag"] = property;
                        });
                }

                for (const char* interface : hasIndicatorLed)
                {
                    if (std::find(interfaces2.begin(), interfaces2.end(),
                                  interface) != interfaces2.end())
                    {
                        getIndicatorLedState(asyncResp);
                        getLocationIndicatorActive(asyncResp);
                        break;
                    }
                }

                crow::connections::systemBus->async_method_call(
                    [asyncResp, chassisId(std::string(chassisId))](
                        const boost::system::error_code /*ec2*/,
                        const dbus::utility::DBusPropertiesMap&
                            propertiesList) {
                    for (const std::pair<std::string,
                                         dbus::utility::DbusVariantType>&
                             property : propertiesList)
                    {
                        // Store DBus properties that are also
                        // Redfish properties with same name and a
                        // string value
                        const std::string& propertyName = property.first;
                        if ((propertyName == "PartNumber") ||
                            (propertyName == "SerialNumber") ||
                            (propertyName == "Manufacturer") ||
                            (propertyName == "Model") ||
                            (propertyName == "SparePartNumber"))
                        {
                            const std::string* value =
                                std::get_if<std::string>(&property.second);
                            if (value == nullptr)
                            {
                                BMCWEB_LOG_ERROR << "Null value returned for "
                                                 << propertyName;
                                messages::internalError(asyncResp->res);
                                return;
                            }
                            // SparePartNumber is optional on D-Bus
                            // so skip if it is empty
                            if (propertyName == "SparePartNumber")
                            {
                                if (value->empty())
                                {
                                    continue;
                                }
                            }
                            asyncResp->res.jsonValue[propertyName] = *value;
                        }
                    }
                    asyncResp->res.jsonValue["Name"] = chassisId;
                    asyncResp->res.jsonValue["Id"] = chassisId;
#ifdef BMCWEB_ALLOW_DEPRECATED_POWER_THERMAL
                    asyncResp->res.jsonValue["Thermal"]["@odata.id"] =
                        "/redfish/v1/Chassis/" + chassisId + "/Thermal";
                    // Power object
                    asyncResp->res.jsonValue["Power"]["@odata.id"] =
                        "/redfish/v1/Chassis/" + chassisId + "/Power";
#endif
                    // SensorCollection
                    asyncResp->res.jsonValue["Sensors"]["@odata.id"] =
                        "/redfish/v1/Chassis/" + chassisId + "/Sensors";
                    asyncResp->res.jsonValue["Status"]["State"] = "Enabled";

                    nlohmann::json::array_t computerSystems;
                    nlohmann::json::object_t system;
                    system["@odata.id"] = "/redfish/v1/Systems/system";
                    computerSystems.push_back(std::move(system));
                    asyncResp->res.jsonValue["Links"]["ComputerSystems"] =
                        std::move(computerSystems);

                    nlohmann::json::array_t managedBy;
                    nlohmann::json::object_t manager;
                    manager["@odata.id"] = "/redfish/v1/Managers/bmc";
                    managedBy.push_back(std::move(manager));
                    asyncResp->res.jsonValue["Links"]["ManagedBy"] =
                        std::move(managedBy);
                    getChassisState(asyncResp);
                    },
                    connectionName, path, "org.freedesktop.DBus.Properties",
                    "GetAll", "xyz.openbmc_project.Inventory.Decorator.Asset");

                for (const auto& interface : interfaces2)
                {
                    if (interface == "xyz.openbmc_project.Common.UUID")
                    {
                        getChassisUUID(asyncResp, connectionName, path);
                    }
                    else if (
                        interface ==
                        "xyz.openbmc_project.Inventory.Decorator.LocationCode")
                    {
                        getChassisLocationCode(asyncResp, connectionName, path);
                    }
                }

                return;
            }

            // Couldn't find an object with that name.  return an error
            messages::resourceNotFound(asyncResp->res,
                                       "#Chassis.v1_16_0.Chassis", chassisId);
            },
            "xyz.openbmc_project.ObjectMapper",
            "/xyz/openbmc_project/object_mapper",
            "xyz.openbmc_project.ObjectMapper", "GetSubTree",
            "/xyz/openbmc_project/inventory", 0, interfaces);

        getPhysicalSecurityData(asyncResp);
        });

    BMCWEB_ROUTE(app, "/redfish/v1/Chassis/<str>/")
        .privileges(redfish::privileges::patchChassis)
        .methods(boost::beast::http::verb::patch)(
            [&app](const crow::Request& req,
                   const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
                   const std::string& param) {
        if (!redfish::setUpRedfishRoute(app, req, asyncResp->res))
        {
            return;
        }
        std::optional<bool> locationIndicatorActive;
        std::optional<std::string> indicatorLed;

        if (param.empty())
        {
            return;
        }

        if (!json_util::readJsonPatch(
                req, asyncResp->res, "LocationIndicatorActive",
                locationIndicatorActive, "IndicatorLED", indicatorLed))
        {
            return;
        }

        // TODO (Gunnar): Remove IndicatorLED after enough time has passed
        if (!locationIndicatorActive && !indicatorLed)
        {
            return; // delete this when we support more patch properties
        }
        if (indicatorLed)
        {
            asyncResp->res.addHeader(
                boost::beast::http::field::warning,
                "299 - \"IndicatorLED is deprecated. Use LocationIndicatorActive instead.\"");
        }

        const std::array<const char*, 2> interfaces = {
            "xyz.openbmc_project.Inventory.Item.Board",
            "xyz.openbmc_project.Inventory.Item.Chassis"};

        const std::string& chassisId = param;

        crow::connections::systemBus->async_method_call(
            [asyncResp, chassisId, locationIndicatorActive, indicatorLed](
                const boost::system::error_code ec,
                const dbus::utility::MapperGetSubTreeResponse& subtree) {
            if (ec)
            {
                messages::internalError(asyncResp->res);
                return;
            }

            // Iterate over all retrieved ObjectPaths.
            for (const std::pair<std::string,
                                 std::vector<std::pair<
                                     std::string, std::vector<std::string>>>>&
                     object : subtree)
            {
                const std::string& path = object.first;
                const std::vector<
                    std::pair<std::string, std::vector<std::string>>>&
                    connectionNames = object.second;

                sdbusplus::message::object_path objPath(path);
                if (objPath.filename() != chassisId)
                {
                    continue;
                }

                if (connectionNames.empty())
                {
                    BMCWEB_LOG_ERROR << "Got 0 Connection names";
                    continue;
                }

                const std::vector<std::string>& interfaces3 =
                    connectionNames[0].second;

                const std::array<const char*, 2> hasIndicatorLed = {
                    "xyz.openbmc_project.Inventory.Item.Panel",
                    "xyz.openbmc_project.Inventory.Item.Board.Motherboard"};
                bool indicatorChassis = false;
                for (const char* interface : hasIndicatorLed)
                {
                    if (std::find(interfaces3.begin(), interfaces3.end(),
                                  interface) != interfaces3.end())
                    {
                        indicatorChassis = true;
                        break;
                    }
                }
                if (locationIndicatorActive)
                {
                    if (indicatorChassis)
                    {
                        setLocationIndicatorActive(asyncResp,
                                                   *locationIndicatorActive);
                    }
                    else
                    {
                        messages::propertyUnknown(asyncResp->res,
                                                  "LocationIndicatorActive");
                    }
                }
                if (indicatorLed)
                {
                    if (indicatorChassis)
                    {
                        setIndicatorLedState(asyncResp, *indicatorLed);
                    }
                    else
                    {
                        messages::propertyUnknown(asyncResp->res,
                                                  "IndicatorLED");
                    }
                }
                return;
            }

            messages::resourceNotFound(asyncResp->res,
                                       "#Chassis.v1_14_0.Chassis", chassisId);
            },
            "xyz.openbmc_project.ObjectMapper",
            "/xyz/openbmc_project/object_mapper",
            "xyz.openbmc_project.ObjectMapper", "GetSubTree",
            "/xyz/openbmc_project/inventory", 0, interfaces);
        });
}

inline void
    doChassisPowerCycle(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
{
    const char* busName = "xyz.openbmc_project.ObjectMapper";
    const char* path = "/xyz/openbmc_project/object_mapper";
    const char* interface = "xyz.openbmc_project.ObjectMapper";
    const char* method = "GetSubTreePaths";

    const std::array<const char*, 1> interfaces = {
        "xyz.openbmc_project.State.Chassis"};

    // Use mapper to get subtree paths.
    crow::connections::systemBus->async_method_call(
        [asyncResp](
            const boost::system::error_code ec,
            const dbus::utility::MapperGetSubTreePathsResponse& chassisList) {
        if (ec)
        {
            BMCWEB_LOG_DEBUG << "[mapper] Bad D-Bus request error: " << ec;
            messages::internalError(asyncResp->res);
            return;
        }

        const char* processName = "xyz.openbmc_project.State.Chassis";
        const char* interfaceName = "xyz.openbmc_project.State.Chassis";
        const char* destProperty = "RequestedPowerTransition";
        const std::string propertyValue =
            "xyz.openbmc_project.State.Chassis.Transition.PowerCycle";
        std::string objectPath = "/xyz/openbmc_project/state/chassis_system0";

        /* Look for system reset chassis path */
        if ((std::find(chassisList.begin(), chassisList.end(), objectPath)) ==
            chassisList.end())
        {
            /* We prefer to reset the full chassis_system, but if it doesn't
             * exist on some platforms, fall back to a host-only power reset
             */
            objectPath = "/xyz/openbmc_project/state/chassis0";
        }

        crow::connections::systemBus->async_method_call(
            [asyncResp](const boost::system::error_code ec) {
            // Use "Set" method to set the property value.
            if (ec)
            {
                BMCWEB_LOG_DEBUG << "[Set] Bad D-Bus request error: " << ec;
                messages::internalError(asyncResp->res);
                return;
            }

            messages::success(asyncResp->res);
            },
            processName, objectPath, "org.freedesktop.DBus.Properties", "Set",
            interfaceName, destProperty,
            dbus::utility::DbusVariantType{propertyValue});
        },
        busName, path, interface, method, "/", 0, interfaces);
}

/**
 * ChassisResetAction class supports the POST method for the Reset
 * action.
 * Function handles POST method request.
 * Analyzes POST body before sending Reset request data to D-Bus.
 */

inline void requestRoutesChassisResetAction(App& app)
{
    BMCWEB_ROUTE(app, "/redfish/v1/Chassis/<str>/Actions/Chassis.Reset/")
        .privileges(redfish::privileges::postChassis)
        .methods(boost::beast::http::verb::post)(
            [&app](const crow::Request& req,
                   const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
                   const std::string&) {
        if (!redfish::setUpRedfishRoute(app, req, asyncResp->res))
        {
            return;
        }
        BMCWEB_LOG_DEBUG << "Post Chassis Reset.";

        std::string resetType;

        if (!json_util::readJsonAction(req, asyncResp->res, "ResetType",
                                       resetType))
        {
            return;
        }

        if (resetType != "PowerCycle")
        {
            BMCWEB_LOG_DEBUG << "Invalid property value for ResetType: "
                             << resetType;
            messages::actionParameterNotSupported(asyncResp->res, resetType,
                                                  "ResetType");

            return;
        }
        doChassisPowerCycle(asyncResp);
        });
}

/**
 * ChassisResetActionInfo derived class for delivering Chassis
 * ResetType AllowableValues using ResetInfo schema.
 */
inline void requestRoutesChassisResetActionInfo(App& app)
{
    BMCWEB_ROUTE(app, "/redfish/v1/Chassis/<str>/ResetActionInfo/")
        .privileges(redfish::privileges::getActionInfo)
        .methods(boost::beast::http::verb::get)(
            [&app](const crow::Request& req,
                   const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
                   const std::string& chassisId) {
        if (!redfish::setUpRedfishRoute(app, req, asyncResp->res))
        {
            return;
        }
        asyncResp->res.jsonValue["@odata.type"] =
            "#ActionInfo.v1_1_2.ActionInfo";
        asyncResp->res.jsonValue["@odata.id"] =
            "/redfish/v1/Chassis/" + chassisId + "/ResetActionInfo";
        asyncResp->res.jsonValue["Name"] = "Reset Action Info";

        asyncResp->res.jsonValue["Id"] = "ResetActionInfo";
        nlohmann::json::array_t parameters;
        nlohmann::json::object_t parameter;
        parameter["Name"] = "ResetType";
        parameter["Required"] = true;
        parameter["DataType"] = "String";
        nlohmann::json::array_t allowed;
        allowed.push_back("PowerCycle");
        parameter["AllowableValues"] = std::move(allowed);
        parameters.push_back(std::move(parameter));

        asyncResp->res.jsonValue["Parameters"] = std::move(parameters);
        });
}

} // namespace redfish