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/lyxtime.h"
  26 #include "support/Package.h"
  27
  28 #include "support/lassert.h"
  29 #include <boost/crc.hpp>
  30
  31 #include <algorithm>
  32 #include <fstream>
  33 #include <iomanip>
  34 #include <map>
  35 #include <sstream>
  36
  37 using namespace std;
  38 using namespace lyx::support;
  39
  40 namespace lyx {
  41
  42 namespace {
  43
  44 unsigned long do_crc(string const & s)
  45 {
  46         boost::crc_32_type crc;
  47         crc = for_each(s.begin(), s.end(), crc);
  48         return crc.checksum();
  49 }
  50
  51
  52 // FIXME THREAD
  53 // This should be OK because it is only assigned during init()
  54 static FileName cache_dir;
  55
  56
  57 class CacheItem {
  58 public:
  59         CacheItem() {}
  60         CacheItem(FileName const & orig_from, string const & to_format,
  61                   time_t t, unsigned long c)
  62                 : timestamp(t), checksum(c)
  63         {
  64                 ostringstream os;
  65                 os << setw(10) << setfill('0') << do_crc(orig_from.absFileName())
  66                    << '-' << to_format;
  67                 cache_name = FileName(addName(cache_dir.absFileName(), os.str()));
  68                 LYXERR(Debug::FILES, "Add file cache item " << orig_from
  69                                      << ' ' << to_format << ' ' << cache_name
  70                                      << ' ' << long(timestamp) << ' ' << checksum << '.');
  71         }
  72         ~CacheItem()
  73         {}
  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 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 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         ifstream is(index.toFilesystemEncoding().c_str());
 113         Lexer lex;
 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         ofstream os(index.toFilesystemEncoding().c_str());
 173         os.close();
 174         if (!index.changePermission(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         delete pimpl_;
 223 }
 224
 225
 226 // FIXME THREAD
 227 ConverterCache & ConverterCache::get()
 228 {
 229         // Now return the cache
 230         static ConverterCache singleton;
 231         return singleton;
 232 }
 233
 234
 235 void ConverterCache::init()
 236 {
 237         if (!lyxrc.use_converter_cache)
 238                 return;
 239         // We do this here and not in the constructor because package() gets
 240         // initialized after all static variables.
 241         cache_dir = FileName(addName(package().user_support().absFileName(), "cache"));
 242         if (!cache_dir.exists())
 243                 if (!cache_dir.createDirectory(0700)) {
 244                         lyxerr << "Could not create cache directory `"
 245                                << cache_dir << "'." << endl;
 246                         exit(EXIT_FAILURE);
 247                 }
 248         get().pimpl_->readIndex();
 249 }
 250
 251
 252 void ConverterCache::writeIndex() const
 253 {
 254         if (!lyxrc.use_converter_cache
 255                   || cache_dir.empty())
 256                 return;
 257         pimpl_->writeIndex();
 258 }
 259
 260
 261 void ConverterCache::add(FileName const & orig_from, string const & to_format,
 262                 FileName const & converted_file) const
 263 {
 264         if (!lyxrc.use_converter_cache || orig_from.empty() ||
 265             converted_file.empty())
 266                 return;
 267         LYXERR(Debug::FILES, ' ' << orig_from
 268                              << ' ' << to_format << ' ' << converted_file);
 269
 270         // FIXME: Should not hardcode this (see bug 3819 for details)
 271         if (to_format == "pstex") {
 272                 FileName const converted_eps(changeExtension(converted_file.absFileName(), "eps"));
 273                 add(orig_from, "eps", converted_eps);
 274         } else if (to_format == "pdftex") {
 275                 FileName const converted_pdf(changeExtension(converted_file.absFileName(), "pdf"));
 276                 add(orig_from, "pdf6", converted_pdf);
 277         }
 278
 279         // Is the file in the cache already?
 280         CacheItem * item = pimpl_->find(orig_from, to_format);
 281
 282         time_t const timestamp = orig_from.lastModified();
 283         Mover const & mover = getMover(to_format);
 284         if (item) {
 285                 LYXERR(Debug::FILES, "ConverterCache::add(" << orig_from << "):\n"
 286                                         "The file is already in the cache.");
 287                 // First test for timestamp
 288                 if (timestamp == item->timestamp) {
 289                         LYXERR(Debug::FILES, "Same timestamp.");
 290                         return;
 291                 }
 292                 // Maybe the contents is still the same?
 293                 item->timestamp = timestamp;
 294                 unsigned long const checksum = orig_from.checksum();
 295                 if (checksum == item->checksum) {
 296                         LYXERR(Debug::FILES, "Same checksum.");
 297                         return;
 298                 }
 299                 item->checksum = checksum;
 300                 if (!mover.copy(converted_file, item->cache_name,
 301                               onlyFileName(item->cache_name.absFileName()))) {
 302                         LYXERR(Debug::FILES, "Could not copy file " << orig_from << " to "
 303                                 << item->cache_name);
 304                 } else if (!item->cache_name.changePermission(0600)) {
 305                         LYXERR(Debug::FILES, "Could not change file mode"
 306                                 << item->cache_name);
 307                 }
 308         } else {
 309                 CacheItem new_item(orig_from, to_format, timestamp,
 310                                 orig_from.checksum());
 311                 if (mover.copy(converted_file, new_item.cache_name,
 312                               onlyFileName(new_item.cache_name.absFileName()))) {
 313                         if (!new_item.cache_name.changePermission(0600)) {
 314                                 LYXERR(Debug::FILES, "Could not change file mode"
 315                                         << new_item.cache_name);
 316                         }
 317                         FormatCache & format_cache = pimpl_->cache[orig_from];
 318                         if (format_cache.from_format.empty())
 319                                 format_cache.from_format =
 320                                         formats.getFormatFromFile(orig_from);
 321                         format_cache.cache[to_format] = new_item;
 322                 } else
 323                         LYXERR(Debug::FILES, "ConverterCache::add(" << orig_from << "):\n"
 324                                                 "Could not copy file.");
 325         }
 326 }
 327
 328
 329 void ConverterCache::remove(FileName const & orig_from,
 330                 string const & to_format) const
 331 {
 332         if (!lyxrc.use_converter_cache || orig_from.empty())
 333                 return;
 334         LYXERR(Debug::FILES, orig_from << ' ' << to_format);
 335
 336         CacheType::iterator const it1 = pimpl_->cache.find(orig_from);
 337         if (it1 == pimpl_->cache.end())
 338                 return;
 339         FormatCacheType & format_cache = it1->second.cache;
 340         FormatCacheType::iterator const it2 = format_cache.find(to_format);
 341         if (it2 == format_cache.end())
 342                 return;
 343
 344         format_cache.erase(it2);
 345         if (format_cache.empty())
 346                 pimpl_->cache.erase(it1);
 347 }
 348
 349
 350 void ConverterCache::remove_all(string const & from_format,
 351                 string const & to_format) const
 352 {
 353         if (!lyxrc.use_converter_cache)
 354                 return;
 355         CacheType::iterator it1 = pimpl_->cache.begin();
 356         while (it1 != pimpl_->cache.end()) {
 357                 if (it1->second.from_format != from_format) {
 358                         ++it1;
 359                         continue;
 360                 }
 361                 FormatCacheType & format_cache = it1->second.cache;
 362                 FormatCacheType::iterator it2 = format_cache.begin();
 363                 while (it2 != format_cache.end()) {
 364                         if (it2->first == to_format) {
 365                                 LYXERR(Debug::FILES, "Removing file cache item "
 366                                         << it1->first << ' ' << to_format);
 367                                 it2->second.cache_name.removeFile();
 368                                 format_cache.erase(it2);
 369                                 // Have to start over again since items in a
 370                                 // map are not ordered
 371                                 it2 = format_cache.begin();
 372                         } else {
 373                                 ++it2;
 374                         }
 375                 }
 376                 if (format_cache.empty()) {
 377                         pimpl_->cache.erase(it1);
 378                         // Have to start over again since items in a map are
 379                         // not ordered
 380                         it1 = pimpl_->cache.begin();
 381                 } else {
 382                         ++it1;
 383                 }
 384         }
 385         pimpl_->writeIndex();
 386 }
 387
 388
 389 bool ConverterCache::inCache(FileName const & orig_from,
 390                 string const & to_format) const
 391 {
 392         if (!lyxrc.use_converter_cache || orig_from.empty())
 393                 return false;
 394         LYXERR(Debug::FILES, orig_from << ' ' << to_format);
 395
 396         CacheItem * const item = pimpl_->find(orig_from, to_format);
 397         if (!item) {
 398                 LYXERR(Debug::FILES, "not in cache.");
 399                 return false;
 400         }
 401
 402         // Special handling of pstex and pdftex formats: These are only
 403         // considered to be in the cache if the corresponding graphics
 404         // fiels are there as well. Otherwise copy() of the graphics below
 405         // would fail.
 406         // FIXME: Should not hardcode this (see bug 3819 for details)
 407         if (to_format == "pstex") {
 408                 if (!inCache(orig_from, "eps"))
 409                         return false;
 410         } else if (to_format == "pdftex") {
 411                 if (!inCache(orig_from, "pdf6"))
 412                         return false;
 413         }
 414
 415         time_t const timestamp = orig_from.lastModified();
 416         if (item->timestamp == timestamp) {
 417                 LYXERR(Debug::FILES, "identical timestamp.");
 418                 return true;
 419         }
 420         if (item->checksum == orig_from.checksum()) {
 421                 item->timestamp = timestamp;
 422                 LYXERR(Debug::FILES, "identical checksum.");
 423                 return true;
 424         }
 425         LYXERR(Debug::FILES, "in cache, but too old.");
 426         return false;
 427 }
 428
 429
 430 FileName const & ConverterCache::cacheName(FileName const & orig_from,
 431                 string const & to_format) const
 432 {
 433         LYXERR(Debug::FILES, orig_from << ' ' << to_format);
 434
 435         CacheItem * const item = pimpl_->find(orig_from, to_format);
 436         LASSERT(item, { static const FileName fn; return fn; });
 437         return item->cache_name;
 438 }
 439
 440
 441 bool ConverterCache::copy(FileName const & orig_from, string const & to_format,
 442                 FileName const & dest) const
 443 {
 444         if (!lyxrc.use_converter_cache || orig_from.empty() || dest.empty())
 445                 return false;
 446         LYXERR(Debug::FILES, orig_from << ' ' << to_format << ' ' << dest);
 447
 448         // FIXME: Should not hardcode this (see bug 3819 for details)
 449         if (to_format == "pstex") {
 450                 FileName const dest_eps(changeExtension(dest.absFileName(), "eps"));
 451                 if (!copy(orig_from, "eps", dest_eps))
 452                         return false;
 453         } else if (to_format == "pdftex") {
 454                 FileName const dest_pdf(changeExtension(dest.absFileName(), "pdf"));
 455                 if (!copy(orig_from, "pdf6", dest_pdf))
 456                         return false;
 457         }
 458
 459         CacheItem * const item = pimpl_->find(orig_from, to_format);
 460         LASSERT(item, return false);
 461         Mover const & mover = getMover(to_format);
 462         return mover.copy(item->cache_name, dest,
 463                           onlyFileName(dest.absFileName()));
 464 }
 465
 466 } // namespace lyx