src/ConverterCache.C

   1 /**
   2  * \file ConverterCache.C
   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 "debug.h"
  18 #include "lyxrc.h"
  19 #include "mover.h"
  20
  21 #include "support/filetools.h"
  22 #include "support/lyxlib.h"
  23 #include "support/lyxtime.h"
  24 #include "support/package.h"
  25
  26 #include <boost/crc.hpp>
  27 #include <boost/filesystem/operations.hpp>
  28 #include <boost/current_function.hpp>
  29
  30 #include <fstream>
  31 #include <iomanip>
  32 #include <map>
  33 #include <sstream>
  34
  35 using lyx::support::addName;
  36
  37 using std::string;
  38
  39 namespace fs = boost::filesystem;
  40
  41 namespace lyx {
  42
  43 using support::FileName;
  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                                      << ' ' << timestamp << ' ' << checksum
  72                                      << '.' << std::endl;
  73         }
  74         ~CacheItem() {}
  75         FileName cache_name;
  76         time_t timestamp;
  77         unsigned long checksum;
  78 };
  79
  80 }
  81
  82
  83 /** The cache contains one item per orig file and target format, so use a
  84  *  nested map to find the cache item quickly by filename and format.
  85  */
  86 typedef std::map<string, CacheItem> FormatCacheType;
  87 typedef std::map<FileName, FormatCacheType> CacheType;
  88
  89
  90 class ConverterCache::Impl {
  91 public:
  92         ///
  93         void readIndex();
  94         ///
  95         void writeIndex();
  96         ///
  97         CacheItem * find(FileName const & from, string const & format);
  98         CacheType cache;
  99 };
 100
 101
 102 void ConverterCache::Impl::readIndex()
 103 {
 104         time_t const now = current_time();
 105         FileName const index(addName(cache_dir.absFilename(), "index"));
 106         std::ifstream is(index.toFilesystemEncoding().c_str());
 107         while (is.good()) {
 108                 string orig_from;
 109                 string to_format;
 110                 time_t timestamp;
 111                 unsigned long checksum;
 112                 if (!(is >> orig_from >> to_format >> timestamp >> checksum))
 113                         return;
 114                 FileName const orig_from_name(orig_from);
 115                 CacheItem item(orig_from_name, to_format, timestamp, checksum);
 116
 117                 // Don't cache files that do not exist anymore
 118                 if (!fs::exists(orig_from_name.toFilesystemEncoding())) {
 119                         lyxerr[Debug::FILES] << "Not caching file `"
 120                                 << orig_from << "' (does not exist anymore)."
 121                                 << std::endl;
 122                         support::unlink(item.cache_name);
 123                         continue;
 124                 }
 125
 126                 // Delete the cached file if it is too old
 127                 if (difftime(now, fs::last_write_time(item.cache_name.toFilesystemEncoding())) >
 128                     lyxrc.converter_cache_maxage) {
 129                         lyxerr[Debug::FILES] << "Not caching file `"
 130                                 << orig_from << "' (too old)." << std::endl;
 131                         support::unlink(item.cache_name);
 132                         continue;
 133                 }
 134
 135                 cache[orig_from_name][to_format] = item;
 136         }
 137         is.close();
 138 }
 139
 140
 141 void ConverterCache::Impl::writeIndex()
 142 {
 143         FileName const index(addName(cache_dir.absFilename(), "index"));
 144         std::ofstream os(index.toFilesystemEncoding().c_str());
 145         os.close();
 146         if (!lyx::support::chmod(index, 0600))
 147                 return;
 148         os.open(index.toFilesystemEncoding().c_str());
 149         CacheType::iterator it1 = cache.begin();
 150         CacheType::iterator const end1 = cache.end();
 151         for (; it1 != end1; ++it1) {
 152                 FormatCacheType::iterator it2 = it1->second.begin();
 153                 FormatCacheType::iterator const end2 = it1->second.end();
 154                 for (; it2 != end2; ++it2)
 155                         os << it1->first << ' ' << it2->first << ' '
 156                            << it2->second.timestamp << ' '
 157                            << it2->second.checksum << '\n';
 158         }
 159         os.close();
 160 }
 161
 162
 163 CacheItem * ConverterCache::Impl::find(FileName const & from,
 164                 string const & format)
 165 {
 166         if (!lyxrc.use_converter_cache)
 167                 return 0;
 168         CacheType::iterator const it1 = cache.find(from);
 169         if (it1 == cache.end())
 170                 return 0;
 171         FormatCacheType::iterator const it2 = it1->second.find(format);
 172         if (it2 == it1->second.end())
 173                 return 0;
 174         return &(it2->second);
 175 }
 176
 177
 178 ConverterCache & ConverterCache::get()
 179 {
 180         // Now return the cache
 181         static ConverterCache singleton;
 182         return singleton;
 183 }
 184
 185
 186 void ConverterCache::init()
 187 {
 188         if (!lyxrc.use_converter_cache)
 189                 return;
 190         // We do this here and not in the constructor because package() gets
 191         // initialized after all static variables.
 192         cache_dir = FileName(addName(support::package().user_support(), "cache"));
 193         if (!fs::exists(cache_dir.toFilesystemEncoding()))
 194                 if (support::mkdir(cache_dir, 0700) != 0) {
 195                         lyxerr << "Could not create cache directory `"
 196                                << cache_dir << "'." << std::endl;
 197                         exit(EXIT_FAILURE);
 198                 }
 199         get().pimpl_->readIndex();
 200 }
 201
 202
 203 ConverterCache::ConverterCache()
 204         : pimpl_(new Impl)
 205 {}
 206
 207
 208 ConverterCache::~ConverterCache()
 209 {
 210         if (!lyxrc.use_converter_cache)
 211                 return;
 212         pimpl_->writeIndex();
 213 }
 214
 215
 216 void ConverterCache::add(FileName const & orig_from, string const & to_format,
 217                 FileName const & converted_file) const
 218 {
 219         if (!lyxrc.use_converter_cache || orig_from.empty() ||
 220             converted_file.empty())
 221                 return;
 222         lyxerr[Debug::FILES] << BOOST_CURRENT_FUNCTION << ' ' << orig_from
 223                              << ' ' << to_format << ' ' << converted_file
 224                              << std::endl;
 225
 226         // Is the file in the cache already?
 227         CacheItem * item = pimpl_->find(orig_from, to_format);
 228
 229         time_t const timestamp = fs::last_write_time(orig_from.toFilesystemEncoding());
 230         Mover const & mover = getMover(to_format);
 231         if (item) {
 232                 lyxerr[Debug::FILES] << "ConverterCache::add(" << orig_from << "):\n"
 233                                         "The file is already in the cache."
 234                                      << std::endl;
 235                 // First test for timestamp
 236                 if (timestamp == item->timestamp) {
 237                         lyxerr[Debug::FILES] << "Same timestamp."
 238                                              << std::endl;
 239                         return;
 240                 } else {
 241                         // Maybe the contents is still the same?
 242                         item->timestamp = timestamp;
 243                         unsigned long const checksum = support::sum(orig_from);
 244                         if (checksum == item->checksum) {
 245                                 lyxerr[Debug::FILES] << "Same checksum."
 246                                                      << std::endl;
 247                                 return;
 248                         }
 249                         item->checksum = checksum;
 250                 }
 251                 if (!mover.copy(converted_file, item->cache_name, 0600))
 252                         lyxerr[Debug::FILES] << "ConverterCache::add("
 253                                              << orig_from << "):\n"
 254                                                 "Could not copy file."
 255                                              << std::endl;
 256         } else {
 257                 CacheItem new_item = CacheItem(orig_from, to_format, timestamp,
 258                                 support::sum(orig_from));
 259                 if (mover.copy(converted_file, new_item.cache_name, 0600))
 260                         pimpl_->cache[orig_from][to_format] = new_item;
 261                 else
 262                         lyxerr[Debug::FILES] << "ConverterCache::add("
 263                                              << orig_from << "):\n"
 264                                                 "Could not copy file."
 265                                              << std::endl;
 266         }
 267 }
 268
 269
 270 void ConverterCache::remove(FileName const & orig_from,
 271                 string const & to_format) const
 272 {
 273         if (!lyxrc.use_converter_cache || orig_from.empty())
 274                 return;
 275         lyxerr[Debug::FILES] << BOOST_CURRENT_FUNCTION << ' ' << orig_from
 276                              << ' ' << to_format << std::endl;
 277
 278         CacheType::iterator const it1 = pimpl_->cache.find(orig_from);
 279         if (it1 == pimpl_->cache.end())
 280                 return;
 281         FormatCacheType::iterator const it2 = it1->second.find(to_format);
 282         if (it2 == it1->second.end())
 283                 return;
 284
 285         it1->second.erase(it2);
 286         if (it1->second.empty())
 287                 pimpl_->cache.erase(it1);
 288 }
 289
 290
 291 bool ConverterCache::inCache(FileName const & orig_from,
 292                 string const & to_format) const
 293 {
 294         if (!lyxrc.use_converter_cache || orig_from.empty())
 295                 return false;
 296         lyxerr[Debug::FILES] << BOOST_CURRENT_FUNCTION << ' ' << orig_from
 297                              << ' ' << to_format << std::endl;
 298
 299         CacheItem * const item = pimpl_->find(orig_from, to_format);
 300         if (!item) {
 301                 lyxerr[Debug::FILES] << "not in cache." << std::endl;
 302                 return false;
 303         }
 304         time_t const timestamp = fs::last_write_time(orig_from.toFilesystemEncoding());
 305         if (item->timestamp == timestamp) {
 306                 lyxerr[Debug::FILES] << "identical timestamp." << std::endl;
 307                 return true;
 308         }
 309         if (item->checksum == support::sum(orig_from)) {
 310                 item->timestamp = timestamp;
 311                 lyxerr[Debug::FILES] << "identical checksum." << std::endl;
 312                 return true;
 313         }
 314         lyxerr[Debug::FILES] << "in cache, but too old." << std::endl;
 315         return false;
 316 }
 317
 318
 319 FileName const & ConverterCache::cacheName(FileName const & orig_from,
 320                 string const & to_format) const
 321 {
 322         lyxerr[Debug::FILES] << BOOST_CURRENT_FUNCTION << ' ' << orig_from
 323                              << ' ' << to_format << std::endl;
 324
 325         CacheItem * const item = pimpl_->find(orig_from, to_format);
 326         BOOST_ASSERT(item);
 327         return item->cache_name;
 328 }
 329
 330
 331 bool ConverterCache::copy(FileName const & orig_from, string const & to_format,
 332                 FileName const & dest) const
 333 {
 334         if (!lyxrc.use_converter_cache || orig_from.empty() || dest.empty())
 335                 return false;
 336         lyxerr[Debug::FILES] << BOOST_CURRENT_FUNCTION << ' ' << orig_from
 337                              << ' ' << to_format << ' ' << dest << std::endl;
 338
 339         CacheItem * const item = pimpl_->find(orig_from, to_format);
 340         BOOST_ASSERT(item);
 341         Mover const & mover = getMover(to_format);
 342         return mover.copy(item->cache_name, dest);
 343 }
 344
 345 } // namespace lyx