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

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