src/main/java/net/pterodactylus/irc/DccReceiver.java

   1 /*
   2  * XdccDownloader - DccReceiver.java - Copyright © 2013 David Roden
   3  *
   4  * This program is free software: you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation, either version 3 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 package net.pterodactylus.irc;
  19
  20 import java.io.IOException;
  21 import java.io.InputStream;
  22 import java.io.OutputStream;
  23 import java.net.InetAddress;
  24 import java.net.Socket;
  25 import java.util.concurrent.TimeUnit;
  26 import java.util.logging.Level;
  27 import java.util.logging.Logger;
  28
  29 import net.pterodactylus.irc.event.DccDownloadFailed;
  30 import net.pterodactylus.irc.event.DccDownloadFinished;
  31 import net.pterodactylus.irc.event.DccSendReceived;
  32 import net.pterodactylus.xdcc.util.io.BandwidthCountingInputStream;
  33
  34 import com.google.common.eventbus.EventBus;
  35 import com.google.common.io.Closeables;
  36 import com.google.common.util.concurrent.AbstractExecutionThreadService;
  37
  38 /**
  39  * Service that receives a file offered by a {@link DccSendReceived}.
  40  *
  41  * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
  42  */
  43 public class DccReceiver extends AbstractExecutionThreadService {
  44
  45         /** The logger. */
  46         private static final Logger logger = Logger.getLogger(DccReceiver.class.getName());
  47
  48         /** The event bus. */
  49         private final EventBus eventBus;
  50
  51         /** The address to connect to. */
  52         private final InetAddress inetAddress;
  53
  54         /** The port number to connect to. */
  55         private final int port;
  56
  57         /** The name of the file being offered. */
  58         private final String filename;
  59
  60         /** The size of the file being offered. */
  61         private final long size;
  62
  63         /** The output stream to write the file to. */
  64         private final OutputStream outputStream;
  65
  66         /** The number of bytes already written. */
  67         private long progress;
  68
  69         /** The bandwidth-measuring input stream. */
  70         private BandwidthCountingInputStream inputStream;
  71
  72         /**
  73          * Creates a new DCC receiver.
  74          *
  75          * @param inetAddress
  76          *              The address to connect to
  77          * @param port
  78          *              The port number to connect to
  79          * @param filename
  80          *              The name of the file being downloaded
  81          * @param size
  82          *              The size of the file being downloaded, or {@code -1} if the size is not
  83          *              known
  84          * @param outputStream
  85          *              The output stream to write the file to
  86          */
  87         public DccReceiver(EventBus eventBus, InetAddress inetAddress, int port, String filename, long size, OutputStream outputStream) {
  88                 this.eventBus = eventBus;
  89                 this.inetAddress = inetAddress;
  90                 this.port = port;
  91                 this.filename = filename;
  92                 this.size = size;
  93                 this.outputStream = outputStream;
  94         }
  95
  96         //
  97         // ACCESSORS
  98         //
  99
 100         /**
 101          * Returns the name of the file being downloaded. The name is not used by the
 102          * DCC receiver, it only serves as a kind of identifier.
 103          *
 104          * @return The name of the file being downloaded
 105          */
 106         public String filename() {
 107                 return filename;
 108         }
 109
 110         /**
 111          * Returns the size of the file being downloaded. If the size of the file is
 112          * not known, {@code -1} is returned.
 113          *
 114          * @return The size of the file being downloaded, or {@code -1} if the size is
 115          *         not known
 116          */
 117         public long size() {
 118                 return size;
 119         }
 120
 121         /**
 122          * Returns the number of bytes that have already been downloaded.
 123          *
 124          * @return The number of bytes that have already been downloaded
 125          */
 126         public long progress() {
 127                 return progress;
 128         }
 129
 130         /**
 131          * Returns the current rate of the download.
 132          *
 133          * @return The current rate of the download, in bytes/second
 134          */
 135         public long currentRate() {
 136                 return inputStream.getCurrentRate();
 137         }
 138
 139         /**
 140          * Returns the overall rate of the download.
 141          *
 142          * @return The overall rate of the download, in bytes/second
 143          */
 144         public long overallRate() {
 145                 return inputStream.getOverallRate();
 146         }
 147
 148         //
 149         // ABSTRACTEXECUTIONTHREADSERVICE METHODS
 150         //
 151
 152         @Override
 153         protected void run() throws IOException {
 154                 Socket socket = null;
 155                 try {
 156                         socket = new Socket(inetAddress, port);
 157                         InputStream socketInputStream = socket.getInputStream();
 158                         inputStream = new BandwidthCountingInputStream(socketInputStream, 5, TimeUnit.SECONDS);
 159                         byte[] buffer = new byte[65536];
 160                         while (isRunning() && ((size == -1) || (progress < size))) {
 161                                 int r = inputStream.read(buffer);
 162                                 if (r == -1) {
 163                                         /* yay, eof! */
 164                                         break;
 165                                 }
 166                                 outputStream.write(buffer, 0, r);
 167                                 progress += r;
 168                         }
 169                         outputStream.flush();
 170                         eventBus.post(new DccDownloadFinished(this));
 171                 } catch (IOException ioe1) {
 172                         logger.log(Level.WARNING, "I/O error while receiving DCC!", ioe1);
 173                         eventBus.post(new DccDownloadFailed(this, ioe1));
 174                 } finally {
 175                         Closeables.close(inputStream, true);
 176                         if (socket != null) {
 177                                 socket.close();
 178                         }
 179                 }
 180         }
 181
 182 }