opentxs::OTServer Class Reference

#include <OTServer.hpp>

Public Member Functions
EXPORT	OTServer ()
EXPORT	~OTServer ()
EXPORT void	Init (bool readOnly=false)
bool	IsFlaggedForShutdown () const
bool	GetConnectInfo (OTString &hostname, int32_t &port) const
const OTPseudonym &	GetServerNym () const
EXPORT void	ActivateCron ()
void	ProcessCron ()

Friends
class	Transactor
class	MessageProcessor
class	UserCommandProcessor
class	MainFile
class	PayDividendVisitor
class	Notary

Detailed Description

Definition at line 155 of file OTServer.hpp.

Constructor & Destructor Documentation

opentxs::OTServer::OTServer

(

)

Definition at line 355 of file OTServer.cpp.

    : mainFile_(this)
    , notary_(this)
    , transactor_(this)
    , userCommandProcessor_(this)
    , m_bReadOnly(false)
    , m_bShutdownFlag(false)
    , m_pServerContract()
{
}

opentxs::OTServer::~OTServer

(

)

Definition at line 366 of file OTServer.cpp.

{
    // PID -- Set it to 0 in the lock file so the next time we run OT, it knows
    // there isn't
    // another copy already running (otherwise we might wind up with two copies
    // trying to write
    // to the same data folder simultaneously, which could corrupt the data...)
    //
    //    OTLog::vError("m_strDataPath: %s\n", m_strDataPath.Get());
    //    OTLog::vError("SERVER_PID_FILENAME: %s\n", SERVER_PID_FILENAME);

    OTString strDataPath;
    const bool bGetDataFolderSuccess = OTDataFolder::Get(strDataPath);
    if (!m_bReadOnly && bGetDataFolderSuccess) {
        OTString strPIDPath;
        OTPaths::AppendFile(strPIDPath, strDataPath, SERVER_PID_FILENAME);

        std::ofstream pid_outfile(strPIDPath.Get());

        if (pid_outfile.is_open()) {
            uint32_t the_pid = 0;
            pid_outfile << the_pid;
            pid_outfile.close();
        }
        else
            OTLog::vError("Failed trying to open data locking file (to wipe "
                          "PID back to 0): %s\n",
                          strPIDPath.Get());
    }
}

Member Function Documentation

void opentxs::OTServer::ActivateCron

(

)

Definition at line 300 of file OTServer.cpp.

{
    OTLog::vOutput(1, "OTServer::ActivateCron: %s \n",
                   m_Cron.ActivateCron() ? "(STARTED)" : "FAILED");
}

bool opentxs::OTServer::GetConnectInfo	(	OTString &	hostname,
		int32_t &	port
	)		const

Definition at line 849 of file OTServer.cpp.

{
    if (!m_pServerContract) return false;

    return m_pServerContract->GetConnectInfo(strHostname, nPort);
}

const OTPseudonym & opentxs::OTServer::GetServerNym

(

)

const

Definition at line 345 of file OTServer.cpp.

{
    return m_nymServer;
}

void opentxs::OTServer::Init

(

bool

readOnly = false

)

Definition at line 397 of file OTServer.cpp.

