243 lines
8.3 KiB
Plaintext
243 lines
8.3 KiB
Plaintext
// ACHTUNG: Die Backups müssen von hinten her, also vor ersten Backup aus, bis NOW durchgegangen werden, nicht umgekehrt!!!
|
|
|
|
|
|
#include <boost/date_time/posix_time/posix_time_config.hpp>
|
|
#include <boost/date_time/posix_time/posix_time_types.hpp>
|
|
#include <boost/date_time/posix_time/time_formatters.hpp>
|
|
#include <boost/date_time/posix_time/time_parsers.hpp>
|
|
#include <boost/program_options/options_description.hpp>
|
|
#include <boost/program_options/parsers.hpp>
|
|
#include <boost/program_options/positional_options.hpp>
|
|
#include <boost/program_options/variables_map.hpp>
|
|
#include <iostream>
|
|
|
|
#include <boost/process.hpp>
|
|
#include <boost/process/v2/stdio.hpp>
|
|
#include <boost/process/v2/environment.hpp>
|
|
#include <boost/asio.hpp>
|
|
|
|
#include <boost/date_time/posix_time/posix_time.hpp>
|
|
#include <set>
|
|
|
|
#include <boost/program_options.hpp>
|
|
#include <boost/filesystem.hpp>
|
|
|
|
namespace bp = boost::process;
|
|
namespace asio = boost::asio;
|
|
namespace po = boost::program_options;
|
|
namespace fs = boost::filesystem;
|
|
|
|
bool dry_run = false;
|
|
|
|
template<int keep_every_x_days,int till_y_day>std::set<boost::posix_time::ptime>::reverse_iterator handle_backups_after(std::string & snapshotbase, std::set<boost::posix_time::ptime> & times, std::set<boost::posix_time::ptime>::reverse_iterator ct, boost::posix_time::ptime now)
|
|
{
|
|
if(ct == times.rend())
|
|
return ct;
|
|
|
|
boost::posix_time::time_duration dur;
|
|
boost::posix_time::ptime last_kept_time;
|
|
|
|
while( ct != times.rend() && (dur = now - *ct).hours() <= till_y_day * 24)
|
|
{
|
|
last_kept_time = *ct;
|
|
std::cout << "Keeping Backup " << last_kept_time << " of this day." << std::endl << std::endl;
|
|
ct++;
|
|
|
|
while( ct != times.rend() && (dur = last_kept_time - *ct).hours() < keep_every_x_days * 24)
|
|
{
|
|
if(ct == --times.rend())
|
|
{
|
|
std::cout << "Keeping last Backup " << *ct << " in this backup-set." << std::endl << std::endl;
|
|
return ct++;
|
|
}
|
|
|
|
std::cout << "Removing Backup " << *ct << " because we have already one in the relevant set of keeping every " << keep_every_x_days << " till " << till_y_day << " days." << std::endl;
|
|
|
|
std::string timestring = boost::posix_time::to_iso_extended_string(*ct);
|
|
timestring[10]='_';
|
|
timestring[13]='-';
|
|
timestring[16]='-';
|
|
timestring=timestring.substr(0, 19);
|
|
|
|
asio::io_context ctx;
|
|
asio::readable_pipe out(ctx);
|
|
|
|
std::vector<std::string> args;
|
|
args.push_back("destroy");
|
|
args.push_back("-v");
|
|
if(dry_run)
|
|
args.push_back("-n");
|
|
args.push_back(snapshotbase + "@" + timestring);
|
|
|
|
bp::process proc(ctx, bp::environment::find_executable("zfs"), args, bp::process_stdio{{/* in to default*/}, out, {/* err to default */}});
|
|
|
|
std::string output;
|
|
|
|
boost::system::error_code ec;
|
|
asio::read(out, asio::dynamic_buffer(output), ec);
|
|
assert(!ec || (ec==asio::error::eof));
|
|
proc.wait();
|
|
|
|
std::cout << output << std::endl;
|
|
|
|
ct++;
|
|
}
|
|
}
|
|
|
|
return ct;
|
|
}
|
|
|
|
std::set<boost::posix_time::ptime>::reverse_iterator handle_backups_after_one_day(std::string & snapshotbase, std::set<boost::posix_time::ptime> & times, std::set<boost::posix_time::ptime>::reverse_iterator ct, boost::posix_time::ptime now)
|
|
{
|
|
// after one day, we keep one backup per day
|
|
|
|
return handle_backups_after<1,30>(snapshotbase, times, ct, now);
|
|
|
|
/*if(ct == times.rend())
|
|
return ct;
|
|
|
|
boost::posix_time::time_duration dur;
|
|
boost::posix_time::ptime last_kept_time;
|
|
|
|
while( ct != times.rend() && (dur = now - *ct).hours() <= 30 * 24)
|
|
{
|
|
last_kept_time = *ct;
|
|
std::cout << "Keeping Backup " << last_kept_time << " of this day." << std::endl;
|
|
ct++;
|
|
|
|
while( ct != times.rend() && (dur = last_kept_time - *ct).hours() < 24)
|
|
{
|
|
std::cout << "Removing Backup " << *ct << " because we have already one in 24 hours." << std::endl;
|
|
ct++;
|
|
}
|
|
}
|
|
|
|
return ct;*/
|
|
}
|
|
|
|
std::set<boost::posix_time::ptime>::reverse_iterator handle_backups_after_30_days(std::string & snapshotbase, std::set<boost::posix_time::ptime> & times, std::set<boost::posix_time::ptime>::reverse_iterator ct, boost::posix_time::ptime now)
|
|
{
|
|
// after 30 days, we keep one backup every 7 days
|
|
|
|
return handle_backups_after<7,365>(snapshotbase, times, ct, now);
|
|
}
|
|
|
|
std::set<boost::posix_time::ptime>::reverse_iterator handle_backups_after_365_days(std::string & snapshotbase, std::set<boost::posix_time::ptime> & times, std::set<boost::posix_time::ptime>::reverse_iterator ct, boost::posix_time::ptime now)
|
|
{
|
|
// after 365 days, we keep one backup every 30 days
|
|
|
|
return handle_backups_after<30, 365*100>(snapshotbase, times, ct, now);
|
|
}
|
|
|
|
|
|
int main(int argc, char** argv){
|
|
std::cout << "Hello, from zfsbackupcleaner!\n";
|
|
|
|
po::options_description options("Argumente");
|
|
options.add_options()
|
|
("help", "Hilfe anzeigen")
|
|
("dry-run,n", "Test-Modus; keine Backups entfernen")
|
|
("backupsystem", po::value<std::string>(), "Computer, dessen Backups bereinigt werden sollen")
|
|
;
|
|
|
|
po::positional_options_description p;
|
|
p.add("backupsystem", 1);
|
|
|
|
po::variables_map vm;
|
|
try {
|
|
po::store(po::command_line_parser(argc,argv).options(options).positional(p).run(), vm);
|
|
po::notify(vm);
|
|
} catch (const boost::program_options::invalid_command_line_syntax & error) {
|
|
std::cout << "Error parsing commandline-arguments:" << std::endl;
|
|
std::cout << error.what() << std::endl;
|
|
return -1;
|
|
}
|
|
|
|
if(vm.count("help") || !vm.count("backupsystem"))
|
|
{
|
|
std::cout << "Benutzung: zfsbackupcleaner [Optionen] <Backupsystem>" << std::endl << std::endl;
|
|
std::cout << options << std::endl;
|
|
return 0;
|
|
}
|
|
|
|
if(vm.count("dry-run"))
|
|
dry_run = true;
|
|
|
|
std::string backupsystem = vm["backupsystem"].as<std::string>();
|
|
|
|
if(backupsystem != "workstation" && ! fs::exists("/backup/"+backupsystem))
|
|
{
|
|
std::cout << "Für das System >" << backupsystem << "< gibt es keine Backups." << std::endl;
|
|
return -1;
|
|
}
|
|
|
|
asio::io_context ctx;
|
|
asio::readable_pipe out(ctx);
|
|
|
|
bp::process proc(ctx, bp::environment::find_executable("zfs"), {"list", "-t", "snapshot", "/backup/"+backupsystem}, bp::process_stdio{{/* in to default*/}, out, {/* err to default */}});
|
|
|
|
std::string output;
|
|
|
|
boost::system::error_code ec;
|
|
asio::read(out, asio::dynamic_buffer(output), ec);
|
|
assert(!ec || (ec==asio::error::eof));
|
|
proc.wait();
|
|
|
|
//std::cout << "OUTPUT" << output << "END" << std::endl;
|
|
|
|
std::stringstream lines(output);
|
|
|
|
std::set<boost::posix_time::ptime> times;
|
|
|
|
std::string snapshotbase;
|
|
|
|
for(std::string line; std::getline(lines, line);)
|
|
{
|
|
std::string::size_type pos = line.find(' ');
|
|
line = line.substr(0,pos);
|
|
//std::cout << "X: " << line << std::endl;
|
|
|
|
if(line == "NAME")
|
|
continue;
|
|
|
|
pos = line.find('@');
|
|
snapshotbase = line.substr(0,pos);
|
|
std::string timestring = line.substr(pos+1);
|
|
timestring[10]=' ';
|
|
timestring[13]=':';
|
|
timestring[16]=':';
|
|
boost::posix_time::ptime t(boost::posix_time::time_from_string(timestring));
|
|
|
|
times.insert(t);
|
|
}
|
|
|
|
if(times.empty())
|
|
{
|
|
std::cout << "NO SNAPSHOTS FOUND — EXIT";
|
|
return 0;
|
|
}
|
|
|
|
std::set<boost::posix_time::ptime>::reverse_iterator current_time = times.rbegin();
|
|
|
|
// handle fist 24 hours!!!
|
|
|
|
boost::posix_time::ptime now = boost::posix_time::second_clock::local_time();
|
|
|
|
std::cout << "Gehe aus von aktueller Zeit: " << now << std::endl << std::endl;
|
|
|
|
boost::posix_time::time_duration dur;
|
|
|
|
while( (dur = now - *current_time).hours() <= 72)
|
|
{
|
|
std::cout << "Omitting Backup " << *current_time << " because it is too young to handle (" << dur.hours() << " hours old)." << std::endl;
|
|
current_time++;
|
|
}
|
|
std::cout << std::endl;
|
|
|
|
current_time = handle_backups_after_one_day(snapshotbase, times, current_time, now);
|
|
current_time = handle_backups_after_30_days(snapshotbase, times, current_time, now);
|
|
current_time = handle_backups_after_365_days(snapshotbase, times, current_time, now);
|
|
|
|
return 0;
|
|
}
|