Annotation of fam/fam/ServerHost.c++, Revision 1.1
1.1 ! trev 1: // Copyright (C) 1999 Silicon Graphics, Inc. All Rights Reserved.
! 2: //
! 3: // This program is free software; you can redistribute it and/or modify it
! 4: // under the terms of version 2 of the GNU General Public License as
! 5: // published by the Free Software Foundation.
! 6: //
! 7: // This program is distributed in the hope that it would be useful, but
! 8: // WITHOUT ANY WARRANTY; without even the implied warranty of
! 9: // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. Further, any
! 10: // license provided herein, whether implied or otherwise, is limited to
! 11: // this program in accordance with the express provisions of the GNU
! 12: // General Public License. Patent licenses, if any, provided herein do not
! 13: // apply to combinations of this program with other product or programs, or
! 14: // any other product whatsoever. This program is distributed without any
! 15: // warranty that the program is delivered free of the rightful claim of any
! 16: // third person by way of infringement or the like. See the GNU General
! 17: // Public License for more details.
! 18: //
! 19: // You should have received a copy of the GNU General Public License along
! 20: // with this program; if not, write the Free Software Foundation, Inc., 59
! 21: // Temple Place - Suite 330, Boston MA 02111-1307, USA.
! 22:
! 23: #include "ServerHost.h"
! 24:
! 25: #include <netdb.h>
! 26: #include <rpc/rpc.h>
! 27: #include <rpc/pmap_clnt.h>
! 28: #include <string.h>
! 29: #include <sys/socket.h>
! 30: #include <unistd.h>
! 31:
! 32: #include "FileSystem.h"
! 33: #include "Event.h"
! 34: #include "Listener.h"
! 35: #include "Log.h"
! 36: #include "Pollster.h"
! 37: #include "Scheduler.h"
! 38: #include "ServerConnection.h"
! 39:
! 40: ///////////////////////////////////////////////////////////////////////////////
! 41: // Construction/Destruction
! 42:
! 43: ServerHost::ServerHost(const hostent& hent)
! 44: : refcount(0), connector(Listener::FAMPROG, Listener::FAMVERS,
! 45: ((in_addr *) hent.h_addr)->s_addr, connect_handler, this),
! 46: connection(NULL), unique_request(1), deferred_scans(NULL), last(NULL),
! 47: min_time(0)
! 48: {
! 49: // Save first component of full hostname.
! 50:
! 51: char *p = strchr(hent.h_name, '.');
! 52: unsigned int nchar;
! 53: if (p)
! 54: nchar = p - hent.h_name;
! 55: else
! 56: nchar = strlen(hent.h_name);
! 57:
! 58: myname = new char[nchar + 1];
! 59: (void) strncpy(myname, hent.h_name, nchar);
! 60: myname[nchar] = '\0';
! 61: }
! 62:
! 63: ServerHost::~ServerHost()
! 64: {
! 65: assert(!active());
! 66: Scheduler::remove_onetime_task(deferred_scan_task, this);
! 67: if (is_connected())
! 68: { delete connection;
! 69: Scheduler::remove_onetime_task(timeout_task, this);
! 70: }
! 71: else
! 72: Pollster::forget(this);
! 73: delete [] myname;
! 74:
! 75: DeferredScan *ds = deferred_scans, *dsp;
! 76: while (ds != NULL)
! 77: {
! 78: dsp = ds;
! 79: ds = ds->next;
! 80: delete dsp;
! 81: }
! 82: }
! 83:
! 84: //////////////////////////////////////////////////////////////////////////////
! 85: // Activation. "Active" means that something on this host needs monitoring.
! 86:
! 87: void
! 88: ServerHost::activate()
! 89: {
! 90: if (is_connected())
! 91: Scheduler::remove_onetime_task(timeout_task, this);
! 92: else
! 93: { connector.activate();
! 94: Pollster::watch(this);
! 95: }
! 96: }
! 97:
! 98: void
! 99: ServerHost::deactivate()
! 100: {
! 101: assert(!active());
! 102: if (is_connected())
! 103: { timeval t;
! 104: (void) gettimeofday(&t, NULL);
! 105: t.tv_sec += Pollster::interval();
! 106: Scheduler::install_onetime_task(t, timeout_task, this);
! 107: }
! 108: else
! 109: { connector.deactivate();
! 110: Pollster::forget(this);
! 111: }
! 112: }
! 113:
! 114: void
! 115: ServerHost::timeout_task(void *closure)
! 116: {
! 117: ServerHost *host = (ServerHost *) closure;
! 118: assert(host->is_connected());
! 119: Log::debug("disconnecting from server fam@%s "
! 120: "after %d seconds of inactivity",
! 121: host->name(), Pollster::interval());
! 122: delete host->connection;
! 123: host->connection = NULL;
! 124: }
! 125:
! 126: //////////////////////////////////////////////////////////////////////////////
! 127: // Connection. Both connection and disconnection are async. events.
! 128:
! 129: void
! 130: ServerHost::connect_handler(int fd, void *closure)
! 131: {
! 132: ServerHost *host = (ServerHost *) closure;
! 133: assert(host->active());
! 134: assert(!host->is_connected());
! 135: host->connection = new ServerConnection(fd, event_handler,
! 136: disconnect_handler, host);
! 137: Pollster::forget(host);
! 138:
! 139: // Tell the server's fam who we are.
! 140:
! 141: char myname[MAXHOSTNAMELEN + 11];
! 142: (void) strcpy(myname, "client fam@");
! 143: int rc = gethostname(myname + 11, sizeof myname - 11);
! 144: assert(rc == 0);
! 145: host->connection->send_name(myname);
! 146: Log::debug("connected to server fam@%s", host->name());
! 147:
! 148: // Tell the server's fam about existing requests.
! 149:
! 150: for (Request r = host->requests.first(); r; r = host->requests.next(r))
! 151: { ClientInterest *ci = host->requests.find(r);
! 152: char remote_path[PATH_MAX];
! 153: ci->filesystem()->hl_map_path(remote_path, ci->name(), ci->cred());
! 154: host->connection->send_monitor(ci->type(), r, remote_path, ci->cred());
! 155: Log::debug("told server fam@%s: request %d monitor file \"%s\"",
! 156: host->name(), r, remote_path);
! 157: if (!ci->active())
! 158: host->send_suspend(r);
! 159: }
! 160: }
! 161:
! 162: void
! 163: ServerHost::disconnect_handler(void *closure)
! 164: {
! 165: ServerHost *host = (ServerHost *) closure;
! 166: Log::debug("lost connection to server fam@%s", host->name());
! 167: if (host->active()) {
! 168: assert(host->is_connected());
! 169: delete host->connection;
! 170: host->connection = NULL;
! 171: Pollster::watch(host);
! 172: host->connector.activate(); // Try to reconnect.
! 173: } else {
! 174: // We're in the timeout period waiting to close the
! 175: // connection. Remove the timeout callback and don't poll
! 176: // this host
! 177: Scheduler::remove_onetime_task(timeout_task, host);
! 178: delete host->connection;
! 179: host->connection = NULL;
! 180: }
! 181: }
! 182:
! 183: ///////////////////////////////////////////////////////////////////////////////
! 184: // Input. For every event of interest, we perform an immediate scan
! 185: // and then we queue a second scan to be done later on. This is
! 186: // necessary because NFS caches attribute information and we have to
! 187: // wait for old cached info to be out of date.
! 188: //
! 189: // For "Changed" events, we save the path because we need it to look
! 190: // up a DirEntry. We don't save the result of the first lookup
! 191: // because result may become invalid while we're sleeping.
! 192: //
! 193: // There is no way to avoid the deferred scan short of adding a
! 194: // hook in the kernel to invalidate an entry in the attribute cache.
! 195:
! 196: void
! 197: ServerHost::event_handler(const Event* event, Request r,
! 198: const char *path, void *closure)
! 199: {
! 200: ServerHost *host = (ServerHost *) closure;
! 201: Log::debug("server fam@%s said request %d \"%s\" %s",
! 202: host->name(), r, path, event->name());
! 203:
! 204: // If we care about this event, tell the ClientInterest to scan itself.
! 205: // Also enqueue a deferred task to rescan later.
! 206:
! 207: if (*event == Event::Changed || *event == Event::Deleted ||
! 208: *event == Event::Created || *event == Event::Exists)
! 209: {
! 210: ClientInterest *cip = host->requests.find(r);
! 211: if (!cip)
! 212: return;
! 213: Interest *ip;
! 214:
! 215: if (*event == Event::Changed || *event == Event::Deleted)
! 216: { ip = cip->find_name(path);
! 217: if (!ip)
! 218: return;
! 219: }
! 220: else
! 221: { ip = cip;
! 222: path = NULL;
! 223: }
! 224: ip->scan();
! 225: int wait = cip->filesystem()->get_attr_cache_timeout();
! 226: if (wait > 0) {
! 227: host->defer_scan(wait < RETRY_INTERVAL ?
! 228: wait :
! 229: RETRY_INTERVAL,(int)((wait-1)/RETRY_INTERVAL),
! 230: r, path);
! 231: }
! 232: }
! 233: }
! 234:
! 235: inline
! 236: ServerHost::DeferredScan::DeferredScan(int then, int rtrys, Request r, const char *s)
! 237: : when(then), retries(rtrys), next(NULL), myrequest(r)
! 238: {
! 239: assert(!s || strlen(s) < sizeof mypath);
! 240: if (s)
! 241: {
! 242: strncpy(mypath, s, (sizeof mypath) - 1);
! 243: mypath[(sizeof mypath) - 1] = '\0';
! 244: }
! 245: else
! 246: mypath[0] = '\0';
! 247: }
! 248:
! 249: void
! 250: ServerHost::defer_scan(int when, int retries, Request r, const char *path)
! 251: {
! 252: timeval t;
! 253: (void) gettimeofday(&t, NULL);
! 254: int then = t.tv_sec + when + 1;
! 255:
! 256: DeferredScan *ds = new DeferredScan(then, retries, r, path);
! 257: // In most cases, our new element will go either
! 258: // at the beginning or end of the list.
! 259: if ((deferred_scans == NULL) || (deferred_scans->when >= then))
! 260: {
! 261: ds->next = deferred_scans;
! 262: deferred_scans = ds;
! 263: if (last == NULL) last = ds;
! 264: }
! 265: else if (last->when <= then)
! 266: {
! 267: last = last->next = ds;
! 268: }
! 269: else
! 270: {
! 271: // It's in the middle after all. Put it in the right spot.
! 272: DeferredScan *prev = deferred_scans;
! 273: while ((prev->next != NULL) && (prev->next->when < then))
! 274: {
! 275: prev = prev->next;
! 276: }
! 277: ds->next = prev->next;
! 278: prev->next = ds;
! 279: // last still points to an element after ds.
! 280: }
! 281:
! 282: // If this new request needs to happen before our previously-first task,
! 283: // or we didn't have any task scheduled at all, tell the scheduler.
! 284: if (!min_time || then < min_time)
! 285: { if (min_time)
! 286: Scheduler::remove_onetime_task(deferred_scan_task, this);
! 287: min_time = then;
! 288: timeval t = { then, 0 };
! 289: Scheduler::install_onetime_task(t, deferred_scan_task, this);
! 290: }
! 291: }
! 292:
! 293: void
! 294: ServerHost::deferred_scan_task(void *closure)
! 295: {
! 296: ServerHost *host = (ServerHost *) closure;
! 297: int& min_time = host->min_time;
! 298: DeferredScan *ds = host->deferred_scans, *dsp;
! 299: assert(ds);
! 300: if(ds == NULL) return;
! 301:
! 302: bool changed;
! 303:
! 304: timeval t;
! 305: (void) gettimeofday(&t, NULL);
! 306: while ((ds != NULL) && (ds->when <= t.tv_sec))
! 307: {
! 308: ClientInterest *cip = host->requests.find(ds->request());
! 309: if (cip)
! 310: {
! 311: Interest *ip = ds->path() ? cip->find_name(ds->path()) : cip;
! 312: if (ip)
! 313: {
! 314: Log::debug("Handing a defered scan on: %s (Request %i)",
! 315: ip->name(), ds->request());
! 316: changed = ip->scan();
! 317: if (!changed) {
! 318: if (ds->retries > 0) {
! 319: Log::debug(
! 320: "Nothing changed, so rescheduling for %i seconds "
! 321: "(%i retries left)", RETRY_INTERVAL, ds->retries-1);
! 322: host->defer_scan(RETRY_INTERVAL, ds->retries-1, ds->request(), ds->path());
! 323: }
! 324: }
! 325: }
! 326: }
! 327: dsp = host->deferred_scans;
! 328: ds = host->deferred_scans = ds->next;
! 329: if (ds == NULL) host->last = NULL;
! 330: delete dsp;
! 331: }
! 332: if (ds != NULL)
! 333: {
! 334: // We still have some deferred scans which need to happen later.
! 335: min_time = ds->when;
! 336: timeval t = { ds->when, 0 };
! 337: Scheduler::install_onetime_task(t, deferred_scan_task, host);
! 338: }
! 339: else min_time = 0;
! 340: }
! 341:
! 342: ///////////////////////////////////////////////////////////////////////////////
! 343: // Output
! 344:
! 345: Request
! 346: ServerHost::send_monitor(ClientInterest *ci,
! 347: ClientInterest::Type type,
! 348: const char *remote_path)
! 349: {
! 350: if (!active())
! 351: activate();
! 352:
! 353: // Find a unique request number.
! 354:
! 355: Request r = unique_request++;
! 356: assert(!requests.find(r));
! 357:
! 358: // Send the monitor message to the remote fam.
! 359:
! 360: if (is_connected())
! 361: { connection->send_monitor(type, r, remote_path, ci->cred());
! 362: Log::debug("told server fam@%s: request %d monitor file \"%s\"",
! 363: name(), r, remote_path);
! 364: }
! 365:
! 366: // Store the request number in the request table.
! 367:
! 368: requests.insert(r, ci);
! 369: return r;
! 370: }
! 371:
! 372: void
! 373: ServerHost::send_cancel(Request r)
! 374: {
! 375: assert(requests.find(r));
! 376: if (connection)
! 377: { connection->send_cancel(r);
! 378: Log::debug("told server fam@%s: cancel request %d", name(), r);
! 379: }
! 380: requests.remove(r);
! 381: if (requests.size() == 0)
! 382: deactivate();
! 383: }
! 384:
! 385: void
! 386: ServerHost::send_suspend(Request r)
! 387: {
! 388: if (connection)
! 389: { connection->send_suspend(r);
! 390: Log::debug("told server fam@%s: suspend request %d", name(), r);
! 391: }
! 392: }
! 393:
! 394: void
! 395: ServerHost::send_resume(Request r)
! 396: {
! 397: if (connection)
! 398: { connection->send_resume(r);
! 399: Log::debug("told server fam@%s: resume request %d", name(), r);
! 400: }
! 401: }
! 402:
! 403: //////////////////////////////////////////////////////////////////////////////
! 404: // Polling
! 405:
! 406: void
! 407: ServerHost::poll()
! 408: {
! 409: for (Request r = requests.first(); r; r = requests.next(r))
! 410: requests.find(r)->poll();
! 411: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/back.gif){kind=icon}
Return to ServerHost.c++ CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [Development] / fam / fam