StreamBaseURI.hpp

// Copyright (c) 2004-2023 TIBCO Software Inc.  All rights reserved.

#ifndef STREAMBASE_URI_H
#define STREAMBASE_URI_H

#include "StreamBase.hpp"

#include "Exceptions.hpp"
NMSTL_NAMESPACE_BEGIN;
class Address;
NMSTL_NAMESPACE_END;

SB_INTERNAL_FWD(Errors);
SB_INTERNAL_FWD(StreamBaseURIUtil);

SB_NAMESPACE_BEGIN;

/// An invalid URI was specified in a StreamBaseURI constructor.
STREAMBASE_EXCEPTION_TYPE(MalformedURIException, sb_internal::Errors::NON_FATAL_ERROR);

/// A URI for a StreamBase client connection.  These URIs
/// are of the form
///
/// \verbatim
/// sb://hostname:port/;param1=val1;param2=val2
/// \endverbatim
///
/// e.g.,
///
/// \verbatim
/// sb://somehost.mycompany.com:10000/;user=me;password=foobar
/// \endverbatim
///
/// Parameters are optional.  The port number is optional; it defaults
/// to 10000.
class StreamBaseURI {
  public:

    /// The default StreamBase port (10000).
    static const unsigned int DEFAULT_PORT = 10000;

    /// The default container name
    static std::string const DEFAULT_HOST;

    /// URI parameter used for username.
    static const char * const USER_PARAM;

    /// URI parameter used for username.
    static const char * const USERNAME_PARAM;

    /// URI parameter used for password.
    static const char * const PASSWORD_PARAM;

    /// The default container name
    static std::string const DEFAULT_CONTAINER;

    /// The system container name
    static std::string const SYSTEM_CONTAINER;

    /// No container specification
    static std::string const NO_CONTAINER;

    /// The default URI (pointing to localhost, port 10000, default container).
    static const StreamBaseURI DEFAULT;

    /// The default URI
    static StreamBaseURI const DEFAULT_URI;

#ifndef DOXYGEN_SKIP
    static const unsigned int DEFAULT_NODE_MANAGER_PORT = 10002;
    static const char *const ENVIRONMENT_VARIABLE;

    static const char *const URI_ENVIRONMENT_VARIABLE;

    static const char *const URI_PROPERTY_NAME;

#endif

    typedef std::map<std::string, std::string> ParamMap;
  private:
    std::string _host;
    unsigned int _port;
    std::string _container;
    
    ParamMap _params;

  public:
    /// Default-constructed object; no operations are allowed.
    StreamBaseURI() {}

    /// Parse URI from a string.
    StreamBaseURI(const std::string &uri);

    /// Create explicitly from host/port.
    StreamBaseURI(const std::string &host, unsigned int port, const std::string &user = "", const std::string &password = "");

    /// Create explicitly from host/port with container
    StreamBaseURI(const std::string &host, const std::string &container, unsigned int port, const std::string &user = "", const std::string &password = "");

    /// Create explicitly from host/port, including a map of parameters
    StreamBaseURI(const std::string &host, unsigned int port, const ParamMap &paramMap)
        : _host(host), _port(port), _container(NO_CONTAINER)
    {
        copy(paramMap.begin(), paramMap.end(), inserter(_params, _params.begin()));
        check();
    }

    /// Create explicitly from host/port with container, including a map of parameters
    StreamBaseURI(const std::string &host, const std::string &container, unsigned int port, const ParamMap &paramMap)
        : _host(host), _port(port), _container(container)
    {
        copy(paramMap.begin(), paramMap.end(), inserter(_params, _params.begin()));
        check();
    }

    /// Return a StreamBaseURI vector from a string of comma sepearted URIs.
    /// The string of URIs supplied must conform to a valid HA URI list, for example
    /// they must all reference the same container.
    static std::vector<StreamBaseURI> vectorFromString(const std::string& uris);

    /// Return a string representation of a list of uris
    static std::string as_string(const std::vector<StreamBaseURI> &uris);

    /// Return the URI as a string.
    std::string as_string() const;

    /// Return the host component of the URI.
    std::string getHost() const { return _host; }

    /// Returns the container name component of the URI.  May return an empty string
    /// if no container was specified.  
    std::string getContainer() const { return _container; }

    /// Return the port component of the URI.
    unsigned int getPort() const { return _port; }

    /// Return the user name component of the URI.
    std::string getUser() const { return getParameter(USER_PARAM); }

    /// Return the password component of the URI.
    std::string getPassword() const { return getParameter(PASSWORD_PARAM); }

    /// Return a parameter, or empty string if undefined.
    std::string getParameter(const std::string &key) const { return NMSTL::lookup(_params, key); }

    /// Return a parameter, or empty string if undefined.
    std::string getParam(const std::string &key) const { return NMSTL::lookup(_params, key); }

    /// Return a parameter into value (returning true if one was found).
    /// Useful to distinguish an undefined parameter from an empty
    /// one.
    bool getParameter(const std::string &key, std::string& value) const;

    /// Add a parameter.
    void addParameter(const std::string &key, const std::string &value) { _params[key] = value; }

    /// Add a parameter.
    void removeParameter(std::string key) { _params.erase(key); }

    /// return the number of parameters
    size_t getNumParameters() { return _params.size(); }

    /// Returns true if this object was not default-constructed.
    operator const void *() const { return _host.empty() ? 0 : this; }

    /// Create from the environment variable
    static StreamBaseURI fromEnvironment();

    /// Create from the environment variable and return a vector of StreamBaseURIs
    static std::vector < StreamBaseURI > vectorFromEnvironment();

    /// return a StreamBaseURI without Parameters
    const StreamBaseURI getBaseURI() const { return StreamBaseURI(_host, _container, _port); }

  private:
    void init(NMSTL::Address address, const std::string &container);

    void processParams(const std::string &uri, std::string::size_type paramsPos);
    // Make sure the URI is valid (currently, just check host name)
    void check();

    // setup authentication
    int auth(const std::string& user, const std::string& password);

    friend class sb_internal::StreamBaseURIUtil;
};

SB_NAMESPACE_END;

inline std::ostream& operator << (std::ostream& os, const sb::StreamBaseURI& uri) {
    os << uri.as_string();
    return os;
}

#endif