safepower_agent.cc

#include "safepower_agent.h"

#include <memory>
#include <ostream>
#include <utility>

#include "bmc/convert_status.h"
#include "safepower_agent.pb.h"
#include "service_impl.h"
#include "state_change_reactor.h"
#include "absl/log/log.h"
#include "absl/status/status.h"
#include "absl/status/statusor.h"
#include "grpcpp/server_context.h"
#include "grpcpp/support/server_callback.h"
#include "grpcpp/support/status.h"

namespace safepower_agent {
using safepower_agent_proto::ActionStateLog;
using safepower_agent_proto::SystemState;

template <typename StateProto>
StateChangeWriteReactor<StateProto>* DetachReactor(
    std::unique_ptr<StateChangeWriteReactor<StateProto>> reactor) {
  return StateChangeWriteReactor<StateProto>::Detach(std::move(reactor));
}

void SafepowerLocalAgentImpl::DumpSafepowerState(std::ostream& os) const {
  service_impl_.DumpSafepowerState(os);
}

grpc::ServerUnaryReactor* SafepowerLocalAgentImpl::StartAction(
    grpc::CallbackServerContext* context,
    const safepower_agent_proto::StartActionRequest* request,
    safepower_agent_proto::StartActionResponse* /*response*/) {
  grpc::ServerUnaryReactor* reactor = context->DefaultReactor();
  absl::Status status = service_impl_.StartAction(*request);
  reactor->Finish(ConvertStatus(status));
  return reactor;
}

grpc::ServerWriteReactor<safepower_agent_proto::ActionStateLog>*
SafepowerLocalAgentImpl::MonitorAction(
    grpc::CallbackServerContext* /*context*/,
    const safepower_agent_proto::MonitorActionRequest* request) {
  auto reactor = std::make_unique<StateChangeWriteReactor<ActionStateLog>>();

  auto result = service_impl_.MonitorAction(*request);
  if (!result.ok()) {
    reactor->Finish(ConvertStatus(result.status()));
    return DetachReactor(std::move(reactor));
  }
  reactor->Connect(*result);
  return DetachReactor(std::move(reactor));
}

grpc::ServerWriteReactor<SystemState>* SafepowerLocalAgentImpl::MonitorState(
    grpc::CallbackServerContext* /*context*/,
    const safepower_agent_proto::MonitorStateRequest* /*request*/) {
  auto reactor = std::make_unique<StateChangeWriteReactor<SystemState>>();
  auto result = service_impl_.MonitorState();
  if (!result.ok()) {
    reactor->Finish(ConvertStatus(result.status()));
    return DetachReactor(std::move(reactor));
  }
  reactor->Connect(*result);
  return DetachReactor(std::move(reactor));
}

grpc::ServerUnaryReactor* SafepowerLocalAgentImpl::SystemStateUpdate(
    grpc::CallbackServerContext* context,
    const safepower_agent_proto::SystemState* request,
    safepower_agent_proto::SystemStateUpdateResponse* /*response*/) {
  grpc::ServerUnaryReactor* reactor = context->DefaultReactor();
  absl::Status status = service_impl_.SystemStateUpdate(*request);
  reactor->Finish(ConvertStatus(status));
  return reactor;
}

grpc::ServerUnaryReactor* SafepowerLocalAgentImpl::GetSupportedActions(
    grpc::CallbackServerContext* context,
    const safepower_agent_proto::GetSupportedActionsRequest* /*request*/,
    safepower_agent_proto::GetSupportedActionsResponse* response) {
  grpc::ServerUnaryReactor* reactor = context->DefaultReactor();
  service_impl_.GetSupportedActions(*response);
  reactor->Finish(grpc::Status::OK);
  return reactor;
}

grpc::ServerUnaryReactor* SafepowerLocalAgentImpl::GetFeatures(
    grpc::CallbackServerContext* context,
    const safepower_agent_proto::GetFeaturesRequest* /*request*/,
    safepower_agent_proto::GetFeaturesResponse* response) {
  grpc::ServerUnaryReactor* reactor = context->DefaultReactor();
  absl::Status status = service_impl_.GetFeatures(*response);
  reactor->Finish(ConvertStatus(status));
  return reactor;
}

void SafepowerLocalAgentImpl::Run() { service_impl_.Run(); }

void SafepowerLocalAgentImpl::Stop() { service_impl_.Stop(); }

}  // namespace safepower_agent