const CommandType* UnitType::findCommandTypeById(int id) const{
for(int i=0; i<getCommandTypeCount(); ++i){
const CommandType* commandType= getCommandType(i);
if(commandType->getId()==id){
return commandType;
}
}
return NULL;
}
StatusWith<OplogApplier::Operations> OplogApplier::getNextApplierBatch(
OperationContext* opCtx, const BatchLimits& batchLimits) {
if (batchLimits.ops == 0) {
return Status(ErrorCodes::InvalidOptions, "Batch size must be greater than 0.");
}
std::uint32_t totalBytes = 0;
Operations ops;
BSONObj op;
while (_oplogBuffer->peek(opCtx, &op)) {
auto entry = OplogEntry(op);
// Check for oplog version change. If it is absent, its value is one.
if (entry.getVersion() != OplogEntry::kOplogVersion) {
std::string message = str::stream()
<< "expected oplog version " << OplogEntry::kOplogVersion << " but found version "
<< entry.getVersion() << " in oplog entry: " << redact(entry.toBSON());
severe() << message;
return {ErrorCodes::BadValue, message};
}
// Commands must be processed one at a time. The only exception to this is applyOps because
// applyOps oplog entries are effectively containers for CRUD operations. Therefore, it is
// safe to batch applyOps commands with CRUD operations when reading from the oplog buffer.
if (entry.isCommand() && (entry.getCommandType() != OplogEntry::CommandType::kApplyOps ||
entry.shouldPrepare())) {
if (ops.empty()) {
// Apply commands one-at-a-time.
ops.push_back(std::move(entry));
BSONObj opToPopAndDiscard;
invariant(_oplogBuffer->tryPop(opCtx, &opToPopAndDiscard));
dassert(ops.back() == OplogEntry(opToPopAndDiscard));
}
// Otherwise, apply what we have so far and come back for the command.
return std::move(ops);
}
// Apply replication batch limits.
if (ops.size() >= batchLimits.ops) {
return std::move(ops);
}
// Never return an empty batch if there are operations left.
if ((totalBytes + entry.getRawObjSizeBytes() >= batchLimits.bytes) && (ops.size() > 0)) {
return std::move(ops);
}
// Add op to buffer.
totalBytes += entry.getRawObjSizeBytes();
ops.push_back(std::move(entry));
BSONObj opToPopAndDiscard;
invariant(_oplogBuffer->tryPop(opCtx, &opToPopAndDiscard));
dassert(ops.back() == OplogEntry(opToPopAndDiscard));
}
return std::move(ops);
}
//======================================================================================
String VirtuinoEthernet_WebServer::checkNetworkCommand(String command){
String returnedString="";
int pos=command.lastIndexOf(COMMAND_END_CHAR);
if (pos>5){ // check the size of command
String command1= command.substring(0,pos+1); // clear the command
if (DEBUG) Serial.println("\r\nCommand = "+ command1);
//------------------ get command password
String commandPassword="";
int k=command1.indexOf(COMMAND_START_CHAR);
if (k>0) commandPassword = command1.substring(0,k);
if (DEBUG) Serial.println("\r\nCommand password:"+commandPassword );
if ((password.length()==0) || (commandPassword.equals(password))) { // check if password correct
while (command1.indexOf(COMMAND_START_CHAR)>=0){
int cStart=command1.indexOf(COMMAND_START_CHAR);
int cEnd=command1.indexOf(COMMAND_END_CHAR);
if (cEnd-cStart>5){
String oneCommand = command1.substring(cStart+1,cEnd); // get one command
char commandType = getCommandType(oneCommand);
if (commandType!='E') {
int pin= getCommandPin(oneCommand);
if (pin!=-1){
boolean returnInfo=false;
float value=0;
if (oneCommand.charAt(4)=='?') returnInfo=true;
else value = getCommandValue(oneCommand);
String commandResponce=executeReceivedCommand(commandType,pin , value,returnInfo);
returnedString += commandResponce;
} else returnedString +=getErrorCommand(ERROR_PIN); // response error pin number !E00=1$
} else returnedString +=getErrorCommand(ERROR_TYPE); // response error type !E00=3$
} else{
returnedString +=getErrorCommand(ERROR_SIZE); // response error size of command !E00=4$
}
command1=command1.substring(cEnd+1);
} // while
} else returnedString=getErrorCommand(ERROR_PASSWORD); // the password is not correct
}
else returnedString=getErrorCommand(ERROR_SIZE); // the size of command is not correct
return returnedString;
}
static int getRtfCommand(FILE *f, RTFcommand *command ) {
int c=fgetc(f);
if (isalpha(c)) {
int name_count=1;
command->name[0]=(char)c;
while(isalpha(c=fgetc(f)) && name_count < RTFNAMEMAXLEN) {
if(feof(f))
return 1;
command->name[name_count++]=(char)c;
}
command->name[name_count]='\0';
command->type=getCommandType(command->name);
/* command->args=NULL; */
ungetc(c,f);
if (isdigit(c) || c == '-' )
command->numarg=getNumber(f);
else
command->numarg=0;
c=fgetc(f);
if(!(c==' ' || c=='\t'))
ungetc(c,f);
} else {
command->name[0]=(char)c;
command->name[1]='\0';
/* command->args=NULL; */
if (c == '\'') {
command->type=RTF_CHAR;
command->numarg=getCharCode(f);
if(feof(f))
return -1;
} else {
command->type=RTF_SPEC_CHAR;
command->numarg=c;
}
}
return 0;
}
