/** * Atomically save \a doc to specified name. Prior to saving, back up * of old config data is created, and only then data is saved. */ bool AtomicXmlFile::saveDocument(const QDomDocument& doc) const { if (!saveDocument(doc, tempFileName())) { qWarning("AtomicXmlFile::saveDocument(): Unable to save '%s'. Possibly drive is full.", qPrintable(tempFileName())); return false; } if (QFile::exists(backupFileName())) QFile::remove(backupFileName()); if (QFile::exists(fileName_)) { if (!QFile::rename(fileName_, backupFileName())) { qWarning("AtomicXmlFile::saveDocument(): Unable to rename '%s' to '%s'.", qPrintable(fileName_), qPrintable(backupFileName())); return false; } } if (!QFile::rename(tempFileName(), fileName_)) { qWarning("AtomicXmlFile::saveDocument(): Unable to rename '%s' to '%s'.", qPrintable(tempFileName()), qPrintable(fileName_)); return false; } return true; }
void DiffDialog::callExternalDiff(const QString& extdiff, OrgKdeCervisia5CvsserviceCvsserviceInterface* service, const QString& fileName, const QString &revA, const QString &revB) { QString extcmdline = extdiff; extcmdline += ' '; // create suffix for temporary file (used QFileInfo to remove path from file name) const QString suffix = '-' + QFileInfo(fileName).fileName(); QDBusReply<QDBusObjectPath> job; if (!revA.isEmpty() && !revB.isEmpty()) { // We're comparing two revisions QString revAFilename = tempFileName(suffix+QString("-")+revA); QString revBFilename = tempFileName(suffix+QString("-")+revB); // download the files for revision A and B job = service->downloadRevision(fileName, revA, revAFilename, revB, revBFilename); if( !job.isValid() ) return; extcmdline += KShell::quoteArg(revAFilename); extcmdline += ' '; extcmdline += KShell::quoteArg(revBFilename); } else { // We're comparing to a file, and perhaps one revision QString revAFilename = tempFileName(suffix+QString("-")+revA); job = service->downloadRevision(fileName, revA, revAFilename); if( !job.isValid() ) return; extcmdline += KShell::quoteArg(revAFilename); extcmdline += ' '; extcmdline += KShell::quoteArg(QFileInfo(fileName).absoluteFilePath()); } ProgressDialog dlg(this, "Diff", service->service(),job, "diff"); if( dlg.execute() ) { // call external diff application KProcess proc; proc.setShellCommand(extcmdline); proc.startDetached(); } }
SAWYER_EXPORT std::string PodFormatter::toNroff(const ParserResult &parsed) { // Generate POD documentation into a temporary file TempFile tmpfile(tempFileName(".pod")); parsed.emit(tmpfile.stream, sharedFromThis()); tmpfile.stream.close(); std::string cmd = "pod2man" " --center='" + escapeSingleQuoted(chapterName_) + "'" " --date='" + escapeSingleQuoted(dateString_) + "'" " --name='" + escapeSingleQuoted(pageName_) + "'" " --release='" + escapeSingleQuoted(versionString_) + "'" " --section='" + escapeSingleQuoted(chapterNumber_) + "'" " " + tmpfile.name; FILE *f = popen(cmd.c_str(), "r"); if (!f) { #include <Sawyer/WarningsOff.h> // suppress strerror unsafe warning from Microsoft C++ throw std::runtime_error(std::string("cannot run command: ") + strerror(errno) + "\ncommand: " + cmd); #include <Sawyer/WarningsRestore.h> } std::string result; while (1) { std::string line = readOneLine(f); if (line.empty()) break; result += line; } if (-1 == Sawyer::pclose(f)) throw std::runtime_error("command failed: " + cmd); return result; }
/// Passes the results of a test to the test suite callback function /// @param record Indicates whether or note the results of the test should be recorded to the results tree ctrl if the test was successful /// @param startTime The time when the test was started /// @param testName Name of the test /// @param success Indicates the success/failure of the test /// @param fileName Name of the file where the test occurred /// @param lineNumber Line number in the file where the test occurred bool TestSuite::Test(bool record, wxLongLong startTime, const wxChar* testName, bool success, char* fileName, size_t lineNumber) { //------Last Checked------// // - Dec 2, 2004 // Calculate the time to execute the test (in seconds) wxLongLong span = ::wxGetLocalTimeMillis() - startTime; double executionTime = ((double)span.ToLong()) / 1000.0; // If the test suite isn't being executed, bail out if (!IsExecuted()) return (false); // Update the success or failure of the test if (success) m_passed++; else m_failed++; wxCHECK(testName != NULL, false); wxCHECK(fileName != NULL, false); wxCHECK(m_testSuiteCallback != NULL, false); // Create a temp string used for the filename (since it's ANSI and we want it this to work on Unicode builds) wxString tempFileName(fileName); // Send the results of the test to the callback return (m_testSuiteCallback(this, testName, success, tempFileName, lineNumber, record, executionTime, m_clientData)); }
QFile::FileError QLCFixtureDef::saveXML(const QString& fileName) { QFile::FileError error; if (fileName.isEmpty() == true) return QFile::OpenError; QString tempFileName(fileName); tempFileName += ".temp"; QFile file(tempFileName); if (file.open(QIODevice::WriteOnly) == false) return file.error(); QXmlStreamWriter doc(&file); doc.setAutoFormatting(true); doc.setAutoFormattingIndent(1); doc.setCodec("UTF-8"); QLCFile::writeXMLHeader(&doc, KXMLQLCFixtureDefDocument, author()); doc.writeTextElement(KXMLQLCFixtureDefManufacturer, m_manufacturer); doc.writeTextElement(KXMLQLCFixtureDefModel, m_model); doc.writeTextElement(KXMLQLCFixtureDefType, m_type); /* Channels */ QListIterator <QLCChannel*> chit(m_channels); while (chit.hasNext() == true) chit.next()->saveXML(&doc); /* Modes */ QListIterator <QLCFixtureMode*> modeit(m_modes); while (modeit.hasNext() == true) modeit.next()->saveXML(&doc); /* End the document and close all the open elements */ error = QFile::NoError; doc.writeEndDocument(); file.close(); // Save to actual requested file name QFile currFile(fileName); if (currFile.exists() && !currFile.remove()) { qWarning() << "Could not erase" << fileName; return currFile.error(); } if (!file.rename(fileName)) { qWarning() << "Could not rename" << tempFileName << "to" << fileName; return file.error(); } return error; }
void CSimpleAppUi::ConstructContainerL() { TRect boundingRect=ClientRect(); // make toolband stretch to the screen width by default iContainer=new(ELeave) CTestContainer; iContainer->ConstructL(); ReduceRect(boundingRect); iContainer->SetRect(boundingRect); //vmTFileName tempFileName(Application()->BitmapStoreName()); TFileName tempFileName(KTBmpAnimMBMFilePath); iContainer->SetAppFileName(tempFileName); iContainer->DrawNow(); }
/** * Tries to load \a doc from config file, or if that fails, from a back up. */ bool AtomicXmlFile::loadDocument(QDomDocument* doc) const { Q_ASSERT(doc); QStringList fileNames; fileNames << tempFileName() << fileName_ << backupFileName(); foreach(QString fileName, fileNames) if (loadDocument(doc, fileName)) return true; return false; }
SAWYER_EXPORT void PodFormatter::emit(const ParserResult &parsed) { // Generate POD documentation into a temporary file. Since perldoc doesn't support the "name" property, but rather // uses the file name, we create a temporary directory and place a POD file inside with the name we want. TempDir tmpdir(tempFileName()); std::string fileName = tmpdir.name + pageName_ + ".pod"; { std::ofstream stream(fileName.c_str()); parsed.emit(stream, sharedFromThis()); } std::string cmd = "perldoc " " -o man" " -w 'center:" + escapeSingleQuoted(chapterName_) + "'" " -w 'date:" + escapeSingleQuoted(dateString_) + "'" // " -w 'name:" + escapeSingleQuoted(pageName_) + "'" " -w 'release:" + escapeSingleQuoted(versionString_) + "'" " -w 'section:" + escapeSingleQuoted(chapterNumber_) + "'" " " + fileName; system(cmd.c_str()); }
//---------------------------------------------------------------------------- void correctEmptyFileExt(const wxString& ext, wxString & fileName) { wxFileName tempFileName(fileName); if (tempFileName.GetExt().IsEmpty()) fileName += "." + ext; }
/** * @return returns temporary directory name. */ std::string digidoc::util::File::tempDirectory() { return tempFileName() + PATH_DELIMITER; }
DWORD CSoundManager::OnRunPlaylist(DWORD size, void *param) { VERIFY_MESSAGE_SIZE(size, sizeof(IHashString*)); IHashString *fileName = (IHashString*)param; IDTOOBJECTMAP::iterator plIter; if (fileName) { // convert to lowercase hashstring StdString szFileName = fileName->GetString(); szFileName.tolower(); CHashString tempFileName(szFileName); if (m_pCurrentPlaylist) { m_pCurrentPlaylist->Stop(); } IDTOOBJECTMAP *objMap = GetObjectMap(&m_hsPlaylistTypeName); bool found = false; if (objMap != NULL) { plIter = objMap->find(tempFileName.GetUniqueID()); if (plIter != objMap->end()) { found = true; } } if (!found) { // not in map... try to load and check again LOADFILEEXTPARAMS lfep; lfep.fileName = (TCHAR*) tempFileName.GetString(); lfep.bInternalLoad = true; static DWORD msgHash_LoadFileByExtension = CHashString(_T("LoadFileByExtension")).GetUniqueID(); m_ToolBox->SendMessage(msgHash_LoadFileByExtension, sizeof(LOADFILEEXTPARAMS), &lfep); objMap = GetObjectMap(&m_hsPlaylistTypeName); if (objMap != NULL) { plIter = objMap->find(tempFileName.GetUniqueID()); if (plIter != objMap->end()) { found = true; } } if (!found) { m_ToolBox->Log(LOGWARNING, _T("Sound manager: could not open playlist file %s\n"), tempFileName.GetString()); return MSG_NOT_HANDLED; } } m_pCurrentPlaylist = dynamic_cast<ISoundObject *>(plIter->second); if (m_pCurrentPlaylist != NULL) { m_pCurrentPlaylist->Play(); } else { m_ToolBox->Log(LOGWARNING, _T("Dynamic cast failed for CMusicPlayList in %s at line %d\n"), __FILE__, __LINE__); return MSG_NOT_HANDLED; } } return MSG_HANDLED_STOP; }
void PRDocument::DoSave() { // Validate pointers. ValidateThis_(); ValidateObject_(mRFMap); ValidateObject_(mFile); // Ensure that memory allocations succeed. StCriticalSection crit; // Finalize any pending actions while resource file is still open. PostAction(nil); // Make a name for temporary file using base string provided by caller and a time stamp. LStr255 tempFileName(STR_FileTitles, str_TempSwapFile); if (tempFileName.Length() > 20) tempFileName[(UInt8)0] = 20; UInt32 time; ::GetDateTime(&time); LStr255 tempFileNumber((SInt32) time); tempFileName += tempFileNumber; // Find Temporary Items folder on source file's volume and create temp file there. FSSpec documentSpec; mFile->GetSpecifier(documentSpec); SInt16 theVRef; SInt32 theDirID; OSErr theErr = ::FindFolder(documentSpec.vRefNum, kTemporaryFolderType, kCreateFolder, &theVRef, &theDirID); // JWW - The volume might not be what we asked, especially if it's on OS X... // ...and on OS X, it looks like FindFolder returns an error, so don't throw if ((theErr != noErr) || (theVRef != documentSpec.vRefNum)) { // ...and in that case, just use the document folder instead why not? theVRef = documentSpec.vRefNum; theDirID = documentSpec.parID; } FSSpec tempFileSpec; theErr = ::FSMakeFSSpec(theVRef, theDirID, tempFileName, &tempFileSpec); if ((theErr != noErr) && (theErr != fnfErr)) ThrowOSErr_(theErr); try { if (mIsFlattened) { // Make a copy of the file. SaveCDEFs(); //* 2.1.2: BUG FIX #370 FSSpec unflattenedSpec; mUnflattenedFile->GetSpecifier(unflattenedSpec); mUnflattenedFile->CloseResourceFork(); //ugh! required for saving on remote volumes ::FSpDelete(&tempFileSpec); ThrowIfOSErr_(::FileCopy(unflattenedSpec.vRefNum, unflattenedSpec.parID, unflattenedSpec.name, tempFileSpec.vRefNum, tempFileSpec.parID, nil, tempFileName, nil, 0, true)); // Open temp file and make changes. LFile tempFile(tempFileSpec); OpenResourceFile(&tempFile); mRFMap->SetMainFile(&tempFile); RawSave(tempFileSpec, documentSpec); // Save is done. Now swap files back. // // With flat files, we'll copy the temp resource fork into the // original file's flattened data fork. SInt16 srcRefNum; SInt16 destRefNum; StPointerBlock buffer(bigCopyBuffSize, false, false); if (not buffer.IsValid()) { StPointerBlock smallBuffer(minCopyBuffSize, true, false); buffer.Adopt(smallBuffer.Release()); } tempFile.CloseResourceFork(); mFile->CloseDataFork(); srcRefNum = tempFile.OpenResourceFork(fsRdPerm); destRefNum = mFile->OpenDataFork(fsRdWrPerm); ThrowIfOSErr_(::CopyFork(srcRefNum, destRefNum, buffer, ::GetPtrSize(buffer))); // The Save is done. Now swap the temp and unflattened files. This fixes // bug WB1-42415 where some changes to a flattened ppob file were overwritten // unless you closed and reopened the flat ppob after each save. tempFile.CloseResourceFork(); ThrowIfOSErr_(::FSpExchangeFiles(&unflattenedSpec, &tempFileSpec)); ::FSpDelete(&tempFileSpec); // deletes old document } else { // Make a copy of the file. SaveCDEFs(); //* 2.1.2: BUG FIX #370 mFile->CloseResourceFork(); //ugh! required for saving on remote volumes ::FSpDelete(&tempFileSpec); ThrowIfOSErr_(::FileCopy(documentSpec.vRefNum, documentSpec.parID, documentSpec.name, tempFileSpec.vRefNum, tempFileSpec.parID, nil, tempFileName, nil, 0, true)); // Open temp file and make changes. LFile tempFile(tempFileSpec); OpenResourceFile(&tempFile); mRFMap->SetMainFile(&tempFile); RawSave(tempFileSpec, documentSpec); // Save is done. Now swap files back. tempFile.CloseResourceFork(); ThrowIfOSErr_(::FSpExchangeFiles(&documentSpec, &tempFileSpec)); ::FSpDelete(&tempFileSpec); // deletes old document } } catch (...) { // Get rid of temp file. ::FSpDelete(&tempFileSpec); if (mIsFlattened) { // Reopen (untouched) main document. OpenResourceFile(mUnflattenedFile); mRFMap->SetMainFile(mUnflattenedFile); } else { // Reopen (untouched) main document. OpenResourceFile(mFile); mRFMap->SetMainFile(mFile); } // Rethrow exception so it gets reported. #if SKIPOMPARSE // grrr- throw; #endif } if (mIsFlattened) { // Reopen (untouched) main document. OpenResourceFile(mUnflattenedFile); mRFMap->SetMainFile(mUnflattenedFile); } else { // Reopen (untouched) main document. OpenResourceFile(mFile); mRFMap->SetMainFile(mFile); } }
QFile::FileError App::saveXML(const QString& fileName) { QString tempFileName(fileName); tempFileName += ".temp"; QFile file(tempFileName); if (file.open(QIODevice::WriteOnly) == false) return file.error(); QXmlStreamWriter doc(&file); doc.setAutoFormatting(true); doc.setAutoFormattingIndent(1); doc.setCodec("UTF-8"); doc.writeStartDocument(); doc.writeDTD(QString("<!DOCTYPE %1>").arg(KXMLQLCWorkspace)); doc.writeStartElement(KXMLQLCWorkspace); doc.writeAttribute("xmlns", QString("%1%2").arg(KXMLQLCplusNamespace).arg(KXMLQLCWorkspace)); /* Currently active context */ doc.writeAttribute(KXMLQLCWorkspaceWindow, m_contextManager->currentContext()); /* Creator information */ doc.writeStartElement(KXMLQLCCreator); doc.writeTextElement(KXMLQLCCreatorName, APPNAME); doc.writeTextElement(KXMLQLCCreatorVersion, APPVERSION); doc.writeTextElement(KXMLQLCCreatorAuthor, QLCFile::currentUserName()); doc.writeEndElement(); /* Write engine components to the XML document */ m_doc->saveXML(&doc); /* Write virtual console to the XML document */ m_virtualConsole->saveXML(&doc); /* Write Simple Desk to the XML document */ //SimpleDesk::instance()->saveXML(&doc); doc.writeEndElement(); // close KXMLQLCWorkspace /* End the document and close all the open elements */ doc.writeEndDocument(); file.close(); // Save to actual requested file name QFile currFile(fileName); if (currFile.exists() && !currFile.remove()) { qWarning() << "Could not erase" << fileName; return currFile.error(); } if (!file.rename(fileName)) { qWarning() << "Could not rename" << tempFileName << "to" << fileName; return file.error(); } /* Set the file name for the current Doc instance and set it also in an unmodified state. */ setFileName(fileName); m_doc->resetModified(); return QFile::NoError; }
// Main Method int main(int argc, char** argv) { // Set up a handler for any signals so that we always shutdown gracefully struct sigaction sigIntHandler; sigIntHandler.sa_handler = my_signal_handler; sigemptyset(&sigIntHandler.sa_mask); sigIntHandler.sa_flags = 0; sigaction(SIGINT, &sigIntHandler, NULL); // Setup the component factories cli_factory = new CommandLineInterpreterFactory; uuid_factory = new uuidComponentFactory; zmq_factory = new ZmqComponentFactory; logging_factory = new LoggingComponentFactory; mongo_factory = new MongoComponentFactory; ObjectListFactory ofactory; ObjectFactory objfactory; // Set up our command line interpreter cli = cli_factory->get_command_line_interface(argc, argv); // Allow for wait on startup, if configured if (cli->opt_exist("-wait")) { std::string wait_time_string = cli->get_opt("-wait"); int wait_time = std::stoi(wait_time_string, NULL); // Accept input on the command line in seconds, convert to microseconds usleep(wait_time * 1000000); } // Set up logging std::string initFileName; // See if we have a command line setting for the log file const char * env_logging_file = std::getenv("CRAZYIVAN_LOGGING_CONF"); if (env_logging_file) { std::string tempFileName(env_logging_file); initFileName = tempFileName; } else if (cli->opt_exist("-log-conf")) { initFileName = cli->get_opt("-log-conf"); } else { initFileName = "log4cpp.properties"; } // This reads the logging configuration file logging = logging_factory->get_logging_interface(initFileName); // Set up the logging submodules for each category start_logging_submodules(); // Set up the UUID Generator uid = uuid_factory->get_uuid_interface(); std::string service_id = "Clyman"; // Set up our configuration manager with the CLI config = new ConfigurationManager(cli, service_id); // Start up the Kafka Producer kafka = new KafkaClient(); // The configuration manager will look at any command line arguments, // configuration files, and Consul connections to try and determine the // correct configuration for the service // The configuration manager will look at any command line arguments, // configuration files, and Consul connections to try and determine the // correct configuration for the service bool config_success = false; bool config_tried = false; int config_attempts = 0; // If we fail configuration, we should sleep for 5 seconds and try again while (!config_success) { if (config_attempts > 50) { main_logging->error("Max Config Attempts failed, exiting"); shutdown(); exit(1); } if (config_tried) { main_logging->error("Configuration Failed, trying again in 5 seconds"); usleep(5000000); } else { config_tried = true; } try { config_success = config->configure(); } catch (std::exception& e) { main_logging->error("Exception encountered during Configuration"); } } // Set up the Mongo Connection std::string DBConnStr = config->get_mongoconnstr(); std::string DBName = config->get_dbname(); std::string DBHeaderCollection = config->get_dbheadercollection(); if (!(DBConnStr.empty() || DBName.empty() \ || DBHeaderCollection.empty())) { try { mongo = mongo_factory->get_mongo_interface(DBConnStr, \ DBName, DBHeaderCollection); main_logging->debug("Connected to Mongo"); } catch (std::exception& e) { main_logging->error("Exception encountered during Mongo Startup"); main_logging->error(e.what()); shutdown(); exit(1); } } else { main_logging->error("Insufficient Mongo Connection Information"); shutdown(); exit(1); } // Connect to the inbound ZMQ Admin std::string ib_zmq_connstr = config->get_ibconnstr(); if (!(ib_zmq_connstr.empty())) { zmqi = zmq_factory->get_zmq_inbound_interface(ib_zmq_connstr, REQ_RESP); main_logging->info("ZMQ Socket Open, opening request loop"); } else { main_logging->error("No IB ZMQ Connection String Supplied"); shutdown(); exit(1); } // Main Request Loop while (true) { std::string resp_str = ""; rapidjson::Document d; protoObj3::Obj3List new_proto; // Convert the OMQ message into a string to be passed on the event char * req_ptr = zmqi->crecv(); if (!req_ptr) continue; main_logging->debug("Conversion to C String performed with result: "); main_logging->debug(req_ptr); // Trim the string recieved std::string recvd_msg(req_ptr); std::string clean_string; std::string new_error_message = ""; // Parsing logic - JSON if (config->get_formattype() == JSON_FORMAT) { response_message = ofactory.build_json_object_list(); int final_closing_char = recvd_msg.find_last_of("}"); int first_opening_char = recvd_msg.find_first_of("{"); clean_string = \ recvd_msg.substr(first_opening_char, final_closing_char+1); main_logging->debug("Input String Cleaned"); main_logging->debug(clean_string); try { d.Parse<rapidjson::kParseStopWhenDoneFlag>(clean_string.c_str()); if (d.HasParseError()) { main_logging->error("Parsing Error: "); main_logging->error(GetParseError_En(d.GetParseError())); response_message->set_error_code(TRANSLATION_ERROR); new_error_message.assign(GetParseError_En(d.GetParseError())); } else {inbound_message = ofactory.build_object_list(d);} } // Catch a possible error and write to logs catch (std::exception& e) { main_logging->error("Exception occurred while parsing document:"); main_logging->error(e.what()); } // Parsing logic - Protocol Buffers } else if (config->get_formattype() == PROTO_FORMAT) { response_message = ofactory.build_proto_object_list(); clean_string = trim(recvd_msg); main_logging->debug("Input String Cleaned"); main_logging->debug(clean_string); try { new_proto.ParseFromString(clean_string); inbound_message = ofactory.build_object_list(new_proto); } catch (std::exception& e) { main_logging->error("Exception occurred while parsing bytes:"); main_logging->error(e.what()); response_message->set_error_code(TRANSLATION_ERROR); new_error_message.assign(e.what()); } } // Determine the Transaction ID UuidContainer id_container; id_container.id = ""; if (config->get_transactionidsactive() && inbound_message) { // Get an existing transaction ID std::string existing_trans_id = \ inbound_message->get_transaction_id(); // If no transaction ID is sent in, generate a new one if (existing_trans_id.empty()) { try { id_container = uid->generate(); if (!id_container.err.empty()) { main_logging->error(id_container.err); } inbound_message->set_transaction_id(id_container.id); } catch (std::exception& e) { main_logging->error("Exception encountered in UUID Generation"); main_logging->error(e.what()); shutdown(); exit(1); } } main_logging->debug("Transaction ID: "); main_logging->debug(inbound_message->get_transaction_id()); } bool shutdown_needed = false; // Core application logic if (inbound_message) { try { // Object Creation if (inbound_message->get_msg_type() == OBJ_CRT) { main_logging->info("Processing Object Creation Message"); for (int i = 0; i < inbound_message->num_objects(); i++) { // Create a new Obj3 to add to the return list ObjectInterface *resp_element = objfactory.build_object(); // Create the Obj3 document for Mongo AOSSL::MongoBufferInterface *bson = mongo_factory->get_mongo_buffer(); inbound_message->get_object(i)->to_bson(bson); MongoResponseInterface *resp = mongo->create_document(bson); delete bson; // Add the key into the new obj3 resp_element->set_key(resp->get_value()); // Add the new obj3 to the response list response_message->add_object(resp_element); delete resp; } // Object Update } else if (inbound_message->get_msg_type() == OBJ_UPD || \ inbound_message->get_msg_type() == OBJ_LOCK || \ inbound_message->get_msg_type() == OBJ_UNLOCK || inbound_message->get_msg_type() == OBJ_OVERWRITE) { main_logging->info("Processing Object Update Message"); for (int i = 0; i < inbound_message->num_objects(); i++) { // Build a query bson to pass to the update_by_query AOSSL::MongoBufferInterface *query_bson = mongo_factory->get_mongo_buffer(); AOSSL::MongoBufferInterface *bson = mongo_factory->get_mongo_buffer(); std::string msg_key = inbound_message->get_object(i)->get_key(); bool execute_query = true; if (msg_key.empty() && \ !(inbound_message->get_object(i)->get_name().empty() && \ inbound_message->get_object(i)->get_scene().empty())) { std::string name_key = "name"; std::string scene_key = "scene"; query_bson->add_string(name_key, inbound_message->get_object(i)->get_name()); query_bson->add_string(scene_key, inbound_message->get_object(i)->get_scene()); } else if (!(msg_key.empty())) { query_bson->add_oid(msg_key); } // Add an owner query if object locking is active if (config->get_locking_active()) { std::string owner_key = "owner"; // If we have a lock message, then look for an empty owner if (inbound_message->get_msg_type() == OBJ_LOCK) { std::string owner_search = ""; query_bson->add_string(owner_key, owner_search); // Otherwise, look for a matching owner to the input } else { std::string owner_search = inbound_message->get_object(i)->get_owner(); query_bson->add_string(owner_key, owner_search); } } if (inbound_message->get_msg_type() == OBJ_OVERWRITE) { // Build the BSON Update main_logging->debug("Overwriting BSON Object"); inbound_message->get_object(i)->to_bson_update(bson); } else { // Load the current doc from the database rapidjson::Document resp_doc; MongoResponseInterface *resp = mongo->load_document(msg_key); if (resp) { std::string mongo_resp_str = resp->get_value(); main_logging->debug("Document loaded from Mongo"); main_logging->debug(mongo_resp_str); resp_doc.Parse(mongo_resp_str.c_str()); ObjectInterface *resp_obj = objfactory.build_object(resp_doc); // Save the resulting object if (inbound_message->get_op_type() == APPEND) { // Apply the object message as changes to the DB Object resp_obj->merge(inbound_message->get_object(i)); // Update the object in case of unlock to have no owner before saving if (inbound_message->get_msg_type() == OBJ_UNLOCK) { std::string new_owner = ""; resp_obj->set_owner(new_owner); } resp_obj->to_bson_update(bson); } else { // Update the object in case of unlock to have no owner before saving if (inbound_message->get_msg_type() == OBJ_UNLOCK) { std::string new_owner = ""; inbound_message->get_object(0)->set_owner(new_owner); } inbound_message->get_object(0)->to_bson_update(true, false, bson); } response_message->add_object(resp_obj); delete resp; } else { main_logging->error("Document not found in Mongo"); response_message->set_error_code(NOT_FOUND); new_error_message = "Object not Found"; response_message->set_error_message(new_error_message); execute_query = false; } } // Actually execute the Mongo update AOSSL::MongoBufferInterface *response_buffer = NULL; bool send_update = false; if (execute_query) { response_buffer = mongo->update_single_by_query(query_bson, bson); // Look at the response buffer to ensure that a single document // was matched and updated std::string mdc_key = "modifiedCount"; std::string mtc_key = "matchedCount"; int num_modified = response_buffer->get_int(mdc_key); int num_matched = response_buffer->get_int(mtc_key); if (num_matched == 0) { main_logging->error("Document not found in Mongo"); response_message->set_error_code(NOT_FOUND); new_error_message = "Object not Found"; response_message->set_error_message(new_error_message); } else if (num_modified == 0) { main_logging->error("Document found in Mongo, but update failed"); response_message->set_error_code(LOCK_EXISTS_ERROR); new_error_message = "Object locked by another device"; response_message->set_error_message(new_error_message); } else { // Updates were successful in Mongo, so send via streams send_update = true; } } // Send an update on the Kafka 'dvs' topic if ((inbound_message->get_msg_type() == OBJ_OVERWRITE || \ inbound_message->get_msg_type() == OBJ_UPD) && send_update) { kafka->send(inbound_message->get_object(i)->to_transform_json(), config->get_kafkabroker()); } delete query_bson; delete bson; } // Object Retrieve } else if (inbound_message->get_msg_type() == OBJ_GET) { main_logging->info("Processing Object Get Message"); for (int i = 0; i < inbound_message->num_objects(); i++) { // Pull down and parse the value from Mongo rapidjson::Document resp_doc; MongoResponseInterface *resp = mongo->load_document(\ inbound_message->get_object(i)->get_key()); if (resp) { std::string mongo_resp_str = resp->get_value(); main_logging->debug("Document loaded from Mongo"); main_logging->debug(mongo_resp_str); resp_doc.Parse(mongo_resp_str.c_str()); // Create a new Obj3 and add to the return list ObjectInterface *resp_obj = objfactory.build_object(resp_doc); response_message->add_object(resp_obj); delete resp; } else { main_logging->error("Document not found in Mongo"); response_message->set_error_code(NOT_FOUND); new_error_message = "Object not Found"; response_message->set_error_message(new_error_message); } } // Object Query } else if (inbound_message->get_msg_type() == OBJ_QUERY) { main_logging->info("Processing Object Batch Query Message"); batch_query(inbound_message, response_message, mongo); // Object Delete } else if (inbound_message->get_msg_type() == OBJ_DEL) { main_logging->info("Processing Object Deletion Message"); for (int i = 0; i < inbound_message->num_objects(); i++) { ObjectInterface *resp_element = objfactory.build_object(); resp_element->set_key(\ inbound_message->get_object(i)->get_key()); mongo->delete_document(\ inbound_message->get_object(i)->get_key()); response_message->add_object(resp_element); } // Ping } else if (inbound_message->get_msg_type() == PING) { main_logging->info("Ping Message Recieved"); // Kill } else if (inbound_message->get_msg_type() == KILL) { main_logging->info("Shutting Down"); shutdown_needed = true; // Invalid Message Type } else { response_message->set_error_code(BAD_MSG_TYPE_ERROR); new_error_message = "Unknown Message Type"; response_message->set_error_message(new_error_message); } // Exception during processing } catch (std::exception& e) { main_logging->error("Exception encountered during Processing"); main_logging->error(e.what()); response_message->set_error_code(PROCESSING_ERROR); new_error_message.assign(e.what()); response_message->set_error_message(new_error_message); } response_message->set_msg_type(inbound_message->get_msg_type()); } // Convert the response object to a message main_logging->debug("Building Response"); std::string application_response; response_message->to_msg_string(application_response); // Send the response via ZMQ main_logging->info("Sending Response"); main_logging->info(application_response); zmqi->send(application_response); // Cleanup if (response_message) { delete response_message; response_message = NULL; } if (inbound_message) { delete inbound_message; inbound_message = NULL; } // If we recieved a shutdown message, then we cleanup and exit if (shutdown_needed) {shutdown(); exit(1);} } return 0; }
MStatus preview(const MArgList& args,bool useVertexColor) { //单实例先清除 if(MaterialSet::getSingletonPtr()) MaterialSet::getSingletonPtr()->clear(); char tempPath[MAX_PATH]; GetTempPath(MAX_PATH, tempPath); std::string tempFileName(tempPath); ExportOptions::instance().m_outFilePath = tempFileName.c_str(); tempFileName += "\\"; tempFileName += _T("maya.mz"); ExportOptions::instance().m_outFile = tempFileName.c_str(); ExportOptions::instance().clipList.clear(); MTime kTimeMin = MAnimControl::animationStartTime(); //整个场景的起始帧 MTime kTimeMax = MAnimControl::animationEndTime(); //整个场景的结束帧 clipInfo clip; clip.name = "Animation"; clip.startFrame = (int)kTimeMin.value(); clip.endFrame = (int)kTimeMax.value(); clip.stepFrame = 1; ExportOptions::instance().clipList.push_back(clip); ExportOptions::instance().exportAnims = true; ExportOptions::instance().exportVertexColour = useVertexColor; /*BindPoseTool bindPoseTool; bindPoseTool.GoIntoBindPose();*/ MWriter writer; writer.read(); MStatus status = writer.write(); #ifdef RELEASEDEBUG #define DLL_NAME "MayaPreview_rd.exe" #elif _DEBUG #define DLL_NAME "MayaPreview_d.exe" #else #define DLL_NAME "MayaPreview.exe" #endif if(status == MS::kSuccess) { HWND hWnd = FindWindowEx(0,0,0,"MayaPreview"); //if(hWnd) //{ // SendMessage(hWnd,WM_CLOSE,0,0); // hWnd = 0; //} if(!hWnd) { static const std::string tMaxProgramName("Maya.exe"); char path[257]; GetModuleFileName(GetModuleHandle(tMaxProgramName.c_str()),path,256); std::string parentPath(path); parentPath.erase(parentPath.size() - tMaxProgramName.size(), tMaxProgramName.size()); std::string previewProgramPath(parentPath + "preview\\" + DLL_NAME); if(!ShellExecute(0,"open",previewProgramPath.c_str(),"","",SW_SHOW)) { MessageBox(0,previewProgramPath.c_str(),"Can't Find MayaPreview Program",0); return MS::kFailure; } hWnd = FindWindowEx(0,0,0,"MayaPreview"); DWORD tick = GetTickCount(); while(!hWnd) { DWORD tickNow = GetTickCount(); if(tickNow - tick > 3000)break; Sleep(1); hWnd = FindWindowEx(0,0,0,"MayaPreview"); } } if(hWnd) { SendMessage(hWnd,WM_USER + 128,0,0); SetActiveWindow(hWnd); SetForegroundWindow(hWnd); BringWindowToTop(hWnd); } } /*bindPoseTool .UndoGoIntoBindPose();*/ return MS::kSuccess; }