Authentication.h

 
#ifndef PULSAR_AUTHENTICATION_H_
#define PULSAR_AUTHENTICATION_H_
 
#include <pulsar/defines.h>
#include <vector>
#include <string>
#include <map>
#include <memory>
#include <pulsar/Result.h>
#include <functional>
 
namespace pulsar {
 
class ClientConfiguration;
class Authentication;
 
class PULSAR_PUBLIC AuthenticationDataProvider {
   public:
    virtual ~AuthenticationDataProvider();
 
    virtual bool hasDataForTls();
 
    virtual std::string getTlsCertificates();
 
    virtual std::string getTlsPrivateKey();
 
    virtual bool hasDataForHttp();
 
    virtual std::string getHttpAuthType();
 
    virtual std::string getHttpHeaders();
 
    virtual bool hasDataFromCommand();
 
    virtual std::string getCommandData();
 
   protected:
    AuthenticationDataProvider();
};
 
typedef std::shared_ptr<AuthenticationDataProvider> AuthenticationDataPtr;
typedef std::shared_ptr<Authentication> AuthenticationPtr;
typedef std::map<std::string, std::string> ParamMap;
 
class PULSAR_PUBLIC Authentication {
   public:
    virtual ~Authentication();
 
    virtual const std::string getAuthMethodName() const = 0;
 
    virtual Result getAuthData(AuthenticationDataPtr& authDataContent) {
        authDataContent = authData_;
        return ResultOk;
    }
 
    static ParamMap parseDefaultFormatAuthParams(const std::string& authParamsString);
 
   protected:
    Authentication();
    AuthenticationDataPtr authData_;
    friend class ClientConfiguration;
};
 
class PULSAR_PUBLIC AuthFactory {
   public:
    static AuthenticationPtr Disabled();
 
    static AuthenticationPtr create(const std::string& pluginNameOrDynamicLibPath);
 
    static AuthenticationPtr create(const std::string& pluginNameOrDynamicLibPath,
                                    const std::string& authParamsString);
 
    static AuthenticationPtr create(const std::string& pluginNameOrDynamicLibPath, ParamMap& params);
 
   protected:
    static bool isShutdownHookRegistered_;
    static std::vector<void*> loadedLibrariesHandles_;
    static void release_handles();
};
 
class PULSAR_PUBLIC AuthTls : public Authentication {
   public:
    AuthTls(AuthenticationDataPtr&);
    ~AuthTls();
 
    static AuthenticationPtr create(ParamMap& params);
 
    static AuthenticationPtr create(const std::string& authParamsString);
 
    static AuthenticationPtr create(const std::string& certificatePath, const std::string& privateKeyPath);
 
    const std::string getAuthMethodName() const;
 
    Result getAuthData(AuthenticationDataPtr& authDataTls);
 
   private:
    AuthenticationDataPtr authDataTls_;
};
 
typedef std::function<std::string()> TokenSupplier;
 
class PULSAR_PUBLIC AuthToken : public Authentication {
   public:
    AuthToken(AuthenticationDataPtr&);
    ~AuthToken();
 
    static AuthenticationPtr create(ParamMap& params);
 
    static AuthenticationPtr create(const std::string& authParamsString);
 
    static AuthenticationPtr createWithToken(const std::string& token);
 
    static AuthenticationPtr create(const TokenSupplier& tokenSupplier);
 
    const std::string getAuthMethodName() const;
 
    Result getAuthData(AuthenticationDataPtr& authDataToken);
 
   private:
    AuthenticationDataPtr authDataToken_;
};
 
class PULSAR_PUBLIC AuthAthenz : public Authentication {
   public:
    AuthAthenz(AuthenticationDataPtr&);
    ~AuthAthenz();
 
    static AuthenticationPtr create(ParamMap& params);
 
    static AuthenticationPtr create(const std::string& authParamsString);
 
    const std::string getAuthMethodName() const;
 
    Result getAuthData(AuthenticationDataPtr& authDataAthenz);
 
   private:
    AuthenticationDataPtr authDataAthenz_;
};
 
// OAuth 2.0 token and associated information.
// currently mainly works for access token
class Oauth2TokenResult {
   public:
    enum
    {
        undefined_expiration = -1
    };
 
    Oauth2TokenResult();
    ~Oauth2TokenResult();
 
    Oauth2TokenResult& setAccessToken(const std::string& accessToken);
 
    Oauth2TokenResult& setIdToken(const std::string& idToken);
 
    Oauth2TokenResult& setRefreshToken(const std::string& refreshToken);
 
    Oauth2TokenResult& setExpiresIn(const int64_t expiresIn);
 
    const std::string& getAccessToken() const;
 
    const std::string& getIdToken() const;
 
    const std::string& getRefreshToken() const;
 
    int64_t getExpiresIn() const;
 
   private:
    // map to json "access_token"
    std::string accessToken_;
    // map to json "id_token"
    std::string idToken_;
    // map to json "refresh_token"
    std::string refreshToken_;
    // map to json "expires_in"
    int64_t expiresIn_;
};
 
typedef std::shared_ptr<Oauth2TokenResult> Oauth2TokenResultPtr;
 
class Oauth2Flow {
   public:
    virtual ~Oauth2Flow();
 
    virtual void initialize() = 0;
 
    virtual Oauth2TokenResultPtr authenticate() = 0;
 
    virtual void close() = 0;
 
   protected:
    Oauth2Flow();
};
 
typedef std::shared_ptr<Oauth2Flow> FlowPtr;
 
class CachedToken {
   public:
    virtual ~CachedToken();
 
    virtual bool isExpired() = 0;
 
    virtual AuthenticationDataPtr getAuthData() = 0;
 
   protected:
    CachedToken();
};
 
typedef std::shared_ptr<CachedToken> CachedTokenPtr;
 
class PULSAR_PUBLIC AuthOauth2 : public Authentication {
   public:
    AuthOauth2(ParamMap& params);
    ~AuthOauth2();
 
    static AuthenticationPtr create(ParamMap& params);
 
    static AuthenticationPtr create(const std::string& authParamsString);
 
    const std::string getAuthMethodName() const;
 
    Result getAuthData(AuthenticationDataPtr& authDataOauth2);
 
   private:
    FlowPtr flowPtr_;
    CachedTokenPtr cachedTokenPtr_;
};
 
}  // namespace pulsar
 
#endif /* PULSAR_AUTHENTICATION_H_ */