/* Clears the web cache, because Qt 5.2 WebView chokes on caches from
* older Qt versions.
*/
void clearWebCache()
{
const QStringList cachePaths = QStandardPaths::standardLocations(
QStandardPaths::CacheLocation);
if (cachePaths.size())
{
// some very old versions of SailfishOS may not find this cache,
// but that's OK since they don't have the web cache bug anyway
const QString tidingsWebCache =
QDir(cachePaths.at(0)).filePath(".QtWebKit");
QDir cacheDir(tidingsWebCache);
if (cacheDir.exists())
{
if (cacheDir.removeRecursively())
{
qDebug() << "Cleared web cache:" << tidingsWebCache;
}
else
{
qDebug() << "Failed to clear web cache:" << tidingsWebCache;
}
}
else
{
qDebug() << "Web cache does not exist:" << tidingsWebCache;
}
}
else
{
qDebug() << "No web cache available.";
}
}
void SFtpFileEngine::readDir(const QString &dir)
{
QString cacheDir(getCachePath(dir, true));
_fileInfoCache->removeDirInfo(cacheDir);
// add an empty entry to distinguish a empty directory from
// a non-existent directory
_fileInfoCache->addFileInfo(cacheDir, QUrlInfo());
LIBSSH2_SFTP_HANDLE* dir_handle;
dir_handle = libssh2_sftp_opendir(_sftp_session,
_textCodec->fromUnicode(dir).data());
if (dir_handle)
{
QByteArray entry(512, 0);
QByteArray longEntry(512, 0);
LIBSSH2_SFTP_ATTRIBUTES attr;
while (libssh2_sftp_readdir_ex(dir_handle, entry.data(),
entry.capacity(), longEntry.data(),
longEntry.capacity(), &attr) > 0)
{
QString entryUni(_textCodec->toUnicode(entry.data()));
QUrlInfo urlInfo;
attr2urlinfo(&urlInfo, entryUni, &attr);
_fileInfoCache->addFileInfo(cacheDir, urlInfo);
}
libssh2_sftp_closedir(dir_handle);
}
}
void setupXDGVars()
{
gcString homeDir(getenv("HOME")); // Used for falling back.
gcString configDir(getenv("XDG_CONFIG_HOME"));
gcString cacheDir(getenv("XDG_CACHE_HOME"));
if (homeDir.empty())
{
// Below we just use 'falling back' and don't note we're setting it,
// but as $HOME is referenced later on it might confuse anybody reading the
// logs.
// Also use 'passwd' instead of 'password' as that may freak out some users.
printf("$HOME not set, temporarily setting it to the user's passwd entry.");
struct passwd* pass = getpwuid(getuid());
homeDir = pass->pw_dir;
}
if (configDir.empty())
{
printf("$XDG_CONFIG_HOME not set, falling back to $HOME/.config.");
configDir = homeDir + "/.config";
}
if (cacheDir.empty())
{
printf("$XDG_CACHE_HOME not set, falling back to $HOME/.cache.");
cacheDir = homeDir + "/.cache";
}
setenv("HOME", homeDir.c_str(), 1);
setenv("XDG_CONFIG_HOME", configDir.c_str(), 1);
setenv("XDG_CACHE_HOME", cacheDir.c_str(), 1);
}
// Loads a revision from the cache
Revision *Cache::get(const std::string &id)
{
if (!m_loaded) {
load();
}
std::string dir = cacheDir();
std::pair<uint32_t, uint32_t> offset = m_index[id];
std::string path = str::printf("%s/cache.%u", dir.c_str(), offset.first);
if (m_cin == NULL || offset.first != m_ciindex) {
delete m_cin;
m_cin = new BIStream(path);
m_ciindex = offset.first;
if (!m_cin->ok()) {
throw PEX(str::printf("Unable to read from cache file: %s", path.c_str()));
}
}
if (!m_cin->seek(offset.second)) {
throw PEX(str::printf("Unable to read from cache file: %s", path.c_str()));
}
Revision *rev = new Revision(id);
std::vector<char> data;
*m_cin >> data;
data = utils::uncompress(data);
if (data.empty()) {
throw PEX(str::printf("Unable to read from cache file: %s", path.c_str()));
}
MIStream rin(data);
if (!rev->load03(rin)) {
throw PEX(str::printf("Unable to read from cache file: %s", path.c_str()));
}
return rev;
}
void lmcMainWindow::stop(void) {
// These settings are saved only if the window was opened at least once by the user
if(windowLoaded) {
pSettings->setValue(IDS_WINDOWMAIN, saveGeometry());
pSettings->setValue(IDS_MINIMIZEMSG, showMinimizeMsg, IDS_MINIMIZEMSG_VAL);
}
pSettings->beginWriteArray(IDS_GROUPEXPHDR);
for(int index = 0; index < ui.tvUserList->topLevelItemCount(); index++) {
pSettings->setArrayIndex(index);
pSettings->setValue(IDS_GROUP, ui.tvUserList->topLevelItem(index)->isExpanded());
}
pSettings->endArray();
pTrayIcon->hide();
// delete all temp files from cache
QDir cacheDir(StdLocation::cacheDir());
if(!cacheDir.exists())
return;
QDir::Filters filters = QDir::Files | QDir::Readable;
QDir::SortFlags sort = QDir::Name;
// save all cached conversations to history, then delete the files
QString filter = "msg_*.tmp";
lmcMessageLog* pMessageLog = new lmcMessageLog();
QStringList fileNames = cacheDir.entryList(QStringList() << filter, filters, sort);
foreach (QString fileName, fileNames) {
QString filePath = cacheDir.absoluteFilePath(fileName);
pMessageLog->restoreMessageLog(filePath, false);
QString szMessageLog = pMessageLog->prepareMessageLogForSave();
History::save(pMessageLog->peerName, QDateTime::currentDateTime(), &szMessageLog);
QFile::remove(filePath);
}
void LogFile::init()
{
assert(dir_.empty());
dir_ = cacheDir() + "log/";
if (!boost::filesystem::is_directory(dir_.c_str()))
{
boost::filesystem::create_directories(dir_.c_str());
}
}
// Loads the index file
void Cache::load()
{
std::string path = cacheDir();
PDEBUG << "Using cache dir: " << path << endl;
m_index.clear();
m_loaded = true;
bool created;
checkDir(path, &created);
lock();
if (created) {
return;
}
// For git repositories, the hardest part is calling uuid()
sys::datetime::Watch watch;
GZIStream *in = new GZIStream(path+"/index");
if (!in->ok()) {
Logger::info() << "Cache: Empty cache for '" << uuid() << '\'' << endl;
return;
}
uint32_t version;
*in >> version;
switch (checkVersion(version)) {
case OutOfDate:
delete in;
throw PEX(str::printf("Cache is out of date - please run the check_cache report", version));
case UnknownVersion:
delete in;
throw PEX(str::printf("Unknown cache version number %u - please run the check_cache report", version));
default:
break;
}
Logger::status() << "Loading cache index... " << ::flush;
std::string buffer;
std::pair<uint32_t, uint32_t> pos;
uint32_t crc;
while (!(*in >> buffer).eof()) {
if (buffer.empty()) {
break;
}
*in >> pos.first >> pos.second;
*in >> crc;
m_index[buffer] = pos;
}
Logger::status() << "done" << endl;
delete in;
Logger::info() << "Cache: Loaded " << m_index.size() << " revisions in " << watch.elapsedMSecs() << " ms" << endl;
}
void StreamCache::PurgeCache( void )
{
std::string cacheDir( WSW_UI_STREAMCACHE_DIR );
std::vector<std::string> cachedFiles;
getFileList( cachedFiles, cacheDir, "*", true );
for( std::vector<std::string>::const_iterator it = cachedFiles.begin(); it != cachedFiles.end(); ++it ) {
trap::FS_RemoveFile( (cacheDir + "/" + *it).c_str() );
}
}
// Checks cache consistency
void LdbCache::check(bool force)
{
try {
if (!m_db) opendb();
} catch (const std::exception &ex) {
PDEBUG << "Exception while opening database: " << ex.what() << endl;
Logger::info() << "LdbCache: Database can't be opened, trying to repair it" << endl;
}
if (force || !m_db) {
std::string path = cacheDir() + "/ldb";
leveldb::Status status = leveldb::RepairDB(path, leveldb::Options());
if (!status.ok()) {
Logger::err() << "Error repairing database: " << status.ToString() << endl;
} else {
Logger::info() << "LdbCache: Database repaired" << endl;
}
closedb();
opendb();
}
// Simply try to read all revisions
Logger::info() << "LdbCache: Checking revisions..." << endl;
std::vector<std::string> corrupted;
size_t n = 0;
leveldb::Iterator* it = m_db->NewIterator(leveldb::ReadOptions());
for (it->SeekToFirst(); it->Valid(); it->Next()) {
Revision rev(it->key().ToString());
std::string value = it->value().ToString();
MIStream rin(value.c_str(), value.length());
if (!rev.load(rin)) {
PDEBUG << "Revision " << it->key().ToString() << " corrupted!" << endl;
corrupted.push_back(it->key().ToString());
}
++n;
}
if (!it->status().ok()) {
Logger::err() << "Error iterating over cached revisions: " << it->status().ToString() << endl;
Logger::err() << "Please re-run with --force to repair the database (might cause data loss)" << endl;
return;
}
Logger::info() << "LdbCache: Checked " << n << " revisions, found " << corrupted.size() << " to be corrupted" << endl;
for (size_t i = 0; i < corrupted.size(); i++) {
Logger::err() << "LdbCache: Revision " << corrupted[i] << " is corrupted, removing from index file" << endl;
leveldb::Status status = m_db->Delete(leveldb::WriteOptions(), corrupted[i]);
if (!status.ok()) {
Logger::err() << "Error: Can't remove from revision " << corrupted[i] << " from database: " << status.ToString() << endl;
return;
}
}
}
CachedImageProvider::CachedImageProvider() :
QDeclarativeImageProvider(QDeclarativeImageProvider::Image)
{
qDebug("entered");
cache = new QHash<QString, QImage>();
QDir cacheDir(CACHE_FOLDER);
if (!cacheDir.exists()) {
cacheDir.mkpath(".");
}
QList<QFileInfo> files = cacheDir.entryInfoList(QDir::Files);
foreach(QFileInfo fi, files){
cache->insert(fi.fileName(), QImage(fi.absoluteFilePath()));
}
void BtrfsBalancer::checkLastBalanced()
{
QDir cacheDir(CACHE_DIR);
if (cacheDir.cd(BALANCER_DIR)) {
QFileInfo timeStampFile(cacheDir.absoluteFilePath(TIMESTAMP_FILE));
if (timeStampFile.exists()) {
emit lastBalanced(timeStampFile.lastModified().toMSecsSinceEpoch());
} else {
emit lastBalanced(0);
}
} else {
emit lastBalanced(0);
}
}
void FSettingsDialog::on_btn_Artwork_ClearCache_clicked() {
QDir cacheDir(FGame::getCacheDir());
#if (QT_VERSION < QT_VERSION_CHECK(5, 0, 0))
cacheDir.setNameFilters(QStringList()<<"*.*");
QStringList steamFiles = cacheDir.entryList();
for(int i=0;i<steamFiles.length();++i) {
cacheDir.remove(steamFiles[i]);
}
#else
cacheDir.removeRecursively();
#endif
}
// Update the cache informations
void SettingsDialog::updateCacheInformations()
{
QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
QDir cacheDir(targetPath->text());
QPair<int, qint64> cacheInfos= cacheNumberAndSize(cacheDir, true);
QString numberOfFiles= QString::number(cacheInfos.first);
numberOfCacheFiles->setText(numberOfFiles);
QString cacheSize= sizeFromQint64ToString(cacheInfos.second);
sizeOfCache->setText(cacheSize);
QApplication::restoreOverrideCursor();
}
STATIC enum cacheRet maybeCache( const char *fullpath, CENTRYPTR *pc )
/********************************************************************/
{
char path[_MAX_PATH];
char name[NAME_MAX + 1];
DHEADPTR dcur;
CENTRYPTR centry;
enum cacheRet ret;
PGROUP pg;
char const *ext;
assert( fullpath != NULL );
_splitpath2( fullpath, pg.buffer, &pg.drive, &pg.dir, &pg.fname, &pg.ext );
_makepath( path, pg.drive, pg.dir, NULL, NULL );
ext = pg.ext;
if( ext[0] == '.' && ext[1] == 0 ) {
ext = NULL;
}
_makepath( name, NULL, NULL, pg.fname, ext );
FixName( path );
FixName( name );
dcur = findDir( path );
if( dcur == NULL ) { /* must cache new directory */
ret = cacheDir( &dcur, path );
if( ret != CACHE_OK ) {
return( ret );
}
dcur->dh_next = cacheHead;
cacheHead = dcur;
}
/* now dcur points to Cached directory */
assert( dcur != NULL );
centry = findFile( dcur, name );
if( centry == NULL ) {
return( CACHE_FILE_NOT_FOUND );
}
if( pc != NULL ) {
*pc = centry;
}
return( CACHE_OK );
}
BarcodeDecoder::BarcodeDecoder(QObject *parent)
: QObject(parent)
// ZXing
, decoder(new QZXing())
{
// prepare cache directory
QString cacheFolderLocation = QStandardPaths::writableLocation(QStandardPaths::PicturesLocation) + "/codereader";
cacheCaptureLocation = cacheFolderLocation + "/screenshot.jpg";
qDebug() << "screenshot location: " << cacheCaptureLocation;
QDir cacheDir(cacheFolderLocation);
if (!cacheDir.exists()) {
cacheDir.mkpath(".");
}
}
// Clears all cache files
void Cache::clear()
{
flush();
std::string path = cacheDir();
if (!sys::fs::dirExists(path)) {
return;
}
PDEBUG << "Clearing cache in dir: " << path << endl;
std::vector<std::string> files = sys::fs::ls(path);
for (size_t i = 0; i < files.size(); i++) {
std::string fullpath = path + "/" + files[i];
PDEBUG << "Unlinking " << fullpath << endl;
sys::fs::unlink(fullpath);
}
}
void lmcChatRoomWindow::setUserAvatar(QString* lpszUserId, QString* lpszFilePath) {
QTreeWidgetItem* pUserItem = getUserItem(lpszUserId);
if(!pUserItem)
return;
QDir cacheDir(StdLocation::cacheDir());
QString fileName = "avt_" + *lpszUserId + ".png";
QString filePath = cacheDir.absoluteFilePath(fileName);
QPixmap avatar(filePath);
avatar = avatar.scaled(QSize(32, 32), Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
pUserItem->setData(0, AvatarRole, QIcon(avatar));
if(lpszFilePath)
filePath = *lpszFilePath;
pMessageLog->updateAvatar(lpszUserId, &filePath);
}
void CopyPhotosDialog::receivedPhotos_get(VKRequest *req)
{
if((req->reqType!=VKRequest::Photos_get) ||
(reqPhotosGet != req->reqId)){
return;
}
reqPhotosGet = -1;
plog(tr("Get source album photos description"));
photos.clear();
QDomDocument doc("Photos");
doc.setContent(req->result);
QDomElement docElem = doc.documentElement();
QDomNodeList users = docElem.elementsByTagName ( "photo" );
for(int i=0; i < users.count(); i++){
QDomElement userElem = users.at(i).toElement();
VKAlbumPhoto photo;
photo.pid = userElem.elementsByTagName("pid").at(0).toElement().text();
photo.aid = userElem.elementsByTagName("aid").at(0).toElement().text();
photo.owner_id = userElem.elementsByTagName("owner_id").at(0).toElement().text();
photo.src = userElem.elementsByTagName("src").at(0).toElement().text();
photo.src_big = userElem.elementsByTagName("src_big").at(0).toElement().text();
photo.src_small = userElem.elementsByTagName("src_small").at(0).toElement().text();
photo.text = userElem.elementsByTagName("text").at(0).toElement().text();
photo.src_xbig = userElem.elementsByTagName("src_xbig").at(0).toElement().text();
photo.src_xxbig = userElem.elementsByTagName("src_xxbig").at(0).toElement().text();
photo.cacheFileName = albumDir + photo.src_big.right(photo.src_big.length() - (photo.src_big.lastIndexOf("/")));
qDebug() << photo.cacheFileName;
photos.append( photo );
}
currentPhoto = 0;
plog(tr("Finded %1 photos").arg(photos.count()));
plog(tr("Caching all photos to local filesystem"));
QDir cacheDir(albumDir);
if (!cacheDir.exists(cacheDir.path())){
cacheDir.mkpath(cacheDir.path());
}
downloadNextPhoto();
}
void NetTree::cleanCacheDir()
{
QString cache = QString("%1/thumbcache")
.arg(GetConfDir());
QDir cacheDir(cache);
QStringList thumbs = cacheDir.entryList(QDir::Files);
for (QStringList::const_iterator i = thumbs.end() - 1;
i != thumbs.begin() - 1; --i)
{
QString filename = QString("%1/%2").arg(cache).arg(*i);
LOG(VB_GENERAL, LOG_DEBUG, QString("Deleting file %1").arg(filename));
QFileInfo fi(filename);
QDateTime lastmod = fi.lastModified();
if (lastmod.addDays(7) < QDateTime::currentDateTime())
QFile::remove(filename);
}
}
void CollectionConfiguration::copyConfiguration(const QHelpEngineCore &source,
QHelpEngineCore &target)
{
setCreationTime(target, creationTime(source));
setWindowTitle(target, windowTitle(source));
target.setCurrentFilter(source.currentFilter());
setCacheDir(target, cacheDir(source), cacheDirIsRelativeToCollection(source));
setFilterFunctionalityEnabled(target, filterFunctionalityEnabled(source));
setFilterToolbarVisible(target, filterToolbarVisible(source));
setAddressBarEnabled(target, addressBarEnabled(source));
setAddressBarVisible(target, addressBarVisible(source));
setDocumentationManagerEnabled(target, documentationManagerEnabled(source));
setApplicationIcon(target, applicationIcon(source));
setAboutMenuTexts(target, aboutMenuTexts(source));
setAboutIcon(target, aboutIcon(source));
setAboutTexts(target, aboutTexts(source));
setAboutImages(target, aboutImages(source));
setDefaultHomePage(target, defaultHomePage(source));
}
// Unlocks the cache directory
void Cache::unlock()
{
if (m_lock < 0) {
PDEBUG << "Not locked yet (" << m_lock << ")" << endl;
return;
}
std::string path = cacheDir();
PTRACE << "Unlocking file " << path + "/lock" << endl;
struct flock flck;
memset(&flck, 0x00, sizeof(struct flock));
flck.l_type = F_UNLCK;
if (fcntl(m_lock, F_SETLK, &flck) == -1) {
throw PEX(str::printf("Unable to unlock cache, please delete %s/lock manually if required", path.c_str()));
}
if (::close(m_lock) == -1) {
throw PEX_ERRNO();
}
}
void ProtocolHandler::LoadPasswords()
{
//find settings dir
BPath passwordPath;
find_directory(B_USER_SETTINGS_DIRECTORY, &passwordPath);
//append Bme path and Cache path
passwordPath.Append(K_BME_SETTINGS_PATH);
passwordPath.Append(K_CACHE_PATH);
//loop through Bme Cache path and find all login names with saved passwords
BDirectory cacheDir(passwordPath.Path());
int32 entryNum = cacheDir.CountEntries();
//compose list of loginNames with passwords
for (int32 i = 0; i < entryNum;i++)
{
BEntry entry;
cacheDir.GetNextEntry(&entry);
//only open if it is a file!!!
if (entry.IsFile())
{
BFile settingsFile(&entry, B_READ_ONLY);
//data is stored as BMessages
BMessage message;
message.Unflatten(&settingsFile);
//see if password is stored in message
BString password;
BMessage userMessage;
if (message.FindMessage("user",&userMessage) == B_OK)
{
if (userMessage.FindString("User::password",&password) == B_OK)
{
BString loginName;
if (userMessage.FindString("Contact::passport" ,&loginName) == B_OK)
{
Login login = {loginName,password};
m_passwords.push_back(login);
}
}
}
}
}
}
bool
CloudDBChartClient::writeChartCache(ChartAPIv1 * chart) {
// make sure the subdir exists
QDir cacheDir(g_cacheDir);
if (cacheDir.exists()) {
cacheDir.mkdir("charts");
} else {
return false;
}
QFile file(g_cacheDir+"/charts/"+QString::number(chart->Header.Id)+".dat");
if (file.exists()) {
// overwrite data
file.resize(0);
}
if (!file.open(QIODevice::WriteOnly)) return false;
QDataStream out(&file);
out.setVersion(QDataStream::Qt_4_6);
// track a version to be able change data structure
out << chart_magic_string;
out << chart_cache_version;
out << chart->Header.LastChanged; // start
out << chart->Header.CreatorId;
out << chart->Header.Curated;
out << chart->Header.Deleted;
out << chart->Header.Description;
out << chart->Header.GcVersion;
out << chart->Header.Id;
out << chart->Header.Language;
out << chart->Header.Name;
out << chart->ChartSport;
out << chart->ChartType;
out << chart->ChartView;
out << chart->ChartDef;
out << chart->CreatorEmail;
out << chart->CreatorNick;
out << chart->Image;
file.close();
return true;
}
CloudDBChartClient::CloudDBChartClient()
{
g_nam = new QNetworkAccessManager(this);
QDir cacheDir(QStandardPaths::standardLocations(QStandardPaths::AppLocalDataLocation).at(0));
cacheDir.cdUp();
g_cacheDir = QString(cacheDir.absolutePath()+"/GoldenCheetahCloudDB");
// general handling for sslErrors
connect(g_nam, SIGNAL(sslErrors(QNetworkReply*,QList<QSslError>)), this,
SLOT(sslErrors(QNetworkReply*,QList<QSslError>)));
// common definitions used
g_chart_url_base = g_chart_url_header = g_chartcuration_url_base = CloudDBCommon::cloudDBBaseURL;
g_chart_url_base.append("gchart/");
g_chart_url_header.append("gchartheader");
g_chartcuration_url_base.append("gchartcuration/");
}
void MetadataResultsDialog::cleanCacheDir()
{
QString cache = QString("%1/cache/metadata-thumbcache")
.arg(GetConfDir());
QDir cacheDir(cache);
QStringList thumbs = cacheDir.entryList(QDir::Files);
for (QStringList::const_iterator i = thumbs.end() - 1;
i != thumbs.begin() - 1; --i)
{
QString filename = QString("%1/%2").arg(cache).arg(*i);
QFileInfo fi(filename);
QDateTime lastmod = fi.lastModified();
if (lastmod.addDays(2) < MythDate::current())
{
LOG(VB_GENERAL, LOG_DEBUG, QString("Deleting old cache file %1")
.arg(filename));
QFile::remove(filename);
}
}
}
// Locks the cache directory for this process
void Cache::lock()
{
if (m_lock >= 0) {
PDEBUG << "Already locked (" << m_lock << ")" << endl;
return;
}
std::string path = cacheDir();
std::string lock = path + "/lock";
m_lock = ::open(lock.c_str(), O_WRONLY | O_CREAT, S_IWUSR);
if (m_lock == -1) {
throw PEX(str::printf("Unable to lock cache %s: %s", path.c_str(), PepperException::strerror(errno).c_str()));
}
PTRACE << "Locking file " << lock << endl;
struct flock flck;
memset(&flck, 0x00, sizeof(struct flock));
flck.l_type = F_WRLCK;
if (fcntl(m_lock, F_SETLK, &flck) == -1) {
throw PEX(str::printf("Unable to lock cache %s, it may be used by another instance", path.c_str()));
}
}
STATIC enum cacheRet maybeCache( const char *fullpath, CENTRYPTR *pc )
/********************************************************************/
{
char path[_MAX_PATH];
char name[NAME_MAX + 1];
DHEADPTR dcur;
CENTRYPTR centry;
enum cacheRet ret;
assert( fullpath != NULL );
splitFullPath( fullpath, path, name );
FixName( path );
FixName( name );
dcur = findDir( path );
if( dcur == NULL ) { /* must cache new directory */
ret = cacheDir( &dcur, path );
if( ret != CACHE_OK ) {
return( ret );
}
dcur->dh_next = cacheHead;
cacheHead = dcur;
}
/* now dcur points to Cached directory */
assert( dcur != NULL );
centry = findFile( dcur, name );
if( centry == NULL ) {
return( CACHE_FILE_NOT_FOUND );
}
if( pc != NULL ) {
*pc = centry;
}
return( CACHE_OK );
}
void KVNetworkReply::writeToDisk(const QByteArray &body) {
int page = 0;
if(body.size() <= 1024)
{
QUrlQuery query(body);
page = query.queryItemValue("api_page_no").toInt();
}
QString cacheDir(QStandardPaths::writableLocation(QStandardPaths::CacheLocation) + "/userdata");
QString path(cacheDir + url().path());
if(page > 0)
path += "__" + QString::number(page);
path += ".json";
QFileInfo fileInfo(path);
fileInfo.absoluteDir().mkpath(".");
QFile file(fileInfo.absoluteFilePath());
if(file.open(QIODevice::WriteOnly))
file.write(body);
else
qWarning() << "Couldn't write reply data to" << fileInfo.absoluteFilePath() << "(" << file.error() << ")";
}
// Opens the database connection
void LdbCache::opendb()
{
if (m_db) return;
std::string path = cacheDir() + "/ldb";
PDEBUG << "Using cache dir: " << path << endl;
if (!sys::fs::dirExists(path)) {
sys::fs::mkpath(path);
}
leveldb::Options options;
options.create_if_missing = false;
leveldb::Status s = leveldb::DB::Open(options, path, &m_db);
if (!s.ok()) {
// New cache: Import revisions from old cache
options.create_if_missing = true;
leveldb::Status s = leveldb::DB::Open(options, path, &m_db);
if (!s.ok()) {
throw PEX(str::printf("Unable to open database %s: %s", path.c_str(), s.ToString().c_str()));
}
Cache c(m_backend, m_opts);
import(&c);
}
}
void KCDocumentRecorder::clear()
{
clearCache();
QDir cacheDir(unclosedUntitledFileDir);
QFileInfoList cacheFileList=cacheDir.entryInfoList();
int cacheFileListCount=cacheFileList.count();
if(cacheFileListCount>2)
{
for(int i=0; i<cacheFileListCount; i++)
{
if(cacheFileList.at(i).isFile())
{
cacheDir.remove(cacheFileList.at(i).fileName());
}
}
}
QSettings settings(unclosedSettingFile,
QSettings::IniFormat);
settings.beginGroup("UnclosedFile");
settings.remove("");
settings.endGroup();
}
