//
// Main Routine
//
int main(void) {
#ifdef DEBUG
	CSerial ser;		// declare a Serial object
	ser.enable();
	CDebug dbg(ser);	// Debug stream use the UART object
	dbg.start();
#endif

	//
	// SoftDevice
	//
	bleDevice ble;
	ble.enable();	// enable BLE SoftDevice stack

	// GAP
	ble.m_gap.settings(DEVICE_NAME, 10, 50);	// set Device Name on GAP, conn. interval min=10ms, max=50ms
	ble.m_gap.tx_power(BLE_TX_0dBm);			// set Output power

	//
	// Add BLE UART Service
	//
	bleServiceUART nus(ble);	// declare a BLE "Nordic UART Service" (NUS) object

	//
	// Add "connection parameters update" negotiation. (optional)
	//
	bleConnParams conn(ble);

	//
	// BLE Advertising
	//
	ble.m_advertising.commpany_identifier(APP_COMPANY_IDENTIFIER);// add company identifier
	ble.m_advertising.update();						// update advertising data

	// Start advertising
	ble.m_advertising.interval(APP_ADV_INTERVAL);	// set advertising interval
	ble.m_advertising.start();

	//
	// my command parse class
	//
	cmdParse cmd;

	//
	// LED output enable
	//
	ledLeft.output();	// set ledLeft as an output pin
	ledRight.output();	// set ledRight as an output pin
	uint8_t ch= 0;

	//
	// Enable Tickless Technology
	//
#ifndef DEBUG
	CPowerSave::tickless(true);
#endif

	//
	// Enter main loop.
	//
	while (1) {
		//
		// Uart Service
		//
		if ( ble.isConnected() ) {
			// block in the read() to wait a char.
			// Also, block task will save the power when tickless enabled.
			while ( nus.readable() ) {
				ch = nus.read();
				if ( ch ) {
					cmd.input(ch);
				}
			}
		} else {
			//
			// alternate led when disconnected (idle)
			//
			ch = (ch ? 0 : 1);
			ledRight = (ch ? LED_ON : LED_OFF);
			ledLeft = (ch ? LED_OFF : LED_ON);
			sleep(10);	// blink a short time (10ms)

			ledRight = LED_OFF;
			ledLeft = LED_OFF;
			sleep(990);	// save power with a long time sleep (990ms)
		}

		// Negotiate the "Connect Parameters Update"
		conn.negotiate();
	}
}

int conn(void)
{
	int syserr = -1;
	int sock = -1;

	sock = socket(AF_INET, SOCK_STREAM, 0);
	if (sock == -1)
	{
		perror("socket");
		goto EXIT_LABEL;
	}

	//u_short port = (time(NULL) % 2) + PORTNO;
	u_short port = PORTNO;

	struct sockaddr_in addr =
	{
		.sin_family=AF_INET,
		.sin_port=htons(port),
		.sin_addr.s_addr=inet_addr("10.96.157.84"),
	};

//fprintf(stderr, "connect to port=%u\n", port);

	syserr = connect(sock, &addr, sizeof addr);
	if (syserr == -1)
	{
		perror("connect");
		goto EXIT_LABEL;
	}

	syserr = 0;

EXIT_LABEL:

	if (syserr)
	{
		close(sock);
		sock = -1;
	}

	return sock;
}

