src/ConverterCache.cpp

   1 /**
   2  * \file ConverterCache.cpp
   3  * This file is part of LyX, the document processor.
   4  * Licence details can be found in the file COPYING.
   5  *
   6  * \author Baruch Even
   7  * \author Angus Leeming
   8  * \author Georg Baum
   9  *
  10  * Full author contact details are available in file CREDITS.
  11  */
  12
  13 #include <config.h>
  14
  15 #include "ConverterCache.h"
  16
  17 #include "Format.h"
  18 #include "Lexer.h"
  19 #include "LyXRC.h"
  20 #include "Mover.h"
  21
  22 #include "support/convert.h"
  23 #include "support/debug.h"
  24 #include "support/filetools.h"
  25 #include "support/lyxlib.h"
  26 #include "support/lyxtime.h"
  27 #include "support/Package.h"
  28
  29 #include <boost/assert.hpp>
  30 #include <boost/crc.hpp>
  31
  32 #include <algorithm>
  33 #include <fstream>
  34 #include <iomanip>
  35 #include <map>
  36 #include <sstream>
  37
  38 using namespace std;
  39
  40 namespace lyx {
  41
  42 using support::FileName;
  43 using support::addName;
  44
  45 namespace {
  46
  47 unsigned long do_crc(string const & s)
  48 {
  49         boost::crc_32_type crc;
  50         crc = std::for_each(s.begin(), s.end(), crc);
  51         return crc.checksum();
  52 }
  53
  54
  55 static FileName cache_dir;
  56
  57
  58 class CacheItem {
  59 public:
  60         CacheItem() {}
  61         CacheItem(FileName const & orig_from, string const & to_format,
  62                   time_t t, unsigned long c)
  63                 : timestamp(t), checksum(c)
  64         {
  65                 std::ostringstream os;
  66                 os << std::setw(10) << std::setfill('0') << do_crc(orig_from.absFilename())
  67                    << '-' << to_format;
  68                 cache_name = FileName(addName(cache_dir.absFilename(), os.str()));
  69                 LYXERR(Debug::FILES, "Add file cache item " << orig_from
  70                                      << ' ' << to_format << ' ' << cache_name
  71                                      << ' ' << long(timestamp) << ' ' << checksum << '.');
  72         }
  73         ~CacheItem() {}
  74         FileName cache_name;
  75         time_t timestamp;
  76         unsigned long checksum;
  77 };
  78
  79 }
  80
  81
  82 /** The cache contains one item per orig file and target format, so use a
  83  *  nested map to find the cache item quickly by filename and format.
  84  */
  85 typedef std::map<string, CacheItem> FormatCacheType;
  86 class FormatCache {
  87 public:
  88         /// Format of the source file
  89         string from_format;
  90         /// Cache target format -> item to quickly find the item by format
  91         FormatCacheType cache;
  92 };
  93 typedef std::map<FileName, FormatCache> CacheType;
  94
  95
  96 class ConverterCache::Impl {
  97 public:
  98         ///
  99         void readIndex();
 100         ///
 101         void writeIndex();
 102         ///
 103         CacheItem * find(FileName const & from, string const & format);
 104         CacheType cache;
 105 };
 106
 107
 108 void ConverterCache::Impl::readIndex()
 109 {
 110         time_t const now = current_time();
 111         FileName const index(addName(cache_dir.absFilename(), "index"));
 112         std::ifstream is(index.toFilesystemEncoding().c_str());
 113         Lexer lex(0, 0);
 114         lex.setStream(is);
 115         while (lex.isOK()) {
 116                 if (!lex.next(true))
 117                         break;
 118                 string const orig_from = lex.getString();
 119                 if (!lex.next())
 120                         break;
 121                 string const to_format = lex.getString();
 122                 if (!lex.next())
 123                         break;
 124                 time_t const timestamp =
 125                         convert<unsigned long>(lex.getString());
 126                 if (!lex.next())
 127                         break;
 128                 unsigned long const checksum =
 129                         convert<unsigned long>(lex.getString());
 130                 FileName const orig_from_name(orig_from);
 131                 CacheItem item(orig_from_name, to_format, timestamp, checksum);
 132
 133                 // Don't cache files that do not exist anymore
 134                 if (!orig_from_name.exists()) {
 135                         LYXERR(Debug::FILES, "Not caching file `"
 136                                 << orig_from << "' (does not exist anymore).");
 137                         item.cache_name.removeFile();
 138                         continue;
 139                 }
 140
 141                 // Don't add items that are not in the cache anymore
 142                 // This can happen if two instances of LyX are running
 143                 // at the same time and update the index file independantly.
 144                 if (!item.cache_name.exists()) {
 145                         LYXERR(Debug::FILES, "Not caching file `" << orig_from
 146                                 << "' (cached copy does not exist anymore).");
 147                         continue;
 148                 }
 149
 150                 // Delete the cached file if it is too old
 151                 if (difftime(now, item.cache_name.lastModified())
 152                                 > lyxrc.converter_cache_maxage) {
 153                         LYXERR(Debug::FILES, "Not caching file `"
 154                                 << orig_from << "' (too old).");
 155                         item.cache_name.removeFile();
 156                         continue;
 157                 }
 158
 159                 FormatCache & format_cache = cache[orig_from_name];
 160                 if (format_cache.from_format.empty())
 161                         format_cache.from_format =
 162                                 formats.getFormatFromFile(orig_from_name);
 163                 format_cache.cache[to_format] = item;
 164         }
 165         is.close();
 166 }
 167
 168
 169 void ConverterCache::Impl::writeIndex()
 170 {
 171         FileName const index(addName(cache_dir.absFilename(), "index"));
 172         std::ofstream os(index.toFilesystemEncoding().c_str());
 173         os.close();
 174         if (!lyx::support::chmod(index, 0600))
 175                 return;
 176         os.open(index.toFilesystemEncoding().c_str());
 177         CacheType::iterator it1 = cache.begin();
 178         CacheType::iterator const end1 = cache.end();
 179         for (; it1 != end1; ++it1) {
 180                 FormatCacheType const & format_cache = it1->second.cache;
 181                 FormatCacheType::const_iterator it2 = format_cache.begin();
 182                 FormatCacheType::const_iterator const end2 = format_cache.end();
 183                 for (; it2 != end2; ++it2)
 184                         os << Lexer::quoteString(it1->first.absFilename())
 185                            << ' ' << it2->first << ' '
 186                            << it2->second.timestamp << ' '
 187                            << it2->second.checksum << '\n';
 188         }
 189         os.close();
 190 }
 191
 192
 193 CacheItem * ConverterCache::Impl::find(FileName const & from,
 194                 string const & format)
 195 {
 196         if (!lyxrc.use_converter_cache)
 197                 return 0;
 198         CacheType::iterator const it1 = cache.find(from);
 199         if (it1 == cache.end())
 200                 return 0;
 201         FormatCacheType & format_cache = it1->second.cache;
 202         FormatCacheType::iterator const it2 = format_cache.find(format);
 203         if (it2 == format_cache.end())
 204                 return 0;
 205         return &(it2->second);
 206 }
 207
 208
 209 /////////////////////////////////////////////////////////////////////
 210 //
 211 // ConverterCache
 212 //
 213 /////////////////////////////////////////////////////////////////////
 214
 215 ConverterCache::ConverterCache()
 216         : pimpl_(new Impl)
 217 {}
 218
 219
 220 ConverterCache::~ConverterCache()
 221 {
 222         if (!lyxrc.use_converter_cache)
 223                 return;
 224         pimpl_->writeIndex();
 225         delete pimpl_;
 226 }
 227
 228
 229 ConverterCache & ConverterCache::get()
 230 {
 231         // Now return the cache
 232         static ConverterCache singleton;
 233         return singleton;
 234 }
 235
 236
 237 void ConverterCache::init()
 238 {
 239         if (!lyxrc.use_converter_cache)
 240                 return;
 241         // We do this here and not in the constructor because package() gets
 242         // initialized after all static variables.
 243         cache_dir = FileName(addName(support::package().user_support().absFilename(), "cache"));
 244         if (!cache_dir.exists())
 245                 if (support::mkdir(cache_dir, 0700) != 0) {
 246                         lyxerr << "Could not create cache directory `"
 247                                << cache_dir << "'." << std::endl;
 248                         exit(EXIT_FAILURE);
 249                 }
 250         get().pimpl_->readIndex();
 251 }
 252
 253
 254 void ConverterCache::add(FileName const & orig_from, string const & to_format,
 255                 FileName const & converted_file) const
 256 {
 257         if (!lyxrc.use_converter_cache || orig_from.empty() ||
 258             converted_file.empty())
 259                 return;
 260         LYXERR(Debug::FILES, ' ' << orig_from
 261                              << ' ' << to_format << ' ' << converted_file);
 262
 263         // FIXME: Should not hardcode this (see bug 3819 for details)
 264         if (to_format == "pstex") {
 265                 FileName const converted_eps(support::changeExtension(converted_file.absFilename(), "eps"));
 266                 add(orig_from, "eps", converted_eps);
 267         } else if (to_format == "pdftex") {
 268                 FileName const converted_pdf(support::changeExtension(converted_file.absFilename(), "pdf"));
 269                 add(orig_from, "pdf", converted_pdf);
 270         }
 271
 272         // Is the file in the cache already?
 273         CacheItem * item = pimpl_->find(orig_from, to_format);
 274
 275         time_t const timestamp = orig_from.lastModified();
 276         Mover const & mover = getMover(to_format);
 277         if (item) {
 278                 LYXERR(Debug::FILES, "ConverterCache::add(" << orig_from << "):\n"
 279                                         "The file is already in the cache.");
 280                 // First test for timestamp
 281                 if (timestamp == item->timestamp) {
 282                         LYXERR(Debug::FILES, "Same timestamp.");
 283                         return;
 284                 }
 285                 // Maybe the contents is still the same?
 286                 item->timestamp = timestamp;
 287                 unsigned long const checksum = orig_from.checksum();
 288                 if (checksum == item->checksum) {
 289                         LYXERR(Debug::FILES, "Same checksum.");
 290                         return;
 291                 }
 292                 item->checksum = checksum;
 293                 if (!mover.copy(converted_file, item->cache_name,
 294                                 support::onlyFilename(item->cache_name.absFilename()), 0600)) {
 295                         LYXERR(Debug::FILES, "ConverterCache::add(" << orig_from << "):\n"
 296                                                 "Could not copy file.");
 297                 }
 298         } else {
 299                 CacheItem new_item(orig_from, to_format, timestamp,
 300                                 orig_from.checksum());
 301                 if (mover.copy(converted_file, new_item.cache_name,
 302                                support::onlyFilename(new_item.cache_name.absFilename()), 0600)) {
 303                         FormatCache & format_cache = pimpl_->cache[orig_from];
 304                         if (format_cache.from_format.empty())
 305                                 format_cache.from_format =
 306                                         formats.getFormatFromFile(orig_from);
 307                         format_cache.cache[to_format] = new_item;
 308                 } else
 309                         LYXERR(Debug::FILES, "ConverterCache::add(" << orig_from << "):\n"
 310                                                 "Could not copy file.");
 311         }
 312 }
 313
 314
 315 void ConverterCache::remove(FileName const & orig_from,
 316                 string const & to_format) const
 317 {
 318         if (!lyxrc.use_converter_cache || orig_from.empty())
 319                 return;
 320         LYXERR(Debug::FILES, orig_from << ' ' << to_format);
 321
 322         CacheType::iterator const it1 = pimpl_->cache.find(orig_from);
 323         if (it1 == pimpl_->cache.end())
 324                 return;
 325         FormatCacheType & format_cache = it1->second.cache;
 326         FormatCacheType::iterator const it2 = format_cache.find(to_format);
 327         if (it2 == format_cache.end())
 328                 return;
 329
 330         format_cache.erase(it2);
 331         if (format_cache.empty())
 332                 pimpl_->cache.erase(it1);
 333 }
 334
 335
 336 void ConverterCache::remove_all(string const & from_format,
 337                 string const & to_format) const
 338 {
 339         if (!lyxrc.use_converter_cache)
 340                 return;
 341         CacheType::iterator it1 = pimpl_->cache.begin();
 342         while (it1 != pimpl_->cache.end()) {
 343                 if (it1->second.from_format != from_format) {
 344                         ++it1;
 345                         continue;
 346                 }
 347                 FormatCacheType & format_cache = it1->second.cache;
 348                 FormatCacheType::iterator it2 = format_cache.begin();
 349                 while (it2 != format_cache.end()) {
 350                         if (it2->first == to_format) {
 351                                 LYXERR(Debug::FILES, "Removing file cache item "
 352                                         << it1->first << ' ' << to_format);
 353                                 it2->second.cache_name.removeFile();
 354                                 format_cache.erase(it2);
 355                                 // Have to start over again since items in a
 356                                 // map are not ordered
 357                                 it2 = format_cache.begin();
 358                         } else {
 359                                 ++it2;
 360                         }
 361                 }
 362                 if (format_cache.empty()) {
 363                         pimpl_->cache.erase(it1);
 364                         // Have to start over again since items in a map are
 365                         // not ordered
 366                         it1 = pimpl_->cache.begin();
 367                 } else {
 368                         ++it1;
 369                 }
 370         }
 371         pimpl_->writeIndex();
 372 }
 373
 374
 375 bool ConverterCache::inCache(FileName const & orig_from,
 376                 string const & to_format) const
 377 {
 378         if (!lyxrc.use_converter_cache || orig_from.empty())
 379                 return false;
 380         LYXERR(Debug::FILES, orig_from << ' ' << to_format);
 381
 382         CacheItem * const item = pimpl_->find(orig_from, to_format);
 383         if (!item) {
 384                 LYXERR(Debug::FILES, "not in cache.");
 385                 return false;
 386         }
 387         time_t const timestamp = orig_from.lastModified();
 388         if (item->timestamp == timestamp) {
 389                 LYXERR(Debug::FILES, "identical timestamp.");
 390                 return true;
 391         }
 392         if (item->checksum == orig_from.checksum()) {
 393                 item->timestamp = timestamp;
 394                 LYXERR(Debug::FILES, "identical checksum.");
 395                 return true;
 396         }
 397         LYXERR(Debug::FILES, "in cache, but too old.");
 398         return false;
 399 }
 400
 401
 402 FileName const & ConverterCache::cacheName(FileName const & orig_from,
 403                 string const & to_format) const
 404 {
 405         LYXERR(Debug::FILES, orig_from << ' ' << to_format);
 406
 407         CacheItem * const item = pimpl_->find(orig_from, to_format);
 408         BOOST_ASSERT(item);
 409         return item->cache_name;
 410 }
 411
 412
 413 bool ConverterCache::copy(FileName const & orig_from, string const & to_format,
 414                 FileName const & dest) const
 415 {
 416         if (!lyxrc.use_converter_cache || orig_from.empty() || dest.empty())
 417                 return false;
 418         LYXERR(Debug::FILES, orig_from << ' ' << to_format << ' ' << dest);
 419
 420         // FIXME: Should not hardcode this (see bug 3819 for details)
 421         if (to_format == "pstex") {
 422                 FileName const dest_eps(support::changeExtension(dest.absFilename(), "eps"));
 423                 if (!copy(orig_from, "eps", dest_eps))
 424                         return false;
 425         } else if (to_format == "pdftex") {
 426                 FileName const dest_pdf(support::changeExtension(dest.absFilename(), "pdf"));
 427                 if (!copy(orig_from, "pdf", dest_pdf))
 428                         return false;
 429         }
 430
 431         CacheItem * const item = pimpl_->find(orig_from, to_format);
 432         BOOST_ASSERT(item);
 433         Mover const & mover = getMover(to_format);
 434         return mover.copy(item->cache_name, dest,
 435                           support::onlyFilename(dest.absFilename()));
 436 }
 437
 438 } // namespace lyx