session.hpp

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
 
#pragma once
 
#include "azure/core/amqp/internal/models/amqp_error.hpp"
#include "azure/core/amqp/models/amqp_value.hpp"
#include "common/async_operation_queue.hpp"
#include "connection_string_credential.hpp"
#include "endpoint.hpp"
#include "models/message_source.hpp"
#include "models/message_target.hpp"
 
#include <chrono>
#include <memory>
#include <string>
#include <vector>
 
#if defined(_azure_TESTING_BUILD)
// Define the test classes dependant on this class here.
namespace Azure { namespace Core { namespace Amqp { namespace Tests {
  namespace MessageTests {
    class AmqpServerMock;
    class MockServiceEndpoint;
    class MessageListenerEvents;
  } // namespace MessageTests
 
  class TestSessions_SimpleSession_Test;
  class TestSessions_SessionProperties_Test;
  class TestSessions_SessionBeginEnd_Test;
  class TestSessions_MultipleSessionBeginEnd_Test;
  class TestLinks_LinkAttachDetach_Test;
  class TestSocketListenerEvents;
  class LinkSocketListenerEvents;
  class TestMessages_SenderSendAsync_Test;
}}}} // namespace Azure::Core::Amqp::Tests
#endif // _azure_TESTING_BUILD
#if defined(SAMPLES_BUILD)
namespace LocalServerSample {
class SampleEvents;
} // namespace LocalServerSample
#endif // SAMPLES_BUILD
 
namespace Azure { namespace Core { namespace Amqp { namespace _detail {
  class SessionImpl;
  class SessionFactory;
}}}} // namespace Azure::Core::Amqp::_detail
 
namespace Azure { namespace Core { namespace Amqp { namespace _internal {
 
  class Connection;
  enum class SessionRole;
  class MessageSender;
  struct MessageSenderOptions;
  class MessageSenderEvents;
  class MessageReceiver;
  struct MessageReceiverOptions;
  class MessageReceiverEvents;
  class ManagementClient;
  struct ManagementClientOptions;
  class ManagementClientEvents;
 
  enum class ExpiryPolicy
  {
    LinkDetach,
    SessionEnd,
    ConnectionClose,
    Never,
  };
 
  enum class SessionState
  {
    Unmapped,
    BeginSent,
    BeginReceived,
    Mapped,
    EndSent,
    EndReceived,
    Discarding,
    Error,
  };
 
  enum class SessionSendTransferResult
  {
    Ok,
    Error,
    Busy,
  };
 
  class Session;
  class SessionEvents {
  protected:
    ~SessionEvents() = default;
 
  public:
    virtual bool OnLinkAttached(
        Session const& session,
        LinkEndpoint& newLink,
        std::string const& name,
        SessionRole role,
        Models::AmqpValue const& source,
        Models::AmqpValue const& target,
        Models::AmqpValue const& properties)
        = 0;
  };
 
  struct SessionOptions final
  {
    Nullable<uint32_t> InitialIncomingWindowSize;
    Nullable<uint32_t> InitialOutgoingWindowSize;
 
    Nullable<uint32_t> MaximumLinkCount;
  };
 
  class Session final {
  public:
    ~Session() noexcept;
 
    MessageSender CreateMessageSender(
        Models::_internal::MessageTarget const& target,
        MessageSenderOptions const& options,
        MessageSenderEvents* events) const;
 
    MessageReceiver CreateMessageReceiver(
        Models::_internal::MessageSource const& receiverSource,
        MessageReceiverOptions const& options,
        MessageReceiverEvents* receiverEvents = nullptr) const;
 
    ManagementClient CreateManagementClient(
        std::string const& managementInstancePath,
        ManagementClientOptions const& options,
        ManagementClientEvents* managementEvents = nullptr) const;
 
  private:
    uint32_t GetIncomingWindow() const;
    uint32_t GetOutgoingWindow() const;
 
    uint32_t GetHandleMax() const;
 
    void Begin();
 
    void End(std::string const& condition_value = {}, std::string const& description = {});
 
    void SendDetach(
        LinkEndpoint const& linkEndpoint,
        bool closeLink,
        Models::_internal::AmqpError const& error) const;
 
    MessageSender CreateMessageSender(
        LinkEndpoint& endpoint,
        Models::_internal::MessageTarget const& target,
        MessageSenderOptions const& options,
        MessageSenderEvents* events) const;
 
    MessageReceiver CreateMessageReceiver(
        LinkEndpoint& linkEndpoint,
        Models::_internal::MessageSource const& receiverSource,
        MessageReceiverOptions const& options,
        MessageReceiverEvents* receiverEvents = nullptr) const;
 
    friend class _detail::SessionFactory;
 
#if _azure_TESTING_BUILD
    friend class Azure::Core::Amqp::Tests::MessageTests::AmqpServerMock;
    friend class Azure::Core::Amqp::Tests::MessageTests::MockServiceEndpoint;
    friend class Azure::Core::Amqp::Tests::MessageTests::MessageListenerEvents;
    friend class Azure::Core::Amqp::Tests::TestSocketListenerEvents;
    friend class Azure::Core::Amqp::Tests::LinkSocketListenerEvents;
    friend class Azure::Core::Amqp::Tests::TestSessions_SimpleSession_Test;
    friend class Azure::Core::Amqp::Tests::TestSessions_SessionProperties_Test;
    friend class Azure::Core::Amqp::Tests::TestSessions_SessionBeginEnd_Test;
    friend class Azure::Core::Amqp::Tests::TestSessions_MultipleSessionBeginEnd_Test;
    friend class Azure::Core::Amqp::Tests::TestLinks_LinkAttachDetach_Test;
 
    friend class Azure::Core::Amqp::Tests::TestMessages_SenderSendAsync_Test;
#endif // _azure_TESTING_BUILD
#if SAMPLES_BUILD
    friend class LocalServerSample::SampleEvents;
#endif // SAMPLES_BUILD
  private:
    Session(std::shared_ptr<_detail::SessionImpl> impl) : m_impl{impl} {}
 
    std::shared_ptr<_detail::SessionImpl> m_impl;
  };
 
}}}} // namespace Azure::Core::Amqp::_internal