View Javadoc
1   package org.apache.maven.wagon.events;
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 org.apache.maven.wagon.Wagon;
23  import org.apache.maven.wagon.resource.Resource;
24  
25  import java.io.File;
26  
27  /**
28   * TransferEvent is used to notify TransferListeners about progress
29   * in transfer of resources form/to the repository
30   *
31   * @author <a href="michal.maczka@dimatics.com">Michal Maczka</a>
32   *
33   */
34  public class TransferEvent
35      extends WagonEvent
36  {
37  
38      /**
39       * A transfer was attempted, but has not yet commenced.
40       */
41      public static final int TRANSFER_INITIATED = 0;
42  
43      /**
44       * A transfer was started.
45       */
46      public static final int TRANSFER_STARTED = 1;
47  
48      /**
49       * A transfer is completed.
50       */
51      public static final int TRANSFER_COMPLETED = 2;
52  
53      /**
54       * A transfer is in progress.
55       */
56      public static final int TRANSFER_PROGRESS = 3;
57  
58      /**
59       * An error occurred during transfer
60       */
61      public static final int TRANSFER_ERROR = 4;
62  
63      /**
64       * Indicates GET transfer  (from the repository)
65       */
66      public static final int REQUEST_GET = 5;
67  
68      /**
69       * Indicates PUT transfer (to the repository)
70       */
71      public static final int REQUEST_PUT = 6;
72  
73      private Resource resource;
74  
75      private int eventType;
76  
77      private int requestType;
78  
79      private Exception exception;
80  
81      private File localFile;
82  
83      public TransferEvent( final Wagon wagon, final Resource resource, final int eventType, final int requestType )
84      {
85          super( wagon );
86  
87          this.resource = resource;
88  
89          setEventType( eventType );
90  
91          setRequestType( requestType );
92  
93      }
94  
95      public TransferEvent( final Wagon wagon, final Resource resource, final Exception exception, final int requestType )
96      {
97          this( wagon, resource, TRANSFER_ERROR, requestType );
98  
99          this.exception = exception;
100     }
101 
102     /**
103      * @return Returns the resource.
104      */
105     public Resource getResource()
106     {
107         return resource;
108     }
109 
110     /**
111      * @return Returns the exception.
112      */
113     public Exception getException()
114     {
115         return exception;
116     }
117 
118     /**
119      * Returns the request type.
120      *
121      * @return Returns the request type. The Request type is one of
122      *         <code>TransferEvent.REQUEST_GET<code> or <code>TransferEvent.REQUEST_PUT<code>
123      */
124     public int getRequestType()
125     {
126         return requestType;
127     }
128 
129     /**
130      * Sets the request type
131      *
132      * @param requestType The requestType to set.
133      *                    The Request type value should be either
134      *                    <code>TransferEvent.REQUEST_GET<code> or <code>TransferEvent.REQUEST_PUT<code>.
135      * @throws IllegalArgumentException when
136      */
137     public void setRequestType( final int requestType )
138     {
139         switch ( requestType )
140         {
141 
142             case REQUEST_PUT:
143             case REQUEST_GET:
144                 break;
145 
146             default :
147                 throw new IllegalArgumentException( "Illegal request type: " + requestType );
148         }
149 
150         this.requestType = requestType;
151     }
152 
153     /**
154      * @return Returns the eventType.
155      */
156     public int getEventType()
157     {
158         return eventType;
159     }
160 
161     /**
162      * @param eventType The eventType to set.
163      */
164     public void setEventType( final int eventType )
165     {
166         switch ( eventType )
167         {
168 
169             case TRANSFER_INITIATED:
170             case TRANSFER_STARTED:
171             case TRANSFER_COMPLETED:
172             case TRANSFER_PROGRESS:
173             case TRANSFER_ERROR:
174                 break;
175             default :
176                 throw new IllegalArgumentException( "Illegal event type: " + eventType );
177         }
178 
179         this.eventType = eventType;
180     }
181 
182     /**
183      * @param resource The resource to set.
184      */
185     public void setResource( final Resource resource )
186     {
187         this.resource = resource;
188     }
189 
190     /**
191      * @return Returns the local file.
192      */
193     public File getLocalFile()
194     {
195         return localFile;
196     }
197 
198     /**
199      * @param localFile The local file to set.
200      */
201     public void setLocalFile( File localFile )
202     {
203         this.localFile = localFile;
204     }
205 
206     public String toString()
207     {
208         StringBuilder sb = new StringBuilder();
209 
210         sb.append( "TransferEvent[" );
211 
212         switch ( this.getRequestType() )
213         {
214             case REQUEST_GET:
215                 sb.append( "GET" );
216                 break;
217             case REQUEST_PUT:
218                 sb.append( "PUT" );
219                 break;
220             default:
221                 sb.append( this.getRequestType() );
222                 break;
223         }
224 
225         sb.append( "|" );
226         switch ( this.getEventType() )
227         {
228             case TRANSFER_COMPLETED:
229                 sb.append( "COMPLETED" );
230                 break;
231             case TRANSFER_ERROR:
232                 sb.append( "ERROR" );
233                 break;
234             case TRANSFER_INITIATED:
235                 sb.append( "INITIATED" );
236                 break;
237             case TRANSFER_PROGRESS:
238                 sb.append( "PROGRESS" );
239                 break;
240             case TRANSFER_STARTED:
241                 sb.append( "STARTED" );
242                 break;
243             default:
244                 sb.append( this.getEventType() );
245                 break;
246         }
247 
248         sb.append( "|" );
249 
250         sb.append( this.getWagon().getRepository() ).append( "|" );
251         sb.append( this.getLocalFile() ).append( "|" );
252         sb.append( this.getResource().inspect() );
253         sb.append( "]" );
254 
255         return sb.toString();
256     }
257 
258     public int hashCode()
259     {
260         final int prime = 31;
261         int result = 1;
262         result = prime * result + eventType;
263         result = prime * result + ( ( exception == null ) ? 0 : exception.hashCode() );
264         result = prime * result + ( ( localFile == null ) ? 0 : localFile.hashCode() );
265         result = prime * result + requestType;
266         result = prime * result + ( ( resource == null ) ? 0 : resource.hashCode() );
267         return result;
268     }
269 
270     public boolean equals( Object obj )
271     {
272         if ( this == obj )
273         {
274             return true;
275         }
276         if ( ( obj == null ) || ( getClass() != obj.getClass() ) )
277         {
278             return false;
279         }
280         final TransferEvent other = (TransferEvent) obj;
281         if ( eventType != other.eventType )
282         {
283             return false;
284         }
285         if ( exception == null )
286         {
287             if ( other.exception != null )
288             {
289                 return false;
290             }
291         }
292         else if ( !exception.getClass().equals( other.exception.getClass() ) )
293         {
294             return false;
295         }
296         if ( requestType != other.requestType )
297         {
298             return false;
299         }
300         if ( resource == null )
301         {
302             if ( other.resource != null )
303             {
304                 return false;
305             }
306         }
307         else if ( !resource.equals( other.resource ) )
308         {
309             return false;
310         }
311         else if ( !source.equals( other.source ) )
312         {
313             return false;
314         }
315         return true;
316     }
317     
318 }