bool StreamToFileManager::startStreamingToFile(QString targetFilePath, bool isRemoveTargetFileIfExists) { if(isRemoveTargetFileIfExists) { // check whether the target-file exists QFile resourceTargetFile(targetFilePath); if(resourceTargetFile.exists()) { if( !resourceTargetFile.remove() ) { WLog("Cannot remove the file:") << targetFilePath; _isStreamingAborted = true; // Q_EMIT streamingFinishedWithError(targetFilePath, "File cannot be removed."); return false; } } } AW_QOBJECT_SAFE_DELETE(_targetFile); _targetFile = new QFile(targetFilePath, this); if(!_targetFile->open(QIODevice::WriteOnly | QIODevice::Append)) { WLog("Cannot open the file: ") << _targetFile->errorString(); _isStreamingAborted = true; // Q_EMIT streamingFinishedWithError(targetFilePath, "File cannot be opened."); return false; } DLog("File opened"); _isStreamingAborted = false; _isStreamClosing = false; _targetFilePath = targetFilePath; return true; }
void CleverApplicationIconPresenterSortingDelegate::_loadSortingDatabase(QString sortingDatabasePath) { if(sortingDatabasePath.isEmpty()) { WLog("Given sorting database path is empty. Cannot load it."); return; } if(!this->_isFilterMapLoadedFromDatabase) { QMutex mutex; mutex.lock(); if(!this->_isFilterMapLoadedFromDatabase) { // load SortingDatabaseManager *sortingDbManager = new SortingDatabaseManager(sortingDatabasePath); bool isSuccess = sortingDbManager->getAllFilterKeyValuePairs(this->_filterKeyValueMap); delete sortingDbManager; // flag if(isSuccess) { this->_currSortingDatabasePath = sortingDatabasePath; this->_isFilterMapLoadedFromDatabase = true; } else { WLog("Couldn't get the filter key-values. Probably invalid database-path."); } } mutex.unlock(); } }
bool PathManager::copyOnlyFilesOfDirectory(QString sourceDirPath, QString destDirPath) { FLAG_FOR_REVIEW_WITH_HINT("Should copy symlink / shortcut files as well?? Temporarily removed / turned off."); QDir sourceDir(sourceDirPath); QStringList files = sourceDir.entryList(QDir::NoDotAndDotDot | QDir::Files | QDir::NoSymLinks); for(int i = 0; i < files.count(); i++) { QString srcName = PathManager::combineAndCleanPathes(sourceDirPath, files[i]); QString destName = PathManager::combineAndCleanPathes(destDirPath, files[i]); // QFile cannot copy the file, when destName exists if(QFileInfo(srcName).isSymLink()) { // tmp, do nothing WLog(QString("The file [%1] is a symlink to file [%2]").arg(srcName).arg( QFileInfo(srcName).symLinkTarget() )); } else { if(!QFile::copy(srcName, destName)) { WLogS << " ! Cannot copy the file from: " << srcName << " to: " << destName; WLog(QString(" ! Cannot copy file from [%1] to [%2]").arg(srcName).arg(destName)); return false; } else { #ifdef ENABLE_PATH_MANAGER_LOGGING DLog(QString("Copy succeeded - file from [%1] to [%2]").arg(srcName).arg(destName)); #endif } } } files.clear(); return true; }
bool PathManager::deleteThisDirectoryAndEverythingBelow(QString topDirPath) { { QDir topDir(topDirPath); if (!topDir.exists()) { WLog(QString("The given topDir does not exists: %1").arg(topDirPath)); return true; } //First delete any files in the current directory QFileInfoList files = topDir.entryInfoList(QDir::NoDotAndDotDot | QDir::Files | QDir::Hidden | QDir::System/* | QDir::NoSymLinks*/); for(int i = 0; i < files.count(); i++) { QString currFileInPath = files.at(i).fileName(); /*QString currFileAbsolutePath = files.at(i).absoluteFilePath(); if(QFileInfo(currFileAbsolutePath).isSymLink()) { // it's a symlink simply remove it PATH_MANAGER_INTERNAL_LOG_TO_DATABASE(QString("The dir is a symlink file [%1]. Simply remove it.").arg(currDirAbsolutePath)); QDir().remove(currDirAbsolutePath); } else */ if( !topDir.remove(currFileInPath) ) { WLogS << " ! The specified file cannot be removed: " << currFileInPath; WLog(QString("The specified file cannot be removed: %1").arg(files.at(i).absoluteFilePath())); return false; } } //Now recursively delete any child directories QFileInfoList dirs = topDir.entryInfoList(QDir::NoDotAndDotDot | QDir::Dirs); for(int i = 0; i < dirs.count(); i++) { QString currDirAbsolutePath = dirs.at(i).absoluteFilePath(); if(QFileInfo(currDirAbsolutePath).isSymLink()) { // it's a symlink to a dir, simply remove this symlink file WLog(QString("The dir is a symlink file [%1]. Simply remove it.").arg(currDirAbsolutePath)); QDir().remove(currDirAbsolutePath); } else if( !PathManager::deleteThisDirectoryAndEverythingBelow( currDirAbsolutePath ) ) { return false; } } } //Finally, remove empty top directory // if( !topDir.rmdir(topDir.path()) ) { if( !QDir().rmdir(topDirPath) ) { WLog(QString("The specified directory cannot be removed: %1. Maybe it's still not empty.").arg(topDirPath)); return false; } return true; }
bool Background_ClientInstaller::tryToBackup() { // remove the previous backup if(!PathHelper::deleteThisDirectoryAndEverythingBelow(AppSpecificPathHelper::getTmp_ClientSelfUpdate_OldVersionBackupFolder())) { WLog("Failed to clear the backup folder."); return false; } else { DLog("Backup folder cleared."); } #ifdef Q_OS_WIN // do the new backup if(!PathHelper::copyWholeDirectory(this->_clientRootPath, AppSpecificPathHelper::getTmp_ClientSelfUpdate_OldVersionBackupFolder(), true, PathHelper::SHM_UseAsFile)) { WLog("Failed to do the backup."); return false; } else { DLog("Backup finished."); } #endif #ifdef Q_OS_MAC // Get apps with *.appwhirr.bitfall bundle identifier and delete them QDir root(this->_clientRootPath); QStringList dirs = root.entryList(QDir::NoDotAndDotDot | QDir::Dirs); QString dir; Q_FOREACH(dir, dirs) { if (dir.endsWith(".app", Qt::CaseInsensitive)) { QString path = PathHelper::combineAndCleanPathes(this->_clientRootPath, dir); if (PathHelper::getBundleIdentifier(path).endsWith(".appwhirr.bitfall")) { // do the new backup if(!PathHelper::copyWholeDirectory(path, AppSpecificPathHelper::getTmp_ClientSelfUpdate_OldVersionBackupFolder(), false, PathHelper::SHM_UseAsFile)) { WLog("Failed to do the backup."); return false; } else { DLog("Backup finished."); } } } } #endif return true; }
void CommunicationDescriptionGateway::requestReceived(QByteArray response) { if(networkRequest == NULL) { WLog("Response recieved, but request is already deleted! Cannot parse the response! This should never happen."); return; } Q_EMIT _receivedResponseData(response); networkResponse = networkRequest->getResponseParser(); if (!networkResponse) { QList<BaseNetworkEntity*> emptyList; Q_EMIT this->finished(emptyList); _finishedWithCommunicationStep(); return; } connect(networkResponse, SIGNAL(finished()), this, SLOT(responseFinished())); connect(networkResponse, SIGNAL(parsingFinished(QList<BaseNetworkEntity*>)), this, SIGNAL(finished(QList<BaseNetworkEntity*>))); connect(networkResponse, SIGNAL(parsingFailed(QString)), this, SIGNAL(failedToRetrieveDescription(QString))); // // parse in background QThreadPool::globalInstance()->start(networkResponse); }
VixMntMsgQue::VixMntMsgQue(const char *msg_name, bool readOnly) { // readOnly is unused now. this->readOnly = readOnly; if (!msg_name) { this->vixMntMsgMapFileName = VixMntMsgQue::vixMntMsgName; } else { this->vixMntMsgMapFileName = msg_name; } this->vixMntMsgID = mq_open(this->vixMntMsgMapFileName.c_str(), O_CREAT | O_RDWR, 0644, NULL); if (this->vixMntMsgID < 0) { if (errno == EEXIST) { WLog("exist mqid : %d | mq_name : %s", this->getVixMntMsgID(), vixMntMsgMapFileName.c_str()); } else { ELog("open mesage queue error %s ", strerror(errno)); } } assert(this->vixMntMsgID > 0); VixMntMsgQue::vixMntMsgMap[this->vixMntMsgMapFileName] = this->vixMntMsgID; }
// Q_SLOT void NotificationManager::itemHiddenAndSafeToRemove(QWidget *widget) { int currDeletingItemCnt = this->_currDeletingTimeoutedNotifWidgets.size(); bool isFound = false; for(int i = 0; i < currDeletingItemCnt && !isFound; i++) { if(_currDeletingTimeoutedNotifWidgets[i] == widget) { isFound = true; } } if(isFound) { // remove from layout -> not necessary - this method is called by the layout // remove from the tmp "deleting" collection NotificationWidget *castedWidget = dynamic_cast<NotificationWidget *>(widget); if(castedWidget != NULL) { this->_currDeletingTimeoutedNotifWidgets.removeOne(castedWidget); // and delete the notification widget AW_QOBJECT_SAFE_DELETE(widget); } else { WLog("Cannot cast the widget to the desired type. This should never happen!"); } } else { // DLog("Item not found int _currDeletingTimeoutedNotifWidgets. It's only temporarily swapped-out from the layout."); } }
void AppUninstaller::_cleanUpFailedWithError(QString errorMessage) { WLog("Clean-up failed with error: ") << errorMessage; PathHelper::logLastOSSpecificFileSystemHandlingError(); // backup cleanup is not a critical action in uninstall - everything else succeeded so the uninstall did succeed this->_currentUninstallFinishedWithSuccess(); }
void AppUninstaller::_appRemoveFailedWithError(QString errorMessage) { WLog("App remove failed with error: ") << errorMessage; PathHelper::logLastOSSpecificFileSystemHandlingError(); // Q_EMIT uninstallSuspendedInternally(this->_uninstallQueue.head()); this->_currentUninstallFailedWithError("App remove failed."); }
void AppUninstaller::_backupFolderClearFinished() { DLog("--- do backup"); // step 2: do backup if(!QDir(this->_uninstallQueue.head().getDynamicDescription_ReadOnly()->getInstalledRootPath()).exists()) { WLog("Application is not installed - it's installed root path does not exists here: ") << this->_uninstallQueue.head().getDynamicDescription_ReadOnly()->getInstalledRootPath(); // will emit success to allow the GUI to refresh as not-installed this->_currentUninstallFinishedWithSuccess(); return; } QString appId = this->_uninstallQueue.head().getDynamicDescription_ReadOnly()->getAppId(); Q_EMIT progressStateMessage(appId, tr("Performing app backup")); #if 0 QString appIntalledDirPath = this->_uninstallQueue.head().getDynamicDescription_ReadOnly()->getInstalledRootPath(); Runnable_CopyDirectory *backupWorker = new Runnable_CopyDirectory(appIntalledDirPath, AppSpecificPathHelper::getTmp_UninstallBackupDirectoryPath(), true, PathHelper::SHM_UseAsFile, true); connect(backupWorker, SIGNAL(failedWithError(QString)), this, SLOT(_backupFailedWithError(QString))); connect(backupWorker, SIGNAL(finishedWithSuccess()), this, SLOT(_backupFinished())); QThreadPool::globalInstance()->start(backupWorker); #endif if( !PathHelper::renameFileOrFolder(this->getCurrentAppInstalledRootDirFileInfo(), this->getCurrentAppTargetBackupDirName()) ) { this->_backupFailedWithError(tr("Cannot backup the app")); } else { this->_backupFinished(); } }
void AWUninstallPerformerTask::removeAppWhirrClient() { Q_EMIT uninstallStateMessage(tr("Removing AppWhirr app...")); QFileInfo clientAppFolderFileInfo(_uninstallConfigs->getAppWhirrClientAppFolderPath()); #ifdef Q_OS_MAC QString clientAppFolderDirName( QDir(clientAppFolderFileInfo.absoluteFilePath()).dirName() ); if( clientAppFolderDirName != "AppWhirrData" ) { // fail for security reasons (don't delete any other folder, especially not the Applications folder) WLog("Because of security reasons the AppWhirr client have to be in the 'AppWhirrData' folder - and it's not. Won't delete the client. => Detected dir-name: ") << clientAppFolderDirName; _uninstallConfigs->addFailedUninstallStep(UninstallDeleteSteps::RemoveAppWhirrClientFiles); Q_EMIT uninstallStateMessage(tr("Failed to remove the AppWhirr app...")); this->finishedWithRemoveAppWhirrClient(); return; } else { DLog("AppWhirr is in the 'AppWhirrData' folder - uninstall can be performed"); } #endif if(clientAppFolderFileInfo.exists()) { if( !this->deleteFileOrFolderWithBackup(QFileInfo(_uninstallConfigs->getAppWhirrClientAppFolderPath())) ) { _uninstallConfigs->addFailedUninstallStep(UninstallDeleteSteps::RemoveAppWhirrClientFiles); Q_EMIT uninstallStateMessage(tr("Failed to remove the AppWhirr app...")); } } this->finishedWithRemoveAppWhirrClient(); }
void AppUninstaller::_revertBackupFailedWithError(QString errorMessage) { WLog("Revert backup failed with error: ") << errorMessage; PathHelper::logLastOSSpecificFileSystemHandlingError(); // don't store anything, revert backup is not that crucial this->_currentUninstallFailedWithError(tr("Cannot remove the application.")); }
void SameSizeLayoutSnapshotChangeDelegateBase::changeSnapshot(WidgetListSnapshot sourceSnapshot, WidgetListSnapshot targetSnapshot) { // check whether a change is currently in progress so we should only store (and compress) // this change or we should make it right now (if we are not busy right now) if(isProcessingSnapshotChangeFlag) { #ifdef ENABLE_SNAPSHOT_HANDLING_LOGGING DLog("isProcessingSnapshotChangeFlag = true"); DLogS << "sourceSnapshot cnt: " << sourceSnapshot.getOrderedItemCount(); DLogS << "targetSnapshot cnt: " << targetSnapshot.getOrderedItemCount(); #endif //snapshotQueue.enqueue(SnapshotQueueItem(sourceSnapshot, targetSnapshot)); isCompactSnapshotChangeAvailable = true; if(isCompactSnapshotSourceNotYetDefined) { isCompactSnapshotSourceNotYetDefined = false; compactSnapshotChange.setSourceSnapshot(sourceSnapshot); } compactSnapshotChange.setTargetSnapshot(targetSnapshot); return; } DynamicDelegateBasedHighPerformanceSameSizeLayoutBase *castedParent = this->getCastedParentLayout(); if(castedParent == NULL) { WLog("Parent is not the type we need."); return; } QSize currentOptimalSize = castedParent->getCalculatedOptimalSize(); isProcessingSnapshotChangeFlag = true; // block until it finished - queue the requests SameSizeHorizontalLayoutingInformations layoutInformations = castedParent->getLayoutingInformations(); // force-recalculate the sizes before layout-blocking // -> the layout has the required informations about the new-state (new item cound, size, ...) // castedParent->recalculateMinimalAndOptimalSizesByTotalLayoutWidth(castedParent->getCachedLastReceivedRect().width()); castedParent->_recalculateOptimalSizeByLastReceivedWidth(); QSize predictedOptimalSizeAfterLayoutChange = castedParent->getCalculatedOptimalSize(); Q_EMIT layoutChangeStarted(currentOptimalSize, predictedOptimalSizeAfterLayoutChange); castedParent->setLayoutUpdateBlocked(true, false); // clear the current animation set - it's allowed here, we are not in a change-progress (animation) this->clearCurrentAnimationGroup(); // // calculate and create the change-animations this->_changeSnapshotImplementation(sourceSnapshot, targetSnapshot, layoutInformations); // // and start the change-animations this->startCurrentAnimationGroup(); }
bool ApplicationDescriptionModel::isUpdateAvailable() { if(this->getDynamicDescription_ReadOnly()->getAppState() == AppWhirr::ApplicationGrabStates::Installed) { if(this->getDynamicDescription_ReadOnly()->getInstalledVersion() != this->getDynamicDescription_ReadOnly()->getNewestAvailableVersionForThisPlatform()) { if(this->getDynamicDescription_ReadOnly()->getNewestAvailableVersionForThisPlatform().isEmpty()) { WLog("Newest available version - is empty!"); return false; } if(this->getDynamicDescription_ReadOnly()->getInstalledVersion().isEmpty()) { WLog("Installed version - is empty!"); } return true; } } return false; }
SameSizeHorizontalLayoutingInformations SameSizeLayoutSnapshotChangeDelegateBase::getLayoutingInformations() { DynamicDelegateBasedHighPerformanceSameSizeLayoutBase *castedParent = this->getCastedParentLayout(); if(castedParent == NULL) { WLog("Parent is not the type we need."); return SameSizeHorizontalLayoutingInformations::CreateEmpty(); } return castedParent->getLayoutingInformations(); }
void CleverApplicationIconPresenterSortingDelegate::addOrSetValueForKey(QString filterKey, QString filterValue) { if(_currSortingDatabasePath.isEmpty()) { WLog("Sorting database path is empty - probably you forgot to call _loadSortingDatabase"); return; } this->_filterKeyValueMap[filterKey] = filterValue; SortingDatabaseManager *sortingDbManager = new SortingDatabaseManager(_currSortingDatabasePath); sortingDbManager->setValueForKey(filterKey, filterValue); delete sortingDbManager; }
void AppUninstaller::_currentUninstallFailedWithError(QString errorMessage) { // remove the item ApplicationDescriptionModel appDescr = this->_uninstallQueue.dequeue(); WLog(" -- Uninstall failed for item: ") << appDescr.getDynamicDescription_ReadOnly()->getAppId() << appDescr.getDynamicDescription_ReadOnly()->getAppName(); // emit the error Q_EMIT failedWithError(appDescr, errorMessage); // and try to start the next uninstall _isInUninstallProcess = false; this->_tryToStartNextUninstallInQueue(); }
bool Background_ClientInstaller::copyNewVersion() { // recreate the directory if(!PathHelper::ensureDirectoryCreated(this->_clientRootPath)) { WLog("Failed to recreate target client directory."); return false; } else { DLog("Target client directory recreated."); } if(!PathHelper::copyWholeDirectory(AppSpecificPathHelper::getTmp_ClientSelfUpdate_UncompressedNewVersionPath(), this->_clientRootPath, true, PathHelper::SHM_UseAsFile)) { WLog("Failed to copy the new version to it's final place."); return false; } else { DLog("New version copied to it's final place."); } return true; }
void SameSizeLayoutSnapshotChangeDelegateBase::layoutChangeAnimationsFinished() { DynamicDelegateBasedHighPerformanceSameSizeLayoutBase *castedParent = this->getCastedParentLayout(); if(castedParent == NULL) { WLog("Parent is not the type we need."); return; } //castedParent->setLayoutUpdateBlocked(false, false); this->_hideAndSendSignalAboutDeletedItems(); // // THIS IS REQUIRED !!! -> the changeSnapshot method will use it and may modify it // for myself (Viktor): do a favor for yourself - don't modify this, or at least check whether it's used anywhere else as well in this code before optimization isProcessingSnapshotChangeFlag = false; #if 0 // // chech for another layout change (happened during the animation-block) if(!snapshotQueue.isEmpty()) { //DLog(" ! there are other queued changes"); // another snapshot is in the queue -> do it SnapshotQueueItem snapshotItem = snapshotQueue.dequeue(); this->changeSnapshot(snapshotItem.getSourceSnapshot(), snapshotItem.getTargetSnapshot()); } #endif // ! this is an optimized solution // it eliminates the quene and compresses the change to only // one SnapshotChange item - it's source is the first unprocessed source // and it's target is the last unprocessed target snapshot if(isCompactSnapshotChangeAvailable) { isCompactSnapshotChangeAvailable = false; isCompactSnapshotSourceNotYetDefined = true; this->changeSnapshot(compactSnapshotChange.getSourceSnapshot(), compactSnapshotChange.getTargetSnapshot()); } if(!isProcessingSnapshotChangeFlag) { // no more snapshots, hurray!! #ifdef ENABLE_SNAPSHOT_HANDLING_LOGGING DLog(" no more changes in the queue"); #endif castedParent->setLayoutUpdateBlocked(false, true); castedParent->update(); Q_EMIT layoutChangeFinished(); } }
bool Background_ClientInstaller::setRequiredPermissionsForTheNewVersion() { #ifdef Q_OS_WIN // set execution permission first if (!PathHelper::setPermissionForFilesOfDirectory(this->_clientRootPath, QFile::ExeGroup | QFile::ExeOther | QFile::ExeOwner | QFile::ExeUser, true, true)) { WLog("Failed to set required permissions."); return false; } else { DLog("Permissions set."); return true; } #endif #ifdef Q_OS_MAC // Get apps with *.appwhirr.bitfall bundle identifier and delete them QDir root(this->_clientRootPath); QStringList dirs = root.entryList(QDir::NoDotAndDotDot | QDir::Dirs); QString dir; Q_FOREACH(dir, dirs) { if (dir.endsWith(".app", Qt::CaseInsensitive)) { QString path = PathHelper::combineAndCleanPathes(this->_clientRootPath, dir); if (PathHelper::getBundleIdentifier(path).endsWith(".appwhirr.bitfall")) { // set execution permission first if (!PathHelper::setPermissionForFilesOfDirectory(path, QFile::ExeGroup | QFile::ExeOther | QFile::ExeOwner | QFile::ExeUser, true, true)) { WLog("Failed to set required permissions."); return false; } else { DLog("Permissions set."); } } } } return true; #endif }
bool AutoStartupDelegate::makeItAutoStartAtSystemStartup() { if(!DesktopShortcutCreator::createShortcut(AppSpecificPathHelper::getWinAndWinUserSpecAppWhirrClientAutoStartupFilePath(), AppSpecificPathHelper::getClientExecutablePath(), QString(), "Start AppWhirr client", true)) { WLog("Cannot create the desktop-shortcut to path: ") << AppSpecificPathHelper::getWinAndWinUserSpecAppWhirrClientAutoStartupFilePath(); return false; } else { // DLog("SUccess!!"); return true; } // bool isSucceeded = true; // // Get the file path // QString qAppPath = QCoreApplication::applicationFilePath(); // // Check if we have already in the autostarup list // if (willStartAtSystemStartup(qAppPath)) { // return true; // } // QString easyAppsWindowStartupFilePath = this->getEasyAppsStartupFile_WinAndUserSpecific(); // DLogS << "startup file path: " << easyAppsWindowStartupFilePath; // if(!easyAppsWindowStartupFilePath.isEmpty()) // { // qDebug(easyAppsWindowStartupFilePath.toAscii()); // QFile f(easyAppsWindowStartupFilePath); // if (!f.open(QFile::WriteOnly | QIODevice::Text)) { // qDebug("FAILED to open the startup file"); // return false; // } // QFileInfo fi(QApplication::applicationFilePath()); // f.write("@ECHO OFF\n"); // // the proper syntax to "start app without waiting to finish" with working dir: // // example: start /d "E:\My Dropbox\EasyApps\Releases\V1\PreAlpha" EasyPortableApps_AppLauncher.exe // QString startCommand = QString("start /d %1 %2").arg( // PathManager::quotePath(QDir::toNativeSeparators(QApplication::applicationDirPath())), // fi.fileName()); // f.write(startCommand.toAscii()); // f.close(); // qDebug(startCommand.toAscii()); // } else { // qDebug("Cannot get the startup-folder. Sorry."); // } // return isSucceeded; }
void CommunicationDescriptionGateway::performThisRequest(BaseNetworkRequest *requestToPerform) { if(_isRequestActive) { WLog("Active request found! Only one request can be active!"); return; } _isRequestActive = true; _finishedSteps = 0; this->networkRequest = requestToPerform; setupRequestConnections(); networkRequest->startThisRequest(); }
bool Background_ClientInstaller::tryToRemoveOldVersion() { #ifdef Q_OS_WIN // remove the current version if(!PathHelper::deleteThisDirectoryAndEverythingBelow(this->_clientRootPath)) { WLog("Failed to remove the old version."); return false; } else { DLog("Old version removed."); } #endif #ifdef Q_OS_MAC // Get apps with *.appwhirr.bitfall bundle identifier and delete them QDir root(this->_clientRootPath); QStringList dirs = root.entryList(QDir::NoDotAndDotDot | QDir::Dirs); QString dir; Q_FOREACH(dir, dirs) { if (dir.endsWith(".app", Qt::CaseInsensitive)) { QString path = PathHelper::combineAndCleanPathes(this->_clientRootPath, dir); if (PathHelper::getBundleIdentifier(path).endsWith(".appwhirr.bitfall")) { // It's an AW app, remove it. if(!PathHelper::deleteThisDirectoryAndEverythingBelow(path)) { WLog("Failed to remove the old version."); return false; } else { DLog("Old version removed."); } } } } #endif return true; }
void MainWindow::_startDeleteTest() { DLog("-- start DELETE test: ") << _testSrcDirLineEdit->text(); if(!PathHelper::deleteThisDirectoryAndEverythingBelow(_testSrcDirLineEdit->text())) { WLog("delete FAILED!"); } else { DLog(" - delete test SUCCESS"); } DLog(" -> end of DELETE test"); }
void MainWindow::_startCopyTest() { DLog("-- start COPY test: ") << _testSrcDirLineEdit->text() << "|" << _testDestDirLineEdit->text(); if(!PathHelper::copyWholeDirectory(_testSrcDirLineEdit->text(), _testDestDirLineEdit->text(), false, PathHelper::SHM_UseAsFile)) { WLog("Copy FAILED!"); } else { DLog(" -> copy test SUCCESS!"); } DLog(" -> end of COPY test"); }
bool AutoStartupDelegate::removeItFromAutoStartList() { bool isSucceeded = true; QString appwhirrWindowStartupFilePath = AppSpecificPathHelper::getWinAndWinUserSpecAppWhirrClientAutoStartupFilePath(); if( QFile::exists(appwhirrWindowStartupFilePath) ) { if( QFile(appwhirrWindowStartupFilePath).remove() ) { DLog("Auto-startup file removed"); } else { WLog("Auto-startup file found but cannot be removed"); isSucceeded = false; } } return isSucceeded; }
void Background_GrabSyncPerformer::run() { DLog("Background grab-sync started"); LocalAppDatabaseManager *localAppDatabaseManager = GlobalObjectRegistry::sharedGlobalObjectRegistry()->getLocalAppDatabaseManager(); // connect(this, SIGNAL(newAppGrabbedSignal(QString,QString,QString)), localAppDatabaseManager, SLOT(_addGrabbedApp(QString,QString,QString))); // localAppDatabaseManager->startBatchGrabApplicationAdd(); int userGrabbedAppsSesultListCnt = _resultList.size(); DLog("Grabbed list - count: ") << userGrabbedAppsSesultListCnt; for(int i = 0; i < userGrabbedAppsSesultListCnt; i++) { AW::Common::Communication::BaseNetworkEntity* currUserGrabbedAppEntity = _resultList[i]; ApplicationBaseInfosNetworkEntity *currCastedUserGrabbedGrabEntity = dynamic_cast<ApplicationBaseInfosNetworkEntity *>(currUserGrabbedAppEntity); if(currCastedUserGrabbedGrabEntity == NULL) { WLog("Invalid communication entity - cannot cast it!"); } else { QString appName = currCastedUserGrabbedGrabEntity->getApplicationName(); QString appId = currCastedUserGrabbedGrabEntity->getApplicationID(); // QString appSupportedPlatformFlags = PlatformFlagsHelper::_convertIntBasedFlagsToStringBased(currCastedUserGrabbedGrabEntity->getApplicationVersionSummedFlags()); FLAG_FOR_REVIEW_WITH_HINT("After code revision: it's not a summed flag, it's just an OS flag indicator for the current OS (whether the current platform is supported or not)"); QString appSupportedPlatformFlags = PlatformFlagsHelper::_convertIntBasedFlagsToStringBased(currCastedUserGrabbedGrabEntity->getApplicationVersionSummedFlags()); QString appNewestVersionForThisPlatform = currCastedUserGrabbedGrabEntity->getApplicationVersion(); DLogS << QString("Newest version of app (%1) (%2): %3").arg(appId).arg(appName).arg(appNewestVersionForThisPlatform); // DLogS << QString("Found user-grabbed app: %1 [with appId:%2]").arg(appName).arg(appId); AppWhirr::ApplicationStatusInStore::ApplicationStatusInStoreEnum appStatusInStore = currCastedUserGrabbedGrabEntity->getAppStatusInStore(); DLog("App status in store: ") << appStatusInStore; // Q_EMIT newAppGrabbedSignal(appId, appName, appSupportedPlatformFlags); localAppDatabaseManager->addOrUpdateGrabbedApp(appId, appName, appSupportedPlatformFlags, appNewestVersionForThisPlatform, appStatusInStore); } } // localAppDatabaseManager->commitBatchGrabApplicationAdd(); // disconnect(this, SIGNAL(newAppGrabbedSignal(QString,QString,QString)), localAppDatabaseManager, SLOT(_addGrabbedApp(QString,QString,QString))); DLog("Background grab-sync ended"); Q_EMIT finished(); }
runall_result test_feature() { vector<accelerator> devices = get_available_devices(); // all but CPU devices runall_result result; for (size_t i = 0; i < devices.size(); i++) { accelerator& device = devices[i]; WLog() << "Device " << i << ": " << device.description << " (" << device.device_path << ")" << std::endl; Log() << " Version: " << device.get_version() << "; Memory: " << device.get_dedicated_memory() << std::endl; Log() << " Debug: " << device.get_is_debug() << "; Emulated: " << device.get_is_emulated() << "; Has Display: " << device.get_has_display() << std::endl; result &= REPORT_RESULT((test_accl_staging_buffer_constructor<_type, _rank, accelerator_view>(device.default_view, device.default_view))); result &= REPORT_RESULT((test_accl_staging_buffer_constructor<_type, _rank, accelerator_view>(device.create_view(queuing_mode_immediate), device.create_view(queuing_mode_automatic)))); result &= REPORT_RESULT((test_accl_staging_buffer_constructor<_type, _rank, accelerator_view>(device.create_view(queuing_mode_automatic), device.create_view(queuing_mode_immediate)))); Log_writeline(); } return result; }
void StreamToFileManager::_chunkWriteToFileFailedWithError(QString errorMessage) { WLog("Chunk write to file FAILED:") << _targetFilePath << "error:" << errorMessage; this->abortStreaming(); }