handshaker.h

Go to the documentation of this file.

/*
 *
 * Copyright 2016 gRPC authors.
 *
 * 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 GRPC_CORE_LIB_TRANSPORT_HANDSHAKER_H
#define GRPC_CORE_LIB_TRANSPORT_HANDSHAKER_H
 
#include <grpc/support/port_platform.h>
 
#include <stddef.h>
 
#include "absl/container/inlined_vector.h"
 
#include <grpc/impl/codegen/grpc_types.h>
#include <grpc/slice.h>
 
#include "src/core/lib/gprpp/ref_counted.h"
#include "src/core/lib/gprpp/ref_counted_ptr.h"
#include "src/core/lib/gprpp/sync.h"
#include "src/core/lib/gprpp/time.h"
#include "src/core/lib/iomgr/closure.h"
#include "src/core/lib/iomgr/endpoint.h"
#include "src/core/lib/iomgr/error.h"
#include "src/core/lib/iomgr/tcp_server.h"
#include "src/core/lib/iomgr/timer.h"
 
namespace grpc_core {
 
 
struct HandshakerArgs {
  grpc_endpoint* endpoint = nullptr;
  grpc_channel_args* args = nullptr;
  grpc_slice_buffer* read_buffer = nullptr;
  // A handshaker may set this to true before invoking on_handshake_done
  // to indicate that subsequent handshakers should be skipped.
  bool exit_early = false;
  // User data passed through the handshake manager.  Not used by
  // individual handshakers.
  void* user_data = nullptr;
  // Deadline associated with the handshake.
  // TODO(anramach): Move this out of handshake args after event engine
  // is the default.
  Timestamp deadline;
};
 
 
class Handshaker : public RefCounted<Handshaker> {
 public:
  ~Handshaker() override = default;
  virtual void Shutdown(grpc_error_handle why) = 0;
  virtual void DoHandshake(grpc_tcp_server_acceptor* acceptor,
                           grpc_closure* on_handshake_done,
                           HandshakerArgs* args) = 0;
  virtual const char* name() const = 0;
};
 
//
// HandshakeManager
//
 
class HandshakeManager : public RefCounted<HandshakeManager> {
 public:
  HandshakeManager();
  ~HandshakeManager() override;
 
  void Add(RefCountedPtr<Handshaker> handshaker);
 
  void Shutdown(grpc_error_handle why);
 
  void DoHandshake(grpc_endpoint* endpoint,
                   const grpc_channel_args* channel_args, Timestamp deadline,
                   grpc_tcp_server_acceptor* acceptor,
                   grpc_iomgr_cb_func on_handshake_done, void* user_data);
 
 private:
  bool CallNextHandshakerLocked(grpc_error_handle error);
 
  // A function used as the handshaker-done callback when chaining
  // handshakers together.
  static void CallNextHandshakerFn(void* arg, grpc_error_handle error);
 
  // Callback invoked when deadline is exceeded.
  static void OnTimeoutFn(void* arg, grpc_error_handle error);
 
  static const size_t HANDSHAKERS_INIT_SIZE = 2;
 
  Mutex mu_;
  bool is_shutdown_ = false;
  // An array of handshakers added via grpc_handshake_manager_add().
  absl::InlinedVector<RefCountedPtr<Handshaker>, HANDSHAKERS_INIT_SIZE>
      handshakers_;
  // The index of the handshaker to invoke next and closure to invoke it.
  size_t index_ = 0;
  grpc_closure call_next_handshaker_;
  // The acceptor to call the handshakers with.
  grpc_tcp_server_acceptor* acceptor_;
  // Deadline timer across all handshakers.
  grpc_timer deadline_timer_;
  grpc_closure on_timeout_;
  // The final callback and user_data to invoke after the last handshaker.
  grpc_closure on_handshake_done_;
  // Handshaker args.
  HandshakerArgs args_;
};
 
}  // namespace grpc_core
 
// TODO(arjunroy): These are transitional to account for the new handshaker API
// and will eventually be removed entirely.
typedef grpc_core::HandshakeManager grpc_handshake_manager;
typedef grpc_core::Handshaker grpc_handshaker;
void grpc_handshake_manager_add(grpc_handshake_manager* mgr,
                                grpc_handshaker* handshaker);
 
#endif /* GRPC_CORE_LIB_TRANSPORT_HANDSHAKER_H */