ant-ivy-user mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From Kirby Files <kfi...@masergy.com>
Subject Re: Publishing 3rd party libraries to local repo
Date Mon, 05 Oct 2009 20:34:25 GMT
Troy Self wrote on 10/05/2009 08:04 AM:
> Is there a tried and true approach for quickly creating repository entries for
> 3rd party libraries? I have used the ivy:install command to copy items that are
> already in Ibiblio or ivyrep, but what is the approach when neither of those
> public repositories have the library you want, or they don't have the latest
> version?

The ivy:install task can copy a module from one repository to another 
(optionally creating the ivy.xml in the process). I use this both to 
copy modules from iBiblio (creating an ivy.xml from the POM), and to 
copy from a filesystem resolver, like our old "big-pile-of-jars-libdir" 
(ivy.xml created from the specified org, module, and rev).

Here's what I wrote in response to a previous poster with this question.

I use this script:

--------------------------------------
#!/bin/csh

if ($1 == "") then
     echo "Usage: installjar <org> <module> <revision> <path-to-file>"
else
     /usr/local/ant/bin/ant -Dorg="$1" -Dmodule="$2" -Drev="$3"
-Dinstall.path="$4" $5 $6 $7 $8 $9
endif
--------------------------------------

With the following build target:

--------------------------------------
<target name="installjar"
           depends="init-ivy"
           description="--> install jar to masrep">
<ivy:install settingsRef="masergy.settings" organisation="${org}"
module="${module}" revision="${rev}" type="jar"
from="${localjar.resolver}" to="${to.resolver}" />
</target>
--------------------------------------

Where my build.properties defines these variables:

localjar.resolver=localjars
to.resolver=masrep_sftp

And my ivysettings.xml includes:
<resolvers>
<filesystem name="localjars">
<artifact pattern="${install.path}/[artifact]-[revision].[ext]" />
<artifact pattern="${install.path}/[artifact].[ext]" />
</filesystem>
</resolvers>

This script allows me to specify a jar on the local filesystem by its
name and the directory in which it resides (install.path), add the
org, and rev metadata, and publish it to one of my resolvers (I use
SFTP with a keyfile to push files up to our webserver; you may use a
filesystem resolver or webdav as a destination). This works well
enough as long as your jars are named like this: module-x.y.z.jar

I also have a bigger hack of a perl script which attempts to read a
directory of jars and guess the org, module, and rev (validating against 
maven2), or prompt the user when it's unclear. See below.

---
Kirby Files
Software Architect
Masergy Communications
kfiles@masergy.com


------------------------ >8 CUT HERE 8< ----------------------
#!/usr/bin/perl
# parse_jars.pl
# Looks for jars in the incoming directory, attemps to parse the
# needed ivy info from the filename, and if successful, publishes
# the jar to the Masergy ivrep repository.

# If using linux with package mgmt, dependencies are:
# perl-libwww-perl
# perl-XML-Xpath
# perl-Archive-Zip
use LWP::UserAgent;
use XML::XPath;
use XML::XPath::XMLParser;
use Archive::Zip;
use strict qw(vars);

use vars qw($indir $ant $rep $pre $post);

$indir = "lib";
$ant = "/usr/local/ant/bin/ant";
$rep = "newjars";
$pre="<ivy:install settingsRef=\"masergy.settings\" organisation=\"";
$post=" from=\"\${from.resolver}\" to=\"\${to.resolver}\" />";

open (DIR, "ls -1 $indir|") || die "could not open $indir\n";
while (<DIR>) {
   my ($org, $module, $jar, $ver);
   next unless /jar/;
   chomp;
   my $file = $indir . "/" . $_;
   $org=$_;
   $module=$_;
   $jar=$_;
   $ver=$_;
   $module=~s/^(.*)\.jar/$1/;
   $module=~s/([^.]*)-\d.*/$1/;
   $ver=~s/^[^.]*-([\d.]+.*)\.jar/$1/;
   $ver="unknown" unless $ver =~ /\d/;
   ## Figure out the org
   ## Ask the user, if there's ambiguity
   $org = &maven_search_org( $module );
   if (-1 == $org) {
     $org = &guess_org($module);
     print "Org guessed from module name:\n  $org\n";
     $org = &classes_org($file);
     print "Org guessed from jar package naming:\n  $org\n"
       unless (-1 == $org);
     do {
       $org = &get_user_org();
     } while ($org =~ /^$/);
   }
   if ($ver eq "unknown" || ($module !~ /^\w+$/) || $org !~ /\w+/) {
     print "Skipping jar $jar:\n";
     print "  $org / $module / $ver\n";
     next;
   } else {
&publish_jar($jar, $org, $module, $ver);
   }
   #&write_ivy_conf($jar, $org, $module, $ver);
}

