View Javadoc
1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one
3    * or more contributor license agreements.  See the NOTICE file
4    * distributed with this work for additional information
5    * regarding copyright ownership.  The ASF licenses this file
6    * to you under the Apache License, Version 2.0 (the
7    * "License"); you may not use this file except in compliance
8    * with the License.  You may obtain a copy of the License at
9    *
10   *   http://www.apache.org/licenses/LICENSE-2.0
11   *
12   * Unless required by applicable law or agreed to in writing,
13   * software distributed under the License is distributed on an
14   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15   * KIND, either express or implied.  See the License for the
16   * specific language governing permissions and limitations
17   * under the License.
18   */
19  package org.eclipse.aether.connector.basic;
20  
21  import java.nio.ByteBuffer;
22  import java.util.Collections;
23  import java.util.Map;
24  
25  import org.eclipse.aether.spi.connector.Transfer;
26  import org.eclipse.aether.spi.connector.transport.TransportListener;
27  import org.eclipse.aether.transfer.TransferCancelledException;
28  import org.eclipse.aether.transfer.TransferEvent;
29  import org.eclipse.aether.transfer.TransferEvent.EventType;
30  import org.eclipse.aether.transfer.TransferListener;
31  
32  class TransferTransportListener<T extends Transfer> extends TransportListener {
33  
34      private final T transfer;
35  
36      private final TransferListener listener;
37  
38      private final TransferEvent.Builder eventBuilder;
39  
40      private ChecksumCalculator checksumCalculator;
41  
42      protected TransferTransportListener(T transfer, TransferEvent.Builder eventBuilder) {
43          this.transfer = transfer;
44          this.listener = transfer.getListener();
45          this.eventBuilder = eventBuilder;
46      }
47  
48      protected T getTransfer() {
49          return transfer;
50      }
51  
52      public void transferInitiated() throws TransferCancelledException {
53          if (listener != null) {
54              eventBuilder.resetType(EventType.INITIATED);
55              listener.transferInitiated(eventBuilder.build());
56          }
57      }
58  
59      @Override
60      public void transportStarted(long dataOffset, long dataLength) throws TransferCancelledException {
61          if (checksumCalculator != null) {
62              checksumCalculator.init(dataOffset);
63          }
64          if (listener != null) {
65              eventBuilder.resetType(EventType.STARTED).setTransferredBytes(dataOffset);
66              TransferEvent event = eventBuilder.build();
67              event.getResource().setContentLength(dataLength).setResumeOffset(dataOffset);
68              listener.transferStarted(event);
69          }
70      }
71  
72      @Override
73      public void transportProgressed(ByteBuffer data) throws TransferCancelledException {
74          if (checksumCalculator != null) {
75              checksumCalculator.update(data);
76          }
77          if (listener != null) {
78              eventBuilder
79                      .resetType(EventType.PROGRESSED)
80                      .addTransferredBytes(data.remaining())
81                      .setDataBuffer(data);
82              listener.transferProgressed(eventBuilder.build());
83          }
84      }
85  
86      public void transferCorrupted(Exception exception) throws TransferCancelledException {
87          if (listener != null) {
88              eventBuilder.resetType(EventType.CORRUPTED).setException(exception);
89              listener.transferCorrupted(eventBuilder.build());
90          }
91      }
92  
93      public void transferFailed(Exception exception, int classification) {
94          if (listener != null) {
95              eventBuilder.resetType(EventType.FAILED).setException(exception);
96              listener.transferFailed(eventBuilder.build());
97          }
98      }
99  
100     public void transferSucceeded() {
101         if (listener != null) {
102             eventBuilder.resetType(EventType.SUCCEEDED);
103             listener.transferSucceeded(eventBuilder.build());
104         }
105     }
106 
107     public Map<String, Object> getChecksums() {
108         if (checksumCalculator == null) {
109             return Collections.emptyMap();
110         }
111         return checksumCalculator.get();
112     }
113 
114     public void setChecksumCalculator(ChecksumCalculator checksumCalculator) {
115         this.checksumCalculator = checksumCalculator;
116     }
117 }