C++ Slave类代码示例

void* RTSPServer::clientAcceptLoop(void *arg) {
    if (pthread_detach(pthread_self())) {
        perror("ERROR on pthread_detach");
        return NULL;
    }

    RTSPServer *server = (RTSPServer*)arg;
    while (true) {
        sockaddr_in sa_cli;
        socklen_t cli_addr_len = sizeof(sa_cli);
        int connfd = accept(server->sfd, (sockaddr*)&sa_cli, &cli_addr_len);
        if (connfd < 0) {
            perror("ERROR on slave accept");
            return NULL;
        }

        char clientIP[16];
        inet_ntop(AF_INET, &sa_cli.sin_addr.s_addr, clientIP, sizeof(clientIP));
        printf("slave %s:%d connected\n", clientIP, ntohs(sa_cli.sin_port));

        Slave *slave = new Slave(connfd);
        slave->setIPandPort(clientIP, ntohs(sa_cli.sin_port));
        server->addSlave(connfd, slave);

        pthread_t thread;
        if (pthread_create(&thread, NULL, clientLoop, slave)) {
            perror("ERROR on pthread_create clientLoop");
            delete slave;
            server->delSlave(connfd);
            return NULL;
        }
    }

    return NULL;
}

void FetchAndStoreAndExpungeAndExpunge(State* state)
{
  Future<Variable<Slaves> > future1 = state->fetch<Slaves>("slaves");
  AWAIT_READY(future1);

  Variable<Slaves> variable = future1.get();

  Slaves slaves1 = variable.get();
  ASSERT_EQ(0, slaves1.slaves().size());

  Slave* slave = slaves1.add_slaves();
  slave->mutable_info()->set_hostname("localhost");

  variable = variable.mutate(slaves1);

  Future<Option<Variable<Slaves> > > future2 = state->store(variable);
  AWAIT_READY(future2);
  ASSERT_SOME(future2.get());

  variable = future2.get().get();

  Future<bool> future3 = state->expunge(variable);
  AWAIT_READY(future3);
  ASSERT_TRUE(future3.get());

  future3 = state->expunge(variable);
  AWAIT_READY(future3);
  ASSERT_FALSE(future3.get());
}

void Master::addSlave(Machine slaveToAdd){
	//Slave p = new Slave(slaveToAdd);
						//cout<<"HERERERERERE"<<endl;
	Slave newSlaveToAdd;
	newSlaveToAdd.setMachineID(slaveToAdd.getMachineID());
	newSlaveToAdd.setMachineIP(slaveToAdd.getMachineIP());
	newSlaveToAdd.setMachineStatus(slaveToAdd.getMachineStatus());
	newSlaveToAdd.setMachineType(slaveToAdd.getMachineType());
	if(slaveCount != 0){
		Slave temp[slaveCount];
		for(int i = 0; i < slaveCount; i++){
			temp[i] = masterSlaves[i];
		}
		masterSlaves = new Slave[slaveCount+1];
		for(int j = 0; j < slaveCount; j++){
			masterSlaves[j] = temp[j];
		}
		masterSlaves[slaveCount] = newSlaveToAdd;
	}
	else{
		//cout<<"dont have"<<endl;
		masterSlaves = new Slave[slaveCount+1];
		masterSlaves[slaveCount] = newSlaveToAdd;
	}
	//masterSlaves[slaveCount] = slaveToAdd;
	slaveCount++;
	//cout<<"leaving"<<endl;
}

int main(int argc, char** argv) {

    parse_args(argc, argv);

    MPI_Init(&argc, &argv);
    MPI_Comm_rank(MPI_COMM_WORLD, &RANK);
    MPI_Comm_size(MPI_COMM_WORLD, &WORLD_SIZE);

    if (RANK == 0) {

        printf("* width: %u\n", WIDTH);
        printf("* height: %u\n", HEIGHT);
        printf("* depth: %u\n", DEPTH);
        printf("\n");

        comm = new CommunicatorMaster(WORLD_SIZE - 1);
        game();
        delete comm;

    } else {

        Slave slave;
        slave.run();
    }

    MPI_Finalize();

    return 0;
}

