f : filesDownloaded)
+ {
+ String fname = (String) f.get(NAME);
+ // the segments file must be copied last
+ // or else if there is a failure in between the
+ // index will be corrupted
+ if (fname.startsWith("segments_"))
+ {
+ //The segments file must be copied in the end
+ //Otherwise , if the copy fails index ends up corrupted
+ segmentsFile = fname;
+ continue;
+ }
+ if (!moveAFile(tmpIdxDir, indexDir, fname))
+ return false;
+ }
+ //copy the segments file last
+ if (segmentsFile != null)
+ {
+ return moveAFile(tmpIdxDir, indexDir, segmentsFile);
+ }
+ return true;
+ }
+
+ /**
+ *
+ * Copy all the tlog files from the temp tlog dir to the actual tlog dir, and reset
+ * the {@link UpdateLog}. The copy will try to preserve the original tlog directory
+ * if the copy fails.
+ *
+ *
+ * This assumes that the tlog files transferred from the leader are in synch with the
+ * index files transferred from the leader. The reset of the update log relies on the version
+ * of the latest operations found in the tlog files. If the tlogs are ahead of the latest commit
+ * point, it will not copy all the needed buffered updates for the replay and it will miss
+ * some operations.
+ *
+ */
+ private boolean moveTlogFiles(File tmpTlogDir)
+ {
+ UpdateLog ulog = solrCore.getUpdateHandler().getUpdateLog();
+
+ VersionInfo vinfo = ulog.getVersionInfo();
+ vinfo.blockUpdates(); // block updates until the new update log is initialised
+ try
+ {
+ // reset the update log before copying the new tlog directory
+ CdcrUpdateLog.BufferedUpdates bufferedUpdates = ((CdcrUpdateLog) ulog).resetForRecovery();
+ // try to move the temp tlog files to the tlog directory
+ if (!copyTmpTlogFiles2Tlog(tmpTlogDir))
+ return false;
+ // reinitialise the update log and copy the buffered updates
+ if (bufferedUpdates.tlog != null)
+ {
+ // map file path to its new backup location
+ File parentDir = FileSystems.getDefault()
+ .getPath(solrCore.getUpdateHandler().getUpdateLog().getLogDir()).getParent().toFile();
+ File backupTlogDir = new File(parentDir, tmpTlogDir.getName());
+ bufferedUpdates.tlog = new File(backupTlogDir, bufferedUpdates.tlog.getName());
+ }
+ // init the update log with the new set of tlog files, and copy the buffered updates
+ ((CdcrUpdateLog) ulog).initForRecovery(bufferedUpdates.tlog, bufferedUpdates.offset);
+ }
+ catch (Exception e)
+ {
+ LOG.error("Unable to copy tlog files", e);
+ return false;
+ }
+ finally
+ {
+ vinfo.unblockUpdates();
+ }
+ return true;
+ }
+
+ /**
+ * Make file list
+ */
+ private List makeTmpConfDirFileList(File dir, List fileList)
+ {
+ File[] files = dir.listFiles();
+
+ if (files != null)
+ {
+ for (File file : files)
+ {
+ if (file.isFile())
+ {
+ fileList.add(file);
+ }
+ else if (file.isDirectory())
+ {
+ fileList = makeTmpConfDirFileList(file, fileList);
+ }
+ }
+ }
+ return fileList;
+ }
+
+ /**
+ * The conf files are copied to the tmp dir to the conf dir. A backup of the old file is maintained
+ */
+ private void copyTmpConfFiles2Conf(File tmpconfDir)
+ {
+ boolean status;
+ File confDir = new File(solrCore.getResourceLoader().getConfigDir());
+ for (File file : makeTmpConfDirFileList(tmpconfDir, new ArrayList<>()))
+ {
+ File oldFile = new File(confDir,
+ file.getPath().substring(tmpconfDir.getPath().length(), file.getPath().length()));
+ if (!oldFile.getParentFile().exists())
+ {
+ status = oldFile.getParentFile().mkdirs();
+ if (!status)
+ {
+ throw new SolrException(ErrorCode.SERVER_ERROR, "Unable to mkdirs: " + oldFile.getParentFile());
+ }
+ }
+ if (oldFile.exists())
+ {
+ File backupFile = new File(oldFile.getPath() + "." + getDateAsStr(new Date(oldFile.lastModified())));
+ if (!backupFile.getParentFile().exists())
+ {
+ status = backupFile.getParentFile().mkdirs();
+ if (!status)
+ {
+ throw new SolrException(ErrorCode.SERVER_ERROR,
+ "Unable to mkdirs: " + backupFile.getParentFile());
+ }
+ }
+ status = oldFile.renameTo(backupFile);
+ if (!status)
+ {
+ throw new SolrException(SolrException.ErrorCode.SERVER_ERROR,
+ "Unable to rename: " + oldFile + " to: " + backupFile);
+ }
+ }
+ status = file.renameTo(oldFile);
+ if (!status)
+ {
+ throw new SolrException(ErrorCode.SERVER_ERROR, "Unable to rename: " + file + " to: " + oldFile);
+ }
+ }
+ }
+
+ /**
+ * Copy the downloaded content store files into the contentstore directory
+ * @param tmpContentStoreDir
+ * @param contentStorePath
+ * @throws IOException
+ */
+ private void copyTmpContentStoreToContentStore(File tmpContentStoreDir, String contentStorePath) throws Exception
+ {
+
+ String tmpContentStorePath = tmpContentStoreDir.getPath();
+
+ Files.walk(tmpContentStoreDir.toPath()).forEach(p -> {
+ File tmpFile = new File(p.toUri());
+ if (!tmpFile.isDirectory())
+ {
+ File csFile = new File(p.toString().replace(tmpContentStorePath, contentStorePath));
+ try
+ {
+ Files.createDirectories(Paths.get(csFile.getParent()));
+ Files.move(tmpFile.toPath(), csFile.toPath(), StandardCopyOption.ATOMIC_MOVE);
+ }
+ catch (IOException e)
+ {
+ throw new RuntimeException(e);
+ }
+ }
+ });
+ }
+
+
+ /**
+ * Deletes the files in filesToDelete list from contentStore
+ * @param contentStorePath
+ * @param filesToDelete
+ */
+ private void deleteContentStoreFiles(String contentStorePath, List> filesToDelete)
+ {
+ filesToDelete.stream().map(f -> (String) f.get(NAME)).forEach(p -> {
+ File f = new File(contentStorePath, p);
+ f.delete();
+ });
+
+ LOG.info("deleted {} files from content store", filesToDelete.size());
+ }
+
+ /**
+ * Deletes from contentstore all the files that has not been updated.
+ * @param contentStorePath
+ */
+ private void cleanUpContentStore(String contentStorePath) throws Exception
+ {
+ AtomicInteger fileDeleted = new AtomicInteger();
+
+ // This is the set of the ONLY files that should be in contentStore.
+ // This set is computed from the information got from master. After a full replication, only the files
+ // that have been downloaded from master (contentStoreFilesToDownload) should be in contentStore.
+ // The file paths are translated in the current OS path notation.
+ Set contentStoreFiles = contentStoreFilesToDownload.stream()
+ .map(e -> (String) e.get(NAME))
+ .map(FilenameUtils::separatorsToSystem)
+ .collect(Collectors.toSet());
+ try
+ {
+ Files.walk(Paths.get(contentStorePath)).forEach(p -> {
+ File f = new File(p.toUri());
+ if (!f.isDirectory() && !contentStoreFiles.contains(p.toString().replace(contentStorePath, "")))
+ {
+ try
+ {
+ Files.delete(p);
+ fileDeleted.getAndIncrement();
+ }
+ catch (IOException ex)
+ {
+ LOG.error("Impossible delete file {}", p);
+ }
+ }
+ });
+ }
+ catch (Exception e)
+ {
+ LOG.error("Impossible to delete unnecessary files. Content store may contains unused contents");
+ throw(e);
+ }
+
+ LOG.info("deleted {} unnecessary files from content store", fileDeleted);
+ }
+
+ /**
+ * The tlog files are moved from the tmp dir to the tlog dir as an atomic filesystem operation.
+ * A backup of the old directory is maintained. If the directory move fails, it will try to revert back the original
+ * tlog directory.
+ */
+ private boolean copyTmpTlogFiles2Tlog(File tmpTlogDir)
+ {
+ Path tlogDir = FileSystems.getDefault().getPath(solrCore.getUpdateHandler().getUpdateLog().getLogDir());
+ Path backupTlogDir = FileSystems.getDefault()
+ .getPath(tlogDir.getParent().toAbsolutePath().toString(), tmpTlogDir.getName());
+
+ try
+ {
+ Files.move(tlogDir, backupTlogDir, StandardCopyOption.ATOMIC_MOVE);
+ }
+ catch (IOException e)
+ {
+ SolrException.log(LOG, "Unable to rename: " + tlogDir + " to: " + backupTlogDir, e);
+ return false;
+ }
+
+ Path src = FileSystems.getDefault().getPath(backupTlogDir.toAbsolutePath().toString(), tmpTlogDir.getName());
+ try
+ {
+ Files.move(src, tlogDir, StandardCopyOption.ATOMIC_MOVE);
+ }
+ catch (IOException e)
+ {
+ SolrException.log(LOG, "Unable to rename: " + src + " to: " + tlogDir, e);
+
+ // In case of error, try to revert back the original tlog directory
+ try
+ {
+ Files.move(backupTlogDir, tlogDir, StandardCopyOption.ATOMIC_MOVE);
+ }
+ catch (IOException e2)
+ {
+ // bad, we were not able to revert back the original tlog directory
+ throw new SolrException(SolrException.ErrorCode.SERVER_ERROR,
+ "Unable to rename: " + backupTlogDir + " to: " + tlogDir);
+ }
+
+ return false;
+ }
+
+ return true;
+ }
+
+ private String getDateAsStr(Date d)
+ {
+ return new SimpleDateFormat(SnapShooter.DATE_FMT, Locale.ROOT).format(d);
+ }
+
+ /**
+ * The local conf files are compared with the conf files in the master. If they are same (by checksum) do not copy.
+ *
+ * @param confFilesToDownload The list of files obtained from master
+ * @return a list of configuration files which have changed on the master and need to be downloaded.
+ */
+ @SuppressWarnings("unchecked")
+ private Collection