int send_data(int loop, int start, const char* wstr)
{
	int syserr = -1;
	int sock = -1;
	char* rstr = NULL;

	const size_t wstr_len = strlen(wstr);

//fprintf(stderr, "wstr=[%s]\n", wstr);

	sock = conn();
	if (sock == -1)
	{
		goto EXIT_LABEL;
	}

	struct AppHeader_st header = { .type=1, .version=95, .payload_len=wstr_len, };

//fprintf(stderr, "sizeof(header) = %zu\n", sizeof(header));

	const size_t hdrlen = sizeof(header);
	ssize_t nw = write(sock, &header, hdrlen);

	if (nw != (ssize_t)hdrlen)
	{
		perror("write header");
		goto EXIT_LABEL;
	}

//fprintf(stderr, "write header success\n");

	nw = write(sock, wstr, wstr_len);
	if (nw != (ssize_t)wstr_len)
	{
		perror("write payload");
		goto EXIT_LABEL;
	}

//fprintf(stderr, "write payload success\n");

	ssize_t nr = read(sock, &header, sizeof(header));

//fprintf(stderr, "nr=%zu\n", nr);

	if (nr != (ssize_t)hdrlen)
	{
		perror("read header");
		goto EXIT_LABEL;
	}

//fprintf(stderr, "read header success\n");

//fprintf(stderr, "payload len=%zu\n", header.payload_len);

	if (header.payload_len != wstr_len)
	{
//.........这里部分代码省略.........

void radiosity_lightmap::generate(world_lightmap_access& data,
                                       const chunk_coordinates& pos,
                                       const surface& s, lightmap_hr &lightchunk,
                                       unsigned int phase) const
{
    std::array<float, 6> irr_sun, irr_ambient, irr_artificial;
    vector half {0.5f, 0.5f, 0.5f};
    auto lmi = std::begin(lightchunk);
    for (const faces& f : s)
    {
        fill(irr_sun, 0.f);
        fill(irr_ambient, 0.f);
        fill(irr_artificial, 0.f);

        auto surr (surroundings(f.pos, phase + 1));
        for (auto sp : surr)
        {
            if (sp == f.pos)
                continue;

            auto found (find(s, sp));
            if (found == s.end())
                continue;

            auto& other (*found);
            for (int i = 0; i < 6; ++i)
            {
                if (!f[i])
                    continue;

                vector this_face (half + f.pos + vector(dir_vector[i]) * 0.52f);
                for (int j = 0; j < 6; ++j)
                {
                    if (i == j || !other[j])
                        continue;

                    vector that_face (half + other.pos + vector(dir_vector[j])* 0.52f);
                    vector conn (that_face - this_face);
                    vector norm_conn (normalize(conn));
                    float dp1 (dot_prod<vector>(dir_vector[j], -norm_conn));
                    if (dp1 <= 0)
                        continue;

                    float dp2 = dot_prod<vector>(dir_vector[i], norm_conn);
                    if (dp2 <= 0)
                        continue;

                    float intensity = dp1 * dp2 / squared_length(conn);

                    auto dist = std::distance(std::begin(s), found);
                    auto& olm = lightchunk.data[dist];

                    irr_sun[i] += olm.sunlight * intensity;
                    irr_ambient[i] += olm.ambient * intensity;
                    irr_artificial[i] += olm.artificial * intensity;
                }
            }
        }

        for (int i (0); i < 6; ++i)
        {
            if (!f[i])
                continue;

            lmi->r_sunlight = irr_sun[i] * 255.f + 0.49f;
            lmi->r_ambient = irr_ambient[i] * 255.f + 0.49f;
            lmi->r_artificial = irr_artificial[i] * 255.f + 0.49f;

            ++lmi;
        }
    }
}

//.........这里部分代码省略.........
                        namespaces.executionNss.ns(),
                        shardQuery,
                        request.getValue().getCollation(),
                        &shardResults);

    if (mergeCtx->isExplain) {
        // This must be checked before we start modifying result.
        uassertAllShardsSupportExplain(shardResults);

        if (needSplit) {
            *result << "needsPrimaryShardMerger" << needPrimaryShardMerger << "splitPipeline"
                    << DOC("shardsPart" << shardPipeline->writeExplainOps() << "mergerPart"
                                        << pipeline.getValue()->writeExplainOps());
        } else {
            *result << "splitPipeline" << BSONNULL;
        }

        BSONObjBuilder shardExplains(result->subobjStart("shards"));
        for (size_t i = 0; i < shardResults.size(); i++) {
            shardExplains.append(shardResults[i].shardTargetId,
                                 BSON("host" << shardResults[i].target.toString() << "stages"
                                             << shardResults[i].result["stages"]));
        }

        return Status::OK();
    }

    if (!needSplit) {
        invariant(shardResults.size() == 1);
        invariant(shardResults[0].target.getServers().size() == 1);
        auto executorPool = Grid::get(txn)->getExecutorPool();
        const BSONObj reply =
            uassertStatusOK(storePossibleCursor(shardResults[0].target.getServers()[0],
                                                shardResults[0].result,
                                                namespaces.requestedNss,
                                                executorPool->getArbitraryExecutor(),
                                                Grid::get(txn)->getCursorManager()));
        result->appendElements(reply);
        return getStatusFromCommandResult(reply);
    }

    pipeline.getValue()->addInitialSource(
        DocumentSourceMergeCursors::create(parseCursors(shardResults), mergeCtx));

    MutableDocument mergeCmd(request.getValue().serializeToCommandObj());
    mergeCmd["pipeline"] = Value(pipeline.getValue()->serialize());
    mergeCmd["cursor"] = Value(cmdObj["cursor"]);

    if (cmdObj.hasField("$queryOptions")) {
        mergeCmd["$queryOptions"] = Value(cmdObj["$queryOptions"]);
    }

    if (cmdObj.hasField(QueryRequest::cmdOptionMaxTimeMS)) {
        mergeCmd[QueryRequest::cmdOptionMaxTimeMS] =
            Value(cmdObj[QueryRequest::cmdOptionMaxTimeMS]);
    }

    mergeCmd.setField("writeConcern", Value(cmdObj["writeConcern"]));
    mergeCmd.setField("readConcern", Value(cmdObj["readConcern"]));

    // If the user didn't specify a collation already, make sure there's a collation attached to
    // the merge command, since the merging shard may not have the collection metadata.
    if (mergeCmd.peek()["collation"].missing()) {
        mergeCmd.setField("collation",
                          mergeCtx->getCollator()
                              ? Value(mergeCtx->getCollator()->getSpec().toBSON())
                              : Value(Document{CollationSpec::kSimpleSpec}));
    }

    std::string outputNsOrEmpty;
    if (DocumentSourceOut* out =
            dynamic_cast<DocumentSourceOut*>(pipeline.getValue()->getSources().back().get())) {
        outputNsOrEmpty = out->getOutputNs().ns();
    }

    // Run merging command on random shard, unless a stage needs the primary shard. Need to use
    // ShardConnection so that the merging mongod is sent the config servers on connection init.
    auto& prng = txn->getClient()->getPrng();
    const auto& mergingShardId =
        (needPrimaryShardMerger || internalQueryAlwaysMergeOnPrimaryShard.load())
        ? conf->getPrimaryId()
        : shardResults[prng.nextInt32(shardResults.size())].shardTargetId;
    const auto mergingShard =
        uassertStatusOK(Grid::get(txn)->shardRegistry()->getShard(txn, mergingShardId));

    ShardConnection conn(mergingShard->getConnString(), outputNsOrEmpty);
    BSONObj mergedResults =
        aggRunCommand(txn, conn.get(), namespaces, mergeCmd.freeze().toBson(), options);
    conn.done();

    if (auto wcErrorElem = mergedResults["writeConcernError"]) {
        appendWriteConcernErrorToCmdResponse(mergingShardId, wcErrorElem, *result);
    }

    // Copy output from merging (primary) shard to the output object from our command.
    // Also, propagates errmsg and code if ok == false.
    result->appendElementsUnique(mergedResults);

    return getStatusFromCommandResult(result->asTempObj());
}

 void appendReplicationInfo(BSONObjBuilder& result, int level) {
     if ( replSet ) {
         if( theReplSet == 0 || theReplSet->state().shunned() ) {
             result.append("ismaster", false);
             result.append("secondary", false);
             result.append("info", ReplSet::startupStatusMsg.get());
             result.append( "isreplicaset" , true );
         }
         else {
             theReplSet->fillIsMaster(result);
         }
         return;
     }
     
     if ( replAllDead ) {
         result.append("ismaster", 0);
         string s = string("dead: ") + replAllDead;
         result.append("info", s);
     }
     else {
         result.appendBool("ismaster", _isMaster() );
     }
     
     if ( level && replSet ) {
         result.append( "info" , "is replica set" );
     }
     else if ( level ) {
         BSONObjBuilder sources( result.subarrayStart( "sources" ) );
         
         int n = 0;
         list<BSONObj> src;
         {
             Client::ReadContext ctx("local.sources", storageGlobalParams.dbpath);
             auto_ptr<Runner> runner(InternalPlanner::collectionScan("local.sources"));
             BSONObj obj;
             Runner::RunnerState state;
             while (Runner::RUNNER_ADVANCED == (state = runner->getNext(&obj, NULL))) {
                 src.push_back(obj);
             }
         }
         
         for( list<BSONObj>::const_iterator i = src.begin(); i != src.end(); i++ ) {
             BSONObj s = *i;
             BSONObjBuilder bb;
             bb.append( s["host"] );
             string sourcename = s["source"].valuestr();
             if ( sourcename != "main" )
                 bb.append( s["source"] );
             {
                 BSONElement e = s["syncedTo"];
                 BSONObjBuilder t( bb.subobjStart( "syncedTo" ) );
                 t.appendDate( "time" , e.timestampTime() );
                 t.append( "inc" , e.timestampInc() );
                 t.done();
             }
             
             if ( level > 1 ) {
                 wassert( !Lock::isLocked() );
                 // note: there is no so-style timeout on this connection; perhaps we should have one.
                 ScopedDbConnection conn(s["host"].valuestr());
                 
                 DBClientConnection *cliConn = dynamic_cast< DBClientConnection* >( &conn.conn() );
                 if ( cliConn && replAuthenticate(cliConn) ) {
                     BSONObj first = conn->findOne( (string)"local.oplog.$" + sourcename,
                                                           Query().sort( BSON( "$natural" << 1 ) ) );
                     BSONObj last = conn->findOne( (string)"local.oplog.$" + sourcename,
                                                          Query().sort( BSON( "$natural" << -1 ) ) );
                     bb.appendDate( "masterFirst" , first["ts"].timestampTime() );
                     bb.appendDate( "masterLast" , last["ts"].timestampTime() );
                     double lag = (double) (last["ts"].timestampTime() - s["syncedTo"].timestampTime());
                     bb.append( "lagSeconds" , lag / 1000 );
                 }
                 conn.done();
             }
             
             sources.append( BSONObjBuilder::numStr( n++ ) , bb.obj() );
         }
         
         sources.done();
     }
 }

 int ConfigServer::dbConfigVersion() {
     ScopedDbConnection conn( _primary );
     int version = dbConfigVersion( conn.conn() );
     conn.done();
     return version;
 }

            bool run(const string& , BSONObj& cmdObj, int, string& errmsg, BSONObjBuilder& result, bool) {
                string target = cmdObj.firstElement().valuestrsafe();
                Shard s = Shard::make( target );
                if ( ! grid.knowAboutShard( s.getConnString() ) ) {
                    errmsg = "unknown shard";
                    return false;
                }

                ScopedDbConnection conn( configServer.getPrimary() );

                if (conn->count("config.shards", BSON("_id" << NE << s.getName() << ShardFields::draining(true)))){
                    conn.done();
                    errmsg = "Can't have more than one draining shard at a time";
                    return false;
                }

                if (conn->count("config.shards", BSON("_id" << NE << s.getName())) == 0){
                    conn.done();
                    errmsg = "Can't remove last shard";
                    return false;
                }

                // If the server is not yet draining chunks, put it in draining mode.
                BSONObj searchDoc = BSON( "_id" << s.getName() );
                BSONObj drainingDoc = BSON( "_id" << s.getName() << ShardFields::draining(true) );
                BSONObj shardDoc = conn->findOne( "config.shards", drainingDoc );
                if ( shardDoc.isEmpty() ) {

                    // TODO prevent move chunks to this shard.

                    log() << "going to start draining shard: " << s.getName() << endl;
                    BSONObj newStatus = BSON( "$set" << BSON( ShardFields::draining(true) ) );
                    conn->update( "config.shards" , searchDoc , newStatus, false /* do no upsert */);

                    errmsg = conn->getLastError();
                    if ( errmsg.size() ) {
                        log() << "error starting remove shard: " << s.getName() << " err: " << errmsg << endl;
                        return false;
                    }

                    Shard::reloadShardInfo();

                    result.append( "msg"   , "draining started successfully" );
                    result.append( "state" , "started" );
                    result.append( "shard" , s.getName() );
                    conn.done();
                    return true;
                }

                // If the server has been completely drained, remove it from the ConfigDB.
                // Check not only for chunks but also databases.
                BSONObj shardIDDoc = BSON( "shard" << shardDoc[ "_id" ].str() );
                long long chunkCount = conn->count( "config.chunks" , shardIDDoc );
                BSONObj primaryDoc = BSON( "primary" << shardDoc[ "_id" ].str() );
                long long dbCount = conn->count( "config.databases" , primaryDoc );
                if ( ( chunkCount == 0 ) && ( dbCount == 0 ) ) {
                    log() << "going to remove shard: " << s.getName() << endl;
                    conn->remove( "config.shards" , searchDoc );

                    errmsg = conn->getLastError();
                    if ( errmsg.size() ) {
                        log() << "error concluding remove shard: " << s.getName() << " err: " << errmsg << endl;
                        return false;
                    }

                    Shard::removeShard( shardDoc[ "_id" ].str() );
                    Shard::reloadShardInfo();

                    result.append( "msg"   , "removeshard completed successfully" );
                    result.append( "state" , "completed" );
                    result.append( "shard" , s.getName() );
                    conn.done();
                    return true;
                }

                // If the server is already in draining mode, just report on its progress.
                // Report on databases (not just chunks) that are left too.
                result.append( "msg"  , "draining ongoing" );
                result.append( "state" , "ongoing" );
                BSONObjBuilder inner;
                inner.append( "chunks" , chunkCount );
                inner.append( "dbs" , dbCount );
                result.append( "remaining" , inner.obj() );

                conn.done();
                return true;
            }

