X-Git-Url: https://git.pterodactylus.net/?a=blobdiff_plain;f=src%2Fmain%2Fjava%2Fnet%2Fpterodactylus%2Fxdcc%2Fui%2Fstdin%2FCommandReader.java;h=2a6ec83158338af02b3fc3f0f1e6ae54dd893507;hb=58dbc9b92a90eb17fecaf12d9ef070bce621ebdb;hp=836f4061b8d4c237bc39e1bea10738eaa62bd9f9;hpb=287af7be5a3fe79882649783649889f079451d27;p=xudocci.git diff --git a/src/main/java/net/pterodactylus/xdcc/ui/stdin/CommandReader.java b/src/main/java/net/pterodactylus/xdcc/ui/stdin/CommandReader.java index 836f406..2a6ec83 100644 --- a/src/main/java/net/pterodactylus/xdcc/ui/stdin/CommandReader.java +++ b/src/main/java/net/pterodactylus/xdcc/ui/stdin/CommandReader.java @@ -17,15 +17,23 @@ package net.pterodactylus.xdcc.ui.stdin; +import static com.google.common.collect.Lists.newArrayList; +import static net.pterodactylus.xdcc.data.Download.BY_NAME; +import static net.pterodactylus.xdcc.data.Download.BY_RUNNING; + import java.io.BufferedReader; import java.io.IOException; import java.io.Reader; import java.io.Writer; +import java.util.Arrays; import java.util.Collection; import java.util.Collections; +import java.util.Comparator; import java.util.List; import java.util.Set; +import java.util.regex.Pattern; +import net.pterodactylus.irc.Connection; import net.pterodactylus.irc.DccReceiver; import net.pterodactylus.irc.util.MessageCleaner; import net.pterodactylus.xdcc.core.Core; @@ -38,7 +46,11 @@ import net.pterodactylus.xdcc.data.Bot; import net.pterodactylus.xdcc.data.Download; import net.pterodactylus.xdcc.data.Pack; +import com.google.common.base.Predicate; +import com.google.common.collect.ComparisonChain; +import com.google.common.collect.FluentIterable; import com.google.common.collect.Lists; +import com.google.common.collect.Ordering; import com.google.common.collect.Sets; import com.google.common.eventbus.Subscribe; import com.google.common.primitives.Ints; @@ -84,16 +96,16 @@ public class CommandReader extends AbstractExecutionThreadService { protected void run() throws Exception { String lastLine = ""; String line; - final List lastResult = Lists.newArrayList(); + State state = new State(); while ((line = reader.readLine()) != null) { if (line.equals("")) { line = lastLine; } String[] words = line.split(" +"); if (words[0].equalsIgnoreCase("search")) { - lastResult.clear(); - for (Bot bot : core.bots()) { - for (Pack pack : bot) { + List lastResult = newArrayList(); + for (Bot bot : newArrayList(core.bots())) { + for (Pack pack : newArrayList(bot)) { boolean found = true; for (int wordIndex = 1; wordIndex < words.length; ++wordIndex) { if (words[wordIndex].startsWith("-") && pack.name().toLowerCase().contains(words[wordIndex].toLowerCase().substring(1))) { @@ -116,9 +128,11 @@ public class CommandReader extends AbstractExecutionThreadService { writeLine(String.format("[%d] %s (%s) from %s (#%s) on %s", counter++, result.pack().name(), result.pack().size(), result.bot().name(), result.pack().id(), result.bot().network().name())); } writeLine("End of Search."); + state = state.setLastResults(lastResult); } else if (words[0].equalsIgnoreCase("dcc")) { int counter = 0; - for (Download download : core.downloads()) { + List downloads = newArrayList(FluentIterable.from(core.downloads()).toSortedList(Ordering.from(BY_NAME).compound(BY_RUNNING))); + for (Download download : downloads) { DccReceiver dccReceiver = download.dccReceiver(); if (dccReceiver == null) { /* download has not even started. */ @@ -127,21 +141,27 @@ public class CommandReader extends AbstractExecutionThreadService { } writer.write(String.format("[%d] %s from %s (%s, ", counter++, dccReceiver.filename(), download.bot().name(), f(dccReceiver.size()))); if (dccReceiver.isRunning()) { - writer.write(String.format("%.1f%%, %s", dccReceiver.progress() * 100.0 / dccReceiver.size(), f(dccReceiver.currentRate()))); + writer.write(String.format("%.1f%%, %s/s, %s", dccReceiver.progress() * 100.0 / dccReceiver.size(), f(dccReceiver.currentRate()), getTimeLeft(dccReceiver))); } else { if (dccReceiver.progress() >= dccReceiver.size()) { - writer.write(String.format("complete, %s", f(dccReceiver.overallRate()))); + writer.write(String.format("complete, %s/s", f(dccReceiver.overallRate()))); } else { - writer.write(String.format("aborted at %.1f%%, %s", dccReceiver.progress() * 100.0 / dccReceiver.size(), f(dccReceiver.currentRate()))); + writer.write(String.format("aborted at %.1f%%, %s/s", dccReceiver.progress() * 100.0 / dccReceiver.size(), f(dccReceiver.currentRate()))); } } - writer.write("/s)\n"); + writer.write(")\n"); } writeLine("End of DCCs."); + state = state.setLastDownloads(downloads); } else if (words[0].equalsIgnoreCase("get")) { Integer index = Ints.tryParse(words[1]); - if ((index != null) && (index < lastResult.size())) { - core.fetch(lastResult.get(index).bot(), lastResult.get(index).pack()); + if ((index != null) && (index < state.getLastResults().size())) { + core.fetch(state.getLastResults().get(index).bot(), state.getLastResults().get(index).pack()); + } + } else if (words[0].equalsIgnoreCase("cancel")) { + Integer index = Ints.tryParse(words[1]); + if ((index != null) && (index < state.getLastDownloads().size())) { + core.cancelDownload(state.getLastDownloads().get(index).bot(), state.getLastDownloads().get(index).pack()); } } else if (words[0].equalsIgnoreCase("stats")) { int configuredChannelsCount = core.channels().size(); @@ -158,6 +178,26 @@ public class CommandReader extends AbstractExecutionThreadService { } writeLine(String.format("%d channels (%d joined, %d extra), %d bots offering %d packs (%d unique).", configuredChannelsCount, joinedChannelsCount, extraChannelsCount, bots.size(), packsCount, packNames.size())); + } else if (words[0].equalsIgnoreCase("connections")) { + List lastConnections = newArrayList(); + int counter = 0; + for (Connection connection : core.connections()) { + lastConnections.add(connection); + writer.write(String.format("[%d] %s:%d, %s/s\n", counter++, connection.hostname(), connection.port(), f(connection.getInputRate()))); + } + writeLine("End of connections."); + state = state.setLastConnections(lastConnections); + } else if (words[0].equalsIgnoreCase("disconnect")) { + if ((words.length == 1) || ("all".equals(words[1]))) { + for (Connection connection : state.getLastConnections()) { + core.closeConnection(connection); + } + } else { + Integer index = Ints.tryParse(words[1]); + if ((index != null) && (index < state.getLastConnections().size())) { + core.closeConnection(state.getLastConnections().get(index)); + } + } } lastLine = line; @@ -284,9 +324,108 @@ public class CommandReader extends AbstractExecutionThreadService { return String.format("%dB", number); } + /** + * Returns the estimated time left for the given transfer. + * + * @param dccReceiver + * The DCC receiver to get the time left for + * @return The time left for the transfer, or “unknown” if the time can not be + * estimated + */ + private static String getTimeLeft(DccReceiver dccReceiver) { + if ((dccReceiver.size() == -1) || (dccReceiver.currentRate() == 0)) { + return "unknown"; + } + long secondsLeft = (dccReceiver.size() - dccReceiver.progress()) / dccReceiver.currentRate(); + if (secondsLeft > 3600) { + return String.format("%02d:%02d:%02d", secondsLeft / 3600, (secondsLeft / 60) % 60, secondsLeft % 60); + } + return String.format("%02d:%02d", (secondsLeft / 60) % 60, secondsLeft % 60); + } + /** Container for result information. */ private static class Result implements Comparable { + /** {@link Predicate} that matches {@link Result}s that contain an archive. */ + private static final Predicate isArchive = new Predicate() { + + /** All suffixes that are recognized as archives. */ + private final List archiveSuffixes = Arrays.asList("rar", "tar", "zip", "tar.gz", "tar.bz2", "tar.lzma", "7z"); + + @Override + public boolean apply(Result result) { + for (String suffix : archiveSuffixes) { + if (result.pack().name().toLowerCase().endsWith(suffix)) { + return true; + } + } + return false; + } + }; + + /** + * {@link Comparator} for {@link Result}s that sorts archives (as per {@link + * #isArchive} to the back of the list. + */ + private static final Comparator packArchiveComparator = new Comparator() { + @Override + public int compare(Result leftResult, Result rightResult) { + if (isArchive.apply(leftResult) && !isArchive.apply(rightResult)) { + return 1; + } + if (!isArchive.apply(leftResult) && isArchive.apply(rightResult)) { + return -1; + } + return 0; + } + }; + + /** + * {@link Comparator} for bot nicknames. It comprises different strategies: + * one name pattern is preferred (and thus listed first), one pattern is + * disliked (and thus listed last), the rest is sorted alphabetically. + */ + private static final Comparator botNameComparator = new Comparator() { + + /** Regular expression pattern for preferred names. */ + private final Pattern preferredNames = Pattern.compile("(?i)[^\\w]EUR?[^\\w]"); + + /** Regular expression pattern for disliked names. */ + private final Pattern dislikedNames = Pattern.compile("(?i)[^\\w]USA?[^\\w]"); + + @Override + public int compare(Result leftResult, Result rightResult) { + String leftBotName = leftResult.bot().name(); + String rightBotName = rightResult.bot().name(); + /* preferred names to the front! */ + if (preferredNames.matcher(leftBotName).find() && !preferredNames.matcher(rightBotName).find()) { + return -1; + } + if (preferredNames.matcher(rightBotName).find() && !preferredNames.matcher(leftBotName).find()) { + return 1; + } + /* disliked names to the back. */ + if (dislikedNames.matcher(leftBotName).find() && !dislikedNames.matcher(rightBotName).find()) { + return 1; + } + if (dislikedNames.matcher(rightBotName).find() && !dislikedNames.matcher(leftBotName).find()) { + return -1; + } + return 0; + } + }; + + /** + * {@link Comparator} for {@link Result}s that sorts them by the name of the + * {@link Pack}. + */ + private static final Comparator packNameComparator = new Comparator() { + @Override + public int compare(Result leftResult, Result rightResult) { + return leftResult.pack().name().compareToIgnoreCase(rightResult.pack().name()); + } + }; + /** The bot carrying the pack. */ private final Bot bot; @@ -334,7 +473,120 @@ public class CommandReader extends AbstractExecutionThreadService { @Override public int compareTo(Result result) { - return pack().name().compareToIgnoreCase(result.pack().name()); + return ComparisonChain.start() + .compare(this, result, packArchiveComparator) + .compare(this, result, botNameComparator) + .compare(this, result, packNameComparator).result(); + } + + } + + /** + * Container for the current state of the command reader. + * + * @author David ‘Bombe’ Roden + */ + private static class State { + + /** The last connections displayed. */ + private final List lastConnections; + + /** The last results displayed. */ + private final List lastResults; + + /** The last downloads displayed. */ + private final List lastDownloads; + + /** Creates a new empty state. */ + public State() { + this(Lists.newArrayList(), Lists.newArrayList(), Lists.newArrayList()); + } + + /** + * Creates a new state. + * + * @param lastConnections + * The last connections + * @param lastResults + * The last results + * @param lastDownloads + * The last downloads + */ + private State(List lastConnections, List lastResults, List lastDownloads) { + this.lastConnections = lastConnections; + this.lastResults = lastResults; + this.lastDownloads = lastDownloads; + } + + // + // ACCESSORS + // + + /** + * Returns the last connections displayed. + * + * @return The last connections displayed + */ + public List getLastConnections() { + return lastConnections; + } + + /** + * Returns the last results displayed. + * + * @return The last results displayed + */ + public List getLastResults() { + return lastResults; + } + + /** + * Returns the last downloads displayed. + * + * @return The last downloads displayed + */ + public List getLastDownloads() { + return lastDownloads; + } + + // + // MUTATORS + // + + /** + * Returns a new state with the given last connections and the last downloads + * and results of this state. + * + * @param lastConnections + * The new last connections displayed + * @return The new state + */ + public State setLastConnections(List lastConnections) { + return new State(lastConnections, lastResults, lastDownloads); + } + + /** + * Returns a new state with the given last results and the last downloads and + * connections of this state. + * + * @param lastResults + * The new last results displayed + * @return The new state + */ + public State setLastResults(List lastResults) { + return new State(lastConnections, lastResults, lastDownloads); + } + + /** + * Returns a new state with the given last downloads and the last connections + * and results of this state. + * + * @param lastDownloads + * The new last downloads displayed + * @return The new state + */ + public State setLastDownloads(List lastDownloads) { + return new State(lastConnections, lastResults, lastDownloads); } }