开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 通讯编程 > 查看源码
http.cc
资源名称：ns-allinone-2.33.tar.gz　[点击查看]
上传用户：rrhhcc
上传日期：2015-12-11
资源大小：54129k
文件大小：41k
源码类别：

通讯编程

开发平台：

Visual C++

http.cc：源码内容
  1. /* 
  2.  * Copyright (c) Xerox Corporation 1998. All rights reserved.
  3.  *
  4.  * This program is free software; you can redistribute it and/or modify it
  5.  * under the terms of the GNU General Public License as published by the
  6.  * Free Software Foundation; either version 2 of the License, or (at your
  7.  * option) any later version.
  8.  *
  9.  * This program is distributed in the hope that it will be useful, but
  10.  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12.  * General Public License for more details.
  13.  *
  14.  * You should have received a copy of the GNU General Public License along
  15.  * with this program; if not, write to the Free Software Foundation, Inc.,
  16.  * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  17.  *
  18.  * Linking this file statically or dynamically with other modules is making
  19.  * a combined work based on this file.  Thus, the terms and conditions of
  20.  * the GNU General Public License cover the whole combination.
  21.  *
  22.  * In addition, as a special exception, the copyright holders of this file
  23.  * give you permission to combine this file with free software programs or
  24.  * libraries that are released under the GNU LGPL and with code included in
  25.  * the standard release of ns-2 under the Apache 2.0 license or under
  26.  * otherwise-compatible licenses with advertising requirements (or modified
  27.  * versions of such code, with unchanged license).  You may copy and
  28.  * distribute such a system following the terms of the GNU GPL for this
  29.  * file and the licenses of the other code concerned, provided that you
  30.  * include the source code of that other code when and as the GNU GPL
  31.  * requires distribution of source code.
  32.  *
  33.  * Note that people who make modified versions of this file are not
  34.  * obligated to grant this special exception for their modified versions;
  35.  * it is their choice whether to do so.  The GNU General Public License
  36.  * gives permission to release a modified version without this exception;
  37.  * this exception also makes it possible to release a modified version
  38.  * which carries forward this exception.
  39.  *
  40.  * $Header: /cvsroot/nsnam/ns-2/webcache/http.cc,v 1.21 2005/09/18 23:33:35 tomh Exp $
  41.  *
  42.  */
  43. //
  44. // Implementation of the HTTP agent. We want a separate agent for HTTP because
  45. // we are interested in (detailed) HTTP headers, instead of just request and 
  46. // response patterns.
  47. //
  49. #include <stdlib.h>
  50. #include <assert.h>
  51. #include <string.h>
  52. #include <stdarg.h>
  54. #include "tclcl.h"
  55. #include "agent.h"
  56. #include "app.h"
  57. #include "tcp-simple.h"
  58. #include "http.h"
  59. #include "http-aux.h"
  60. #include "trace.h"
  61. #include "tcpapp.h"
  62. #include "mcache.h"
  64. //----------------------------------------------------------------------
  65. // Http Application
  66. //
  67. // Allows multiple concurrent HTTP connections
  68. //----------------------------------------------------------------------
  69. static class HttpAppClass : public TclClass {
  70. public:
  71.         HttpAppClass() : TclClass("Http") {}
  72.         TclObject* create(int, const char*const*) {
  73. return (new HttpApp());
  74. }
  75. } class_http_app;
  77. // What states should be in a http agent?
  78. HttpApp::HttpApp() : log_(0)
  79. {
  80. bind("id_", &id_);
  81. // Map a client address to a particular TCP agent
  82. tpa_ = new Tcl_HashTable;
  83. Tcl_InitHashTable(tpa_, TCL_ONE_WORD_KEYS);
  84. }
  86. HttpApp::~HttpApp()
  87. {
  88. if (tpa_ != NULL) {
  89. Tcl_DeleteHashTable(tpa_);
  90. delete tpa_;
  91. }
  92. }
  94. int HttpApp::add_cnc(HttpApp* client, TcpApp *agt)
  95. {
  96. int newEntry = 1;
  97. long key = client->id();
  98. Tcl_HashEntry *he = Tcl_CreateHashEntry(tpa_, 
  99. (const char *) key,
  100. &newEntry);
  101. if (he == NULL) 
  102. return -1;
  103. if (newEntry)
  104. Tcl_SetHashValue(he, (ClientData)agt);
  105. return 0;
  106. }
  108. void HttpApp::delete_cnc(HttpApp* client)
  109. {
  110.         long key = client->id();
  111. Tcl_HashEntry *he = Tcl_FindHashEntry(tpa_,(const char *)key);
  112. if (he != NULL) {
  113. TcpApp *cnc = (TcpApp *)Tcl_GetHashValue(he);
  114. Tcl_DeleteHashEntry(he);
  115. delete cnc;
  116. }
  117. }
  119. TcpApp* HttpApp::lookup_cnc(HttpApp* client)
  120. {
  121.         long key = client->id();
  122. Tcl_HashEntry *he = 
  123. Tcl_FindHashEntry(tpa_, (const char *)key);
  124. if (he == NULL)
  125. return NULL;
  126. return (TcpApp *)Tcl_GetHashValue(he);
  127. }
  129. // Basic functionalities: 
  130. int HttpApp::command(int argc, const char*const* argv)
  131. {
  132. Tcl& tcl = Tcl::instance();
  134. if (argc == 2) {
  135. if (strcmp(argv[1], "id") == 0) {
  136. if (argc == 3) {
  137. id_ = atoi(argv[2]);
  138. tcl.resultf("%d", id_);
  139. } else
  140. tcl.resultf("%d", id_);
  141. return TCL_OK;
  142. } else if (strcmp(argv[1], "log") == 0) {
  143. // Return the name of the log channel
  144. if (log_ != NULL)
  145. tcl.resultf("%s", Tcl_GetChannelName(log_));
  146. else
  147. tcl.result("");
  148. return TCL_OK;
  149. }
  150. } else if (argc == 3) {
  151. if (strcmp(argv[1], "get-modtime") == 0) {
  152. double mt;
  153. if (pool_->get_mtime(argv[2], mt) != -1) {
  154. tcl.resultf("%.17g", mt);
  155. return TCL_OK;
  156. } else 
  157. return TCL_ERROR;
  158. } else if (strcmp(argv[1], "exist-page") == 0) { 
  159. tcl.resultf("%d", pool_->exist_page(argv[2]));
  160. return TCL_OK;
  161. } else if (strcmp(argv[1], "get-size") == 0) {
  162. int size;
  163. if (pool_->get_size(argv[2], size) != -1) {
  164. tcl.resultf("%d", size);
  165. return TCL_OK;
  166. } else 
  167. return TCL_ERROR;
  168. } else if (strcmp(argv[1], "get-age") == 0) {
  169. double age;
  170. if (pool_->get_age(argv[2], age) != -1) {
  171. tcl.resultf("%.17g", age);
  172. return TCL_OK;
  173. } else 
  174. return TCL_ERROR;
  175. } else if (strcmp(argv[1], "get-cachetime") == 0) {
  176. double et;
  177. if (pool_->get_etime(argv[2], et) != -1) {
  178. tcl.resultf("%.17g", et);
  179. return TCL_OK;
  180. } else 
  181. return TCL_ERROR;
  182. } else if (strcmp(argv[1], "get-page") == 0) {
  183. char buf[4096];
  184. if (pool_->get_pageinfo(argv[2], buf) != -1) {
  185. tcl.resultf("%s", buf);
  186. return TCL_OK;
  187. } else 
  188. return TCL_ERROR;
  189. } else if (strcmp(argv[1], "get-cnc") == 0) {
  190. /*
  191.  * <http> get-cnc <client>
  192.  *
  193.  * Given the communication party, get the tcp agent 
  194.  * connected to it.
  195.  */
  196. HttpApp *client = 
  197. (HttpApp *)TclObject::lookup(argv[2]);
  198. TcpApp *cnc = (TcpApp *)lookup_cnc(client);
  199. if (cnc == NULL)
  200. tcl.result("");
  201. else 
  202. tcl.resultf("%s", cnc->name());
  203. return TCL_OK;
  205. } else if (strcmp(argv[1], "set-pagepool") == 0) {
  206. pool_ = (ClientPagePool*)TclObject::lookup(argv[2]);
  207. if (pool_ != NULL) 
  208. return TCL_OK;
  209. else 
  210. return TCL_ERROR;
  211. } else if (strcmp(argv[1], "is-connected") == 0) {
  212. /*
  213.  * <http> is-connected <server>
  214.  */
  215. HttpApp *a = (HttpApp*)TclObject::lookup(argv[2]);
  216. TcpApp *cnc = (TcpApp*)lookup_cnc(a);
  217. if (cnc == NULL) 
  218. tcl.result("0");
  219. else 
  220. tcl.result("1");
  221. return TCL_OK;
  222. } else if (strcmp(argv[1], "is-valid") == 0) {
  223. ClientPage *pg = 
  224. (ClientPage *)pool_->get_page(argv[2]);
  225. if (pg == NULL) {
  226. tcl.resultf("%d is-valid: No page %s", 
  227.     id_, argv[2]);
  228. return TCL_ERROR;
  229. }
  230. tcl.resultf("%d", pg->is_valid());
  231. return TCL_OK;
  232. } else if (strcmp(argv[1], "log") == 0) {
  233. int mode;
  234. log_ = Tcl_GetChannel(tcl.interp(), 
  235.       (char*)argv[2], &mode);
  236. if (log_ == 0) {
  237. tcl.resultf("%d: invalid log file handle %sn",
  238.     id_, argv[2]);
  239. return TCL_ERROR;
  240. }
  241. return TCL_OK;
  242. } else if (strcmp(argv[1], "disconnect") == 0) {
  243. /*
  244.  * <http> disconnect <client> 
  245.  * Delete the association of source and sink TCP.
  246.  */
  247. HttpApp *client = 
  248. (HttpApp *)TclObject::lookup(argv[2]);
  249. delete_cnc(client);
  250. return TCL_OK;
  251. } else if (strcmp(argv[1], "get-pagetype") == 0) {
  252. /*
  253.  * <http> get-pagetype <pageid>
  254.  * return the page type
  255.  */
  256. ClientPage *pg = 
  257. (ClientPage*)pool_->get_page(argv[2]);
  258. if (pg == NULL) {
  259. tcl.resultf("%d get-pagetype: No page %s", 
  260.     id_, argv[2]);
  261. return TCL_ERROR;
  262. }
  263. switch (pg->type()) {
  264. case HTML:
  265. tcl.result("HTML");
  266. break;
  267. case MEDIA:
  268. tcl.result("MEDIA");
  269. break;
  270. default:
  271. fprintf(stderr, "Unknown page type %d", 
  272. pg->type());
  273. return TCL_ERROR;
  274. }
  275. return TCL_OK;
  276. } else if (strcmp(argv[1], "get-layer") == 0) {
  277. // Assume the page is a MediaPage
  278. MediaPage *pg = (MediaPage *)pool_->get_page(argv[2]);
  279. if (pg == NULL) {
  280. tcl.resultf("%d get-layer: No page %s", 
  281.     id_, argv[2]);
  282. return TCL_ERROR;
  283. }
  284. if (pg->type() != MEDIA) {
  285. tcl.resultf("%d get-layer %s not a media page",
  286.     id_, argv[2]);
  287. return TCL_ERROR;
  288. }
  289. tcl.resultf("%d", pg->num_layer());
  290. return TCL_OK;
  291. }
  292. } else if (argc == 4) {
  293. if (strcmp(argv[1], "connect") == 0) {
  294. /*
  295.  * <http> connect <client> <ts>
  296.  *
  297.  * Associate a TCP agent with the given client. 
  298.  * <ts> is the agent used to send packets out.
  299.  * We assume two-way TCP connection, therefore we 
  300.  * only need one agent.
  301.  */
  302. HttpApp *client = 
  303. (HttpApp *)TclObject::lookup(argv[2]);
  304. TcpApp *cnc = (TcpApp *)TclObject::lookup(argv[3]);
  305. if (add_cnc(client, cnc)) {
  306. tcl.resultf("%s: failed to connect to %s", 
  307.     name_, argv[2]);
  308. return TCL_ERROR;
  309. }
  310. // Set data delivery target
  311. cnc->target() = (Process*)this;
  312. return TCL_OK;
  313. } else if (strcmp(argv[1], "set-modtime") == 0) {
  314. double mt = strtod(argv[3], NULL);
  315. if (pool_->set_mtime(argv[2], mt) != -1)
  316. return TCL_OK;
  317. else 
  318. return TCL_ERROR;
  319. } else if (strcmp(argv[1], "set-cachetime") == 0) {
  320. double et = Scheduler::instance().clock();
  321. if (pool_->set_etime(argv[2], et) != -1)
  322. return TCL_OK;
  323. else 
  324. return TCL_ERROR;
  325. }
  326. } else {
  327. if (strcmp(argv[1], "send") == 0) {
  328. /*
  329.  * <http> send <client> <bytes> <callback> 
  330.  */
  331. HttpApp *client = 
  332. (HttpApp *)TclObject::lookup(argv[2]);
  333. if (client == NULL) {
  334. tcl.add_errorf("%s: bad client name %s",
  335.        name_, argv[2]);
  336. return TCL_ERROR;
  337. }
  338. int bytes = atoi(argv[3]);
  339. TcpApp *cnc = (TcpApp *)lookup_cnc(client);
  340. if (cnc == NULL) {
  341. //tcl.resultf("%s: no connection to client %s",
  342. //     name_, argv[2]);
  343. // Tolerate it
  344. return TCL_OK;
  345. }
  346. char *buf = strdup(argv[4]);
  347. HttpNormalData *d = 
  348. new HttpNormalData(id_, bytes, buf);
  349. cnc->send(bytes, d);
  350. // delete d;
  351. free(buf);
  352. return TCL_OK;
  354. } else if (strcmp(argv[1], "enter-page") == 0) {
  355. ClientPage* pg = pool_->enter_page(argc, argv);
  356. if (pg == NULL)
  357. return TCL_ERROR;
  358. else 
  359. return TCL_OK;
  361. } else if (strcmp(argv[1], "evTrace") == 0) { 
  362. char buf[1024], *p;
  363. if (log_ != 0) {
  364. sprintf(buf, TIME_FORMAT" i %d ", 
  365.   BaseTrace::round(Scheduler::instance().clock()), 
  366. id_);
  367. p = &(buf[strlen(buf)]);
  368. for (int i = 2; i < argc; i++) {
  369. strcpy(p, argv[i]);
  370. p += strlen(argv[i]);
  371. *(p++) = ' ';
  372. }
  373. // Stick in a newline.
  374. *(p++) = 'n', *p = 0;
  375. Tcl_Write(log_, buf, p-buf);
  376. }
  377. return TCL_OK;
  378. }
  379. }
  381. return TclObject::command(argc, argv);
  382. }
  384. void HttpApp::log(const char* fmt, ...)
  385. {
  386. // Don't do anything if we don't have a log file.
  387. if (log_ == 0) 
  388. return;
  390. char buf[10240], *p;
  391. sprintf(buf, TIME_FORMAT" i %d ", 
  392. BaseTrace::round(Scheduler::instance().clock()), id_);
  393. p = &(buf[strlen(buf)]);
  394. va_list ap;
  395. va_start(ap, fmt);
  396. vsprintf(p, fmt, ap);
  397. Tcl_Write(log_, buf, strlen(buf));
  398. }
  400. void HttpApp::process_data(int, AppData* data)
  401. {
  402. if (data == NULL) 
  403. return;
  405. switch (data->type()) {
  406. case HTTP_NORMAL: {
  407. HttpNormalData *tmp = (HttpNormalData*)data;
  408. Tcl::instance().eval(tmp->str());
  409. break;
  410. }
  411. default:
  412. fprintf(stderr, "Bad http invalidation data type %dn", 
  413. data->type());
  414. abort();
  415. break;
  416. }
  417. }
  421. //----------------------------------------------------------------------
  422. // Clients
  423. //----------------------------------------------------------------------
  424. static class HttpClientClass : public TclClass {
  425. public:
  426. HttpClientClass() : TclClass("Http/Client") {}
  427.         TclObject* create(int, const char*const*) {
  428. return (new HttpClient());
  429. }
  430. } class_httpclient_app;
  434. //----------------------------------------------------------------------
  435. // Servers
  436. //----------------------------------------------------------------------
  437. static class HttpServerClass : public TclClass {
  438. public:
  439.         HttpServerClass() : TclClass("Http/Server") {}
  440.         TclObject* create(int, const char*const*) {
  441. return (new HttpServer());
  442. }
  443. } class_httpserver_app;
  445. static class HttpInvalServerClass : public TclClass {
  446. public:
  447.         HttpInvalServerClass() : TclClass("Http/Server/Inval") {}
  448.         TclObject* create(int, const char*const*) {
  449. return (new HttpInvalServer());
  450. }
  451. } class_httpinvalserver_app;
  453. static class HttpYucInvalServerClass : public TclClass {
  454. public:
  455.         HttpYucInvalServerClass() : TclClass("Http/Server/Inval/Yuc") {}
  456.         TclObject* create(int, const char*const*) {
  457. return (new HttpYucInvalServer());
  458. }
  459. } class_httpyucinvalserver_app;
  461. HttpYucInvalServer::HttpYucInvalServer() :
  462. inv_sender_(0), invlist_(0), num_inv_(0)
  463. {
  464. bind("hb_interval_", &hb_interval_);
  465. bind("enable_upd_", &enable_upd_);
  466. bind("Ca_", &Ca_);
  467. bind("Cb_", &Cb_);
  468. bind("push_thresh_", &push_thresh_);
  469. bind("push_high_bound_", &push_high_bound_);
  470. bind("push_low_bound_", &push_low_bound_);
  471. }
  473. int HttpYucInvalServer::command(int argc, const char*const* argv)
  474. {
  475. Tcl& tcl = Tcl::instance();
  477. switch (argv[1][0]) {
  478. case 'a': 
  479. if (strcmp(argv[1], "add-inval-sender") == 0) {
  480. HttpUInvalAgent *tmp = 
  481. (HttpUInvalAgent *)TclObject::lookup(argv[2]);
  482. if (tmp == NULL) {
  483. tcl.resultf("Non-existent agent %s", argv[2]);
  484. return TCL_ERROR;
  485. }
  486. inv_sender_ = tmp;
  487. return TCL_OK;
  488. } if (strcmp(argv[1], "add-inv") == 0) {
  489. /*
  490.  * <server> add-inv <pageid> <modtime>
  491.  */
  492. double mtime = strtod(argv[3], NULL);
  493. add_inv(argv[2], mtime);
  494. return TCL_OK;
  495. }
  496. break;
  497. case 'c': 
  498. if (strcmp(argv[1], "count-request") == 0) {
  499. ClientPage *pg = 
  500. (ClientPage *)pool_->get_page(argv[2]);
  501. if (pg == NULL) {
  502. tcl.resultf("%d count-request: No page %s", 
  503.     id_, argv[2]);
  504. return TCL_ERROR;
  505. }
  506. pg->count_request(Cb_, push_high_bound_);
  507. log("S NTF p %s v %dn", argv[2], pg->counter());
  508. return TCL_OK;
  509. } else if (strcmp(argv[1], "count-inval") == 0) {
  510. ClientPage *pg = 
  511. (ClientPage *)pool_->get_page(argv[2]);
  512. if (pg == NULL) {
  513. tcl.resultf("%d count-inval: No page %s", 
  514.     id_, argv[2]);
  515. return TCL_ERROR;
  516. }
  517. pg->count_inval(Ca_, push_low_bound_);
  518. log("S NTF p %s v %dn", argv[2], pg->counter());
  519. return TCL_OK;
  520. } 
  521. break;
  522. case 'i': 
  523. if (strcmp(argv[1], "is-pushable") == 0) {
  524. ClientPage *pg = 
  525. (ClientPage *)pool_->get_page(argv[2]);
  526. if (pg == NULL) {
  527. tcl.resultf("%d is-pushable: No page %s", 
  528.     id_, argv[2]);
  529. return TCL_ERROR;
  530. }
  531. if (pg->is_mpush() && 
  532.     (Scheduler::instance().clock() - pg->mpush_time() >
  533.      HTTP_HBEXPIRE_COUNT*hb_interval_)) {
  534. // If mandatory push timer expires, stop push
  535. pg->clear_mpush();
  536. fprintf(stderr, 
  537. "server %d timeout mpushn", id_);
  538. }
  539. tcl.resultf("%d", (enable_upd_ && 
  540.    (pg->counter() >= push_thresh_) ||
  541.    pg->is_mpush()));
  542. return TCL_OK;
  543. }
  544. break;
  545. case 'r': 
  546. if ((strcmp(argv[1], "request-mpush") == 0) ||
  547.     (strcmp(argv[1], "refresh-mpush") == 0)) {
  548. ClientPage *pg = 
  549. (ClientPage *)pool_->get_page(argv[2]);
  550. if (pg == NULL) {
  551. tcl.resultf("%d is-valid: No page %s", 
  552.     id_, argv[2]);
  553. return TCL_ERROR;
  554. }
  555. pg->set_mpush(Scheduler::instance().clock());
  556. return TCL_OK;
  557. } 
  558. break;
  559. case 's': 
  560. if (strcmp(argv[1], "send-hb") == 0) {
  561. send_heartbeat();
  562. return TCL_OK;
  563. } else if (strcmp(argv[1], "stop-mpush") == 0) {
  564. ClientPage *pg = 
  565. (ClientPage *)pool_->get_page(argv[2]);
  566. if (pg == NULL) {
  567. tcl.resultf("%d is-valid: No page %s", 
  568.     id_, argv[2]);
  569. return TCL_ERROR;
  570. }
  571. pg->clear_mpush();
  572. fprintf(stderr, "server %d stopped mpushn", id_);
  573. return TCL_OK;
  574. }
  575. break;
  576. }
  578. return HttpApp::command(argc, argv);
  579. }
  581. void HttpYucInvalServer::add_inv(const char *name, double mtime)
  582. {
  583. InvalidationRec *p = get_invrec(name);
  584. if ((p != NULL) && (p->mtime() < mtime)) {
  585. p->detach();
  586. delete p;
  587. p = NULL;
  588. num_inv_--;
  589. } 
  590. if (p == NULL) {
  591. p = new InvalidationRec(name, mtime);
  592. p->insert(&invlist_);
  593. num_inv_++;
  594. }
  595. }
  597. InvalidationRec* HttpYucInvalServer::get_invrec(const char *name)
  598. {
  599. // XXX What should we do if we already have an
  600. // invalidation record of this page in our 
  601. // invlist_? --> We should replace it with the new one
  602. InvalidationRec *r = invlist_;
  603. for (r = invlist_; r != NULL; r = r->next())
  604. if (strcmp(name, r->pg()) == 0)
  605. return r;
  606. return NULL;
  607. }
  609. HttpHbData* HttpYucInvalServer::pack_heartbeat()
  610. {
  611. HttpHbData *data = new HttpHbData(id_, num_inv_);
  612. InvalidationRec *p = invlist_, *q;
  613. int i = 0;
  614. while (p != NULL) {
  615. data->add(i++, p);
  616. // Clearing up invalidation sending list
  617. if (!p->dec_scount()) {
  618. // Each invalidation is sent to its children
  619. // for at most HTTP_HBEXPIRE times. After that 
  620. // the invalidation record is removed from 
  621. // the list
  622. q = p;
  623. p = p->next();
  624. q->detach();
  625. delete q;
  626. num_inv_--;
  627. } else 
  628. p = p->next();
  629. }
  630. return data;
  631. }
  633. void HttpYucInvalServer::send_hb_helper(int size, AppData *data)
  634. {
  635. inv_sender_->send(size, data);
  636. }
  638. void HttpYucInvalServer::send_heartbeat()
  639. {
  640. if (inv_sender_ == NULL)
  641. return;
  643. HttpHbData* d = pack_heartbeat();
  644. send_hb_helper(d->cost(), d);
  645. }
  650. //----------------------------------------------------------------------
  651. // Http cache with invalidation protocols. Http/Cache and Http/Cache/Inval
  652. // are used as base classes and provide common TCL methods. Http/Cache 
  653. // derives Http/Cache/TTL and Http/Cache/TTL/Old. Http/Cache/Inval derives
  654. // unicast invalidation and multicast invalidation.
  655. //----------------------------------------------------------------------
  657. static class HttpCacheClass : public TclClass {
  658. public:
  659.         HttpCacheClass() : TclClass("Http/Cache") {}
  660.         TclObject* create(int, const char*const*) {
  661. return (new HttpCache());
  662. }
  663. } class_httpcache_app;
  665. static class HttpInvalCacheClass : public TclClass {
  666. public:
  667.         HttpInvalCacheClass() : TclClass("Http/Cache/Inval") {}
  668.         TclObject* create(int, const char*const*) {
  669. return (new HttpInvalCache());
  670. }
  671. } class_httpinvalcache_app;
  673. static class HttpMInvalCacheClass : public TclClass {
  674. public:
  675.         HttpMInvalCacheClass() : TclClass("Http/Cache/Inval/Mcast") {}
  676.         TclObject* create(int, const char*const*) {
  677. return (new HttpMInvalCache());
  678. }
  679. } class_HttpMInvalCache_app;
  681. // Static members and functions
  682. HttpMInvalCache** HttpMInvalCache::CacheRepository_ = NULL;
  683. int HttpMInvalCache::NumCache_ = 0;
  685. void HttpMInvalCache::add_cache(HttpMInvalCache *c)
  686. {
  687. if (CacheRepository_ == NULL) {
  688. CacheRepository_ = new HttpMInvalCache* [c->id() + 1];
  689. CacheRepository_[c->id()] = c;
  690. NumCache_ = c->id();
  691. } else if (NumCache_ < c->id()) {
  692. HttpMInvalCache** p = new HttpMInvalCache* [c->id()+1];
  693. memcpy(p, CacheRepository_, 
  694.        (c->id()+1)*sizeof(HttpMInvalCache*));
  695. delete[]CacheRepository_;
  696. CacheRepository_ = p;
  697. NumCache_ = c->id();
  698. p[c->id()] = c;
  699. } else
  700. CacheRepository_[c->id()] = c;
  701. }
  703. HttpMInvalCache::HttpMInvalCache() : 
  704. hb_timer_(this, HTTP_HBINTERVAL),
  705. inv_sender_(0), num_sender_(0), size_sender_(0), 
  706. invlist_(0), num_inv_(0), inv_parent_(NULL),
  707. upd_sender_(NULL), num_updater_(0), size_updater_(0)
  708. {
  709. bind("hb_interval_", &hb_interval_);
  710. bind("enable_upd_", &enable_upd_); // If we allow push
  711. bind("Ca_", &Ca_);
  712. bind("Cb_", &Cb_);
  713. bind("push_thresh_", &push_thresh_);
  714. bind("push_high_bound_", &push_high_bound_);
  715. bind("push_low_bound_", &push_low_bound_);
  717. hb_timer_.set_interval(hb_interval_);
  718. Tcl_InitHashTable(&sstate_, TCL_ONE_WORD_KEYS);
  719. Tcl_InitHashTable(&nbr_, TCL_ONE_WORD_KEYS);
  720. }
  722. HttpMInvalCache::~HttpMInvalCache() 
  723. {
  724. if (num_sender_ > 0) 
  725. delete []inv_sender_;
  726. Tcl_DeleteHashTable(&sstate_);
  727. Tcl_DeleteHashTable(&nbr_);
  728. }
  730. int HttpMInvalCache::command(int argc, const char*const* argv)
  731. {
  732. Tcl& tcl = Tcl::instance();
  733. if (argc < 2) 
  734. return HttpInvalCache::command(argc, argv);
  736. switch (argv[1][0]) {
  737. case 'a':
  738. if ((strcmp(argv[1], "add-inval-listener") == 0) ||
  739.     (strcmp(argv[1], "add-upd-listener") == 0)) {
  740. HttpInvalAgent *tmp = 
  741. (HttpInvalAgent *)TclObject::lookup(argv[2]);
  742. tmp->attachApp((Application *)this);
  743. return TCL_OK;
  744. } else if (strcmp(argv[1], "add-inval-sender") == 0) {
  745. HttpInvalAgent *tmp = 
  746. (HttpInvalAgent *)TclObject::lookup(argv[2]);
  747. if (tmp == NULL) {
  748. tcl.resultf("Non-existent agent %s", argv[2]);
  749. return TCL_ERROR;
  750. }
  751. if (num_sender_ == size_sender_) {
  752. HttpInvalAgent **tt = 
  753. new HttpInvalAgent*[size_sender_+5];
  754. memcpy(tt, inv_sender_, 
  755.        sizeof(HttpInvalAgent*)*size_sender_);
  756. delete []inv_sender_;
  757. size_sender_ += 5;
  758. inv_sender_ = tt;
  759. }
  760. inv_sender_[num_sender_++] = tmp;
  761. return TCL_OK;
  762. } else if (strcmp(argv[1], "add-to-map") == 0) {
  763. add_cache(this);
  764. return TCL_OK;
  765. } else if (strcmp(argv[1], "add-upd-sender") == 0) {
  766. HttpInvalAgent *tmp = 
  767. (HttpInvalAgent *)TclObject::lookup(argv[2]);
  768. if (tmp == NULL) {
  769. tcl.resultf("Non-existent agent %s", argv[2]);
  770. return TCL_ERROR;
  771. }
  772. if (num_updater_ == size_updater_) {
  773. HttpInvalAgent **tt = 
  774. new HttpInvalAgent*[size_updater_+5];
  775. memcpy(tt, upd_sender_, 
  776.        sizeof(HttpInvalAgent*)*size_updater_);
  777. delete []upd_sender_;
  778. size_updater_ += 5;
  779. upd_sender_ = tt;
  780. }
  781. upd_sender_[num_updater_++] = tmp;
  782. return TCL_OK;
  783. }
  784. break;
  786. case 'c':
  787. if (strcmp(argv[1], "count-request") == 0) {
  788. ClientPage *pg = 
  789. (ClientPage *)pool_->get_page(argv[2]);
  790. if (pg == NULL) {
  791. tcl.resultf("%d count-request: No page %s", 
  792.     id_, argv[2]);
  793. return TCL_ERROR;
  794. }
  795. pg->count_request(Cb_, push_high_bound_);
  796. log("E NTF p %s v %dn", argv[2], pg->counter());
  797. return TCL_OK;
  798. } else if (strcmp(argv[1], "check-sstate") == 0) {
  799. /*
  800.  * <cache> check-sstate <sid> <cid>
  801.  * If server is re-connected, reinstate it
  802.  */
  803. int sid = atoi(argv[2]);
  804. int cid = atoi(argv[3]);
  805. check_sstate(sid, cid);
  806. return TCL_OK;
  807. }
  808. break;
  810. case 'i':
  811. // XXX We don't need a "is-pushable" for cache!
  812. if (strcmp(argv[1], "is-unread") == 0) {
  813. ClientPage *pg = 
  814. (ClientPage *)pool_->get_page(argv[2]);
  815. if (pg == NULL) {
  816. tcl.resultf("%d is-unread: No page %s", 
  817.     id_, argv[2]);
  818. return TCL_ERROR;
  819. }
  820. tcl.resultf("%d", pg->is_unread());
  821. return TCL_OK;
  822. }
  823. break;
  825. case 'j':
  826. if (strcmp(argv[1], "join") == 0) {
  827. /*
  828.  * <cache> join <server_id> <cache>
  829.  *
  830.  * <server> join via <cache>. If they are the same,
  831.  * it means we are the primary cache for <server>.
  832.  */
  833. int sid = atoi(argv[2]);
  834. HttpMInvalCache *cache = 
  835. (HttpMInvalCache*)TclObject::lookup(argv[3]);
  836. if (cache == NULL) {
  837.     tcl.add_errorf("Non-existent cache %s", argv[3]);
  838.     return TCL_ERROR;
  839. }
  840. // Add neighbor cache if necessary
  841. NeighborCache *c = lookup_nbr(cache->id());
  842. if (c == NULL)
  843. add_nbr(cache);
  844. // Establish server invalidation contract
  845. check_sstate(sid, cache->id());
  846. return TCL_OK;
  847. }
  848. break;
  850. case 'p':
  851. if (strcmp(argv[1], "parent-cache") == 0) {
  852. /*
  853.  * <cache> parent-cache <web_server_id>
  854.  * Return the parent cache of <web_server_id> in the 
  855.  * virtual distribution tree. 
  856.  */
  857. int sid = atoi(argv[2]);
  858. SState *sst = lookup_sstate(sid);
  859. if (sst == NULL)
  860. tcl.result("");
  861. else {
  862. // Bad hack... :(
  863. NeighborCache *c = lookup_nbr(sst->cache()->cache()->id());
  864. tcl.resultf("%s", c->cache()->name());
  865. }
  866. return TCL_OK;
  867. } else if (strcmp(argv[1], "push-children") == 0) {
  868. // Multicast the pushed page to all children
  869. ClientPage *pg = 
  870. (ClientPage *)pool_->get_page(argv[2]);
  871. if (pg == NULL) {
  872. tcl.resultf("%d is-valid: No page %s", 
  873.     id_, argv[2]);
  874. return TCL_ERROR;
  875. }
  876. send_upd(pg);
  877. return TCL_OK;
  878. }
  879. break;
  881. case 'r':
  882. if (strcmp(argv[1], "recv-inv") == 0) {
  883. /*
  884.  * <cache> recv-inv <pageid> <modtime>
  885.  * This should be called only by a web server, 
  886.  * therefore we do not check the validity of the 
  887.  * invalidation
  888.  */
  889. // Pack it into a HttpHbData, and process it
  890. HttpHbData *d = new HttpHbData(id_, 1);
  891. strcpy(d->rec_pg(0), argv[2]);
  892. d->rec_mtime(0) = strtod(argv[3], NULL);
  893. //int old_inv = num_inv_;
  894. tcl.resultf("%d", recv_inv(d));
  895. delete d;
  896. return TCL_OK;
  897. } else if (strcmp(argv[1], "recv-push") == 0) {
  898. /* 
  899.  * <cache> recv-push <pageid> args
  900.  */
  901. HttpUpdateData *d = new HttpUpdateData(id_, 1);
  902. strcpy(d->rec_page(0), argv[2]);
  903. for (int i = 3; i < argc; i+=2) {
  904. if (strcmp(argv[i], "modtime") == 0)
  905.   d->rec_mtime(0) = strtod(argv[i+1], NULL);
  906. else if (strcmp(argv[i], "size") == 0) {
  907.   d->rec_size(0) = atoi(argv[i+1]);
  908.   // XXX need to set total update page size
  909.   d->set_pgsize(d->rec_size(0));
  910. } else if (strcmp(argv[i], "age") == 0)
  911.   d->rec_age(0) = strtod(argv[i+1], NULL);
  912. }
  913. tcl.resultf("%d", recv_upd(d));
  914. delete d;
  915. return TCL_OK;
  916. } else if (strcmp(argv[1], "register-server") == 0) {
  917. /*
  918.  * <self> register-server <cache_id> <server_id>
  919.  * We get a GET response about a page from <server>, 
  920.  * which we hear from <cache> 
  921.  */
  922. int cid = atoi(argv[2]);
  923. int sid = atoi(argv[3]);
  924. // Assuming we've already known the cache
  925. check_sstate(sid, cid);
  926. return TCL_OK;
  927. }
  928. break;
  930. case 's':
  931. if (strcmp(argv[1], "start-hbtimer") == 0) {
  932. if (hb_timer_.status() == TIMER_IDLE)
  933. hb_timer_.sched();
  934. return TCL_OK;
  935. } else if (strcmp(argv[1], "server-hb") == 0) {
  936. int id = atoi(argv[2]);
  937. recv_heartbeat(id);
  938. return TCL_OK;
  939. } else if (strcmp(argv[1], "set-pinv-agent") == 0) {
  940. inv_parent_ = 
  941. (HttpUInvalAgent*)TclObject::lookup(argv[2]);
  942. return TCL_OK;
  943. } else if (strcmp(argv[1], "set-parent") == 0) {
  944. HttpMInvalCache *c = 
  945. (HttpMInvalCache*)TclObject::lookup(argv[2]);
  946. if (c == NULL) {
  947.     tcl.add_errorf("Non-existent cache %s", argv[2]);
  948.     return TCL_ERROR;
  949. }
  950. // Add parent cache into known cache list
  951. add_nbr(c);
  952. return TCL_OK;
  953. } else if (strcmp(argv[1], "set-unread") == 0) {
  954. ClientPage *pg = 
  955. (ClientPage *)pool_->get_page(argv[2]);
  956. if (pg == NULL) {
  957. tcl.resultf("%d is-valid: No page %s", 
  958.     id_, argv[2]);
  959. return TCL_ERROR;
  960. }
  961. pg->set_unread();
  962. return TCL_OK;
  963. } else if (strcmp(argv[1], "set-read") == 0) {
  964. ClientPage *pg = 
  965. (ClientPage *)pool_->get_page(argv[2]);
  966. if (pg == NULL) {
  967. tcl.resultf("%d is-valid: No page %s", 
  968.     id_, argv[2]);
  969. return TCL_ERROR;
  970. }
  971. pg->set_read();
  972. return TCL_OK;
  973. } else if (strcmp(argv[1], "set-mandatory-push") == 0) { 
  974. ClientPage *pg = 
  975. (ClientPage *)pool_->get_page(argv[2]);
  976. if (pg == NULL) {
  977. tcl.resultf("%d is-valid: No page %s", 
  978.     id_, argv[2]);
  979. return TCL_ERROR;
  980. }
  981. pg->set_mpush(Scheduler::instance().clock());
  982. return TCL_OK;
  983. } else if (strcmp(argv[1], "stop-mpush") == 0) {
  984. ClientPage *pg = 
  985. (ClientPage *)pool_->get_page(argv[2]);
  986. if (pg == NULL) {
  987. tcl.resultf("%d is-valid: No page %s", 
  988.     id_, argv[2]);
  989. return TCL_ERROR;
  990. }
  991. pg->clear_mpush();
  992. return TCL_OK;
  993. }
  994. break;
  996. default:
  997. break;
  998. }
  999. return HttpInvalCache::command(argc, argv);
  1000. }
  1002. void HttpMInvalCache::check_sstate(int sid, int cid)
  1003. {
  1004. if ((sid == cid) && (cid == id_))
  1005. // How come?
  1006. return;
  1007. SState *sst = lookup_sstate(sid);
  1008. NeighborCache *c = lookup_nbr(cid);
  1009. if (sst == NULL) {
  1010. if (c == NULL) {
  1011. fprintf(stderr, 
  1012. "%g: cache %d: No neighbor cache for received invalidation from %d via %dn", 
  1013. Scheduler::instance().clock(), id_, sid, cid);
  1014. abort();
  1015. }
  1016. #ifdef WEBCACHE_DEBUG
  1017. fprintf(stderr,
  1018. "%g: cache %d: registered server %d via cache %dn",
  1019. Scheduler::instance().clock(), id_, sid, cid);
  1020. #endif
  1021. sst = new SState(c);
  1022. add_sstate(sid, sst);
  1023. c->add_server(sid);
  1024. } else if (sst->is_down()) {
  1025. sst->up();
  1026. if (cid != id_) {
  1027. if (c == NULL) {
  1028. fprintf(stderr, 
  1029.  "[%g]: Cache %d has an invalid neighbor cache %dn",
  1030.  Scheduler::instance().clock(), id_, cid);
  1031. abort();
  1032. }
  1033. c->server_up(sid);
  1034. }
  1035. #ifdef WEBCACHE_DEBUG
  1036. fprintf(stderr, 
  1037. "[%g] Cache %d reconnected to server %d via cache %dn", 
  1038. Scheduler::instance().clock(), id_, 
  1039. sid, cid);
  1040. #endif
  1041. Tcl::instance().evalf("%s mark-rejoin", name_);
  1042. }
  1043. }
  1045. void HttpMInvalCache::add_sstate(int sid, SState *sst)
  1046. {
  1047. int newEntry = 1;
  1048. long key = sid;
  1049. Tcl_HashEntry *he = 
  1050. Tcl_CreateHashEntry(&sstate_, (const char *)key, &newEntry);
  1051. if (he == NULL) 
  1052. return;
  1053. if (newEntry)
  1054. Tcl_SetHashValue(he, (ClientData)sst);
  1055. }
  1057. HttpMInvalCache::SState* HttpMInvalCache::lookup_sstate(int sid)
  1058. {
  1059.         long key = sid;
  1060. Tcl_HashEntry *he = Tcl_FindHashEntry(&sstate_, (const char *)key);
  1061. if (he == NULL)
  1062. return NULL;
  1063. return (SState *)Tcl_GetHashValue(he);
  1064. }
  1066. NeighborCache* HttpMInvalCache::lookup_nbr(int id)
  1067. {
  1068.         long key = id;
  1069. Tcl_HashEntry *he = Tcl_FindHashEntry(&nbr_, (const char *)key);
  1070. if (he == NULL)
  1071. return NULL;
  1072. return (NeighborCache *)Tcl_GetHashValue(he);
  1073. }
  1075. // Add a new neighbor cache
  1076. void HttpMInvalCache::add_nbr(HttpMInvalCache *cache)
  1077. {
  1078. int newEntry = 1;
  1079. long key = cache->id ();
  1080. Tcl_HashEntry *he = 
  1081. Tcl_CreateHashEntry(&nbr_, (const char *)key, 
  1082.     &newEntry);
  1083. if (he == NULL) 
  1084. return;
  1085. // If this cache already exists, don't do anything
  1086. if (!newEntry)
  1087. return;
  1089. // Start a timer for the neighbor
  1090. LivenessTimer *timer = 
  1091. new LivenessTimer(this,HTTP_HBEXPIRE_COUNT*hb_interval_,
  1092.   cache->id());
  1094. double time = Scheduler::instance().clock();
  1095. NeighborCache *c = new NeighborCache(cache, time, timer);
  1096. Tcl_SetHashValue(he, (ClientData)c);
  1097. }
  1099. // Two ways to receive a heartbeat: (1) via HttpInvalAgent; (2) via TCP 
  1100. // connection between a server and a primary cache. (See "server-hb" handling
  1101. // in command().
  1102. void HttpMInvalCache::recv_heartbeat(int id)
  1103. {
  1104. // Receive time of the heartbeat
  1105. double time = Scheduler::instance().clock();
  1107. NeighborCache *c = lookup_nbr(id);
  1108. if (c == NULL) {
  1109. // XXX
  1110. // The only possible place for this to happen is in the TLC
  1111. // group, where no JOIN could ever reach. Moreover, 
  1112. // we don't even have an entry for that cache yet, so here
  1113. // we add that cache into our entry, and later on we'll add
  1114. // corresponding servers there.
  1115. if (id == id_) 
  1116. return;
  1117. add_nbr(map_cache(id));
  1118. #ifdef WEBCACHE_DEBUG
  1119. fprintf(stderr, "TLC %d discovered TLC %dn", id_, id);
  1120. #endif
  1121. return;
  1122. } else if (c->is_down()) {
  1123. // Neighbor cache recovers. Don't do anything special and
  1124. // let invalid entries recover themselves
  1125. c->up();
  1126. #ifdef WEBCACHE_DEBUG
  1127. fprintf(stderr, "[%g] Cache %d reconnected to cache %dn", 
  1128. Scheduler::instance().clock(), id_, id);
  1129. #endif
  1130. Tcl::instance().evalf("%s mark-rejoin", name_);
  1131. } else
  1132. // Update heartbeat time
  1133. c->reset_timer(time);
  1134. }
  1136. void HttpMInvalCache::invalidate_server(int sid)
  1137. {
  1138. SState *sst = lookup_sstate(sid);
  1139. if (sst->is_down())
  1140. // If this server is already marked down, return
  1141. return;
  1142. sst->down();
  1143. pool_->invalidate_server(sid);
  1144. }
  1146. void HttpMInvalCache::handle_node_failure(int cid)
  1147. {
  1148. #ifdef WEBCACHE_DEBUG
  1149. fprintf(stderr, "[%g] Cache %d disconnected from cache %dn", 
  1150. Scheduler::instance().clock(), id_, cid);
  1151. #endif
  1152. Tcl::instance().evalf("%s mark-leave", name_);
  1154. NeighborCache *c = lookup_nbr(cid);
  1155. if (c == NULL) {
  1156. fprintf(stderr, "%s: An unknown neighbor cache %d failed.n",
  1157. name_, cid);
  1158. }
  1159. // Mark the cache down
  1160. c->down();
  1161. // Invalidate entries of all servers related to that cache
  1162. // XXX We don't have an iterator for all servers in NeighborCache!
  1163. c->invalidate(this);
  1165. // Send leave message to all children
  1166. HttpLeaveData* data = new HttpLeaveData(id_, c->num());
  1167. c->pack_leave(*data);
  1168. send_leave(data);
  1169. }
  1171. void HttpMInvalCache::recv_leave(HttpLeaveData *d)
  1172. {
  1173. #ifdef WEBCACHE_DEBUG
  1174. fprintf(stderr, "[%g] Cache %d gets a LEAVE from cache %dn", 
  1175. Scheduler::instance().clock(), id_, d->id());
  1176. #endif
  1178. if (d->num() == 0) {
  1179. fprintf(stderr, 
  1180.     "%s (%g) gets a leave from cache without server!n", 
  1181. name_, Scheduler::instance().clock());
  1182. return;
  1183. }
  1185. SState *sst;
  1186. HttpLeaveData* data = new HttpLeaveData(id_, d->num());
  1187. NeighborCache *c = lookup_nbr(d->id());
  1188. int i, j;
  1189. for (i = 0, j = 0; i < d->num(); i++) {
  1190. sst = lookup_sstate(d->rec_id(i));
  1192. // If we haven't heard of that server, which means we don't 
  1193. // have any page of that server, ignore the leave message.
  1194. if (sst == NULL) 
  1195. continue;
  1196. // If it's already marked down, don't bother again.
  1197. if (sst->is_down()) 
  1198. continue;
  1199. // If we hear a LEAVE about a server from one of 
  1200. // our child in the virtual distribution tree 
  1201. // of the server, ignore it.
  1202. if (c != sst->cache()) 
  1203. continue;
  1205. // We have the page, and we hold inval contract. Invalidate 
  1206. // the page and inform our children of it.
  1207. sst->down();
  1208. data->add(j++, d->rec_id(i));
  1209. pool_->invalidate_server(d->rec_id(i));
  1210. Tcl::instance().evalf("%s mark-leave", name_);
  1211. }
  1212. // Delete it if it's not sent out 
  1213. if (j > 0)
  1214. send_leave(data);
  1215. delete data;
  1216. }
  1218. void HttpMInvalCache::send_leave(HttpLeaveData *d)
  1219. {
  1220. send_hb_helper(d->cost(), d);
  1221. }
  1223. void HttpMInvalCache::timeout(int reason)
  1224. {
  1225. switch (reason) {
  1226. case HTTP_INVALIDATION:
  1227. // Send an invalidation message
  1228. send_heartbeat();
  1229. break;
  1230. case HTTP_UPDATE:
  1231. // XXX do nothing. May put client selective joining update
  1232. // group here.
  1233. break;
  1234. default:
  1235. fprintf(stderr, "%s: Unknown reason %d", name_, reason);
  1236. break;
  1237. }
  1238. }
  1240. void HttpMInvalCache::process_data(int size, AppData* data)
  1241. {
  1242. if (data == NULL)
  1243. return;
  1245. switch (data->type()) {
  1246. case HTTP_INVALIDATION: {
  1247. // Update timer for the source of the heartbeat
  1248. HttpHbData *inv = (HttpHbData*)data;
  1249. recv_heartbeat(inv->id());
  1250. recv_inv(inv);
  1251. break;
  1252. }
  1253. case HTTP_UPDATE: {
  1254. // Replace all updated pages
  1255. HttpUpdateData *pg = (HttpUpdateData*)data;
  1256. recv_upd(pg);
  1257. break;
  1258. }
  1259. // JOIN messages are sent via TCP and direct TCL callback.
  1260. case HTTP_LEAVE: {
  1261. HttpLeaveData *l = (HttpLeaveData*)data;
  1262. recv_leave(l);
  1263. break;
  1264. }
  1265. default:
  1266. HttpApp::process_data(size, data);
  1267. return;
  1268. }
  1269. }
  1271. void HttpMInvalCache::add_inv(const char *name, double mtime)
  1272. {
  1273. InvalidationRec *p = get_invrec(name);
  1274. if ((p != NULL) && (p->mtime() < mtime)) {
  1275. p->detach();
  1276. delete p;
  1277. p = NULL;
  1278. num_inv_--;
  1279. } 
  1280. if (p == NULL) {
  1281. p = new InvalidationRec(name, mtime);
  1282. p->insert(&invlist_);
  1283. num_inv_++;
  1284. }
  1285. }
  1287. InvalidationRec* HttpMInvalCache::get_invrec(const char *name)
  1288. {
  1289. // XXX What should we do if we already have an
  1290. // invalidation record of this page in our 
  1291. // invlist_? --> We should replace it with the new one
  1292. InvalidationRec *r = invlist_;
  1293. for (r = invlist_; r != NULL; r = r->next())
  1294. if (strcmp(name, r->pg()) == 0)
  1295. return r;
  1296. return NULL;
  1297. }
  1299. HttpHbData* HttpMInvalCache::pack_heartbeat()
  1300. {
  1301. HttpHbData *data = new HttpHbData(id_, num_inv_);
  1302. InvalidationRec *p = invlist_, *q;
  1303. int i = 0;
  1304. while (p != NULL) {
  1305. data->add(i++, p);
  1306. // Clearing up invalidation sending list
  1307. if (!p->dec_scount()) {
  1308. // Each invalidation is sent to its children
  1309. // for at most HTTP_HBEXPIRE times. After that 
  1310. // the invalidation record is removed from 
  1311. // the list
  1312. q = p;
  1313. p = p->next();
  1314. q->detach();
  1315. delete q;
  1316. num_inv_--;
  1317. } else 
  1318. p = p->next();
  1319. }
  1320. return data;
  1321. }
  1323. int HttpMInvalCache::recv_inv(HttpHbData *data)
  1324. {
  1325. if (data->num_inv() == 0)
  1326. return 0;
  1328. InvalidationRec *head;
  1329. data->extract(head);
  1330. int old_inv = num_inv_;
  1331. process_inv(data->num_inv(), head, data->id());
  1332. //log("E GINV z %dn", data->size());
  1333. if (old_inv < num_inv_) 
  1334. // This invalidation is valid
  1335. return 1;
  1336. else 
  1337. return 0;
  1338. }
  1340. // Get an invalidation, check invalidation modtimes, then setup 
  1341. // invalidation forwarding entries
  1342. // The input invalidation record list is destroyed.
  1343. void HttpMInvalCache::process_inv(int, InvalidationRec *ivlist, int cache)
  1344. {
  1345. InvalidationRec *p = ivlist, *q, *r;
  1346. //int upd = 0;
  1347. while (p != NULL) {
  1348. ClientPage* pg = (ClientPage *)pool_->get_page(p->pg());
  1350. // XXX Establish server states. Server states only gets 
  1351. // established when we have a page (no matter if we have its
  1352. // content), and we have got an invalidation for the page. 
  1353. // Then we know we've got an invalidation contract for the 
  1354. // page.
  1355. if (pg != NULL) {
  1356. check_sstate(pg->server()->id(), cache);
  1357. // Count this invalidation no matter whether we're
  1358. // going to drop it. But if we doesn't get it 
  1359. // from our virtual parent, don't count it
  1360. SState *sst = lookup_sstate(pg->server()->id());
  1361. if (sst == NULL) {
  1362. // How come we doesn't know the server???
  1363. fprintf(stderr, 
  1364. "%s %d: couldn't find the server.n", 
  1365. __FILE__, __LINE__);
  1366. abort();
  1367. }
  1368. if ((sst->cache()->cache()->id() == cache) && 
  1369.     (pg->mtime() > p->mtime())) {
  1370. // Don't count repeated invalidations.
  1371. pg->count_inval(Ca_, push_low_bound_);
  1372. log("E NTF p %s v %dn",p->pg(),pg->counter());
  1373. }
  1374. }
  1376. // Hook for filters of derived classes
  1377. if (recv_inv_filter(pg, p) == HTTP_INVALCACHE_FILTERED) {
  1378. // If we do not have the page, or we have (or know 
  1379. // about) a newer page, ignore this invalidation 
  1380. // record and keep going.
  1381. //
  1382. // If we have this version of the page, and it's 
  1383. // already invalid, ignore this extra invalidation
  1384. q = p;
  1385. p = p->next();
  1386. q->detach();
  1387. delete q;
  1388. } else {
  1389. // Otherwise we invalidate our page and setup a 
  1390. // invalidation sending record for the page
  1391. pg->invalidate(p->mtime());
  1392. // Delete existing record for that page if any
  1393. q = get_invrec(p->pg());
  1394. if ((q != NULL) && (q->mtime() < p->mtime())) {
  1395. q->detach();
  1396. delete q;
  1397. q = NULL;
  1398. num_inv_--;
  1399. }
  1400. r = p; 
  1401. p = p->next();
  1402. r->detach();
  1403. // Insert it if necessary
  1404. if (q == NULL) {
  1405. r->insert(&invlist_);
  1406. num_inv_++;
  1407. // XXX
  1408. Tcl::instance().evalf("%s mark-invalid",name_);
  1409. log("E GINV p %s m %.17gn", r->pg(), r->mtime());
  1410. } else
  1411. delete r;
  1412. }
  1413. }
  1414. }
  1416. void HttpMInvalCache::send_hb_helper(int size, AppData *data)
  1417. {
  1418. if (inv_parent_ != NULL) 
  1419. inv_parent_->send(size, data->copy());
  1420. for (int i = 0; i < num_sender_; i++)
  1421. inv_sender_[i]->send(size, data->copy());
  1422. }
  1424. void HttpMInvalCache::send_heartbeat()
  1425. {
  1426. if ((num_sender_ == 0) && (inv_parent_ == NULL))
  1427. return;
  1429. HttpHbData* d = pack_heartbeat();
  1430. send_hb_helper(d->cost(), d);
  1431. delete d;
  1432. }
  1434. int HttpMInvalCache::recv_upd(HttpUpdateData *d)
  1435. {
  1436. if (d->num() != 1) {
  1437. fprintf(stderr, 
  1438. "%d gets an update which contain !=1 pages.n", id_);
  1439. abort();
  1440. }
  1442. ClientPage *pg = pool_->get_page(d->rec_page(0));
  1443. if (pg != NULL) 
  1444. if (pg->mtime() >= d->rec_mtime(0)) {
  1445. // If we've already had this version, or a newer 
  1446. // version, ignore this old push
  1447. // fprintf(stderr, "[%g] %d gets an old pushn", 
  1448. //  Scheduler::instance().clock(), id_);
  1449. // log("E OLD m %g p %gn", d->rec_mtime(0), pg->mtime());
  1450. return 0;
  1451. } else {
  1452. // Our old page is invalidated by this new push,
  1453. // set up invalidation records for our children
  1454. add_inv(d->rec_page(0), d->rec_mtime(0));
  1455. pg->count_inval(Ca_, push_low_bound_);
  1456. log("E NTF p %s v %dn", d->rec_page(0),pg->counter());
  1457. }
  1459. // Add the new page into our pool
  1460. ClientPage *q = pool_->enter_page(d->rec_page(0), d->rec_size(0), 
  1461.   d->rec_mtime(0),
  1462.   Scheduler::instance().clock(),
  1463.   d->rec_age(0));
  1464. // By default the page is valid and read. Set it as unread
  1465. q->set_unread();
  1467. log("E GUPD m %.17g z %dn", d->rec_mtime(0), d->pgsize());
  1468. Tcl::instance().evalf("%s mark-valid", name_);
  1470. // XXX If the page was previously marked as MandatoryPush, then
  1471. // we need to check if it's timed out
  1472. if (q->is_mpush() && (Scheduler::instance().clock() - q->mpush_time()
  1473.       > HTTP_HBEXPIRE_COUNT*hb_interval_)) {
  1474. // If mandatory push timer expires, stop push
  1475. q->clear_mpush();
  1476. Tcl::instance().evalf("%s cancel-mpush-refresh %s", 
  1477.       name_, d->rec_page(0));
  1478. }
  1480. if (enable_upd_ && (q->counter() >= push_thresh_) || q->is_mpush())
  1481. // XXX Continue pushing if we either select to push, or 
  1482. // were instructed to do so.
  1483. return 1;
  1484. else 
  1485. return 0;
  1486. }
  1488. HttpUpdateData* HttpMInvalCache::pack_upd(ClientPage* page)
  1489. {
  1490. HttpUpdateData *data = new HttpUpdateData(id_, 1);
  1491. data->add(0, page);
  1492. return data;
  1493. }
  1495. void HttpMInvalCache::send_upd_helper(int pgsize, AppData* data)
  1496. {
  1497. for (int i = 0; i < num_updater_; i++)
  1498. upd_sender_[i]->send(pgsize, data->copy());
  1499. }
  1501. void HttpMInvalCache::send_upd(ClientPage *page)
  1502. {
  1503. if ((num_updater_ == 0) || !enable_upd_) 
  1504. return;
  1506. HttpUpdateData* d = pack_upd(page);
  1507. send_upd_helper(d->pgsize(), d);
  1508. delete d;
  1509. }
  1512. //----------------------------------------------------------------------
  1513. // Multicast invalidation + two way liveness messages + 
  1514. // invalidation filtering. 
  1515. //----------------------------------------------------------------------
  1516. static class HttpPercInvalCacheClass : public TclClass {
  1517. public:
  1518.         HttpPercInvalCacheClass() : TclClass("Http/Cache/Inval/Mcast/Perc") {}
  1519.         TclObject* create(int, const char*const*) {
  1520. return (new HttpPercInvalCache());
  1521. }
  1522. } class_HttpPercInvalCache_app;
  1524. HttpPercInvalCache::HttpPercInvalCache() 
  1525. {
  1526. bind("direct_request_", &direct_request_);
  1527. }
  1529. int HttpPercInvalCache::command(int argc, const char*const* argv)
  1530. {
  1531. Tcl& tcl = Tcl::instance();
  1533. if (strcmp(argv[1], "is-header-valid") == 0) {
  1534. ClientPage *pg = 
  1535. (ClientPage *)pool_->get_page(argv[2]);
  1536. if (pg == NULL) {
  1537. tcl.resultf("%d is-valid: No page %s", 
  1538.     id_, argv[2]);
  1539. return TCL_ERROR;
  1540. }
  1541. tcl.resultf("%d", pg->is_header_valid());
  1542. return TCL_OK;
  1543. } else if (strcmp(argv[1], "enter-metadata") == 0) {
  1544. /* 
  1545.  * <cache> enter-metadata <args...>
  1546.  * The same arguments as enter-page, but set the page status
  1547.  * as HTTP_VALID_HEADER, i.e., if we get a request, we need 
  1548.  * to fetch the actual valid page content
  1549.  */
  1550. ClientPage *pg = pool_->enter_metadata(argc, argv);
  1551. if (pg == NULL)
  1552. return TCL_ERROR;
  1553. else
  1554. return TCL_OK;
  1555. }
  1557. return HttpMInvalCache::command(argc, argv);
  1558. }