void PDOResource::persistentSave() {
  String serialized = HHVM_FN(serialize)(def_stmt_ctor_args);
  conn()->serialized_def_stmt_ctor_args = serialized.toCppString();
  def_stmt_ctor_args.releaseForSweep(); // we're called from requestShutdown
}

void PDOResource::persistentRestore() {
  auto const serialized = conn()->serialized_def_stmt_ctor_args;
  if (!serialized.empty()) {
    def_stmt_ctor_args = unserialize_from_string(serialized);
  }
}

int main()
{

	int content_length = -1;
	char method[1024];
	char query_string[1024];
	char post_data[4096];

	memset(method, '\0', sizeof(method));
	memset(query_string, '\0', sizeof(query_string));
	memset(post_data, '\0', sizeof(post_data));

	std::cout<<"<html>"<<std::endl;
	std::cout<<"<head>Register The Car's Information Result</head><br/>"<<std::endl;
	std::cout<<"<body>"<<std::endl;

	strcpy(method, getenv("REQUEST_METHOD"));
	if( strcasecmp("GET", method) == 0 )
	{
		strcpy(query_string, getenv("QUERY_STRING"));	
		regis_ter(query_string);
	}
	else if( strcasecmp("POST", method) == 0 )
	{
		content_length = atoi(getenv("CONTENT_LENGTH"));
		int i = 0; 
		for(; i < content_length; i++ )
		{
			read(0, &post_data[i], 1);
		}
		post_data[i] = '\0';
		regis_ter(post_data);
	}
	

	std::string _sql_data[1024][5];
	std::string header[5];
	int curr_row = -1;

	sql_connecter conn(_remote_ip,_remote_user,_remote_passwd,_remote_db);
	conn.begin_connect();
	conn.select_sql(header,_sql_data,curr_row);
	std::cout<<"<table border=\"1\">"<<std::endl;
	std::cout<<"<tr>"<<std::endl;

	for(int i = 0;i < 5;i++)
	{
		std::cout<<"<th>"<<header[i]<<"</th>"<<std::endl;

	}

	std::cout<<"</tr>"<<std::endl;

	for(int i = 0;i < curr_row; i++)
	{
		std::cout<<"<tr>"<<std::endl;
		for(int j =0;j < 5;j++)
		{
			std::cout<<"<td>"<<_sql_data[i][j]<<"</td>"<<std::endl;
		}
		std::cout<<"</tr>"<<std::endl;
	}
	std::cout<<"</table>"<<std::endl;
	std::cout<<"</body>"<<std::endl;
	std::cout<<"</html>"<<std::endl;
return 0;
}

