/**
* Clean up filesystem
*
* Called on filesystem exit.
*
* Introduced in version 2.3
*/
void sfs_destroy(void *userdata) {
char pidpath[PATH_MAX];
snprintf(pidpath, PATH_MAX, "/var/run/syncedfs/fs/%s.pid", config.resource);
deletePidFile(config.pidfd, pidpath);
}
// ----------------------------------------------------
// Function called when we want to stop the server.
// This code is called by the stop-ds.bat batch file to stop the server
// in windows.
// This function expects just one parameter to be passed
// to the executable: the directory of the server we want
// to stop.
//
// If the instance could be stopped the pid file
// is removed. This is done for security reasons: if we do
// not delete the pid file and the old pid of the process
// is used by a new process, when we call again this executable
// the new process will be killed.
// Note: even if the code in the class org.opends.server.core.DirectoryServer
// sets the pid file to be deleted on the exit of the process
// the file is not always deleted.
//
// Returns 0 if the instance could be stopped using the
// pid stored in a file of the server installation and
// -1 otherwise.
// ----------------------------------------------------
int stop(const char* instanceDir)
{
int returnCode = -1;
int childPid;
debug("Attempting to stop the server running at root '%s'.", instanceDir);
childPid = getPid(instanceDir);
if (childPid != 0)
{
if (killProcess(childPid))
{
returnCode = 0;
deletePidFile(instanceDir);
}
}
else
{
debug("Could not stop the server running at root '%s' because the pid could not be located.", instanceDir);
}
return returnCode;
} // stop
void startServer(void) {
int pidfd;
char pidpath[PATH_MAX];
int lfd, cfd;
socklen_t addrlen;
struct sockaddr claddr;
lfd = inetListen(config.port, 0, &addrlen);
if (lfd == -1) {
errMsg(LOG_ERR, "Could not listen on port %s.", config.port);
return;
}
snprintf(pidpath, PATH_MAX, "/var/run/syncedfs/server/%s.pid",
config.resource);
pidfd = createPidFile(config.ident, pidpath, 0);
if (pidfd == -1) {
errMsg(LOG_ERR, "Could not create pid file %s, Exiting server.", pidpath);
return;
}
errMsg(LOG_INFO, "Server booted.");
//setup signal handler to stop handling requests
for (;;) {
cfd = accept(lfd, (struct sockaddr *) &claddr, &addrlen);
if (cfd == -1) {
errnoMsg(LOG_ERR, "Error accepting client.");
continue;
}
handleClient(cfd, &claddr, &addrlen);
}
// delete pid file
if (deletePidFile(pidfd, pidpath) == -1)
errExit(LOG_ERR, "Deleting PID file '%s'", pidpath);
}
int synchronize(void) {
int pidfd;
char pidpath[PATH_MAX];
int logfd;
char logpath[PATH_MAX];
int newsync = 0;
// make sure, that there isn't another client process for this resource
// already running
snprintf(pidpath, PATH_MAX, "/var/run/syncedfs/client/%s.pid",
config.resource);
pidfd = createPidFile(config.ident, pidpath, 0);
if (pidfd == -1) {
errMsg(LOG_ERR, "Could not create pid file %s, Exiting sync.", pidpath);
return -1;
}
// if sync log does not exist, switch log
snprintf(logpath, PATH_MAX, "%s/%s.sync", config.logdir, config.resource);
errMsg(LOG_INFO, "logpath: %s", logpath);
logfd = open(logpath, O_RDONLY);
if (logfd == -1) {
if (switchLog() != 0) {
errMsg(LOG_ERR, "Could not switch log file. Stopping.");
return -1;
}
logfd = open(logpath, O_RDONLY);
if (logfd == -1) {
errnoMsg(LOG_ERR, "Could not open log file %s", logpath);
return -1;
}
newsync = 1;
}
// sync-id
char id[SYNCID_MAX];
char idpath[PATH_MAX];
snprintf(idpath, PATH_MAX, "%s/%s.id", config.logdir, config.resource);
// second part of the condition covers weird states after crash etc.
if (newsync == 1 || readSyncId(id, idpath, SYNCID_MAX) != 0) {
if (generateSyncId(id, SYNCID_MAX) != 0) {
errMsg(LOG_ERR, "Could not get sync-id. Stopping.");
return -1;
}
if (writeSyncId(id, idpath) != 0) {
errMsg(LOG_ERR, "Could not write sync-id. Stopping.");
return -1;
}
}
// create snapshot
if (newsync || !fileExists(config.snapshot)) {
if (createSnapshot(config.rootdir, config.snapshot, 1) == -1) {
errMsg(LOG_ERR, "Could not create snapshot of %s to %s Stopping.",
config.rootdir, config.snapshot);
return -1;
}
}
// load log
if (loadLog(logfd) != 0) {
errMsg(LOG_ERR, "Could not load log %s", logpath);
return -1;
}
// transfer changes
if (transfer(config.host, config.port) == -1) {
errMsg(LOG_ERR, "Error in transfer. Exiting sync.");
// in case of failure only delete pid file
if (deletePidFile(pidfd, pidpath) == -1)
errExit(LOG_ERR, "Deleting PID file '%s'", pidpath);
return -1;
}
// delete snapshot
if (deleteSnapshot(config.snapshot) == -1)
errMsg(LOG_ERR, "Could not delete snapshot %s", config.snapshot);
// delete syncid
if (unlink(idpath) == -1)
errExit(LOG_ERR, "Deleting sync-id file '%s'", idpath);
// delete sync log
close(logfd);
if (unlink(logpath) == -1)
errExit(LOG_ERR, "Deleting log file '%s'", logpath);
// delete pid file
if (deletePidFile(pidfd, pidpath) == -1)
errExit(LOG_ERR, "Deleting PID file '%s'", pidpath);
return 0;
}
