X-Git-Url: https://git.pterodactylus.net/?a=blobdiff_plain;f=src%2Fmain%2Fjava%2Fnet%2Fpterodactylus%2Fxdcc%2Fcore%2FCore.java;h=dce8da3b7000be38ac3a06ff63949989355a2e94;hb=073337dd8309e3d6e2cf57b9a763de7de679a6a9;hp=58afb8e150e8d92841923165bd0c0ae8bcbb9cb5;hpb=217a38af85ffb6cc6ddc5276b8915da12d15631c;p=xudocci.git diff --git a/src/main/java/net/pterodactylus/xdcc/core/Core.java b/src/main/java/net/pterodactylus/xdcc/core/Core.java index 58afb8e..dce8da3 100644 --- a/src/main/java/net/pterodactylus/xdcc/core/Core.java +++ b/src/main/java/net/pterodactylus/xdcc/core/Core.java @@ -17,7 +17,11 @@ package net.pterodactylus.xdcc.core; +import java.io.File; +import java.io.FileNotFoundException; +import java.io.FileOutputStream; import java.io.IOException; +import java.io.OutputStream; import java.util.Collection; import java.util.Collections; import java.util.List; @@ -28,25 +32,44 @@ import java.util.logging.Logger; import net.pterodactylus.irc.Connection; import net.pterodactylus.irc.ConnectionBuilder; +import net.pterodactylus.irc.DccReceiver; +import net.pterodactylus.irc.event.ChannelJoined; +import net.pterodactylus.irc.event.ChannelLeft; import net.pterodactylus.irc.event.ChannelMessageReceived; +import net.pterodactylus.irc.event.ClientQuit; import net.pterodactylus.irc.event.ConnectionEstablished; +import net.pterodactylus.irc.event.DccAcceptReceived; +import net.pterodactylus.irc.event.DccDownloadFailed; +import net.pterodactylus.irc.event.DccDownloadFinished; +import net.pterodactylus.irc.event.DccSendReceived; +import net.pterodactylus.irc.event.PrivateMessageReceived; import net.pterodactylus.irc.util.MessageCleaner; import net.pterodactylus.irc.util.RandomNickname; +import net.pterodactylus.xdcc.core.event.BotAdded; import net.pterodactylus.xdcc.core.event.CoreStarted; +import net.pterodactylus.xdcc.core.event.DownloadFailed; +import net.pterodactylus.xdcc.core.event.DownloadFinished; +import net.pterodactylus.xdcc.core.event.DownloadStarted; +import net.pterodactylus.xdcc.core.event.GenericError; +import net.pterodactylus.xdcc.core.event.GenericMessage; +import net.pterodactylus.xdcc.core.event.MessageReceived; import net.pterodactylus.xdcc.data.Bot; import net.pterodactylus.xdcc.data.Channel; +import net.pterodactylus.xdcc.data.Download; import net.pterodactylus.xdcc.data.Network; import net.pterodactylus.xdcc.data.Pack; import net.pterodactylus.xdcc.data.Server; -import com.beust.jcommander.internal.Maps; -import com.beust.jcommander.internal.Sets; import com.google.common.base.Optional; import com.google.common.collect.HashBasedTable; +import com.google.common.collect.ImmutableSet; import com.google.common.collect.Lists; +import com.google.common.collect.Maps; +import com.google.common.collect.Sets; import com.google.common.collect.Table; import com.google.common.eventbus.EventBus; import com.google.common.eventbus.Subscribe; +import com.google.common.io.Closeables; import com.google.common.util.concurrent.AbstractIdleService; import com.google.inject.Inject; @@ -63,24 +86,98 @@ public class Core extends AbstractIdleService { /** The event bus. */ private final EventBus eventBus; + /** The temporary directory to download files to. */ + private final String temporaryDirectory; + + /** The directory to move finished downloads to. */ + private final String finalDirectory; + /** The channels that should be monitored. */ private final Collection channels = Sets.newHashSet(); + /** The channels that are currentlymonitored. */ + private final Collection joinedChannels = Sets.newHashSet(); + + /** The channels that are joined but not configured. */ + private final Collection extraChannels = Sets.newHashSet(); + /** The current network connections. */ private final Map networkConnections = Collections.synchronizedMap(Maps.newHashMap()); /** The currently known bots. */ private final Table networkBots = HashBasedTable.create(); + /** The current downloads. */ + private final Map downloads = Maps.newHashMap(); + + /** The current DCC receivers. */ + private final Collection dccReceivers = Lists.newArrayList(); + /** * Creates a new core. * * @param eventBus * The event bus + * @param temporaryDirectory + * The directory to download files to + * @param finalDirectory + * The directory to move finished files to */ @Inject - public Core(EventBus eventBus) { + public Core(EventBus eventBus, String temporaryDirectory, String finalDirectory) { this.eventBus = eventBus; + this.temporaryDirectory = temporaryDirectory; + this.finalDirectory = finalDirectory; + } + + // + // ACCESSORS + // + + /** + * Returns all configured channels. Due to various circumstances, configured + * channels might not actually be joined. + * + * @return All configured channels + */ + public Collection channels() { + return ImmutableSet.copyOf(channels); + } + + /** + * Returns all currently joined channels. + * + * @return All currently joined channels + */ + public Collection joinedChannels() { + return ImmutableSet.copyOf(joinedChannels); + } + + /** + * Returns all currently joined channels that are not configured. + * + * @return All currently joined but not configured channels + */ + public Collection extraChannels() { + return ImmutableSet.copyOf(extraChannels); + } + + /** + * Returns all currently known bots. + * + * @return All currently known bots + */ + public Collection bots() { + return networkBots.values(); + } + + /** + * Returns the currently active DCC receivers. + * + * @return The currently active DCC receivers + */ + public Collection dccReceivers() { + return dccReceivers; } // @@ -97,6 +194,30 @@ public class Core extends AbstractIdleService { channels.add(channel); } + /** + * Fetches the given pack from the given bot. + * + * @param bot + * The bot to fetch the pack from + * @param pack + * The pack to fetch + */ + public void fetch(Bot bot, Pack pack) { + Connection connection = networkConnections.get(bot.network()); + if (connection == null) { + return; + } + + Download download = new Download(bot, pack); + downloads.put(pack.name(), download); + + try { + connection.sendMessage(bot.name(), "XDCC SEND " + pack.id()); + } catch (IOException ioe1) { + logger.log(Level.WARNING, "Could not send message to bot!", ioe1); + } + } + // // ABSTRACTIDLESERVICE METHODS // @@ -159,6 +280,95 @@ public class Core extends AbstractIdleService { } /** + * Shows a message when a channel was joined by us. + * + * @param channelJoined + * The channel joined event + */ + @Subscribe + public void channelJoined(ChannelJoined channelJoined) { + if (channelJoined.connection().isSource(channelJoined.client())) { + Optional network = getNetwork(channelJoined.connection()); + if (!network.isPresent()) { + return; + } + + Optional channel = getChannel(network.get(), channelJoined.channel()); + if (!channel.isPresent()) { + /* it’s an extra channel. */ + extraChannels.add(new Channel(network.get(), channelJoined.channel())); + logger.info(String.format("Joined extra Channel %s on %s.", channelJoined.channel(), network.get().name())); + return; + } + + joinedChannels.add(channel.get()); + logger.info(String.format("Joined Channel %s on %s.", channelJoined.channel(), network.get().name())); + } + } + + /** + * Removes bots that leave a channel, or channels when it’s us that’s leaving. + * + * @param channelLeft + * The channel left event + */ + @Subscribe + public void channelLeft(ChannelLeft channelLeft) { + Optional network = getNetwork(channelLeft.connection()); + if (!network.isPresent()) { + return; + } + + Bot bot = networkBots.get(network.get(), channelLeft.client().nick().get()); + if (bot == null) { + /* maybe it was us? */ + if (channelLeft.connection().isSource(channelLeft.client())) { + Optional channel = getChannel(network.get(), channelLeft.channel()); + if (!channel.isPresent()) { + /* maybe it was an extra channel? */ + channel = getExtraChannel(network.get(), channelLeft.channel()); + if (!channel.isPresent()) { + /* okay, whatever. */ + return; + } + + extraChannels.remove(channel); + } else { + channels.remove(channel.get()); + } + + eventBus.post(new GenericMessage(String.format("Left Channel %s on %s.", channel.get().name(), channel.get().network().name()))); + } + + return; + } + + Bot removedBot = networkBots.remove(network.get(), channelLeft.client().nick().get()); + if (removedBot != null) { + eventBus.post(new GenericMessage(String.format("Bot %s (%s) was removed, %d packs removed.", removedBot.name(), removedBot.network().name(), removedBot.packs().size()))); + } + } + + /** + * Removes a client (which may be a bot) from the table of known bots. + * + * @param clientQuit + * The client quit event + */ + @Subscribe + public void clientQuit(ClientQuit clientQuit) { + Optional network = getNetwork(clientQuit.connection()); + if (!network.isPresent()) { + return; + } + + Bot removedBot = networkBots.remove(network.get(), clientQuit.client().nick().get()); + if (removedBot != null) { + eventBus.post(new GenericMessage(String.format("Bot %s (%s) was removed, %d packs removed.", removedBot.name(), removedBot.network().name(), removedBot.packs().size()))); + } + } + + /** * If a message on a channel is received, it is parsed for pack information * with is then added to a bot. * @@ -179,25 +389,185 @@ public class Core extends AbstractIdleService { return; } - Bot bot; - synchronized (networkBots) { - if (!networkBots.contains(network.get(), channelMessageReceived.source().nick().get())) { - networkBots.put(network.get(), channelMessageReceived.source().nick().get(), new Bot(network.get()).name(channelMessageReceived.source().nick().get())); - } - bot = networkBots.get(network.get(), channelMessageReceived.source().nick().get()); - } - /* parse pack information. */ Optional pack = parsePack(message); if (!pack.isPresent()) { return; } + Bot bot; + synchronized (networkBots) { + if (!networkBots.contains(network.get(), channelMessageReceived.source().nick().get())) { + bot = new Bot(network.get()).name(channelMessageReceived.source().nick().get()); + networkBots.put(network.get(), channelMessageReceived.source().nick().get(), bot); + eventBus.post(new BotAdded(bot)); + } else { + bot = networkBots.get(network.get(), channelMessageReceived.source().nick().get()); + } + } + /* add pack. */ bot.addPack(pack.get()); logger.fine(String.format("Bot %s now has %d packs.", bot, bot.packs().size())); } + /** + * Forward all private messages to every console. + * + * @param privateMessageReceived + * The private message recevied event + */ + @Subscribe + public void privateMessageReceived(PrivateMessageReceived privateMessageReceived) { + eventBus.post(new MessageReceived(privateMessageReceived.source(), privateMessageReceived.message())); + } + + /** + * Starts a DCC download. + * + * @param dccSendReceived + * The DCC SEND event + */ + @Subscribe + public void dccSendReceived(DccSendReceived dccSendReceived) { + Optional network = getNetwork(dccSendReceived.connection()); + if (!network.isPresent()) { + return; + } + + Download download = downloads.get(dccSendReceived.filename()); + if (download == null) { + /* unknown download, ignore. */ + return; + } + + /* check if the file already exists. */ + File outputFile = new File(temporaryDirectory, dccSendReceived.filename()); + if (outputFile.exists()) { + long existingFileSize = outputFile.length(); + + /* file already complete? */ + if ((dccSendReceived.filesize() > -1) && (existingFileSize >= dccSendReceived.filesize())) { + /* file is apparently already complete. just move it. */ + if (outputFile.renameTo(new File(finalDirectory, download.pack().name()))) { + eventBus.post(new GenericMessage(String.format("File %s already downloaded.", download.pack().name()))); + } else { + eventBus.post(new GenericMessage(String.format("File %s already downloaded but not moved to %s.", download.pack().name(), finalDirectory))); + } + + /* remove download. */ + downloads.remove(download); + return; + } + + /* file not complete yet, DCC resume it. */ + try { + download.remoteAddress(dccSendReceived.inetAddress()).filesize(dccSendReceived.filesize()); + dccSendReceived.connection().sendDccResume(dccSendReceived.source().nick().get(), dccSendReceived.filename(), dccSendReceived.port(), existingFileSize); + } catch (IOException ioe1) { + eventBus.post(new GenericError(String.format("Could not send DCC RESUME %s to %s (%s).", dccSendReceived.filename(), dccSendReceived.source().nick().get(), ioe1.getMessage()))); + } + + return; + } + + /* file does not exist, start the download. */ + try { + OutputStream fileOutputStream = new FileOutputStream(outputFile); + DccReceiver dccReceiver = new DccReceiver(eventBus, dccSendReceived.inetAddress(), dccSendReceived.port(), dccSendReceived.filename(), dccSendReceived.filesize(), fileOutputStream); + download.filename(outputFile.getPath()).outputStream(fileOutputStream).dccReceiver(dccReceiver); + dccReceivers.add(dccReceiver); + dccReceiver.start(); + eventBus.post(new DownloadStarted(download)); + } catch (FileNotFoundException fnfe1) { + eventBus.post(new GenericError(String.format("Could not start download of %s from %s (%s).", dccSendReceived.filename(), dccSendReceived.source().nick().get(), fnfe1.getMessage()))); + } + } + + @Subscribe + public void dccAcceptReceived(DccAcceptReceived dccAcceptReceived) { + Optional network = getNetwork(dccAcceptReceived.connection()); + if (!network.isPresent()) { + return; + } + + Download download = downloads.get(dccAcceptReceived.filename()); + if (download == null) { + /* unknown download, ignore. */ + return; + } + + try { + File outputFile = new File(temporaryDirectory, dccAcceptReceived.filename()); + if (outputFile.length() != dccAcceptReceived.position()) { + eventBus.post(new GenericError(String.format("Download %s from %s does not start at the right position!"))); + logger.log(Level.WARNING, String.format("Download %s from %s: have %d bytes but wants to resume from %d!", dccAcceptReceived.filename(), dccAcceptReceived.source(), outputFile.length(), dccAcceptReceived.position())); + + downloads.remove(download); + return; + } + OutputStream outputStream = new FileOutputStream(outputFile, true); + DccReceiver dccReceiver = new DccReceiver(eventBus, download.remoteAddress(), dccAcceptReceived.port(), dccAcceptReceived.filename(), dccAcceptReceived.position(), download.filesize(), outputStream); + download.filename(outputFile.getPath()).outputStream(outputStream).dccReceiver(dccReceiver); + dccReceivers.add(dccReceiver); + dccReceiver.start(); + eventBus.post(new DownloadStarted(download)); + } catch (FileNotFoundException fnfe1) { + } + } + + /** + * Closes the output stream of the download and moves the file to the final + * location. + * + * @param dccDownloadFinished + * The DCC download finished event + */ + @Subscribe + public void dccDownloadFinished(DccDownloadFinished dccDownloadFinished) { + Download download = downloads.get(dccDownloadFinished.dccReceiver().filename()); + if (download == null) { + /* probably shouldn’t happen. */ + return; + } + + try { + download.outputStream().close(); + File file = new File(download.filename()); + file.renameTo(new File(finalDirectory, download.pack().name())); + eventBus.post(new DownloadFinished(download)); + dccReceivers.remove(dccDownloadFinished.dccReceiver()); + downloads.remove(download); + } catch (IOException ioe1) { + /* TODO - handle all the errors. */ + logger.log(Level.WARNING, String.format("Could not move file %s to directory %s.", download.filename(), finalDirectory), ioe1); + } + } + + /** + * Closes the output stream and notifies all listeners of the failure. + * + * @param dccDownloadFailed + * The DCC download failed event + */ + @Subscribe + public void dccDownloadFailed(DccDownloadFailed dccDownloadFailed) { + Download download = downloads.get(dccDownloadFailed.dccReceiver().filename()); + if (download == null) { + /* probably shouldn’t happen. */ + return; + } + + try { + Closeables.close(download.outputStream(), true); + eventBus.post(new DownloadFailed(download)); + dccReceivers.remove(dccDownloadFailed.dccReceiver()); + downloads.remove(download); + } catch (IOException ioe1) { + /* swallow silently. */ + } + } + // // PRIVATE METHODS // @@ -221,6 +591,44 @@ public class Core extends AbstractIdleService { } /** + * Returns the configured channel for the given network and name. + * + * @param network + * The network the channel is located on + * @param channelName + * The name of the channel + * @return The configured channel, or {@link Optional#absent()} if no + * configured channel matching the given network and name was found + */ + public Optional getChannel(Network network, String channelName) { + for (Channel channel : channels) { + if (channel.network().equals(network) && (channel.name().equalsIgnoreCase(channelName))) { + return Optional.of(channel); + } + } + return Optional.absent(); + } + + /** + * Returns the extra channel for the given network and name. + * + * @param network + * The network the channel is located on + * @param channelName + * The name of the channel + * @return The extra channel, or {@link Optional#absent()} if no extra channel + * matching the given network and name was found + */ + public Optional getExtraChannel(Network network, String channelName) { + for (Channel channel : extraChannels) { + if (channel.network().equals(network) && (channel.name().equalsIgnoreCase(channelName))) { + return Optional.of(channel); + } + } + return Optional.absent(); + } + + /** * Parses {@link Pack} information from the given message. * * @param message