Program Listing for File http_internal.hpp

↰ Return to documentation for file (/workspace/amdinfer/src/amdinfer/clients/http_internal.hpp)

// Copyright 2022 Xilinx, Inc.
// Copyright 2022 Advanced Micro Devices, Inc.
//
// 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.

#ifndef GUARD_AMDINFER_CLIENTS_HTTP_INTERNAL
#define GUARD_AMDINFER_CLIENTS_HTTP_INTERNAL

#include <drogon/HttpRequest.h>   // for HttpRequestPtr
#include <drogon/HttpResponse.h>  // for HttpResponsePtr
#include <json/value.h>           // for Value

#include <cstddef>     // for size_t
#include <exception>   // for invalid_argument
#include <functional>  // for function
#include <memory>      // for shared_ptr
#include <string>      // for string
#include <vector>      // for vector

#include "amdinfer/build_options.hpp"   // for AMDINFER_ENABLE_TRACING
#include "amdinfer/core/interface.hpp"  // for Interface
#include "amdinfer/core/predict_api_internal.hpp"  // for InferenceRequestBui...
#include "amdinfer/declarations.hpp"               // for BufferRawPtrs, Infe...

namespace amdinfer {

RequestParametersPtr mapJsonToParameters(Json::Value json);
Json::Value mapParametersToJson(RequestParameters *parameters);

InferenceResponse mapJsonToResponse(Json::Value *json);
Json::Value mapRequestToJson(const InferenceRequest &request);

// class InferenceRequestOutputBuilder {
//  public:
//   static InferenceRequestOutput fromJson(
//     std::shared_ptr<Json::Value> const &req);
// };

template <>
class InferenceRequestBuilder<std::shared_ptr<Json::Value>> {
 public:
  static InferenceRequestPtr build(const std::shared_ptr<Json::Value> &req,
                                   const BufferRawPtrs &input_buffers,
                                   std::vector<size_t> &input_offsets,
                                   const BufferRawPtrs &output_buffers,
                                   std::vector<size_t> &output_offsets);
};

using RequestBuilder = InferenceRequestBuilder<std::shared_ptr<Json::Value>>;

#ifdef AMDINFER_ENABLE_TRACING
void propagate(drogon::HttpResponse *resp, const StringMap &context);
#endif

using DrogonCallback = std::function<void(const drogon::HttpResponsePtr &)>;

class DrogonHttp : public Interface {
 public:
  DrogonHttp(const drogon::HttpRequestPtr &req, DrogonCallback callback);

  std::shared_ptr<InferenceRequest> getRequest(
    const BufferRawPtrs &input_buffers, std::vector<size_t> &input_offsets,
    const BufferRawPtrs &output_buffers,
    std::vector<size_t> &output_offsets) override;

  size_t getInputSize() override;
  void errorHandler(const std::exception &e) override;

 private:
  drogon::HttpRequestPtr req_;
  DrogonCallback callback_;
  std::shared_ptr<Json::Value> json_;
};

drogon::HttpResponsePtr errorHttpResponse(const std::string &error,
                                          int status_code);

Json::Value modelMetadataToJson(const ModelMetadata &metadata);
ModelMetadata mapJsonToModelMetadata(const Json::Value *json);

}  // namespace amdinfer

#endif  // GUARD_AMDINFER_CLIENTS_HTTP_INTERNAL