runtime/org.argeo.slc.rpmfactory/src/main/java/org/argeo/slc/rpmfactory/core/RpmIndexer.java

   1 package org.argeo.slc.rpmfactory.core;
   2
   3 import static org.freecompany.redline.header.Header.HeaderTag.HEADERIMMUTABLE;
   4 import static org.freecompany.redline.header.Signature.SignatureTag.SIGNATURES;
   5
   6 import java.io.InputStream;
   7 import java.nio.ByteBuffer;
   8 import java.nio.channels.Channels;
   9
  10 import javax.jcr.Node;
  11 import javax.jcr.Property;
  12
  13 import org.apache.commons.io.FilenameUtils;
  14 import org.argeo.slc.SlcException;
  15 import org.argeo.slc.jcr.SlcNames;
  16 import org.argeo.slc.jcr.SlcTypes;
  17 import org.argeo.slc.repo.NodeIndexer;
  18 import org.freecompany.redline.ChannelWrapper.Key;
  19 import org.freecompany.redline.ReadableChannelWrapper;
  20 import org.freecompany.redline.header.AbstractHeader;
  21 import org.freecompany.redline.header.Format;
  22 import org.freecompany.redline.header.Header;
  23
  24 /** Indexes an RPM file. */
  25 public class RpmIndexer implements NodeIndexer, SlcNames {
  26
  27         @Override
  28         public Boolean support(String path) {
  29                 return FilenameUtils.getExtension(path).equals("rpm");
  30         }
  31
  32         @Override
  33         public void index(Node node) {
  34                 try {
  35                         InputStream in = node.getNode(Node.JCR_CONTENT)
  36                                         .getProperty(Property.JCR_DATA).getBinary().getStream();
  37                         ReadableChannelWrapper channel = new ReadableChannelWrapper(
  38                                         Channels.newChannel(in));
  39                         Format format = readRpmInfo(channel);
  40
  41                         node.addMixin(SlcTypes.SLC_RPM);
  42                         node.setProperty(SLC_NAME, readTag(format, Header.HeaderTag.NAME));
  43                         String rpmVersion = readTag(format, Header.HeaderTag.VERSION);
  44                         String rpmRelease = readTag(format, Header.HeaderTag.RELEASE);
  45                         node.setProperty(SLC_RPM_VERSION, rpmVersion);
  46                         node.setProperty(SLC_RPM_RELEASE, rpmRelease);
  47                         node.setProperty(SLC_VERSION, rpmVersion + "-" + rpmRelease);
  48
  49                         String arch = readTag(format, Header.HeaderTag.ARCH);
  50                         if (arch != null)
  51                                 node.setProperty(SLC_RPM_ARCH, arch);
  52
  53                         String archiveSize = readTag(format, Header.HeaderTag.ARCHIVESIZE);
  54                         if (archiveSize != null)
  55                                 node.setProperty(SLC_RPM_ARCHIVE_SIZE,
  56                                                 Long.parseLong(archiveSize));
  57
  58                         node.getSession().save();
  59                 } catch (Exception e) {
  60                         throw new SlcException("Cannot index " + node, e);
  61                 }
  62
  63         }
  64
  65         @SuppressWarnings("unused")
  66         public Format readRpmInfo(ReadableChannelWrapper channel) throws Exception {
  67                 Format format = new Format();
  68
  69                 Key<Integer> lead = channel.start();
  70                 format.getLead().read(channel);
  71                 // System.out.println( "Lead ended at '" + in.finish( lead) + "'.");
  72
  73                 Key<Integer> signature = channel.start();
  74                 int count = format.getSignature().read(channel);
  75                 int expected = ByteBuffer
  76                                 .wrap((byte[]) format.getSignature().getEntry(SIGNATURES)
  77                                                 .getValues(), 8, 4).getInt()
  78                                 / -16;
  79                 // System.out.println( "Signature ended at '" + in.finish( signature) +
  80                 // "' and contained '" + count + "' headers (expected '" + expected +
  81                 // "').");
  82
  83                 Key<Integer> header = channel.start();
  84                 count = format.getHeader().read(channel);
  85                 expected = ByteBuffer.wrap(
  86                                 (byte[]) format.getHeader().getEntry(HEADERIMMUTABLE)
  87                                                 .getValues(), 8, 4).getInt()
  88                                 / -16;
  89                 // System.out.println( "Header ended at '" + in.finish( header) +
  90                 // " and contained '" + count + "' headers (expected '" + expected +
  91                 // "').");
  92
  93                 return format;
  94         }
  95
  96         private String readTag(Format format, Header.HeaderTag tag) {
  97                 AbstractHeader.Entry<?> entry = format.getHeader().getEntry(tag);
  98                 if (entry == null)
  99                         return null;
 100                 if (entry.getValues() == null)
 101                         return null;
 102                 Object[] values = (Object[]) entry.getValues();
 103                 return values[0].toString().trim();
 104         }
 105 }