void FetchAndStoreAndFetch(State* state)
{
  Future<Variable<Slaves> > future1 = state->fetch<Slaves>("slaves");
  AWAIT_READY(future1);

  Variable<Slaves> variable = future1.get();

  Slaves slaves1 = variable.get();
  ASSERT_EQ(0, slaves1.slaves().size());

  Slave* slave = slaves1.add_slaves();
  slave->mutable_info()->set_hostname("localhost");

  variable = variable.mutate(slaves1);

  Future<Option<Variable<Slaves> > > future2 = state->store(variable);
  AWAIT_READY(future2);
  ASSERT_SOME(future2.get());

  future1 = state->fetch<Slaves>("slaves");
  AWAIT_READY(future1);

  variable = future1.get();

  Slaves slaves2 = variable.get();
  ASSERT_EQ(1, slaves2.slaves().size());
  EXPECT_EQ("localhost", slaves2.slaves(0).info().hostname());
}

int main(int argc, char** argv)
{
   cout << SectorVersionString << endl;

   SlaveConf global_conf;

   CmdLineParser clp;
   clp.parse(argc, argv);

   for (map<string, string>::const_iterator i = clp.m_mDFlags.begin(); i != clp.m_mDFlags.end(); ++ i)
   {
      if (i->first == "mh")
         global_conf.m_strMasterHost = i->second;
      else if (i->first == "mp")
         global_conf.m_iMasterPort = atoi(i->second.c_str());
      else if (i->first == "h")
      {
         global_conf.m_strHomeDir = i->second;
      }
      else if (i->first == "ds")
         global_conf.m_llMaxDataSize = atoll(i->second.c_str()) * 1024 * 1024;
      else if (i->first == "log")
         global_conf.m_iLogLevel = atoi(i->second.c_str());
      else
      {
         cout << "warning: unrecognized flag " << i->first << endl;
         help();
      }
   }

   string base = "";
   if (clp.m_vParams.size() == 1)
      base = clp.m_vParams.front();
   else if (clp.m_vParams.size() > 1)
      cout << "warning: wrong parameters ignored.\n";

   Slave s;

   if (s.init(&base, &global_conf) < 0)
   {
      cout << "error: failed to initialize the slave. check slave configurations.\n";
      return-1;
   }

   if (s.connect() < 0)
   {
      cout << "error: failed to connect to the master, or the connection request is rejected.\n";
      return -1;
   }

   s.run();

   s.close();

   return 0;
}

Slave* Slave::holdSlave( const QString &protocol, const KURL& url )
{
    //kdDebug(7002) << "holdSlave '" << protocol << "' for " << url.prettyURL() << endl;
    // Firstly take into account all special slaves
    if (protocol == "data")
        return 0;

    DCOPClient *client = kapp->dcopClient();
    if (!client->isAttached())
	client->attach();

    QString prefix = locateLocal("socket", KGlobal::instance()->instanceName());
    KTempFile socketfile(prefix, QString::fromLatin1(".slave-socket"));
    if ( socketfile.status() != 0 )
	return 0;

#ifdef __CYGWIN__
   socketfile.close();
   socketfile.unlink();
#endif

#ifndef Q_WS_WIN
    KServerSocket *kss = new KServerSocket(QFile::encodeName(socketfile.name()));

    Slave *slave = new Slave(kss, protocol, socketfile.name());
#else
    Slave *slave = 0;
#endif

    QByteArray params, reply;
    QCString replyType;
    QDataStream stream(params, IO_WriteOnly);
    stream << url << socketfile.name();

    QCString launcher = KApplication::launcher();
    if (!client->call(launcher, launcher, "requestHoldSlave(KURL,QString)",
        params, replyType, reply)) {
        delete slave;
        return 0;
    }
    QDataStream stream2(reply, IO_ReadOnly);
    pid_t pid;
    stream2 >> pid;
    if (!pid)
    {
        delete slave;
        return 0;
    }
#ifndef Q_WS_WIN
    slave->setPID(pid);
    QTimer::singleShot(1000*SLAVE_CONNECTION_TIMEOUT_MIN, slave, SLOT(timeout()));
#endif
    return slave;
}

