Factory classes: Session, Device, and User

Session Factories

There are three classes for creating Session objects:

• NetconfSessionFactory

• RestconfSessionFactory

• DeviceSessionFactory

They are defined in api-session.hpp and use the base class SessionFactory.

NetconfSessionFactory

class NetconfSessionFactory:
    virtual public SessionFactory,
    public _CommonAddin<NetconfSessionFactory>,
    public _KeyfilesAddin<NetconfSessionFactory>,
    public _SslFilesAddin<NetconfSessionFactory>
{
    public:
    // 'username' is the username for the account. 'target' is the ASCII IP
    // address or DNS hostname of the target machine. 'port' is the port number
    // to use, if not default. Will throw std::invalid_argument if 'username' or
    // 'target' are NULL.
    NetconfSessionFactory(const xstring &username, const xstring &target,
        uint16_t port = 0);

    // This variant uses a User object, which may specify several options.
    NetconfSessionFactory(const User &user, const xstring &target, uint16_t port
        = 0);

    NetconfSessionFactory& tcpTransport();
    NetconfSessionFactory& tcpNcxTransport();
    NetconfSessionFactory& sshTransport();
    NetconfSessionFactory& tlsTransport();

    private:
    NetconfSessionFactory(pvt_t&, const xstring &target, uint16_t port);
};

RestconfSessionFactory

class RestconfSessionFactory:
    virtual public SessionFactory,
    public _CommonAddin<RestconfSessionFactory>,
    public _EncodingAddin<RestconfSessionFactory>,
    public _KeyfilesAddin<RestconfSessionFactory>,
    public _SslFilesAddin<RestconfSessionFactory>
{
    public:
    // 'username' is the username for the account. 'target' is the ASCII IP
    // address or DNS hostname of the target machine. 'port' is the port number
    // to use, if not default. Will throw std::invalid_argument if 'username' or
    // 'target' are NULL.
    RestconfSessionFactory(const xstring &username, const xstring &target,
        uint16_t port = 0);

    RestconfSessionFactory(const User &user, const xstring &target, uint16_t
        port = 0);

    RestconfSessionFactory& tcpTransport();
    RestconfSessionFactory& tlsTransport();

    private:
    RestconfSessionFactory(pvt_t&, const xstring &target, uint16_t port);
};

DeviceSessionFactory

// Use this when you have a Device that you want to use for configuration. It
// will automatically determine the device type and the default transport to
// use. You can alter the transport, but attempting to select one that doesn't
// match the Device type will fail with an exception.
class DeviceSessionFactory:
    virtual public SessionFactory,
    public _CommonAddin<DeviceSessionFactory>,
    public _EncodingAddin<DeviceSessionFactory>,
    public _KeyfilesAddin<DeviceSessionFactory>,
    public _SslFilesAddin<DeviceSessionFactory>
{
    public: //
    DeviceSessionFactory(const xstring &username, const Device &device);
    DeviceSessionFactory(const User &user, const Device &device,
                         bool use_defserver = false);

    // Only usable with a Netconf or Restconf device.
    DeviceSessionFactory& tcpTransport();

    // Only usable with a Netconf device.
    DeviceSessionFactory& tcpNcxTransport();

    // Only usable with a Netconf device.
    DeviceSessionFactory& sshTransport();

    // Only usable with a Restconf device.
    DeviceSessionFactory& tlsTransport();

    private:
    DeviceSessionFactory(pvt_t&, const Device &device);

    Device::Type::type_t mType;
};

Device Factories

There are two classes for creating Device objects:

• NetconfDeviceFactory

• RestconfDeviceFactory

They are defined in api-device.hpp and use the base class DeviceFactory.

NetconfDeviceFactory

class NetconfDeviceFactory:
    public DeviceFactory
{
    public: //
    NetconfDeviceFactory(const xstring &name,
                         const xstring &address,
                         uint16_t port = 0,
                         const xstring &transport = "ssh");

};

RestconfDeviceFactory

class RestconfDeviceFactory:
    public DeviceFactory
{
    public: //
    RestconfDeviceFactory(const xstring &name,
                          const xstring &address,
                          uint16_t port = 0);
};

User Factory

Listed below is the User Factory which is defined in api-users.hpp,

// Creating a user could require a number of parameters, many of which have
// default values. The UserFactory class provides an easy-to-use way to specify
// only the parameters that you need to.
//
// All parameters, except the 'id' and 'username' parameters to the constructor,
// are optional.
class UserFactory {
    public: //
    // Creates a UserFactory object. 'id' is the name this User will be known
    // by; 'username' is the username for logging into a server.
    UserFactory(const xstring &id, const xstring &username);

    // The password. Omit this (or use nullptr for it) if no password will be
    // used, or if you'll specify the password separately.
    UserFactory& password(const xstring &password);

    // The filespecs for the public key/private key files.
    UserFactory& publicPrivateKeyFiles(const filesystem::path &publicFilespec,
        const filesystem::path &privateFilespec);

    // The filespecs for the SSL client certificate and its keyfile.
    UserFactory& sslClientCertificate(const filesystem::path &filespec);
    UserFactory& sslClientCertificateKeyFile(const filesystem::path &filespec);

    // The filespec for the SSL trust store. Required (?) if using SSL.
    UserFactory& sslTrustStore(const filesystem::path &filespec);

    // Allow fallback to tcp if ssl failed. Defaults to true.
    UserFactory& fallbackOkay(bool setTo);

    // After filling in the required parameters, you can either call this
    // function or pass the class to the User constructor.
    User create() const;

    // Writes a text-format version of the object's settings, for debugging
    // purposes.
    std::string str() const;

    ////////////////////////////////////////////////////////////////////////////
    private: //
    xstring mName;
    xstring mUsername;

    xstring mPassword;

    filesystem::path mPublicKey, mPrivateKey;

    bool mSslFallbackOk;
    filesystem::path mSslCert, mSslKey, mSslTrustStore;

    friend class User;
};