|
|
|
/*
|
|
|
|
Copyright (C) 2021 Kasyanov Nikolay Alexeevich (Unbewohnte (me@unbewohnte.xyz))
|
|
|
|
|
|
|
|
This file is part of broom.
|
|
|
|
|
|
|
|
broom is free software: you can redistribute it and/or modify
|
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
broom is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
along with broom. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <iostream>
|
|
|
|
#include <algorithm>
|
|
|
|
#include <iterator>
|
|
|
|
#include <map>
|
|
|
|
#include <chrono>
|
|
|
|
#include <stdexcept>
|
|
|
|
|
|
|
|
#include "entry.hpp"
|
|
|
|
#include "broom.hpp"
|
|
|
|
|
|
|
|
Broom::Broom(Options options) {
|
|
|
|
m_benchmarking = options.benchmarking;
|
|
|
|
m_sweeping = options.sweeping;
|
|
|
|
};
|
|
|
|
|
|
|
|
Broom::~Broom() {
|
|
|
|
m_tracked_entries.clear();
|
|
|
|
};
|
|
|
|
|
|
|
|
// recursively track every file that lies in given path. Throws an invalid_argument
|
|
|
|
// error in case path does not exist
|
|
|
|
void Broom::track(const std::filesystem::path path) {
|
|
|
|
auto t0 = std::chrono::high_resolution_clock::now();
|
|
|
|
|
|
|
|
// check if given path even exists
|
|
|
|
if (!std::filesystem::exists(path)) {
|
|
|
|
throw std::invalid_argument("\"" + path.string() + "\"" + " does not exist !");
|
|
|
|
};
|
|
|
|
|
|
|
|
if (std::filesystem::is_directory(path)) {
|
|
|
|
// it`s a directory. Track every regular file recursively
|
|
|
|
std::filesystem::directory_options options = (
|
|
|
|
std::filesystem::directory_options::skip_permission_denied
|
|
|
|
);
|
|
|
|
|
|
|
|
for (auto dir_entry : std::filesystem::recursive_directory_iterator(path, options)) {
|
|
|
|
if (!dir_entry.is_regular_file()) {
|
|
|
|
continue;
|
|
|
|
};
|
|
|
|
|
|
|
|
Entry entry(dir_entry.path());
|
|
|
|
m_tracked_entries.push_back(entry);
|
|
|
|
};
|
|
|
|
} else if (std::filesystem::is_regular_file(path)) {
|
|
|
|
Entry entry(path);
|
|
|
|
m_tracked_entries.push_back(entry);
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
if (m_benchmarking) {
|
|
|
|
auto tracking_time = std::chrono::high_resolution_clock::now();
|
|
|
|
|
|
|
|
std::cout
|
|
|
|
<< "[BENCHMARK] Tracking took "
|
|
|
|
<< std::chrono::duration_cast<std::chrono::milliseconds>(tracking_time - t0).count()
|
|
|
|
<< " ms" << std::endl;
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
|
|
|
// removes entries with unique file sizes. Returns amount of files
|
|
|
|
// that are no longer being tracked
|
|
|
|
uintmax_t Broom::untrack_unique_sizes() {
|
|
|
|
// key: size, value: amount of occurences
|
|
|
|
std::map<uintmax_t, uintmax_t> sizes_map;
|
|
|
|
|
|
|
|
for (auto entry_iter = m_tracked_entries.begin(); entry_iter != m_tracked_entries.end(); entry_iter++) {
|
|
|
|
// check if size of this entry is already in the map
|
|
|
|
// if yes --> increment occurences counter
|
|
|
|
// if not --> add it to the map with a counter of 1
|
|
|
|
entry_iter->get_size();
|
|
|
|
|
|
|
|
auto iterator = sizes_map.find(entry_iter->filesize);
|
|
|
|
if (iterator == sizes_map.end()) {
|
|
|
|
// there is no such size
|
|
|
|
sizes_map.insert({entry_iter->filesize, 1});
|
|
|
|
} else {
|
|
|
|
// there is such size
|
|
|
|
sizes_map[iterator->first]++;
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
|
|
|
uintmax_t untracked = 0;
|
|
|
|
m_tracked_entries.erase(std::remove_if(m_tracked_entries.begin(), m_tracked_entries.end(), [&untracked, sizes_map](Entry entry) -> bool{
|
|
|
|
auto iter = sizes_map.find(entry.filesize);
|
|
|
|
if (iter->second == 1) {
|
|
|
|
// unique
|
|
|
|
untracked++;
|
|
|
|
return true;
|
|
|
|
};
|
|
|
|
|
|
|
|
// std::cout << "duplicate fsize: " << iter->first << " occurences: " << iter->second << std::endl;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}), m_tracked_entries.end());
|
|
|
|
|
|
|
|
// std::cout << "Size after untracking by size: " << m_tracked_entries.size() << std::endl;
|
|
|
|
|
|
|
|
|
|
|
|
return untracked;
|
|
|
|
};
|
|
|
|
|
|
|
|
// removes entries with the same content-pieces. Returns amount of
|
|
|
|
// files that are no longer being tracked
|
|
|
|
uintmax_t Broom::untrack_unique_contents() {
|
|
|
|
// contents, occurences
|
|
|
|
std::map<std::string, uintmax_t> contents_map;
|
|
|
|
std::map<std::string, uintmax_t>::iterator map_iter;
|
|
|
|
|
|
|
|
for (auto entry_iter = m_tracked_entries.begin(); entry_iter != m_tracked_entries.end();) {
|
|
|
|
// the same logic:
|
|
|
|
// check if contents of this entry is already in the map
|
|
|
|
// if yes --> increment occurences counter
|
|
|
|
// if not --> add it to the map with a counter of 1
|
|
|
|
|
|
|
|
try{
|
|
|
|
// can get "permission denied" when opening file
|
|
|
|
entry_iter->get_pieces();
|
|
|
|
} catch(const std::ifstream::failure& e) {
|
|
|
|
// there is nothing we can do. Untrack this entry
|
|
|
|
// std::cerr << e.what();
|
|
|
|
entry_iter = m_tracked_entries.erase(entry_iter);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
map_iter = contents_map.find(entry_iter->pieces);
|
|
|
|
if (map_iter == contents_map.end()) {
|
|
|
|
// add it to the map
|
|
|
|
contents_map.insert({entry_iter->pieces, 1});
|
|
|
|
// std::cout << "First time seeing this piece: " << entry_iter->pieces << std::endl;
|
|
|
|
} else {
|
|
|
|
// increment occurences counter
|
|
|
|
contents_map[map_iter->first]++;
|
|
|
|
};
|
|
|
|
|
|
|
|
entry_iter++;
|
|
|
|
};
|
|
|
|
|
|
|
|
uintmax_t untracked = 0;
|
|
|
|
m_tracked_entries.erase(std::remove_if(m_tracked_entries.begin(), m_tracked_entries.end(), [&untracked, contents_map](Entry entry) -> bool {
|
|
|
|
auto iter = contents_map.find(entry.pieces);
|
|
|
|
if (iter->second == 1) {
|
|
|
|
// unique
|
|
|
|
untracked++;
|
|
|
|
return true;
|
|
|
|
} else {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}), m_tracked_entries.end());
|
|
|
|
|
|
|
|
return untracked;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
// find all duplicates among tracked entries, stop tracking uniques
|
|
|
|
void Broom::find_duplicates() {
|
|
|
|
auto t0 = std::chrono::high_resolution_clock::now();
|
|
|
|
|
|
|
|
// print how many files are being tracked
|
|
|
|
uintmax_t global_untracked = m_tracked_entries.size();
|
|
|
|
std::cout << "[INFO] Tracking " << m_tracked_entries.size() << " files" << std::endl;
|
|
|
|
|
|
|
|
// untrack by size
|
|
|
|
uintmax_t untracked_by_size = untrack_unique_sizes();
|
|
|
|
global_untracked += untracked_by_size;
|
|
|
|
std::cout << "[INFO] Untracked " << untracked_by_size << " unique sizes" << std::endl;
|
|
|
|
|
|
|
|
auto sizes_untrack_time = std::chrono::high_resolution_clock::now();
|
|
|
|
|
|
|
|
if (m_benchmarking) {
|
|
|
|
std::cout
|
|
|
|
<< "[BENCHMARK] Untracking by size took "
|
|
|
|
<< std::chrono::duration_cast<std::chrono::milliseconds>(sizes_untrack_time - t0).count()
|
|
|
|
<< " ms" << std::endl;
|
|
|
|
};
|
|
|
|
|
|
|
|
// untrack by contents
|
|
|
|
uintmax_t untracked_by_contents = untrack_unique_contents();
|
|
|
|
global_untracked += untracked_by_contents;
|
|
|
|
|
|
|
|
auto contents_untrack_time = std::chrono::high_resolution_clock::now();
|
|
|
|
|
|
|
|
if (m_benchmarking) {
|
|
|
|
std::cout
|
|
|
|
<< "[BENCHMARK] Untracking by contents took "
|
|
|
|
<< std::chrono::duration_cast<std::chrono::milliseconds>(contents_untrack_time - sizes_untrack_time).count()
|
|
|
|
<< " ms" << std::endl;
|
|
|
|
};
|
|
|
|
|
|
|
|
std::cout << "[INFO] Untracked " << untracked_by_contents << " unique contents" << std::endl;
|
|
|
|
|
|
|
|
std::cout << "[INFO] Duplicates: " << m_tracked_entries.size() << std::endl;
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
// remove ALL duplicate files
|
|
|
|
void Broom::sweep_all() {
|
|
|
|
};
|