void PDOResource::sweep() {
  assert(!conn()->is_persistent);
  def_stmt_ctor_args.releaseForSweep();
  this->~PDOResource();
}

    bool run(const char *ns, BSONObj& cmdObj, string& errmsg, BSONObjBuilder& result, bool) {
        string dbname = cc().database()->name; // this has to come before dbtemprelease
        dbtemprelease temprelease; // we don't touch the db directly

        string shardedOutputCollection = cmdObj["shardedOutputCollection"].valuestrsafe();

        MRSetup mr( dbname , cmdObj.firstElement().embeddedObjectUserCheck() , false );

        set<ServerAndQuery> servers;

        BSONObjBuilder shardCounts;
        map<string,long long> counts;

        BSONObj shards = cmdObj["shards"].embeddedObjectUserCheck();
        vector< auto_ptr<DBClientCursor> > shardCursors;
        BSONObjIterator i( shards );
        while ( i.more() ) {
            BSONElement e = i.next();
            string shard = e.fieldName();

            BSONObj res = e.embeddedObjectUserCheck();

            uassert( 10078 ,  "something bad happened" , shardedOutputCollection == res["result"].valuestrsafe() );
            servers.insert( shard );
            shardCounts.appendAs( res["counts"] , shard.c_str() );

            BSONObjIterator j( res["counts"].embeddedObjectUserCheck() );
            while ( j.more() ) {
                BSONElement temp = j.next();
                counts[temp.fieldName()] += temp.numberLong();
            }

        }

        BSONObj sortKey = BSON( "_id" << 1 );

        ParallelSortClusteredCursor cursor( servers , dbname + "." + shardedOutputCollection ,
                                            Query().sort( sortKey ) );


        auto_ptr<Scope> s = globalScriptEngine->getPooledScope( ns );
        ScriptingFunction reduceFunction = s->createFunction( mr.reduceCode.c_str() );
        ScriptingFunction finalizeFunction = 0;
        if ( mr.finalizeCode.size() )
            finalizeFunction = s->createFunction( mr.finalizeCode.c_str() );

        BSONList values;

        result.append( "result" , mr.finalShort );

        DBDirectClient db;

        while ( cursor.more() ) {
            BSONObj t = cursor.next().getOwned();

            if ( values.size() == 0 ) {
                values.push_back( t );
                continue;
            }

            if ( t.woSortOrder( *(values.begin()) , sortKey ) == 0 ) {
                values.push_back( t );
                continue;
            }


            db.insert( mr.tempLong , reduceValues( values , s.get() , reduceFunction , 1 , finalizeFunction ) );
            values.clear();
            values.push_back( t );
        }

        if ( values.size() )
            db.insert( mr.tempLong , reduceValues( values , s.get() , reduceFunction , 1 , finalizeFunction ) );

        long long finalCount = mr.renameIfNeeded( db );
        log(0) << " mapreducefinishcommand " << mr.finalLong << " " << finalCount << endl;

        for ( set<ServerAndQuery>::iterator i=servers.begin(); i!=servers.end(); i++ ) {
            ScopedDbConnection conn( i->_server );
            conn->dropCollection( dbname + "." + shardedOutputCollection );
        }

        result.append( "shardCounts" , shardCounts.obj() );

        {
            BSONObjBuilder c;
            for ( map<string,long long>::iterator i=counts.begin(); i!=counts.end(); i++ ) {
                c.append( i->first , i->second );
            }
            result.append( "counts" , c.obj() );
        }

        return 1;
    }

    bool ClientInfo::getLastError( const string& dbName,
                                   const BSONObj& options,
                                   BSONObjBuilder& result,
                                   string& errmsg,
                                   bool fromWriteBackListener)
    {

        scoped_ptr<TimerHolder> gleTimerHolder;
        if ( ! fromWriteBackListener ) {
            bool doTiming = false;
            const BSONElement& e = options["w"];
            if ( e.isNumber() ) {
                doTiming = e.numberInt() > 1;
            }
            else if ( e.type() == String ) {
                doTiming = true;
            }
            if ( doTiming ) {
                gleTimerHolder.reset( new TimerHolder( &gleWtimeStats ) );
            }
        }


        set<string> * shards = getPrev();

        if ( shards->size() == 0 ) {
            result.appendNull( "err" );
            return true;
        }

        vector<WBInfo> writebacks;

        //
        // TODO: These branches should be collapsed into a single codepath
        //

        // handle single server
        if ( shards->size() == 1 ) {
            string theShard = *(shards->begin() );

            BSONObj res;
            bool ok = false;
            {
                LOG(5) << "gathering response for gle from: " << theShard << endl;

                ShardConnection conn( theShard , "" );
                try {
                    ok = conn->runCommand( dbName , options , res );
                }
                catch( std::exception &e ) {

                    string message =
                            str::stream() << "could not get last error from shard " << theShard
                                          << causedBy( e );

                    warning() << message << endl;
                    errmsg = message;

                    // Catch everything that happens here, since we need to ensure we return our connection when we're
                    // finished.
                    conn.done();

                    return false;
                }


                res = res.getOwned();
                conn.done();
            }

            _addWriteBack( writebacks, res, true );

            LOG(4) << "gathering writebacks from " << sinceLastGetError().size() << " hosts for"
                   << " gle (" << theShard << ")" << endl;

            // hit other machines just to block
            for ( set<string>::const_iterator i=sinceLastGetError().begin(); i!=sinceLastGetError().end(); ++i ) {
                string temp = *i;
                if ( temp == theShard )
                    continue;

                LOG(5) << "gathering writebacks for single-shard gle from: " << temp << endl;

                try {
                    ShardConnection conn( temp , "" );
                    ON_BLOCK_EXIT_OBJ( conn, &ShardConnection::done );
                    _addWriteBack( writebacks, conn->getLastErrorDetailed(), false );

                }
                catch( std::exception &e ){
                    warning() << "could not clear last error from shard " << temp << causedBy( e ) << endl;
                }

            }
            clearSinceLastGetError();

            // We never need to handle writebacks if we're coming from the wbl itself
            if ( writebacks.size() && !fromWriteBackListener ){

                LOG(4) << "checking " << writebacks.size() << " writebacks for"
//.........这里部分代码省略.........

        void reload() {

            list<BSONObj> all;
            {
                scoped_ptr<ScopedDbConnection> conn(
                        ScopedDbConnection::getInternalScopedDbConnection(
                                configServer.getPrimary().getConnString(), 30));
                auto_ptr<DBClientCursor> c = conn->get()->query(ShardType::ConfigNS , Query());
                massert( 13632 , "couldn't get updated shard list from config server" , c.get() );
                while ( c->more() ) {
                    all.push_back( c->next().getOwned() );
                }
                conn->done();
            }

            scoped_lock lk( _mutex );

            // We use the _lookup table for all shards and for the primary config DB. The config DB info,
            // however, does not come from the ShardNS::shard. So when cleaning the _lookup table we leave
            // the config state intact. The rationale is that this way we could drop shards that
            // were removed without reinitializing the config DB information.

            ShardMap::iterator i = _lookup.find( "config" );
            if ( i != _lookup.end() ) {
                ShardPtr config = i->second;
                _lookup.clear();
                _lookup[ "config" ] = config;
            }
            else {
                _lookup.clear();
            }
            _rsLookup.clear();
            
            for ( list<BSONObj>::iterator i=all.begin(); i!=all.end(); ++i ) {
                BSONObj o = *i;
                string name = o[ ShardType::name() ].String();
                string host = o[ ShardType::host() ].String();

                long long maxSize = 0;
                BSONElement maxSizeElem = o[ ShardType::maxSize.name() ];
                if ( ! maxSizeElem.eoo() ) {
                    maxSize = maxSizeElem.numberLong();
                }

                bool isDraining = false;
                BSONElement isDrainingElem = o[ ShardType::draining.name() ];
                if ( ! isDrainingElem.eoo() ) {
                    isDraining = isDrainingElem.Bool();
                }

                ShardPtr s( new Shard( name , host , maxSize , isDraining ) );

                if ( o[ ShardType::tags() ].type() == Array ) {
                    vector<BSONElement> v = o[ ShardType::tags() ].Array();
                    for ( unsigned j=0; j<v.size(); j++ ) {
                        s->addTag( v[j].String() );
                    }
                }

                _lookup[name] = s;
                _installHost( host , s );
            }

        }

    bool DBConfig::dropDatabase( string& errmsg ) {
        /**
         * 1) make sure everything is up
         * 2) update config server
         * 3) drop and reset sharded collections
         * 4) drop and reset primary
         * 5) drop everywhere to clean up loose ends
         */

        log() << "DBConfig::dropDatabase: " << _name << endl;
        configServer.logChange( "dropDatabase.start" , _name , BSONObj() );

        // 1
        if ( ! configServer.allUp( errmsg ) ) {
            log(1) << "\t DBConfig::dropDatabase not all up" << endl;
            return 0;
        }

        // 2
        grid.removeDB( _name );
        {
            ScopedDbConnection conn( configServer.modelServer() );
            conn->remove( ShardNS::database , BSON( "_id" << _name ) );
            errmsg = conn->getLastError();
            if ( ! errmsg.empty() ) {
                log() << "could not drop '" << _name << "': " << errmsg << endl;
                conn.done();
                return false;
            }

            conn.done();
        }

        if ( ! configServer.allUp( errmsg ) ) {
            log() << "error removing from config server even after checking!" << endl;
            return 0;
        }
        log(1) << "\t removed entry from config server for: " << _name << endl;

        set<Shard> allServers;

        // 3
        while ( true ) {
            int num = 0;
            if ( ! _dropShardedCollections( num , allServers , errmsg ) )
                return 0;
            log() << "   DBConfig::dropDatabase: " << _name << " dropped sharded collections: " << num << endl;
            if ( num == 0 )
                break;
        }

        // 4
        {
            ScopedDbConnection conn( _primary );
            BSONObj res;
            if ( ! conn->dropDatabase( _name , &res ) ) {
                errmsg = res.toString();
                return 0;
            }
            conn.done();
        }

        // 5
        for ( set<Shard>::iterator i=allServers.begin(); i!=allServers.end(); i++ ) {
            ScopedDbConnection conn( *i );
            BSONObj res;
            if ( ! conn->dropDatabase( _name , &res ) ) {
                errmsg = res.toString();
                return 0;
            }
            conn.done();
        }

        log(1) << "\t dropped primary db for: " << _name << endl;

        configServer.logChange( "dropDatabase" , _name , BSONObj() );
        return true;
    }

int main(int argc, char **argv)
{
    toConfigurationNew::setQSettingsEnv();

    /*! \warning: Keep the code before QApplication init as small
      as possible. There could be serious display issues when
      you construct some Qt classes before QApplication.
      It's the same for global static stuff - some instances can
      break it (e.g. qscintilla lexers etc.).
    */
    QApplication app(argc, argv);

    QString style(toConfigurationNewSingle::Instance().option(ToConfiguration::Global::Style).toString());
    if (!style.isEmpty())
        QApplication::setStyle(QStyleFactory::create(style));

    try
    {
        toQValue::setNumberFormat(
            toConfigurationNewSingle::Instance().option(ToConfiguration::Database::NumberFormatInt).toInt(),
            toConfigurationNewSingle::Instance().option(ToConfiguration::Database::NumberDecimalsInt).toInt()
        );

        qRegisterMetaType<toQColumnDescriptionList>("toQColumnDescriptionList&");
        qRegisterMetaType<ValuesList>("ValuesList&");
        qRegisterMetaType<toConnection::exception>("toConnection::exception");

        if (argc == 1)
            usage();

        QString connect = QString::fromLatin1(argv[1]);
        QString user, password, database, schema, table;

        QStringList slashList, atList = connect.split("@", QString::SkipEmptyParts);
        if ( atList.size() == 1)
            database = QString::fromLatin1(qgetenv("ORACLE_SID"));
        if ( atList.size() > 2)
            usage();

        if ( atList.at(0).contains("/"))
        {
            slashList = atList.at(0).split("/", QString::SkipEmptyParts);
            user = slashList.at(0);
            password = slashList.at(1);
            database = atList.at(1);
        }
        else
        {
            slashList = atList.at(1).split("/", QString::SkipEmptyParts);
            user = atList.at(0);
            database = slashList.at(0);
            password = slashList.at(1);
        }
        if ( argc == 2)
        {
            schema = user;
        }
        else
        {
            schema = QString::fromLatin1(argv[2]);
        }

        if ( argc == 4)
        {
            table = QString::fromLatin1(argv[3]) ;
        }
        else
        {
            table = QString::fromLatin1("T_CHILD6");
        }

        // List of all connection provider finders
        std::vector<std::string> finders = ConnectionProviderFinderFactory::Instance().keys();
        // Resulting list of all the providers found
        QList<toConnectionProviderFinder::ConnectionProvirerParams> allProviders;
        // Loop over all finders and all ther find method each of them can return more locations
        for (std::vector<std::string>::const_iterator i = finders.begin(); i != finders.end(); ++i)
        {
            TLOG(5, toDecorator, __HERE__) << "Looking for client: " << *i << std::endl;
            std::unique_ptr<toConnectionProviderFinder> finder = ConnectionProviderFinderFactory::Instance().create(*i, 0);
            QList<toConnectionProviderFinder::ConnectionProvirerParams> l = finder->find();
            allProviders.append(l);
        }
	QDir oHome = toConfigurationNewSingle::Instance().option(ToConfiguration::Global::OracleHomeDirectory).toString();
        foreach(toConnectionProviderFinder::ConnectionProvirerParams const& params, allProviders)
        {
	    if ( params.value("PROVIDER").toString() != ORACLE_PROVIDER)
	      continue;
	    QDir pHome(params.value("ORACLE_HOME").toString());
	    if (oHome != pHome)
	      continue;
	    QString providerName = params.value("PROVIDER").toString();
            if (providerName == "Oracle")
            {
                toConnectionProviderRegistrySing::Instance().load(params);
                break;
            }
        }
        foreach(toConnectionProviderFinder::ConnectionProvirerParams const& params, allProviders)
        {
//.........这里部分代码省略.........

 void appendReplicationInfo(OperationContext* txn, BSONObjBuilder& result, int level) {
     ReplicationCoordinator* replCoord = getGlobalReplicationCoordinator();
     if (replCoord->getSettings().usingReplSets()) {
         IsMasterResponse isMasterResponse;
         replCoord->fillIsMasterForReplSet(&isMasterResponse);
         result.appendElements(isMasterResponse.toBSON());
         return;
     }
     
     // TODO(dannenberg) replAllDead is bad and should be removed when master slave is removed
     if (replAllDead) {
         result.append("ismaster", 0);
         string s = string("dead: ") + replAllDead;
         result.append("info", s);
     }
     else {
         result.appendBool("ismaster",
                           getGlobalReplicationCoordinator()->isMasterForReportingPurposes());
     }
     
     if (level) {
         BSONObjBuilder sources( result.subarrayStart( "sources" ) );
         
         int n = 0;
         list<BSONObj> src;
         {
             const char* localSources = "local.sources";
             Client::ReadContext ct