// Listing 0 code/ch10
int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
  if (argc > 1)   // Slave mode
    {
      Slave s;
      return s.doWork ();
    }

  // Else, Master mode
  Manager m (argv[0]);
  return m.doWork ();
}

 void Slave::LoadRDBRoutine(void* cb)
 {
     Slave* slave = (Slave*) cb;
     if (NULL != slave->m_client)
     {
         slave->m_client->GetService().Continue();
     }
     if (time(NULL) - slave->m_routine_ts > 10)
     {
         slave->Routine();
     }
 }

SSDBServer::~SSDBServer(){
	std::vector<Slave *>::iterator it;
	for(it = slaves.begin(); it != slaves.end(); it++){
		Slave *slave = *it;
		slave->stop();
		delete slave;
	}

	delete backend_dump;
	delete backend_sync;
	delete expiration;
	delete cluster;

	log_debug("SSDBServer finalized");
}

int main(int argc, char** argv)
{
   Slave s;

   int res;

   if (argc > 1)
      res = s.init(argv[1]);
   else
      res = s.init();

   if (res < 0)
      return -1;

   if (s.connect() < 0)
      return -1;

   s.run();

   return 1;
}

SSDB::~SSDB(){
	for(std::vector<Slave *>::iterator it = slaves.begin(); it != slaves.end(); it++){
		Slave *slave = *it;
		slave->stop();
		delete slave;
	}
	if(binlogs){
		delete binlogs;
	}
	if(db){
		delete db;
	}
	if(options.block_cache){
		delete options.block_cache;
	}
	if(options.filter_policy){
		delete options.filter_policy;
	}
	if(meta_db){
		delete meta_db;
	}
	log_debug("SSDB finalized");
}

void Names(State* state)
{
  Future<Variable<Slaves> > future1 = state->fetch<Slaves>("slaves");
  AWAIT_READY(future1);

  Variable<Slaves> variable = future1.get();

  Slaves slaves1 = variable.get();
  ASSERT_EQ(0, slaves1.slaves().size());

  Slave* slave = slaves1.add_slaves();
  slave->mutable_info()->set_hostname("localhost");

  variable = variable.mutate(slaves1);

  Future<Option<Variable<Slaves> > > future2 = state->store(variable);
  AWAIT_READY(future2);
  ASSERT_SOME(future2.get());

  Future<set<string> > names = state->names();
  AWAIT_READY(names);
  ASSERT_EQ(1u, names.get().size());
  EXPECT_NE(names.get().find("slaves"), names.get().end());
}

TEST_F(LogStateTest, Timeout)
{
  Clock::pause();

  Future<Variable<Slaves> > future1 = state->fetch<Slaves>("slaves");
  AWAIT_READY(future1);

  Variable<Slaves> variable = future1.get();

  Slaves slaves1 = variable.get();
  ASSERT_EQ(0, slaves1.slaves().size());

  Slave* slave = slaves1.add_slaves();
  slave->mutable_info()->set_hostname("localhost");

  variable = variable.mutate(slaves1);

  // Now terminate the replica so the store will timeout.
  terminate(replica2->pid());
  wait(replica2->pid());

  Future<Option<Variable<Slaves> > > future2 = state->store(variable);

  Future<Option<Variable<Slaves> > > future3 =
    future2.after(Seconds(5), lambda::bind(&timeout, lambda::_1));

  ASSERT_TRUE(future2.isPending());
  ASSERT_TRUE(future3.isPending());

  Clock::advance(Seconds(5));

  AWAIT_DISCARDED(future2);
  AWAIT_FAILED(future3);

  Clock::resume();
}

int proc_info(NetworkServer *net, Link *link, const Request &req,
    Response *resp){
    Slave *slave = (Slave *)net->data;

    resp->push_back("ok");
    resp->push_back("info");
    resp->push_back(slave->name());
    resp->push_back("links");
    resp->add(net->link_count);

    int64_t calls = 0;
    for(proc_map_t::iterator it = net->proc_map.begin();
        it != net->proc_map.end(); it++){
        Command *cmd = it->second;
        calls += cmd->calls;
    }
    resp->push_back("total_calls");
    resp->add(calls);

    resp->push_back("master");
    resp->push_back(slave->master->name());

    return 0;
}