## Use ivy::install to publish the jar via sftp to ivyrep
sub publish_jar
{
   my ($jar, $org, $module, $ver) = @_;
   print "Uploading $org / $module / $jar ... ";
   my $resp = `$ant -Dorg=$org -Dmodule=$module -Drev=$ver 
-Dinstall.path=./$indir 2>&1`;
   if ($resp =~ /failed/i) {
     print STDERR "Error uploading $jar:\n", $resp;
     print "\n";
   } else {
     print "Done.\n";
   }
}

## Find a directory in the jar to propose as the org
## searches for any dirs with two path elements
sub classes_org
{
   my ($file) = @_;
   my $somezip = Archive::Zip->new();
   unless ( $somezip->read( $file ) == AZ_OK ) {
        die "Error reading jarfile $file";
   }
   my @members = $somezip->members();
   my @dirnames = ();
   foreach (@members) {
     if ($_->isDirectory()) {
       my $fname = $_->fileName();
       if ($fname =~ /^\w+\/\w+\/$/) {
         $fname =~ s/^(\w+)\/(\w+)\/$/$1.$2/;
         return $fname;
       }
     }
   }
   return -1;
}

## Ask the user for the best org name
sub get_user_org
{
   print "Enter preferred org:> ";
   my $line = <STDIN>;
   chomp($line);
   return $line;
}

## Make a guess about the org name from the module name
sub guess_org
{
   my ($module) = @_;
   my $org = $module;
     $org=~s/spring.*/springframework/;
     $org=~s/hiber.*/hibernate/;
     $org=~s/standard.*/taglibs/;
     $org=~s/jstl.*/taglibs/;
     $org=~s/persistence.*/sun/;
     $org=~s/jta.*/sun/;
     $org=~s/servlet-api.*/tomcat/;
     $org=~s/ojdbc.*/oracle/;
     $org=~s/cglib.*/cglib/;
     $org=~s/javassist.*/jboss/;
     $org=~s/([^.]*)-\d.*jar/$1/;
     $org=~s/(.*)\.jar/$1/;
   return $org;
}

## Search the maven repo for a module matching this jar
## If found, return the module's organization
## if none, or more than one, are found, ask the user
sub maven_search_org
{
   my ($module) = @_;

   my $ua = LWP::UserAgent->new;
   $ua->agent('Maven Repo Search');

   my $service= 
'http://maven.ozacc.com/search?format=xml&type=jar&keyword=';
   my $url=URI->new($service . $module);
   my $req=HTTP::Request->new;
   $req->method('GET');
   $req->uri($url);
   my $resp = $ua->request($req)->content;

   my $org = &parse_resp( $module, $resp );
   return $org;
}

## Parse the XML response from the Maven search service
sub parse_resp
{
   my ($module, $data) = @_;

   my $xp = XML::XPath->new(xml => $data);

   my $nodeset = $xp->find('//groupId'); # find all paragraphs

   # Get rid of duplicates
   my %uniq=();
   foreach my $node ($nodeset->get_nodelist) {
      $uniq{ $xp->getNodeText( $node ) } = 1;
   }
   my @keys = (sort keys %uniq);

   if ($#keys == 0) {
     return ($keys[0]);
   } elsif ($#keys == -1) {
     print "Found no module matching $module in Maven repo\n";
     return -1;
   } else {
     print "Found multiple possible orgs for $module in Maven repo:\n";
     foreach (@keys) {
       print "  $_\n";
     }
     return -1;
   }
}

## (obsolete) Write ant task and ivy.xml conf lines to create repo
sub write_ivy_conf
{
   my ($jar, $org, $module, $ver) = @_;
   my $line = $pre . $org . "\" module=\"" . $module . "\" revision=\"" 
. $ver . "\"". $post . "\n";
   system("mkdir -p $rep/$org/$module/jars");
   link "$indir/$jar", "$rep/$org/$module/jars/$jar";
   print $line;
   print "<dependency org=\"" . $org . "\" name=\"" . $module . "\" 
rev=\"" . $ver . "\"/>\n";
}



Mime
  • Unnamed multipart/alternative (inline, None, 0 bytes)
View raw message