}
-void CDir::dump_to_disk()
+void CDir::dump_to_disk(MDS *mds)
{
map<string,CDentry*>::iterator iter = items.begin();
while (iter != items.end()) {
CDentry* d = iter->second;
char isdir = ' ';
if (d->inode->dir != NULL) isdir = '/';
- cout << "dump2disk: " << d->inode->inode.ino << " " << d->name << isdir << endl;
- d->inode->dump_to_disk();
+ //cout << "dump2disk: " << d->inode->inode.ino << " " << d->name << isdir << endl;
+ d->inode->dump_to_disk(mds);
iter++;
}
- g_mds->mdstore->commit_dir(inode, NULL);
-
+ mds->mdstore->commit_dir(inode, NULL);
}
dir->dump(dep);
}
-void CInode::dump_to_disk()
+void CInode::dump_to_disk(MDS *mds)
{
if (dir)
- dir->dump_to_disk();
+ dir->dump_to_disk(mds);
}
#include "include/MDCache.h"
#include "include/MDStore.h"
+#include "messages/MPing.h"
+
#include <iostream>
using namespace std;
// extern
-MDS *g_mds;
+//MDS *g_mds;
// cons/des
num_nodes = num;
mdcache = new DentryCache();
- mdstore = new MDStore();
+ mdstore = new MDStore(this);
messenger = m;
}
MDS::~MDS() {
int MDS::init()
{
- messenger->init(nodeid);
+ messenger->init(this);
}
void MDS::shutdown()
void MDS::proc_message(Message *m)
{
- cout << "implement MDS::proc_message" << endl;
+ switch (m->get_type()) {
+ case MSG_PING:
+ cout << nodeid << " received ping from " << m->get_from() << " with count " << ((MPing*)m)->num << endl;
+ if (((MPing*)m)->num > 0) {
+ cout << nodeid << " responding to " << m->get_from() << endl;
+ messenger->send_message(new MPing(((MPing*)m)->num-1), m->get_from());
+ }
+ break;
+
+ default:
+ cout << "implement MDS::proc_message" << endl;
+ }
+
}
class OpenRootContext : public Context {
protected:
Context *c;
+ MDS *mds;
public:
- OpenRootContext(Context *c) {
+ OpenRootContext(MDS *m, Context *c) {
+ mds = m;
this->c = c;
}
void finish(int result) {
- g_mds->open_root_2(result, c);
+ mds->open_root_2(result, c);
}
};
// inode
inodeno_t ino = ((struct inode_t*)(buf+p+1))->ino;
- if (g_mds->mdcache->have_inode(ino))
+ if (mds->mdcache->have_inode(ino))
throw "inode already exists! uh oh\n";
// new inode
p += sizeof(inode_t);
// add and link
- g_mds->mdcache->add_inode( in );
- g_mds->mdcache->link_inode( dir, dname, in );
+ mds->mdcache->add_inode( in );
+ mds->mdcache->link_inode( dir, dname, in );
}
}
class CInode;
class CDentry;
+class MDS;
// CDir
typedef map<string, CDentry*> CDir_map_t;
CDentry* lookup(string n);
void dump(int d = 0);
- void dump_to_disk();
+ void dump_to_disk(MDS *m);
};
class CDentry;
class CDir;
+class MDS;
// cached inode wrapper
class CInode : LRUObject {
// dbg
void dump(int d = 0);
- void dump_to_disk();
+ void dump_to_disk(MDS *m);
};
#include "CDir.h"
+class MDS;
+
// DCache
typedef hash_map<inodeno_t, CInode*> inode_map_t;
if (root) root->dump();
}
- void dump_to_disk() {
- if (root) root->dump_to_disk();
+ void dump_to_disk(MDS *m) {
+ if (root) root->dump_to_disk(m);
}
};
MDS(int id, int num, Messenger *m);
~MDS();
+ int get_nodeid() {
+ return nodeid;
+ }
+
int init();
void shutdown();
};
-extern MDS *g_mds;
+//extern MDS *g_mds;
#endif
#include "Context.h"
#include "Message.h"
+class MDS;
+
class MDStore {
protected:
-
+ MDS *mds;
public:
- MDStore() { }
- ~MDStore() { }
+ MDStore(MDS *m) {
+ mds = m;
+ }
// i/o
/*
--- /dev/null
+
+#ifndef __MPING_H
+#define __MPING_H
+
+#include "../include/Message.h"
+
+class MPing : public Message {
+ public:
+ int num;
+ MPing(int n) {
+ num = n;
+ subsys = MSG_SUBSYS_SERVER;
+ type = MSG_PING;
+ }
+};
+
+#endif
#include "include/FakeMessenger.h"
+#include "include/mds.h"
#include <map>
#include <ext/hash_map>
}
-int FakeMessenger::init(int whoami)
+int FakeMessenger::init(MDS *mds)
{
- this->whoami = whoami;
+ mymds = mds;
+ whoami = mds->get_nodeid();
directory[ whoami ] = this;
}
directory.erase(whoami);
}
-bool FakeMessenger::send_message(Message *m)
+bool FakeMessenger::send_message(Message *m, int dest)
{
- int d = m->destination();
+ m->set_from(whoami);
try {
- FakeMessenger *dm = directory[d];
+ FakeMessenger *dm = directory[dest];
dm->queue_incoming(m);
}
catch (...) {
- cout << "no destination " << d << endl;
+ cout << "no destination " << dest << endl;
}
}
#include <map>
class FakeMessenger : public Messenger {
+ protected:
int whoami;
public:
FakeMessenger();
- virtual int init(int whoami);
+ virtual int init(MDS *m);
virtual int shutdown();
- virtual bool send_message(Message *m);
+ virtual bool send_message(Message *m, int dest);
virtual int wait_message(time_t seconds);
virtual int loop();
unsigned long serial_len;
int type;
int subsys;
- int dest;
+
+ int from, dest;
public:
Message() {
int destination() {
return dest;
}
+ int get_from() {
+ return from;
+ }
+ int set_from(int f) {
+ from = f;
+ return f;
+ }
// serialization
- virtual unsigned long serialize() = 0;
+ virtual unsigned long serialize() { } // = 0;
void *get_serialized() {
return serialized;
}
switch (m->get_subsys()) {
case MSG_SUBSYS_MDSTORE:
- g_mds->mdstore->proc_message(m);
+ mymds->mdstore->proc_message(m);
break;
/*
case MSG_SUBSYS_MDLOG:
- g_mds->logger->proc_message(m);
+ mymds->logger->proc_message(m);
break;
case MSG_SUBSYS_BALANCER:
- g_mds->balancer->proc_message(m);
+ mymds->balancer->proc_message(m);
break;
*/
case MSG_SUBSYS_SERVER:
- g_mds->proc_message(m);
+ mymds->proc_message(m);
break;
}
}
#include "Message.h"
+class MDS;
class Messenger {
protected:
list<Message*> incoming;
+ MDS *mymds;
public:
Messenger() {}
~Messenger() {}
// ...
- virtual int init(int whoami) = 0;
+ virtual int init(MDS *m) = 0;
virtual int shutdown() = 0;
- virtual bool send_message(Message *m) = 0;
+ virtual bool send_message(Message *m, int dest) = 0;
virtual int wait_message(time_t seconds) = 0;
virtual int loop() {
#include "include/MDStore.h"
#include "include/FakeMessenger.h"
+#include "messages/MPing.h"
+
using namespace std;
__uint64_t ino = 1;
cout << "hi there" << endl;
// init
- g_mds = new MDS(0, 1, new FakeMessenger());
- g_mds->open_root(NULL);
+ MDS *mds1 = new MDS(0, 2, new FakeMessenger());
+ mds1->open_root(NULL);
+ mds1->init();
- g_mds->mdstore->fetch_dir( g_mds->mdcache->get_root(), NULL );
+ mds1->mdstore->fetch_dir( mds1->mdcache->get_root(), NULL );
+
+ MDS *mds2 = new MDS(1,2,new FakeMessenger());
+ mds2->init();
// send an initial message...?
+ mds1->messenger->send_message(new MPing(10), 1);
// loop
fakemessenger_do_loop();
// cleanup
- if (g_mds->mdcache->clear()) {
+ if (mds1->mdcache->clear()) {
cout << "clean shutdown" << endl;
- g_mds->mdcache->dump();
- delete g_mds;
+ mds1->mdcache->dump();
+ delete mds1;
} else {
cout << "can't empty cache";
}