View Javadoc

1   package org.apache.maven.repository.legacy;
2   
3   /*
4    * Licensed to the Apache Software Foundation (ASF) under one
5    * or more contributor license agreements.  See the NOTICE file
6    * distributed with this work for additional information
7    * regarding copyright ownership.  The ASF licenses this file
8    * to you under the Apache License, Version 2.0 (the
9    * "License"); you may not use this file except in compliance
10   * with the License.  You may obtain a copy of the License at
11   *
12   *   http://www.apache.org/licenses/LICENSE-2.0
13   *
14   * Unless required by applicable law or agreed to in writing,
15   * software distributed under the License is distributed on an
16   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
17   * KIND, either express or implied.  See the License for the
18   * specific language governing permissions and limitations
19   * under the License.
20   */
21  
22  import java.util.IdentityHashMap;
23  import java.util.Map;
24  
25  import org.apache.maven.repository.ArtifactTransferEvent;
26  import org.apache.maven.repository.ArtifactTransferListener;
27  import org.apache.maven.repository.ArtifactTransferResource;
28  import org.apache.maven.wagon.events.TransferEvent;
29  import org.apache.maven.wagon.events.TransferListener;
30  import org.apache.maven.wagon.repository.Repository;
31  import org.apache.maven.wagon.resource.Resource;
32  
33  public class TransferListenerAdapter
34      implements TransferListener
35  {
36  
37      private final ArtifactTransferListener listener;
38  
39      private final Map<Resource, ArtifactTransferResource> artifacts;
40  
41      private final Map<Resource, Long> transfers;
42  
43      public static TransferListener newAdapter( ArtifactTransferListener listener )
44      {
45          if ( listener == null )
46          {
47              return null;
48          }
49          else
50          {
51              return new TransferListenerAdapter( listener );
52          }
53      }
54  
55      private TransferListenerAdapter( ArtifactTransferListener listener )
56      {
57          this.listener = listener;
58          this.artifacts = new IdentityHashMap<Resource, ArtifactTransferResource>();
59          this.transfers = new IdentityHashMap<Resource, Long>();
60      }
61  
62      public void debug( String message )
63      {
64      }
65  
66      public void transferCompleted( TransferEvent transferEvent )
67      {
68          ArtifactTransferEvent event = wrap( transferEvent );
69  
70          Long transferred = null;
71          synchronized ( transfers )
72          {
73              transferred = transfers.remove( transferEvent.getResource() );
74          }
75          if ( transferred != null )
76          {
77              event.setTransferredBytes( transferred.longValue() );
78          }
79  
80          synchronized ( artifacts )
81          {
82              artifacts.remove( transferEvent.getResource() );
83          }
84  
85          listener.transferCompleted( event );
86      }
87  
88      public void transferError( TransferEvent transferEvent )
89      {
90          synchronized ( transfers )
91          {
92              transfers.remove( transferEvent.getResource() );
93          }
94          synchronized ( artifacts )
95          {
96              artifacts.remove( transferEvent.getResource() );
97          }
98      }
99  
100     public void transferInitiated( TransferEvent transferEvent )
101     {
102         listener.transferInitiated( wrap( transferEvent ) );
103     }
104 
105     public void transferProgress( TransferEvent transferEvent, byte[] buffer, int length )
106     {
107         Long transferred;
108         synchronized ( transfers )
109         {
110             transferred = transfers.get( transferEvent.getResource() );
111             if ( transferred == null )
112             {
113                 transferred = Long.valueOf( length );
114             }
115             else
116             {
117                 transferred = Long.valueOf( transferred.longValue() + length );
118             }
119             transfers.put( transferEvent.getResource(), transferred );
120         }
121 
122         ArtifactTransferEvent event = wrap( transferEvent );
123         event.setDataBuffer( buffer );
124         event.setDataOffset( 0 );
125         event.setDataLength( length );
126         event.setTransferredBytes( transferred.longValue() );
127 
128         listener.transferProgress( event );
129     }
130 
131     public void transferStarted( TransferEvent transferEvent )
132     {
133         listener.transferStarted( wrap( transferEvent ) );
134     }
135 
136     private ArtifactTransferEvent wrap( TransferEvent event )
137     {
138         if ( event == null )
139         {
140             return null;
141         }
142         else
143         {
144             String wagon = event.getWagon().getClass().getName();
145 
146             ArtifactTransferResource artifact = wrap( event.getWagon().getRepository(), event.getResource() );
147 
148             ArtifactTransferEvent evt;
149             if ( event.getException() != null )
150             {
151                 evt = new ArtifactTransferEvent( wagon, event.getException(), event.getRequestType(), artifact );
152             }
153             else
154             {
155                 evt = new ArtifactTransferEvent( wagon, event.getEventType(), event.getRequestType(), artifact );
156             }
157 
158             evt.setLocalFile( event.getLocalFile() );
159 
160             return evt;
161         }
162     }
163 
164     private ArtifactTransferResource wrap( Repository repository, Resource resource )
165     {
166         if ( resource == null )
167         {
168             return null;
169         }
170         else
171         {
172             synchronized ( artifacts )
173             {
174                 ArtifactTransferResource artifact = artifacts.get( resource );
175 
176                 if ( artifact == null )
177                 {
178                     artifact = new MavenArtifact( repository.getUrl(), resource );
179                     artifacts.put( resource, artifact );
180                 }
181 
182                 return artifact;
183             }
184         }
185     }
186 
187 }