{
    m_bReadOnly = readOnly;

    if (!OTDataFolder::IsInitialized()) {
        OTLog::vError("Unable to Init data folders!");
        OT_FAIL;
    }
    if (!ConfigLoader::load(m_strWalletFilename)) {
        OTLog::vError("Unable to Load Config File!");
        OT_FAIL;
    }

    OTString dataPath;
    bool bGetDataFolderSuccess = OTDataFolder::Get(dataPath);

    // PID -- Make sure we're not running two copies of OT on the same data
    // simultaneously here.
    if (bGetDataFolderSuccess) {
        // If we want to WRITE to the data location, then we can't be in
        // read-only mode.
        if (!readOnly) {
            // 1. READ A FILE STORING THE PID. (It will already exist, if OT is
            // already running.)
            //
            // We open it for reading first, to see if it already exists. If it
            // does, we read the number. 0 is fine, since we overwrite with 0 on
            // shutdown. But any OTHER number means OT is still running. Or it
            // means it was killed while running and didn't shut down properly,
            // and that you need to delete the pid file by hand before running
            // OT again. (This is all for the purpose of preventing two copies
            // of OT running at the same time and corrupting the data folder.)
            //
            OTString strPIDPath;
            OTPaths::AppendFile(strPIDPath, dataPath, SERVER_PID_FILENAME);

            std::ifstream pid_infile(strPIDPath.Get());

            // 2. (IF FILE EXISTS WITH ANY PID INSIDE, THEN DIE.)
            if (pid_infile.is_open()) {
                uint32_t old_pid = 0;
                pid_infile >> old_pid;
                pid_infile.close();

                // There was a real PID in there.
                if (old_pid != 0) {
                    uint64_t lPID = old_pid;
                    OTLog::vError(
                        "\n\n\nIS OPEN-TRANSACTIONS ALREADY RUNNING?\n\n"
                        "I found a PID (%llu) in the data lock file, located "
                        "at: %s\n\n"
                        "If the OT process with PID %llu is truly not running "
                        "anymore, "
                        "then just ERASE THAT FILE and then RESTART.\n",
                        lPID, strPIDPath.Get(), lPID);
                    exit(-1);
                }
                // Otherwise, though the file existed, the PID within was 0.
                // (Meaning the previous instance of OT already set it to 0 as
                // it was shutting down.)
            }
            // Next let's record our PID to the same file, so other copies of OT
            // can't trample on US.

            // 3. GET THE CURRENT (ACTUAL) PROCESS ID.
            uint64_t the_pid = 0;

#ifdef _WIN32
            the_pid = GetCurrentProcessId();
#else
            the_pid = getpid();
#endif

            // 4. OPEN THE FILE IN WRITE MODE, AND SAVE THE PID TO IT.
            std::ofstream pid_outfile(strPIDPath.Get());

            if (pid_outfile.is_open()) {
                pid_outfile << the_pid;
                pid_outfile.close();
            }
            else {
                OTLog::vError("Failed trying to open data locking file (to "
                              "store PID %llu): %s\n",
                              the_pid, strPIDPath.Get());
            }
        }
    }
    OTDB::InitDefaultStorage(OTDB_DEFAULT_STORAGE, OTDB_DEFAULT_PACKER);

    // Load up the transaction number and other OTServer data members.
    bool mainFileExists = m_strWalletFilename.Exists()
                              ? OTDB::Exists(".", m_strWalletFilename.Get())
                              : false;

    if (!mainFileExists) {
        if (readOnly) {
            OTLog::vError(
                "Error: Main file non-existent (%s). "
                "Plus, unable to create, since read-only flag is set.\n",
                m_strWalletFilename.Get());
            OT_FAIL;
        }
        else {
            std::string strContract;
            std::string strServerID;
            std::string strCert;
            std::string strNymID;
            std::string strCachedKey;
            askInteractively(strContract, strServerID, strCert, strNymID,
                             strCachedKey);
            mainFileExists = mainFile_.CreateMainFile(
                strContract, strServerID, strCert, strNymID, strCachedKey);
        }
    }

    if (mainFileExists) {
        if (!mainFile_.LoadMainFile(readOnly)) {
            OTLog::vError("Error in Loading Main File!\n");
            OT_FAIL;
        }
    }

    // With the Server's private key loaded, and the latest transaction number
    // loaded, and all the various other data (contracts, etc) the server is now
    // ready for operation!
}

bool opentxs::OTServer::IsFlaggedForShutdown

(

)

const

Definition at line 350 of file OTServer.cpp.

{
    return m_bShutdownFlag;
}

void opentxs::OTServer::ProcessCron

(

)

Currently the test server calls this 10 times per second. It also processes all the input/output at the same rate. It sleeps in between. (See testserver.cpp for the call and OTLog::Sleep() for the sleep code.)

Definition at line 311 of file OTServer.cpp.

{
    if (!m_Cron.IsActivated()) return;

    bool bAddedNumbers = false;

    // Cron requires transaction numbers in order to process.
    // So every time before I call Cron.Process(), I make sure to replenish
    // first.
    while (m_Cron.GetTransactionCount() < OTCron::GetCronRefillAmount()) {
        int64_t lTransNum = 0;
        bool bSuccess = transactor_.issueNextTransactionNumber(
            m_nymServer, lTransNum, false);

        if (bSuccess) {
            m_Cron.AddTransactionNumber(lTransNum);
            bAddedNumbers = true;
        }
        else
            break;
    }

    if (bAddedNumbers) {
        m_Cron.SaveCron();
    }

    m_Cron.ProcessCronItems(); // This needs to be called regularly for trades,
                               // markets, payment plans, etc to process.

    // NOTE:  TODO:  OTHER RE-OCCURRING SERVER FUNCTIONS CAN GO HERE AS WELL!!
    //
    // Such as sweeping server accounts after expiration dates, etc.
}

Friends And Related Function Documentation

friend class MainFile

friend

Definition at line 160 of file OTServer.hpp.

friend class MessageProcessor

friend

Definition at line 158 of file OTServer.hpp.

friend class Notary

friend

Definition at line 162 of file OTServer.hpp.

friend class PayDividendVisitor

friend

Definition at line 161 of file OTServer.hpp.

friend class Transactor

friend

Definition at line 157 of file OTServer.hpp.

friend class UserCommandProcessor

friend

Definition at line 159 of file OTServer.hpp.

---

The documentation for this class was generated from the following files:

• /usr/local/src/opentxs/include/opentxs/server/OTServer.hpp
• /usr/local/src/opentxs/src/server/OTServer.cpp