001: /*
002: * This file is part of DrFTPD, Distributed FTP Daemon.
003: *
004: * DrFTPD is free software; you can redistribute it and/or modify
005: * it under the terms of the GNU General Public License as published by
006: * the Free Software Foundation; either version 2 of the License, or
007: * (at your option) any later version.
008: *
009: * DrFTPD is distributed in the hope that it will be useful,
010: * but WITHOUT ANY WARRANTY; without even the implied warranty of
011: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
012: * GNU General Public License for more details.
013: *
014: * You should have received a copy of the GNU General Public License
015: * along with DrFTPD; if not, write to the Free Software
016: * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
017: */
018: package org.drftpd.master;
019:
020: import net.sf.drftpd.SlaveUnavailableException;
021:
022: import java.io.IOException;
023:
024: import java.net.InetSocketAddress;
025:
026: import org.drftpd.slave.ConnectInfo;
027: import org.drftpd.slave.RemoteIOException;
028: import org.drftpd.slave.Transfer;
029: import org.drftpd.slave.TransferFailedException;
030: import org.drftpd.slave.TransferIndex;
031: import org.drftpd.slave.TransferStatus;
032:
033: import com.sun.org.apache.bcel.internal.generic.GETFIELD;
034:
035: /**
036: * @author zubov
037: * @author mog
038: * @version $Id: RemoteTransfer.java 1428 2006-02-24 03:01:21Z zubov $
039: */
040: public class RemoteTransfer {
041: private InetSocketAddress _address;
042: private TransferIndex _transferIndex;
043: private RemoteSlave _rslave;
044: private TransferStatus _status;
045: private char _state = Transfer.TRANSFER_UNKNOWN;
046: private String _path;
047:
048: public RemoteTransfer(ConnectInfo ci, RemoteSlave rslave)
049: throws SlaveUnavailableException {
050: _transferIndex = ci.getTransferIndex();
051: _address = new InetSocketAddress(rslave.getPASVIP(), ci
052: .getPort());
053: _rslave = rslave;
054: _status = ci.getTransferStatus();
055: }
056:
057: public void updateTransferStatus(TransferStatus ts) {
058: synchronized (_rslave) {
059: _status = ts;
060: }
061: }
062:
063: public char getState() {
064: return _state;
065: }
066:
067: public long getChecksum() {
068: return _status.getChecksum();
069: }
070:
071: /**
072: * Returns how long this transfer has been running in milliseconds.
073: */
074: public long getElapsed() {
075: return _status.getElapsed();
076: }
077:
078: /**
079: * For a passive connection, returns the port the serversocket is listening on.
080: */
081: public int getLocalPort() {
082: return _address.getPort();
083: }
084:
085: public TransferStatus getTransferStatus()
086: throws TransferFailedException {
087: if (!_rslave.isOnline()) {
088: throw new TransferFailedException("Slave is offline",
089: _status);
090: }
091:
092: if (_status.threwException()) {
093: throw new TransferFailedException((IOException) _status
094: .getThrowable(), _status);
095: }
096:
097: return _status;
098: }
099:
100: /**
101: * Returns the number of bytes transfered.
102: */
103: public long getTransfered() {
104: return _status.getTransfered();
105: }
106:
107: /**
108: * Returns how fast the transfer is going in bytes per second.
109: */
110: public long getXferSpeed() {
111: return _status.getXferSpeed();
112: }
113:
114: public String getPathNull() {
115: return _path;
116: }
117:
118: public TransferIndex getTransferIndex() {
119: return _transferIndex;
120: }
121:
122: public InetSocketAddress getAddress() {
123: return _address;
124: }
125:
126: public void abort(String reason) {
127: synchronized (_rslave) {
128: if (_status.isFinished()) {
129: // no need to abort a transfer that isn't transferring
130: return;
131: }
132: try {
133: _rslave.issueAbortToSlave(getTransferIndex(), reason);
134: } catch (SlaveUnavailableException e) {
135: _status = new TransferStatus(getTransferIndex(), e);
136: }
137: }
138: }
139:
140: public void receiveFile(String path, char type, long position)
141: throws IOException, SlaveUnavailableException {
142: _path = path;
143: String index = _rslave.issueReceiveToSlave(path, type,
144: position, getTransferIndex());
145: _state = Transfer.TRANSFER_RECEIVING_UPLOAD;
146: try {
147: _rslave.fetchResponse(index);
148: } catch (RemoteIOException e) {
149: throw (IOException) e.getCause();
150: }
151: }
152:
153: public void sendFile(String path, char type, long position)
154: throws IOException, SlaveUnavailableException {
155: _path = path;
156: String index = _rslave.issueSendToSlave(path, type, position,
157: getTransferIndex());
158: _state = Transfer.TRANSFER_SENDING_DOWNLOAD;
159: try {
160: _rslave.fetchResponse(index);
161: } catch (RemoteIOException e) {
162: throw (IOException) e.getCause();
163: }
164: }
165:
166: public String toString() {
167: try {
168: return getClass().getName() + "[file=" + _path + ",status="
169: + getTransferStatus() + "]";
170: } catch (TransferFailedException e) {
171: return getClass().getName() + "[file=" + _path
172: + ",status=failed]";
173: }
174:
175: }
176: }
|