View Javadoc

1   /*
2    * Copyright 2001,2004 The Apache Software Foundation.
3    * 
4    * Licensed under the Apache License, Version 2.0 (the "License");
5    * you may not use this file except in compliance with the License.
6    * You may obtain a copy of the License at
7    * 
8    *      http://www.apache.org/licenses/LICENSE-2.0
9    * 
10   * Unless required by applicable law or agreed to in writing, software
11   * distributed under the License is distributed on an "AS IS" BASIS,
12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   * See the License for the specific language governing permissions and
14   * limitations under the License.
15   */
16  
17  package org.apache.commons.jjar;
18  
19  import java.lang.reflect.Method;
20  import java.util.List;
21  import java.util.Iterator;
22  import java.net.URLConnection;
23  import java.net.URL;
24  
25  /**
26   *  JJAR command line program
27   *
28   *  @author <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a>
29   *  @version $Id: JJAR.java 155454 2005-02-26 13:23:34Z dirkv $
30   */
31  public class JJAR
32  {
33      public static String title = "JJAR : Jakarta Jar Archive Respository v@version@";
34      public static String defaultRepository = ClasspathUtil.getDefaultRepository();
35  
36      public static void main( String args[])
37      {
38          /*
39           *  first thing is the verb
40           */
41  
42          if (args.length < 1 )
43          {
44              System.out.println(title);
45              return;
46          }
47  
48          String verb = args[0];
49          Class [] ca = {args.getClass() };
50          Object [] arg = { args };
51  
52          try 
53          {
54              Method m = Class.forName("org.apache.commons.jjar.JJAR").getMethod(verb, ca );
55  
56              m.invoke( null, arg );
57          }
58          catch( NoSuchMethodException nsme )
59          {
60              System.out.println("JJAR : invalid action " + verb );
61              JJAR.help(  args );
62          }
63          catch( Exception e )
64          {
65              System.out.println("JJAR : exception : " + e );
66          }
67      }
68  
69      public static void help( String args[] )
70      {
71          header();
72          
73          System.out.println("list : list the JJAR packages in the repository");
74          System.out.println("fetch : fetch a JJAR package from the repository");
75          System.out.println("See the README.txt for more info.");
76      }
77  
78      public static void fetch( String args[] )
79      {
80          boolean classpath = false;
81          String jarname = null;
82          String packagename = null;
83          String version = null;
84          boolean verifyignore = false;
85          boolean getdeps = true;
86          boolean onlydeps = false;
87  
88          String dir = ".";
89  
90          if ( args.length < 3 )
91          {
92              System.out.println("Usage :  fetch [-v] [-od] -j jarname -p package -v version ");
93              return;
94          }
95  
96          for( int i = 1; i < args.length; i++)
97          {
98              String arg = args[i];
99  
100             if (arg.startsWith("-"))
101             {
102                 if (arg.equals("-j"))
103                 {
104                     jarname = args[i+1];
105                     i++;
106                 }
107                 else if (arg.equals("-p"))
108                 {
109                     packagename = args[i+1];
110                     i++;
111                 }
112                 else if (arg.equals("-v"))
113                 {
114                     version = args[i+1];
115                     i++;
116                 }
117                 else if (arg.equals("-c"))
118                 {
119                     classpath = true;
120                 }
121                 else if (arg.equals("-vi"))
122                 {
123                     verifyignore = true;
124                 }
125                 else if( arg.equals("-d"))
126                 {
127                     dir = args[i+1];
128                     i++;
129                 }
130                 else if( arg.equals("-nd"))
131                 {
132                     getdeps = false;
133                 }
134                 else if( arg.equals("-od"))
135                 {
136                     onlydeps = true;
137                 }
138                 
139             }
140         }
141 
142         if ( packagename == null)
143         {
144             System.out.println("Usage :  fetch -j jarname -p package -v version ");
145             return;
146         }
147 
148         /*
149          * now go get
150          */
151         
152         try
153         {
154             /*
155              *  get the repository info
156              */
157 
158             Repository rep = new RepositoryXML();
159             rep.load( new URL( defaultRepository + "repository.xml") );
160         
161             /*
162              *  get the fetch target
163              */
164 
165             if( version == null)
166                 version = rep.getPackageDefaultVersion( packagename );
167 
168             System.out.println("Fetching " + packagename + " v" + version + " into file " + (jarname == null? "<default name>" : jarname ) );
169  
170             String fetchTarget = rep.getFetchTarget( packagename, version );
171 
172             if (fetchTarget == null)
173             {
174                 System.out.println("JJAR.fetch : target not found for " + packagename + " v" + version );
175                 return;
176             }
177 
178             /*
179              *  are there any dependencies for this fetch target?
180              */
181 
182             String deptarget = "";
183 
184             if (getdeps)
185             {
186                 List deplist = rep.getDependencyList( packagename, version );
187                 
188                 Iterator ii = deplist.iterator();
189                 
190                 while(ii.hasNext())
191                 {
192                     /*
193                      *  for now, use the fetchtarget names
194                      */
195                     
196                     String depnameuni = (String) ii.next();
197                     
198                     JJARPackage jjarp = new JJARPackage( depnameuni );
199                     
200                     String depname = jjarp.getName();
201                     String depver = jjarp.getVersionString();
202                     
203                     deptarget = rep.getFetchTarget( depname, depver );
204                     
205                     if( deptarget == null)
206                     {
207                         System.out.println("  Repository error : returned null for dependency " + depname + " v" + depver 
208                                            + " Skipping.");
209                         continue;
210                     }
211                     
212                     /*
213                      *  check to see if exists if verifyignore
214                      */
215 
216   
217                     if (verifyignore )
218                     {
219                         JJARPackage jpak = null;
220                         
221                         try
222                         {
223                             jpak = ClasspathUtil.getPackage( dir + "/" + deptarget );
224                         }
225                         catch(Exception e)
226                         {
227                             // ignore 
228                         }
229 
230                         if (jpak != null)
231                         {
232                             if( jpak.equals( depname, depver ))
233                             {
234                                 System.out.println(" Dependency '" + depname + "' exists.  Skipping.");
235                                 continue;
236                             }
237                         }
238                     }
239                      
240                     /*
241                      *  now get it
242                      */
243 
244                     URL url = new URL( defaultRepository + deptarget );
245                     URLConnection uconn  = (URLConnection) url.openConnection(); 
246                     
247                     System.out.println(" Fetching dependency : " + deptarget + " to " + dir + "/" + deptarget  );
248 
249                     Transport.fetchJar( uconn, dir + "/" + deptarget );                
250                 }
251             }
252 
253             /*
254              *  now the actual jar.  If we are told to ignore the deps, so be it
255              */
256 
257             if ( onlydeps )
258             {
259                 return;
260             }
261 
262             /*
263              *  if verifyignore then check the jar to see if it satisfies the request
264              */
265             
266             if (jarname == null)
267                 jarname = fetchTarget;
268 
269             if( verifyignore)
270             {
271                 try
272                 {
273                     JJARPackage packageinfo = ClasspathUtil.getPackage( dir + "/" + jarname );
274 
275                     if( packageinfo.equals( packagename, version ))
276                     {
277                         System.out.println("Target exists.  skipping fetch");
278                         return;
279                     }
280                 }
281                 catch(Exception e)
282                 {
283                     // ignore and continue
284                 }
285             }
286 
287             URL url = new URL( defaultRepository + fetchTarget );
288             URLConnection uconn  = (URLConnection) url.openConnection(); 
289 
290             String destjar = dir + "/" + jarname;
291 
292             System.out.println(" Fetching target : " + fetchTarget + " to " + destjar );
293 
294             Transport.fetchJar( uconn, destjar);
295         }
296         catch( Exception e )
297         {
298             System.out.println("JJAR.fetch : exception " + e );
299             e.printStackTrace();
300         } 
301      }
302 
303     public static void verify( String args[] )
304     {
305         header();
306 
307         /*
308          *  do we do it to classpath, or was a jar specified
309          */
310 
311         String flag = null;
312         String jarname = null;
313 
314         if (args.length > 1 )
315         {
316             flag = args[1];
317 
318             if (flag.equals("-j"))
319             {
320                 if (args.length >= 3)
321                 {
322                     jarname = args[2];
323     
324                     try 
325                     {
326                         JJARPackage jjarp = ClasspathUtil.getPackage( jarname );
327                         
328                         if (jjarp != null)
329                             System.out.println("    " + jjarp.getName() + " v" + jjarp.getVersionString() );
330                         else
331                             System.out.println("    " + jarname + "not a jjar compatable jar");
332                     }
333                     catch( Exception e )
334                     {
335                     }
336                 }
337             }
338             else
339             {
340                 /*
341                  * do the classpath
342                  */
343                 List jars = ClasspathUtil.getJarList( null );
344                 
345                 Iterator i = jars.iterator();
346                 
347                 while( i.hasNext() )
348                 {
349                     String jar =  (String) i.next();
350                     
351                     try 
352                     {
353                         JJARPackage jjarp = ClasspathUtil.getPackage( jar );
354                         
355                         if (jjarp != null)
356                             System.out.println("    " + jjarp.getName() + " v" + jjarp.getVersionString() );
357                         else
358                             System.out.println("    " + jar + "not a jjar compatable jar");
359                     }
360                     catch( Exception e )
361                     {
362                     }
363                 }
364             }
365         }
366         else
367         {
368             System.out.println(" usage : verify -c | -j jarname");
369         }
370         return;
371     }
372 
373     public static void list( String args[] ) 
374     {
375         header();
376 
377         try
378         {
379             URL url = new URL(defaultRepository + "repository.xml");
380             
381             Repository rep = new RepositoryXML();
382             rep.load(url);
383 
384             if (args.length >= 3 )
385             {
386                 String flag = args[1];
387 
388                 if (flag.equals("-p"))
389                 {
390                     String pkg = args[2];
391                 
392                     dumpInfo( rep, pkg );
393                 }
394             }
395             else
396             {
397                 System.out.println("Repository contains " + rep.getPackageCount() + " packages : " );
398 
399                 Iterator i = rep.getPackageListIter();
400            
401                 while( i.hasNext() )
402                 {
403                     String p = (String) i.next();
404                     dumpInfo( rep, p );
405                     System.out.println("");
406                 }
407             }
408         }
409         catch( Exception e )
410         {
411             System.out.println("JJAR.list : exception " + e );
412             e.printStackTrace();
413         } 
414     }
415 
416     private static void dumpInfo(Repository rep, String p )
417     {
418         System.out.println(" " + p );
419         System.out.println("    desc     : " + rep.getPackageDescription( p ) );
420         System.out.println("    default  : " + rep.getPackageDefaultVersion( p ));
421         System.out.println("    versions : ");
422         
423         List l = rep.getPackageVersionList( p );
424         
425         Iterator ii = l.iterator();
426         
427         while( ii.hasNext() )
428         {
429             String version = (String) ii.next() ;
430 
431             System.out.print(  "      " + version + " deps : "  );
432             
433             List depl = rep.getDependencyList( p, version );
434             
435             Iterator iii = depl.iterator();
436             
437             while( iii.hasNext() )
438             {
439                 System.out.print( iii.next() + ", " );
440             }   
441             
442             System.out.println("");
443         }
444              
445        System.out.println("--");
446       
447     }
448 
449     public static void mark( String args[] )
450     {
451         //   mark -j jarname -p package -v version
452 
453         String packagename = null;
454         String jarname = null;
455         String version = null;
456 
457         if ( args.length < 7 )
458         {
459             System.out.println("Usage : mark  -j jarname -p package -v version ");
460             return;
461         }
462 
463         for( int i = 1; i < args.length; i++)
464         {
465             String arg = args[i];
466 
467             if (arg.startsWith("-"))
468             {
469                 if (arg.equals("-j"))
470                 {
471                     jarname = args[i+1];
472                     i++;
473                 }
474                 else if (arg.equals("-p"))
475                 {
476                     packagename = args[i+1];
477                     i++;
478                 }
479                 else if (arg.equals("-v"))
480                 {
481                     version = args[i+1];
482                     i++;
483                 }
484                 
485             }
486         }
487 
488         if ( packagename == null || jarname == null || version == null)
489         {
490             System.out.println("Usage :  mark -j jarname -p package -v version ");
491             return;
492         }
493         
494         try
495         {
496             if (ClasspathUtil.markJar( jarname, packagename, version ))
497                 System.out.println("successful");
498 
499         }
500         catch( Exception e)
501         {
502             System.out.println("Exception e : " + e );
503             }
504         
505     }
506 
507     private static void header()
508     {
509         System.out.println(title);
510         System.out.println(" - using repository " + defaultRepository);
511        System.out.println("---------------------------------------------");
512         System.out.println("");
513     }
514 }