Adding upstream version 18.2.2.upstream/18.2.2

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 147 insertions, 0 deletions

diff --git a/src/crimson/net/Connection.h b/src/crimson/net/Connection.h
new file mode 100644
index 000000000..7141e20f4
--- /dev/null
+++ b/src/crimson/net/Connection.h
@@ -0,0 +1,147 @@
+// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
+// vim: ts=8 sw=2 smarttab
+/*
+ * Ceph - scalable distributed file system
+ *
+ * Copyright (C) 2017 Red Hat, Inc
+ *
+ * This is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License version 2.1, as published by the Free Software
+ * Foundation.  See file COPYING.
+ *
+ */
+
+#pragma once
+
+#include <queue>
+#include <seastar/core/future.hh>
+#include <seastar/core/shared_ptr.hh>
+
+#include "Fwd.h"
+
+namespace crimson::net {
+
+using seq_num_t = uint64_t;
+
+/**
+ * Connection
+ *
+ * Abstraction for messenger connections.
+ *
+ * Except when otherwise specified, methods must be invoked from the core on which
+ * the connection originates.
+ */
+class Connection : public seastar::enable_shared_from_this<Connection> {
+ public:
+  using clock_t = seastar::lowres_system_clock;
+
+  Connection() {}
+
+  virtual ~Connection() {}
+
+  /**
+   * get_shard_id
+   *
+   * The shard id where the Connection is dispatching events and handling I/O.
+   *
+   * May be changed with the accept/connect events.
+   */
+  virtual const seastar::shard_id get_shard_id() const = 0;
+
+  virtual const entity_name_t &get_peer_name() const = 0;
+
+  entity_type_t get_peer_type() const { return get_peer_name().type(); }
+  int64_t get_peer_id() const { return get_peer_name().num(); }
+  bool peer_is_mon() const { return get_peer_name().is_mon(); }
+  bool peer_is_mgr() const { return get_peer_name().is_mgr(); }
+  bool peer_is_mds() const { return get_peer_name().is_mds(); }
+  bool peer_is_osd() const { return get_peer_name().is_osd(); }
+  bool peer_is_client() const { return get_peer_name().is_client(); }
+
+  virtual const entity_addr_t &get_peer_addr() const = 0;
+
+  const entity_addrvec_t get_peer_addrs() const {
+    return entity_addrvec_t(get_peer_addr());
+  }
+
+  virtual const entity_addr_t &get_peer_socket_addr() const = 0;
+
+  virtual uint64_t get_features() const = 0;
+
+  bool has_feature(uint64_t f) const {
+    return get_features() & f;
+  }
+
+  /// true if the handshake has completed and no errors have been encountered
+  virtual bool is_connected() const = 0;
+
+  /**
+   * send
+   *
+   * Send a message over a connection that has completed its handshake.
+   *
+   * May be invoked from any core, but that requires to chain the returned
+   * future to preserve ordering.
+   */
+  virtual seastar::future<> send(MessageURef msg) = 0;
+
+  /**
+   * send_keepalive
+   *
+   * Send a keepalive message over a connection that has completed its
+   * handshake.
+   *
+   * May be invoked from any core, but that requires to chain the returned
+   * future to preserve ordering.
+   */
+  virtual seastar::future<> send_keepalive() = 0;
+
+  virtual clock_t::time_point get_last_keepalive() const = 0;
+
+  virtual clock_t::time_point get_last_keepalive_ack() const = 0;
+
+  // workaround for the monitor client
+  virtual void set_last_keepalive_ack(clock_t::time_point when) = 0;
+
+  // close the connection and cancel any any pending futures from read/send,
+  // without dispatching any reset event
+  virtual void mark_down() = 0;
+
+  struct user_private_t {
+    virtual ~user_private_t() = default;
+  };
+
+  virtual bool has_user_private() const = 0;
+
+  virtual user_private_t &get_user_private() = 0;
+
+  virtual void set_user_private(std::unique_ptr<user_private_t>) = 0;
+
+  virtual void print(std::ostream& out) const = 0;
+
+#ifdef UNIT_TESTS_BUILT
+  virtual bool is_protocol_ready() const = 0;
+
+  virtual bool is_protocol_standby() const = 0;
+
+  virtual bool is_protocol_closed() const = 0;
+
+  virtual bool is_protocol_closed_clean() const = 0;
+
+  virtual bool peer_wins() const = 0;
+#endif
+};
+
+inline std::ostream& operator<<(std::ostream& out, const Connection& conn) {
+  out << "[";
+  conn.print(out);
+  out << "]";
+  return out;
+}
+
+} // namespace crimson::net
+
+#if FMT_VERSION >= 90000
+template <> struct fmt::formatter<crimson::net::Connection> : fmt::ostream_formatter {};
+#endif