690 lines
27 KiB
Perl
690 lines
27 KiB
Perl
package BotSync;
|
|
|
|
use strict;
|
|
use warnings;
|
|
|
|
use Data::Dumper;
|
|
use HTTP::Request;
|
|
use HTTP::Response;
|
|
use HTML::TreeBuilder;
|
|
use HTML::Strip;
|
|
use FindBin;
|
|
|
|
use Epiquote; #woot! spun off, contains the code for updating episode quotes, i only need to call Epiquote::doupdate with an eid
|
|
|
|
use POE qw(Component::Client::HTTP Component::Client::Keepalive);
|
|
use DB;
|
|
my $schema = DB->new();
|
|
|
|
my $pool = POE::Component::Client::Keepalive->new(
|
|
keep_alive => 10, # seconds to keep connections alive
|
|
max_open => 1000, # max concurrent connections - total
|
|
max_per_host => 1, # max concurrent connections - per host
|
|
timeout => 20, # max time (seconds) to establish a new connection
|
|
);
|
|
|
|
POE::Component::Client::HTTP->spawn(
|
|
Agent => 'Conanquotes (see simcop2387@simcop2387.info for more information)', # defaults to something long
|
|
Alias => 'ua', # defaults to 'weeble'
|
|
From => 'simcop2387@simcop2387.info', # defaults to undef (no header)
|
|
Timeout => 60, # defaults to 180 seconds
|
|
ConnectionManager => $pool,
|
|
FollowRedirects => 2, # defaults to 0 (off)
|
|
);
|
|
|
|
my $ses = POE::Session->create(
|
|
package_states => [
|
|
BotSync => [
|
|
qw(_start gethttp_packlist getdcc_packlist httpcallback dccdone dccerror parse_packlist startupdate updatelog setepisodes packepisode getmulinks mucallback updateepisodequote checklock)
|
|
],
|
|
],
|
|
);
|
|
|
|
sub _start {
|
|
my $kernel = $_[KERNEL];
|
|
my $heap = $_[HEAP];
|
|
$kernel->alias_set("BotSync");
|
|
$heap->{updatelock} = 0;
|
|
}
|
|
|
|
sub packepisode {
|
|
my ($kernel, $heap) = @_[ KERNEL, HEAP ];
|
|
my ($filename, $pack, $botsource, $size) = @_[ ARG0, ARG1, ARG2, ARG3 ];
|
|
my $epihash = $heap->{episodes};
|
|
|
|
my ($episode, $group, $crc, $special) = parsefilename($kernel, $filename);
|
|
|
|
if (defined $episode) {
|
|
if (!ref($episode)) {
|
|
$episode =~ s/^0*//; #remove extra 0's on the start of the number
|
|
if (defined $special) {
|
|
if (ref($special) eq "ARRAY") {
|
|
if ($special->[0] eq "HD") {
|
|
if ($special->[1] eq "1080") {
|
|
$epihash->{$episode}{hd}{1080}{group} = $group;
|
|
$epihash->{$episode}{hd}{1080}{crc} = $crc;
|
|
$epihash->{$episode}{hd}{1080}{pack}{$botsource} = $pack;
|
|
$epihash->{$episode}{hd}{1080}{size} = $size;
|
|
$epihash->{$episode}{hd}{1080}{botsource} = $botsource;
|
|
}
|
|
elsif ($special->[1] eq "720") {
|
|
$epihash->{$episode}{hd}{720}{group} = $group;
|
|
$epihash->{$episode}{hd}{720}{crc} = $crc;
|
|
$epihash->{$episode}{hd}{720}{pack}{$botsource} = $pack;
|
|
$epihash->{$episode}{hd}{720}{size} = $size;
|
|
$epihash->{$episode}{hd}{720}{botsource} = $botsource;
|
|
}
|
|
else { #its either 1080 or 720, default to 1080 IIRC
|
|
$epihash->{$episode}{hd}{1080}{group} = $group;
|
|
$epihash->{$episode}{hd}{1080}{crc} = $crc;
|
|
$epihash->{$episode}{hd}{1080}{pack}{$botsource} = $pack;
|
|
$epihash->{$episode}{hd}{1080}{size} = $size;
|
|
$epihash->{$episode}{hd}{1080}{botsource} = $botsource;
|
|
}
|
|
}
|
|
elsif ($special->[0] eq "ALT") {
|
|
$epihash->{$episode}{alt}{group} = $group;
|
|
$epihash->{$episode}{alt}{crc} = $crc;
|
|
$epihash->{$episode}{alt}{pack}{$botsource} = $pack;
|
|
$epihash->{$episode}{alt}{size} = $size;
|
|
$epihash->{$episode}{alt}{botsource} = $botsource;
|
|
}
|
|
elsif ($special->[0] eq "ALT2") {
|
|
$epihash->{$episode}{alt2}{group} = $group;
|
|
$epihash->{$episode}{alt2}{crc} = $crc;
|
|
$epihash->{$episode}{alt2}{pack}{$botsource} = $pack;
|
|
$epihash->{$episode}{alt2}{size} = $size;
|
|
$epihash->{$episode}{alt2}{botsource} = $botsource;
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
$epihash->{$episode}{group} = $group;
|
|
$epihash->{$episode}{crc} = $crc;
|
|
$epihash->{$episode}{pack}{$botsource} = $pack;
|
|
$epihash->{$episode}{size} = $size;
|
|
$epihash->{$episode}{botsource} = $botsource;
|
|
}
|
|
}
|
|
elsif (ref $episode eq "ARRAY") {
|
|
for my $epi ($episode->[0] .. $episode->[1]) {
|
|
#print "DEBUGEPI: $epi\n";
|
|
$epihash->{$epi}{group} = $group;
|
|
$epihash->{$epi}{crc} = $crc;
|
|
$epihash->{$epi}{pack}{$botsource} = $pack;
|
|
$epihash->{$epi}{size} = $size;
|
|
$epihash->{$epi}{botsource} = $botsource;
|
|
}
|
|
|
|
print "Episodes ", $episode->[0], " to ", $episode->[1], " from $group with $crc are all on pack $pack\n";
|
|
}
|
|
}
|
|
|
|
$heap->{episodes} = $epihash; # copy it back in.
|
|
}
|
|
|
|
sub parse_packlist {
|
|
my ($sender, $kernel, $heap) = @_[ SENDER, KERNEL, HEAP ];
|
|
my ($botsource, $packlist) = @_[ ARG0, ARG1 ];
|
|
|
|
if (open(my $output, ">", $FindBin::Bin . "/packs/$botsource")) #this isn't fatal if it doesn't work
|
|
{
|
|
print $output $packlist;
|
|
close($output);
|
|
}
|
|
else {
|
|
$kernel->yield(updatelog => "unable to open file ".$FindBin::Bin ."/packs/$botsource");
|
|
}
|
|
|
|
my @lines = split(/\n/, $packlist);
|
|
|
|
print "----BEGIN $botsource----\n";
|
|
for my $line (@lines) {
|
|
|
|
# #466 205x [700M] Detective Conan - Movie 09 - Strategy Above the Depths [KnKF][Part1][359C82E9].avi
|
|
#^#pack times size Filename$
|
|
chomp $line;
|
|
|
|
if ($line =~ /^\s*#(\d+)\s*\d+x\s*\[([^\]]+).\]\s*(.*)(?:[\r\n]*)$/) {
|
|
$kernel->yield(packepisode => $3, $1, $botsource, $2);
|
|
}
|
|
else {
|
|
print "BADLINE: $line\n";
|
|
}
|
|
}
|
|
print "-----END $botsource-----\n";
|
|
|
|
print Dumper($heap->{episodes});
|
|
$kernel->delay(setepisodes => 25); #use delay to let POE::Kernel make sure only one happens, if someone takes more than 25 seconds to respond we should go ahead and set the new ones anyway
|
|
}
|
|
|
|
sub getbotmsg {
|
|
my $pack = shift;
|
|
my $needjoin = shift;
|
|
|
|
my %joinmsg = (
|
|
Kienai => "Join #Kienai and type ",
|
|
AZFS => "Join #AZFS and type ",
|
|
"[DCTP]Archive" => "Join #DCTP and type ",
|
|
INB4DCTP => "Join #DCTP and type ",
|
|
"AZFS|Kudo" => "Join #AZFS and type ",
|
|
"[DCTP]Arutha" => "Join #DCTP and type "
|
|
);
|
|
my %bots = (
|
|
Kienai => "/msg Sonoko-Chan XDCC send ",
|
|
AZFS => "/msg [AZFS]Releases XDCC send ",
|
|
"[DCTP]Archive" => "/msg [DCTP]Archive XDCC send ",
|
|
INB4DCTP => "/msg INB4DCTP XDCC send ",
|
|
"AZFS|Kudo" => "/msg AZFS|Kudo XDCC send ",
|
|
"[DCTP]Arutha" => "/msg [DCTP]Arutha XDCC send ",
|
|
);
|
|
|
|
my %sortorder = (
|
|
"[DCTP]Arutha" => 1,
|
|
Kienai => 1,
|
|
"AZFS|Kudo" => 2,
|
|
"[DCTP]Archive" => 3,
|
|
INB4DCTP => 4,
|
|
);
|
|
|
|
my $getnum = sub {
|
|
if (exists($sortorder{ $_[0] })) { $sortorder{ $_[0] } }
|
|
else {5}
|
|
}; #this is so i can have easy default action
|
|
|
|
my $string = "";
|
|
|
|
for my $w (sort { $getnum->($a) <=> $getnum->($b) } keys %$pack) {
|
|
$w = "[DCTP]Archive" if (!exists($bots{$w}));
|
|
$string .= " | " . (($needjoin ? $joinmsg{$w} : "") . $bots{$w} . $pack->{$w});
|
|
}
|
|
|
|
$string =~ s/^\s*\|\s*//; #remove the first one, i don't feel like properly using join
|
|
return $string;
|
|
}
|
|
|
|
sub _makesuffix {
|
|
my $size = shift;
|
|
|
|
if (!defined($size) || $size eq "") {
|
|
return ();
|
|
}
|
|
elsif ($size < 10) {
|
|
return "${size}gb";
|
|
}
|
|
else {
|
|
return "${size}mb";
|
|
}
|
|
}
|
|
|
|
sub getepisodestrings {
|
|
my $episode = shift;
|
|
|
|
#print Dumper($episode);
|
|
|
|
my $bot = getbotmsg($episode->{pack}, 1);
|
|
my $crc = $episode->{crc};
|
|
my $group = $episode->{group};
|
|
my $size = _makesuffix($episode->{size});
|
|
my $mu = $episode->{mu};
|
|
|
|
no warnings 'uninitialized';
|
|
|
|
if (exists($episode->{hd}{1080})) {
|
|
$bot .= " | 1080: " . getbotmsg($episode->{hd}{1080}{pack}) if (defined($episode->{hd}{1080}{pack}));
|
|
$crc .= " | " . $episode->{hd}{1080}{crc} if (defined $episode->{hd}{1080}{crc});
|
|
$group .= " | " . $episode->{hd}{1080}{group} if (defined $episode->{hd}{1080}{group} && $group ne $episode->{hd}{1080}{group});
|
|
$size .= " | " . _makesuffix($episode->{hd}{1080}{size}) if (defined $episode->{hd}{1080}{size});
|
|
$mu .= " | 1080: " . $episode->{hd}{1080}{mu} if (defined $episode->{hd}{1080}{mu});
|
|
}
|
|
|
|
if (exists($episode->{hd}{720})) {
|
|
$bot .= " | 720: " . getbotmsg($episode->{hd}{720}{pack}) if (defined($episode->{hd}{720}{pack}));
|
|
$crc .= " | " . $episode->{hd}{720}{crc} if (defined $episode->{hd}{720}{crc});
|
|
$group .= " | " . $episode->{hd}{720}{group} if (defined $episode->{hd}{720}{group} && $group ne $episode->{hd}{720}{group});
|
|
$size .= " | " . _makesuffix($episode->{hd}{720}{size}) if (defined $episode->{hd}{720}{size});
|
|
$mu .= " | 720: " . $episode->{hd}{720}{mu} if (defined $episode->{hd}{720}{mu});
|
|
}
|
|
|
|
if (exists($episode->{alt})) {
|
|
$bot .= " | Part2: " . getbotmsg($episode->{alt}{pack}) if (defined($episode->{alt}{pack}));
|
|
$crc .= " | " . $episode->{alt}{crc} if (defined $episode->{alt}{crc});
|
|
$group .= " | " . $episode->{alt}{group} if (defined $episode->{alt}{group} && $group ne $episode->{alt}{group});
|
|
$size .= " | " . _makesuffix($episode->{alt}{size}) if (defined $episode->{alt}{size});
|
|
$mu .= " | " . $episode->{alt}{mu} if (defined $episode->{alt}{mu});
|
|
}
|
|
|
|
if (exists($episode->{alt2})) {
|
|
$bot .= " | Single File: " . getbotmsg($episode->{alt2}{pack}) if (defined($episode->{alt2}{pack}));
|
|
$crc .= " | " . $episode->{alt2}{crc} if (defined($episode->{alt2}{pack}));
|
|
$group .= " | " . $episode->{alt2}{group} if (defined $episode->{alt2}{group} && $group ne $episode->{alt2}{group});
|
|
$size .= " | " . _makesuffix($episode->{alt2}{size}) if (defined($episode->{alt2}{pack}));
|
|
}
|
|
|
|
return ($bot, $crc, $group, $size, $mu);
|
|
}
|
|
|
|
sub setepisodes {
|
|
my ($sender, $kernel, $heap) = @_[ SENDER, KERNEL, HEAP ];
|
|
|
|
my @updated; #which episodes have been updated!
|
|
|
|
print "Setting episodes..\n";
|
|
for my $epinum (keys %{ $heap->{episodes} }) {
|
|
my $episode = $heap->{episodes}{$epinum};
|
|
|
|
my ($bot, $crc, $group, $size, $mu) = getepisodestrings($episode);
|
|
|
|
die "Can't update episode $epinum if its an arrayref: " . Dumper($episode) if ($epinum =~ /ARRAY/);
|
|
|
|
#this next one happens on .txt files and things
|
|
next if ($epinum eq "");
|
|
die "Can't update episode $epinum if its undef: " . Dumper($episode) if (!defined($epinum));
|
|
my $row = $schema->episodeinfo->find_or_create({eid => $epinum});
|
|
|
|
$schema->updatebotlist($epinum, $bot) if ($bot && $bot !~ /^\s*$/);
|
|
$schema->updatecrc($epinum, $crc) if ($crc && $crc !~ /^\s*$/);
|
|
$schema->updategroup($epinum, $group) if ($group && $group !~ /^\s*$/);
|
|
$schema->updatesize($epinum, $size) if ($size && $size !~ /^\s*$/);
|
|
$schema->updatemu($epinum, $mu) if ($mu && $mu !~ /^\s*$/);
|
|
|
|
#print "Setting episode $epinum :: $bot :: $crc :: $group\n";
|
|
push @updated, $epinum;
|
|
}
|
|
|
|
$heap->{updatethis} = \@updated;
|
|
|
|
# my $url = "http://farnsworth.simcop2387.info/cgi-bin/conanedit.pl?action=edit&eid=$episode";
|
|
# my $resp = $mech->get($url);
|
|
|
|
# if ($resp->is_success)
|
|
# {
|
|
# print "Successfully updated episode $episode\n";
|
|
# }
|
|
# else
|
|
# {
|
|
# print "Episode $episode failed to update properly! ", $resp->status_line,"\n";
|
|
# }
|
|
|
|
$kernel->yield(updatelog => "Starting updates, this will take a while");
|
|
$kernel->yield("updateepisodequote");
|
|
}
|
|
|
|
sub updateepisodequote {
|
|
my ($sender, $kernel, $heap) = @_[ SENDER, KERNEL, HEAP ];
|
|
|
|
print "INUPDATE: ";
|
|
|
|
if (@{ $heap->{updatethis} }) {
|
|
my $episode = shift @{ $heap->{updatethis} };
|
|
# my $req = HTTP::Request->new(GET => "http://farnsworth.simcop2387.info/cgi-bin/conanedit.pl?action=edit&eid=$episode"); # a simple HTTP request
|
|
|
|
print "There are " . (@{ $heap->{updatethis} }) . " episodes left\n";
|
|
|
|
Epiquote::doupdate($episode);
|
|
$kernel->yield("updateepisodequote");
|
|
}
|
|
else {
|
|
print "DONE!\n";
|
|
$kernel->yield(updatelog => "Out of things to update! this is a good thing!");
|
|
$heap->{updatelock} = 0; #unset the update lock
|
|
}
|
|
}
|
|
|
|
sub parsefilename { #do this seperate since it's a PITA
|
|
my $kernel = shift;
|
|
my $filename = shift;
|
|
$filename =~ s/[\r\n]+$//g; #strip the line endings if they aren't already
|
|
my $s = qr/(?:\s|_)*/;
|
|
|
|
#print "parse: $filename\n";
|
|
|
|
if ($filename =~ /^Detective${s}Conan${s}-${s}(\d+)${s}-?${s}.*\[([^\]]+)\]${s}\[?([[:xdigit:]]{8})\].*$/i) {
|
|
return ($1, $2, $3);
|
|
}
|
|
elsif ($filename =~ /^Detective${s}Conan${s}-${s}(\d+)v2${s}-?${s}.*\[([^\]]+)\]${s}\[([[:xdigit:]]{8})\].*$/i) {
|
|
return ($1, $2, $3);
|
|
}
|
|
# Detective Conan - 409 [Kienai][C04F0F911].mp4
|
|
elsif ($filename eq 'Detective Conan - 409 [Kienai][C04F0F911].mp4') {
|
|
return (409, "Kienai", "04F0F911");
|
|
}
|
|
if ($filename =~ /^Detective${s}Conan${s}-${s}(\d+)${s}Remastered.*\[([^\]]+)\]${s}\[([[:xdigit:]]{8})\].*$/i) {
|
|
return ($1, $2, $3, ["ALT"]);
|
|
}
|
|
elsif ($filename =~ /^\[HorribleSubs\]${s}Detective${s}Conan${s}-${s}(\d+)${s}\[(720p|1080i|1080p)\].*$/i) {
|
|
return ($1, "HorribleSubs", undef, ["HD", $2]);
|
|
}
|
|
elsif ($filename =~ /^Detective${s}Conan${s}-${s}(\d+)-(\d+)(?:${s}v\d+)?${s}\[([^\]]+)\]${s}\[([[:xdigit:]]{8})\].*$/i) {
|
|
return ([ $1, $2 ], $3, $4);
|
|
}
|
|
|
|
#Detective Conan - 222-224 [DCTP][13885484C].avi wrong file name
|
|
elsif ($filename =~ /^Detective${s}Conan${s}-${s}(222)-(224)${s}\[([^\]]+)\]${s}\[([[:xdigit:]]{8})\].*$/i) {
|
|
return ([ $1, $2 ], $3, "1388584C");
|
|
}
|
|
|
|
#Detective Conan - 345 Special Digest Edition Part 1 [Kaizou][48D4549B].avi;
|
|
elsif ($filename
|
|
=~ /^Detective${s}Conan${s}-${s}345${s}Special${s}Digest${s}Edition${s}Part${s}(\d)${s}\[Kaizou\]\[([[:xdigit:]]{8})\].*$/i)
|
|
{
|
|
if ($1 == 1) #part one
|
|
{
|
|
return (345, "Kaizou", $2);
|
|
}
|
|
else {
|
|
return (345, "Kaizou", $2, ["ALT"]);
|
|
}
|
|
}
|
|
elsif ($filename =~ /^Detective${s}Conan${s}-${s}(\d+)${s}\[([^\]]+)\]${s}(?:\[H264-AAC\]|\[H264\])?${s}\[([[:xdigit:]]{8})\].*$/) {
|
|
return ($1, $2, $3, [ "HD", 1080 ]);
|
|
}
|
|
elsif ($filename
|
|
=~ /^Detective${s}Conan${s}-${s}(\d+)${s}\[([^\]]+)\]${s}(?:\[H264-AAC\]|\[H264\])?${s}\[(?:1920x|1280x)?(1080|720)p?\]${s}\[([[:xdigit:]]{8})\].*$/
|
|
)
|
|
{
|
|
return ($1, $2, $4, [ "HD", $3 ]);
|
|
}
|
|
elsif ($filename =~ /^Detective${s}Conan${s}-${s}OVA${s}?(\d+)${s}\[([^\]]+)\]${s}\[H264\]${s}\[([[:xdigit:]]{8})\].*$/i) {
|
|
return (20000 + $1, $2, $3, [ "ALT", "H264" ]); #ignore hd ova for now
|
|
}
|
|
elsif ($filename =~ /^Detective${s}Conan${s}-${s}Magic${s}File${s}(\d+)(?:${s}OVA)?${s}\[([^\]]+)\]${s}\[([[:xdigit:]]{8})\].*$/i) {
|
|
return (30000 + $1, $2, $3); #magic files are 30000+which magic file
|
|
}
|
|
elsif ($filename
|
|
=~ /^Detective${s}Conan${s}-${s}Magic${s}File${s}(\d+)(?:${s}OVA)?${s}\[([^\]]+)\]${s}\[H264-AAC\]${s}\[([[:xdigit:]]{8})\].*$/i)
|
|
{
|
|
return (30000 + $1, $2, $3, [ "ALT", "H264" ]); #magic files are 30000+which magic file
|
|
}
|
|
#Detective Conan - OVA 1 [DCTP][FE02E18F].avi
|
|
elsif ($filename =~ /^Detective${s}Conan${s}-${s}OVA${s}?(\d+)${s}\[([^\]]+)\]${s}\[([[:xdigit:]]{8})\].*$/i) {
|
|
return (20000 + $1, $2, $3); #ovas are 20000 +
|
|
}
|
|
elsif ($filename =~ /^Detective${s}Conan${s}-${s}J-Drama${s}(\d+)${s}\[([^\]]+)\]${s}\[([[:xdigit:]]{8})\].*$/i) {
|
|
return (30019 + $1, $2, $3);
|
|
}
|
|
|
|
#Detective Conan - J-Drama 2 [TimeLes].avi
|
|
elsif ($filename =~ /^Detective${s}Conan${s}-${s}J-Drama${s}2${s}\[TimeLes\].*$/i) {
|
|
return (30021, "TimeLes", undef);
|
|
}
|
|
# Detective Conan - Movie 03 - The Last Wizard of the Century [DCTP][720p][H264][6BD835B3].mp4
|
|
elsif ($filename =~ /Detective${s}Conan${s}-${s}Movie${s}(\d+)(?:${s}v\d)?${s}-${s}(?:[^\[]+)\[([^\]]+)\]${s}\[(1080|720)p\]${s}(?:\[H264\])?${s}\[([[:xdigit:]]{8})\]....$/i) {
|
|
return (10000 + $1, $2, $4, [HD => $3]);
|
|
}
|
|
elsif ($filename =~ /Detective${s}Conan${s}-${s}Movie${s}(\d+)(?:${s}v\d)?${s}-${s}(?:[^\[]+)\[([^\]]+)\]${s}(?:\[H264\])?(?:\[DVD\])?${s}\[([[:xdigit:]]{8})\]....$/i) {
|
|
return (10000 + $1, $2, $3);
|
|
}
|
|
elsif ($filename
|
|
=~ /Detective${s}Conan${s}-${s}Movie${s}(\d+)${s}-${s}(?:[^\[]+)\[([^\]]+)\]${s}\[(?:Xvid-)?Part(\d)\]${s}\[([[:xdigit:]]{8})\]....$/i
|
|
)
|
|
{
|
|
return (10000 + $1, $2, $4) if ($3 == 1);
|
|
return (10000 + $1, $2, $4, ["ALT"]);
|
|
}
|
|
elsif ($filename
|
|
=~ /Detective${s}Conan${s}-${s}Movie${s}(\d+)${s}-${s}(?:[^\[]+)\[([^\]]+)\]${s}\[H264-(?:AAC|AC3)\]${s}\[([[:xdigit:]]{8})\]....$/i
|
|
)
|
|
{
|
|
return (10000 + $1, $2, $3, ["ALT2"]);
|
|
}
|
|
elsif ($filename eq "_Detective_Conan_Movie_11_-_Jolly_Roger_of_the_Deep_Azure_v2_[Kienai][DDBEA582].mp4_") { #fucking bots
|
|
return (10011, "Kienai", "DDBEA582");
|
|
}
|
|
# Lupin III vs Detective Conan - The Movie [M-L][1080p][3941F580].mkv
|
|
elsif ($filename =~ /Lupin${s}III${s}vs${s}Detective${s}Conan${s}-${s}The${s}Movie${s}\[([^\]]+)\]\[(720|1080)p\]\[([[:xdigit:]]{8})\]\.mkv/) { #special case, no real way to genericise it.
|
|
return (30010, $1, $3, [ "HD", $2 ]);
|
|
}
|
|
# Lupin III Part III - 01 - The Gold Ingots Summon Lupin [CF&B][374C1D73].mkv
|
|
# Lupin III Part III - 02v2 - Break the Big Trap [CF&B][BF2B652E].mkv
|
|
elsif ($filename =~ /Lupin${s}III${s}Part${s}III${s}-${s}(\d+)(?:v2)?${s}-${s}(?:[^\]]+)\[([^\]]+)\]\[([[:xdigit:]]{8})\].mkv/i) {
|
|
return (32000 + $1, $2, $3);
|
|
}
|
|
# Kid the Phantom Thief (Magic Kaito) - 02 [DCTP][720p][F83A7F70].mp4
|
|
# Kid the Phantom Thief (Magic Kaito) - 07 - The Splendid Rivals [M-L][720p][H264-AAC][9308E13F].mkv
|
|
elsif ($filename =~ /Kid${s}the${s}Phantom${s}Thief${s}\(Magic${s}Kaito\)${s}-${s}(\d+)${s}(?:${s}-${s}[^\]]+)?\[([^\]]+)\](?:\[720p\])?(?:\[H264-AAC\])?\[([[:xdigit:]]{8})\]\..../i){
|
|
return (40000 + $1, $2, $3);
|
|
}
|
|
elsif ($filename =~ /\[Kienai\]${s}GARNET${s}CROW/i) { #why the fuck are they doing non conan stuff?
|
|
return (); #ignore the file
|
|
}
|
|
elsif ($filename =~ /^.*txt$/i) #ignore text files
|
|
{
|
|
return ();
|
|
}
|
|
else {
|
|
open(my $log, ">>", $FindBin::Bin . '/botsync.log');
|
|
print $log "Can't parse $filename\n";
|
|
print "Can't parse $filename\n";
|
|
close($log);
|
|
|
|
# $kernel->yield(updatelog => "Can't parse $filename");
|
|
}
|
|
}
|
|
|
|
sub updatelog {
|
|
my ($sender, $kernel, $heap) = @_[ SENDER, KERNEL, HEAP ];
|
|
my $msg = $_[ARG0];
|
|
|
|
print "BotSyncLog: $msg\n";
|
|
$kernel->post(IRCHANDLER => msgfromdb => "#DCTV", "#DCTV", $msg);
|
|
}
|
|
|
|
sub getdcc_packlist {
|
|
my ($sender, $kernel, $heap) = @_[ SENDER, KERNEL, HEAP ];
|
|
my ($bot) = $_[ARG0];
|
|
|
|
$kernel->yield(updatelog => "Starting XDCC transfer for $bot");
|
|
$kernel->post(IRCHANDLER => cancelotherxdcc => $bot);
|
|
$kernel->post(IRCHANDLER => startxdcc => $bot);
|
|
}
|
|
|
|
# $kernel->post("BotSync", "dccerror", $user, $file, $error, $addr);
|
|
sub dccdone {
|
|
my ($sender, $kernel, $heap) = @_[ SENDER, KERNEL, HEAP ];
|
|
my ($user, $file, $addr) = @_[ ARG0, ARG1 ];
|
|
$user =~ s/!.*//;
|
|
|
|
my $content;
|
|
$kernel->yield(updatelog => "Got dcc file from $user named $file, beginning parsing");
|
|
|
|
open(my $fh, "<", $file)
|
|
or do { $kernel->yield(updatelog => "Failed to open $file: $!"); return };
|
|
{
|
|
local $/;
|
|
$content = <$fh>;
|
|
}
|
|
close($fh);
|
|
unlink($file); #uncomment after finding out it works
|
|
|
|
$kernel->post("BotSync", "parse_packlist", $user, $content);
|
|
}
|
|
|
|
sub dccerror {
|
|
my ($sender, $kernel, $heap) = @_[ SENDER, KERNEL, HEAP ];
|
|
my ($user, $file, $error, $addr) = @_[ ARG0, ARG1 ];
|
|
|
|
$kernel->yield(updatelog => "Got error '$error' from $user\@$addr for file '$file'");
|
|
}
|
|
|
|
sub httpcallback {
|
|
my ($sender, $kernel, $heap) = @_[ SENDER, KERNEL, HEAP ];
|
|
my ($request_packet, $response_packet) = @_[ ARG0, ARG1 ];
|
|
|
|
my $response = $response_packet->[0];
|
|
my $source = $request_packet->[1];
|
|
|
|
print "Got http response\n";
|
|
if ($response->is_success) {
|
|
$kernel->yield(updatelog => "$source List came back successful, starting to parse");
|
|
my $q = $response->content();
|
|
if ($source eq "AZFS") {
|
|
eval {
|
|
my $tree = HTML::TreeBuilder->new_from_content($q);
|
|
my $content = $tree->look_down("id", "content")->as_text();
|
|
$kernel->post("BotSync", "parse_packlist", $source, $content);
|
|
}; #ignore failures in parsing
|
|
}
|
|
elsif ($source eq "Kienai" || $source eq "[DCTP]Arutha") {
|
|
$kernel->post("BotSync", "parse_packlist", $source, $q);
|
|
}
|
|
}
|
|
}
|
|
|
|
sub gethttp_packlist {
|
|
my ($kernel, $heap) = @_[ KERNEL, HEAP ];
|
|
my $source = $_[ARG0];
|
|
|
|
my %urls = (
|
|
AZFS => 'http://xdcc.omni-downloads.com/?group=Azfs',
|
|
Kienai => 'http://truth-ou.com/Kienai/Sonoko-Chan.txt',
|
|
"[DCTP]Arutha" => 'http://arutha.info:5750/txt'
|
|
);
|
|
|
|
my $url = $urls{$source};
|
|
|
|
print "Fetching http list\n";
|
|
my $req = HTTP::Request->new(GET => $url); # a simple HTTP request
|
|
|
|
$kernel->post(
|
|
'ua', 'request', # http session alias & state
|
|
'httpcallback', # my state to receive responses
|
|
$req, # a simple HTTP request
|
|
$source #where from
|
|
);
|
|
|
|
$kernel->yield(updatelog => "Fetching $source list");
|
|
}
|
|
|
|
sub getmulinks {
|
|
my ($kernel, $heap) = @_[ KERNEL, HEAP ];
|
|
|
|
my $url = "http://forums.dctp.ws/index.php?topic=710.0";
|
|
|
|
print "Fetching http list\n";
|
|
my $req = HTTP::Request->new(GET => $url); # a simple HTTP request
|
|
|
|
$kernel->post(
|
|
'ua', 'request', # http session alias & state
|
|
'mucallback', # my state to receive responses
|
|
$req, # a simple HTTP request
|
|
"mulinks" #where from
|
|
);
|
|
|
|
$kernel->yield(updatelog => "Fetching mu list");
|
|
}
|
|
|
|
sub mucallback {
|
|
my ($sender, $kernel, $heap) = @_[ SENDER, KERNEL, HEAP ];
|
|
my ($request_packet, $response_packet) = @_[ ARG0, ARG1 ];
|
|
|
|
my $response = $response_packet->[0];
|
|
my $source = $request_packet->[1];
|
|
|
|
#print "MUCALLBACK: IN\n";
|
|
$kernel->yield("Got response from mu links\n");
|
|
|
|
if ($response->is_success) {
|
|
print "MUCALLBACK: SUCCESS\n";
|
|
$kernel->yield(updatelog => "Mu links came back successful, about to attempt to parse");
|
|
my $qhtml = $response->content();
|
|
|
|
my $hs = HTML::Strip->new();
|
|
|
|
my $q = $hs->parse($qhtml);
|
|
|
|
# print "---BEGIN CONTEXT---\n", $q, "\n----END CONTEXT----\n";
|
|
#0* makes it easy to remove the padding 0's that he adds
|
|
while ($q =~ m|Episode #0*(\d+): (http://www.megaupload.com/\?d=........)\s*(?!\(remastered version\))|g) #should grab single episodes fine
|
|
{
|
|
my ($episode, $link) = ($1, $2);
|
|
# print "Got link $episode at $link\n";
|
|
$heap->{episodes}{$episode}{mu} = $link;
|
|
}
|
|
|
|
while ($q =~ m|Episode #0*(\d+)-0*(\d+): (http://www.megaupload.com/\?d=........)|g) {
|
|
my ($e1, $e2, $link) = ($1, $2, $3);
|
|
for my $epi ($e1 .. $e2) {
|
|
# print "Got link $epi at $link\n";
|
|
$heap->{episodes}{$epi}{mu} = $link;
|
|
}
|
|
}
|
|
|
|
#special case for 345, i fucking hate that episode
|
|
#Episode #345:
|
|
#->Part 01: http://www.megaupload.com/?d=........
|
|
#->Part 02: http://www.megaupload.com/?d=........
|
|
|
|
if ($q
|
|
=~ m|Episode #345:[\s\r\n]*->Part 01: (http://www.megaupload.com/\?d=........)[\s\r\n]*->Part 02: (http://www.megaupload.com/\?d=........)|i
|
|
)
|
|
{
|
|
# print "Yay i got 345! $1 $2\n";
|
|
$heap->{episodes}{345}{mu} = $1;
|
|
$heap->{episodes}{345}{alt}{mu} = $2;
|
|
}
|
|
|
|
#these grab hd episodes
|
|
while ($q =~ m{Episode 0*(\d+): (http://www.megaupload.com/\?d=........)\s*\((1920x1080|1280x720)\)}g) #should grab single episodes fine
|
|
{
|
|
my ($episode, $link, $res) = ($1, $2, $3);
|
|
# print "HD: Got link $episode at $link at $res\n";
|
|
|
|
if ($res eq "1280x720") {
|
|
$heap->{episodes}{$episode}{hd}{720}{mu} = $link;
|
|
}
|
|
elsif ($res eq "1920x1080") {
|
|
$heap->{episodes}{$episode}{hd}{1080}{mu} = $link;
|
|
}
|
|
else {
|
|
$kernel->yield(updatelog => "MULINK failure, should not happen, ever; $episode :: $link :: $res");
|
|
}
|
|
}
|
|
}
|
|
# print "MUCALLBACK: OUT\n";
|
|
#$kernel->yield("gethttp_packlist", "AZFS");
|
|
#$kernel->yield("gethttp_packlist", "Kienai");
|
|
|
|
#$kernel->yield("getdcc_packlist", "INB4DCTP"); #don't need them yet
|
|
#$kernel->yield("getdcc_packlist", "[DCTP]Archive");
|
|
$kernel->yield("getdcc_packlist", "AZFS|Kudo");
|
|
}
|
|
|
|
sub checklock {
|
|
my ($kernel, $heap) = @_[ KERNEL, HEAP ];
|
|
|
|
if ($heap->{updatelock}) {
|
|
$kernel->yield(updatelog => "WARNING! found stuck updatelock! tell simcop2387 NOW!");
|
|
$kernel->yield(updatelog => "Lock has been reset, but use caution in starting it again");
|
|
$heap->{updatelock} = 0;
|
|
}
|
|
}
|
|
|
|
sub startupdate {
|
|
my ($kernel, $heap) = @_[ KERNEL, HEAP ];
|
|
my $who = $_[ARG0];
|
|
my $where = $_[ARG1];
|
|
$heap->{lastuser} = $who; #this could probably be more safe but i'm not considering concurrent updates very well anyway
|
|
$heap->{lastwhere} = $where;
|
|
|
|
if ($heap->{updatelock}) {
|
|
$kernel->yield(updatelog => "Still updating, please wait");
|
|
return;
|
|
}
|
|
|
|
print "Starting updates\n";
|
|
$kernel->delay_add("checklock", 300);
|
|
$heap->{updatelock} = 1;
|
|
$kernel->yield(updatelog => "performing updates");
|
|
|
|
# $kernel->yield("getmulinks");
|
|
|
|
# $kernel->yield("gethttp_packlist", "AZFS");
|
|
# $kernel->yield("gethttp_packlist", "Kienai");
|
|
$kernel->yield("gethttp_packlist", "[DCTP]Arutha");
|
|
|
|
# $kernel->yield("getdcc_packlist", "INB4DCTP"); #don't need them yet
|
|
# $kernel->yield("getdcc_packlist", "[DCTP]Archive");
|
|
}
|
|
|
|
1;
|