opentxs::OT_API::Pid Class Reference

Public Member Functions
	Pid ()
	~Pid ()
void	OpenPid (const OTString &strPidFilePath)
void	ClosePid ()
bool	IsPidOpen () const

Detailed Description

Definition at line 385 of file OpenTransactions.cpp.

Constructor & Destructor Documentation

opentxs::OT_API::Pid::Pid

(

)

Definition at line 399 of file OpenTransactions.cpp.

    : m_bIsPidOpen(false)
    , m_strPidFilePath("")
{
}

opentxs::OT_API::Pid::~Pid

(

)

Definition at line 405 of file OpenTransactions.cpp.

{
    // nothing for now
}

Member Function Documentation

void opentxs::OT_API::Pid::ClosePid

(

)

Definition at line 513 of file OpenTransactions.cpp.

{
    if (!IsPidOpen()) {
        otErr
            << __FUNCTION__
            << ": strPidFilePath is CLOSED, WHY CLOSE A PID IF NONE IS OPEN!\n";
        OT_FAIL;
    }
    if (!m_strPidFilePath.Exists()) {
        otErr << __FUNCTION__ << ": m_strPidFilePath is Empty!\n";
        OT_FAIL;
    }

    // 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...)
    //

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

    if (pid_outfile.is_open()) {
        uint32_t the_pid = 0;
        pid_outfile << the_pid;
        pid_outfile.close();
        m_bIsPidOpen = false;
    }
    else {
        otErr << "Failed trying to open data locking file (to wipe PID "
                 "back to 0): " << m_strPidFilePath << "\n";
        m_bIsPidOpen = true;
    }
}

bool opentxs::OT_API::Pid::IsPidOpen

(

)

const

Definition at line 548 of file OpenTransactions.cpp.

{
    return m_bIsPidOpen;
}

void opentxs::OT_API::Pid::OpenPid

(

const OTString &

strPidFilePath

)

Definition at line 410 of file OpenTransactions.cpp.

{
    if (IsPidOpen()) {
        otErr << __FUNCTION__ << ": strPidFilePath is OPEN, MUST CLOSE BEFORE "
                                 "OPENING A NEW ONE!\n";
        OT_FAIL;
    }

    if (!strPidFilePath.Exists()) {
        otErr << __FUNCTION__ << ": strPidFilePath is Empty!\n";
        OT_FAIL;
    }
    if (3 > strPidFilePath.GetLength()) {
        otErr << __FUNCTION__ << ": strPidFilePath is Too Short! ("
              << strPidFilePath << ")\n";
        OT_FAIL;
    }

    otWarn << __FUNCTION__ << ": Using Pid File: " << strPidFilePath << "\n";
    m_strPidFilePath = strPidFilePath;

    {
        // 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.)
        //
        std::ifstream pid_infile(m_strPidFilePath.Get());

        // 2. (IF FILE EXISTS WITH ANY PID INSIDE, THEN DIE.)
        //

        if (pid_infile.is_open()) // it existed already
        {
            uint32_t old_pid = 0;
            pid_infile >> old_pid;
            pid_infile.close();

            // There was a real PID in there.
            if (old_pid != 0) {
                const uint64_t lPID = old_pid;
                otErr
                    << "\n\n\nIS OPEN-TRANSACTIONS ALREADY RUNNING?\n\n"
                       "I found a PID (" << lPID
                    << ") in the data lock file, located at: "
                    << m_strPidFilePath << "\n\n"
                                           "If the OT process with PID " << lPID
                    << " is truly not running "
                       "anymore, "
                       "then just erase that file and restart.\nThis is "
                       "normally "
                       "cleaned "
                       "up during AppCleanup / AppShutdown. (Or should be.)\n";
#ifndef ANDROID
                m_bIsPidOpen = false;
                return;
#endif
            }
            // 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(m_strPidFilePath.Get());

        if (pid_outfile.is_open()) {
            pid_outfile << the_pid;
            pid_outfile.close();
            m_bIsPidOpen = true;
        }
        else {
            otErr << "Failed trying to open data locking file (to store "
                     "PID " << the_pid << "): " << m_strPidFilePath << "\n";
            m_bIsPidOpen = false;
        }
    }
}

---

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

• /usr/local/src/opentxs/src/client/OpenTransactions.cpp