CompressorUtilities.java

  1. /*
  2.  * GovWay - A customizable API Gateway 
  3.  * https://govway.org
  4.  * 
  5.  * Copyright (c) 2005-2025 Link.it srl (https://link.it). 
  6.  * 
  7.  * This program is free software: you can redistribute it and/or modify
  8.  * it under the terms of the GNU General Public License version 3, as published by
  9.  * the Free Software Foundation.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18.  *
  19.  */

  21. package org.openspcoop2.utils.io;

  23. import java.io.ByteArrayInputStream;
  24. import java.io.ByteArrayOutputStream;
  25. import java.io.File;
  26. import java.io.InputStream;
  27. import java.io.OutputStream;
  28. import java.util.ArrayList;
  29. import java.util.List;
  30. import java.util.zip.DeflaterOutputStream;
  31. import java.util.zip.GZIPInputStream;
  32. import java.util.zip.GZIPOutputStream;
  33. import java.util.zip.InflaterInputStream;
  34. import java.util.zip.ZipEntry;
  35. import java.util.zip.ZipFile;
  36. import java.util.zip.ZipOutputStream;

  38. import org.apache.commons.compress.archivers.ArchiveEntry;
  39. import org.apache.commons.compress.archivers.ArchiveInputStream;
  40. import org.apache.commons.compress.archivers.tar.TarArchiveEntry;
  41. import org.apache.commons.compress.archivers.tar.TarArchiveInputStream;
  42. import org.apache.commons.compress.archivers.tar.TarArchiveOutputStream;
  43. import org.apache.commons.compress.archivers.zip.ZipArchiveEntry;
  44. import org.apache.commons.compress.archivers.zip.ZipArchiveInputStream;
  45. import org.apache.commons.compress.archivers.zip.ZipArchiveOutputStream;
  46. import org.apache.commons.compress.compressors.CompressorInputStream;
  47. import org.apache.commons.compress.compressors.gzip.GzipCompressorInputStream;
  48. import org.apache.commons.compress.compressors.gzip.GzipCompressorOutputStream;
  49. import org.openspcoop2.utils.UtilsException;
  50. import org.openspcoop2.utils.resources.FileSystemUtilities;

  52. /**
  53.  * CompressorUtilities
  54.  *
  55.  *
  56.  * @author Poli Andrea (apoli@link.it)
  57.  * @author $Author$
  58.  * @version $Rev$, $Date$
  59.  */
  60. public class CompressorUtilities {

  62.     public static void main(String [] args) throws Exception{
  63.         
  64.         testCompressor(null);
  65.         testArchive(null);
  66.         
  67.     }
  68.     
  69.     private static void print(String msg) {
  70.         System.out.println(msg);
  71.     }
  72.     
  73.     private static final String COMPRESSO_DIMENSIONE = "Compresso, dimensione: ";
  74.     private static final String COMPRESSO_IN_STRING = "Compresso, in stringa: ";
  75.     private static final String DECOMPRESSO_IN_STRING = "De-Compresso, in stringa: ";
  76.     private static final String INFORMAZIONE_DECOMPRESSA_DIFFERENTE = "Informazione decompressa non uguale al sorgente";
  77.     private static final String INFORMAZIONE_DECOMPRESSA_DIFFERENTE_SIZE = "Informazione decompressa non uguale al sorgente (size)";
  78.     private static final String INFORMAZIONE_DECOMPRESSA_DIFFERENTE_ENTRY_1 = "Informazione decompressa non uguale al sorgente (entry1 name:";
  79.     private static final String INFORMAZIONE_DECOMPRESSA_DIFFERENTE_ENTRY_2 = "Informazione decompressa non uguale al sorgente (entry2 name:";
  80.     private static final String INFORMAZIONE_DECOMPRESSA_DIFFERENTE_ENTRY_1_DIFFERENTE = "Informazione decompressa non uguale al sorgente (entry1 contenuto differente)";
  81.     private static final String INFORMAZIONE_DECOMPRESSA_UGUALE = "De-Compresso: test di comparazione completati con successo";
  82.     private static final String DECOMPRESSO = "De-Compresso: ";
  83.     private static final String ATTESO = " atteso:";
  84.     
  85.     public static void testCompressor(CompressorType tipo) throws UtilsException{
  86.         
  87.         String test = "<prova xmlns=\"www.test.it\">PROVA</prova>";
  88.         byte[]testB = test.getBytes();
  89.         
  90.         if(tipo==null || CompressorType.DEFLATER.equals(tipo)) {
  91.             print("\n\n=== DEFLATER ===");
  92.             byte [] compress = compress(testB, CompressorType.DEFLATER);
  93.             print(COMPRESSO_DIMENSIONE+compress.length);
  94.             print(COMPRESSO_IN_STRING+new String(compress));
  95.             String decompresso = new String(decompress(compress, CompressorType.DEFLATER));
  96.             print(DECOMPRESSO_IN_STRING+decompresso);
  97.             if(!decompresso.equals(test)) {
  98.                 throw new UtilsException(INFORMAZIONE_DECOMPRESSA_DIFFERENTE);
  99.             }
  100.         }
  101.         
  102.         if(tipo==null || CompressorType.GZIP.equals(tipo)) {
  103.             print("\n\n=== GZIP ===");
  104.             byte [] compress = compress(testB, CompressorType.GZIP);
  105.             print(COMPRESSO_DIMENSIONE+compress.length);
  106.             print(COMPRESSO_IN_STRING+new String(compress));
  107.             String decompresso = new String(decompress(compress, CompressorType.GZIP));
  108.             print(DECOMPRESSO_IN_STRING+decompresso);
  109.             if(!decompresso.equals(test)) {
  110.                 throw new UtilsException(INFORMAZIONE_DECOMPRESSA_DIFFERENTE);
  111.             }
  112.         }
  113.             
  114.         if(tipo==null || CompressorType.ZIP.equals(tipo)) {
  115.             print("\n\n=== ZIP ===");
  116.             byte [] compress = compress(testB, CompressorType.ZIP);
  117.             print(COMPRESSO_DIMENSIONE+compress.length);
  118.             print(COMPRESSO_IN_STRING+new String(compress));
  119.             String decompresso = new String(decompress(compress, CompressorType.ZIP));
  120.             print(DECOMPRESSO_IN_STRING+decompresso);
  121.             if(!decompresso.equals(test)) {
  122.                 throw new UtilsException(INFORMAZIONE_DECOMPRESSA_DIFFERENTE);
  123.             }
  124.         }
  125.         
  126.     }
  127.     
  128.     public static void testArchive(ArchiveType tipo) throws Exception{
  129.         
  130.         String entryName = "entry1";
  131.         String test = "<prova xmlns=\"www.test.it\">PROVA</prova>";
  132.         byte[]testB = test.getBytes();
  133.         
  134.         String entryName2 = "dir/subdir/entry2";
  135.         String test2 = "<prova xmlns=\"www.test.it\">PROVA2</prova>";
  136.         byte[]test2B = test2.getBytes();
  137.         
  138.         List<Entry> entries = new ArrayList<>();
  139.         entries.add(new Entry(entryName,testB));
  140.         entries.add(new Entry(entryName2,test2B));
  141.         
  142.         if(tipo==null || ArchiveType.ZIP.equals(tipo)) {
  143.             print("\n\n=== ZIP ===");
  144.             byte [] compress = archive(entries, ArchiveType.ZIP);
  145.             print(COMPRESSO_DIMENSIONE+compress.length);
  146.             List<Entry> entriesRead = read(compress, ArchiveType.ZIP);
  147.             print(DECOMPRESSO+entriesRead.size());
  148.             if(entriesRead.size()!=2) {
  149.                 throw new UtilsException(INFORMAZIONE_DECOMPRESSA_DIFFERENTE_SIZE);
  150.             }
  151.             Entry entryRead1 = entriesRead.get(0);
  152.             Entry entryRead2 = entriesRead.get(1);
  153.             if(!entryName.equals(entryRead1.getName())) {
  154.                 throw new UtilsException(INFORMAZIONE_DECOMPRESSA_DIFFERENTE_ENTRY_1+entryRead1.getName()+ATTESO+entryName+")");
  155.             }
  156.             if(!entryName2.equals(entryRead2.getName())) {
  157.                 throw new UtilsException(INFORMAZIONE_DECOMPRESSA_DIFFERENTE_ENTRY_2+entryRead2.getName()+ATTESO+entryName2+")");
  158.             }
  159.             if(!test.equals(new String(entryRead1.getContent()))) {
  160.                 throw new UtilsException(INFORMAZIONE_DECOMPRESSA_DIFFERENTE_ENTRY_1_DIFFERENTE);
  161.             }
  162.             if(!test2.equals(new String(entryRead2.getContent()))) {
  163.                 throw new UtilsException(INFORMAZIONE_DECOMPRESSA_DIFFERENTE_ENTRY_1_DIFFERENTE);
  164.             }
  165.             print(INFORMAZIONE_DECOMPRESSA_UGUALE);
  166.         }
  167.         
  168.         if(tipo==null || ArchiveType.TAR.equals(tipo)) {
  169.             print("\n\n=== TAR ===");
  170.             byte [] compress = archive(entries, ArchiveType.TAR);
  171.             print(COMPRESSO_DIMENSIONE+compress.length);
  172.             List<Entry> entriesRead = read(compress, ArchiveType.TAR);
  173.             print(DECOMPRESSO+entriesRead.size());
  174.             if(entriesRead.size()!=2) {
  175.                 throw new UtilsException(INFORMAZIONE_DECOMPRESSA_DIFFERENTE_SIZE);
  176.             }
  177.             Entry entryRead1 = entriesRead.get(0);
  178.             Entry entryRead2 = entriesRead.get(1);
  179.             if(!entryName.equals(entryRead1.getName())) {
  180.                 throw new UtilsException(INFORMAZIONE_DECOMPRESSA_DIFFERENTE_ENTRY_1+entryRead1.getName()+ATTESO+entryName+")");
  181.             }
  182.             if(!entryName2.equals(entryRead2.getName())) {
  183.                 throw new UtilsException(INFORMAZIONE_DECOMPRESSA_DIFFERENTE_ENTRY_2+entryRead2.getName()+ATTESO+entryName2+")");
  184.             }
  185.             if(!test.equals(new String(entryRead1.getContent()))) {
  186.                 throw new UtilsException(INFORMAZIONE_DECOMPRESSA_DIFFERENTE_ENTRY_1_DIFFERENTE);
  187.             }
  188.             if(!test2.equals(new String(entryRead2.getContent()))) {
  189.                 throw new UtilsException(INFORMAZIONE_DECOMPRESSA_DIFFERENTE_ENTRY_1_DIFFERENTE);
  190.             }
  191.             print(INFORMAZIONE_DECOMPRESSA_UGUALE);
  192.         }
  193.         
  194.         if(tipo==null || ArchiveType.TGZ.equals(tipo)) {
  195.             print("\n\n=== TGZ ===");
  196.             byte [] compress = archive(entries, ArchiveType.TGZ);
  197.             print(COMPRESSO_DIMENSIONE+compress.length);
  198.             List<Entry> entriesRead = read(compress, ArchiveType.TGZ);
  199.             print(DECOMPRESSO+entriesRead.size());
  200.             if(entriesRead.size()!=2) {
  201.                 throw new UtilsException(INFORMAZIONE_DECOMPRESSA_DIFFERENTE_SIZE);
  202.             }
  203.             Entry entryRead1 = entriesRead.get(0);
  204.             Entry entryRead2 = entriesRead.get(1);
  205.             if(!entryName.equals(entryRead1.getName())) {
  206.                 throw new UtilsException(INFORMAZIONE_DECOMPRESSA_DIFFERENTE_ENTRY_1+entryRead1.getName()+ATTESO+entryName+")");
  207.             }
  208.             if(!entryName2.equals(entryRead2.getName())) {
  209.                 throw new UtilsException(INFORMAZIONE_DECOMPRESSA_DIFFERENTE_ENTRY_2+entryRead2.getName()+ATTESO+entryName2+")");
  210.             }
  211.             if(!test.equals(new String(entryRead1.getContent()))) {
  212.                 throw new UtilsException(INFORMAZIONE_DECOMPRESSA_DIFFERENTE_ENTRY_1_DIFFERENTE);
  213.             }
  214.             if(!test2.equals(new String(entryRead2.getContent()))) {
  215.                 throw new UtilsException(INFORMAZIONE_DECOMPRESSA_DIFFERENTE_ENTRY_1_DIFFERENTE);
  216.             }
  217.             print(INFORMAZIONE_DECOMPRESSA_UGUALE);
  218.         }

  220.         
  221.     }
  222.     
  223.     public static byte[] compress(byte[] content, CompressorType type) throws UtilsException {
  224.         ByteArrayOutputStream baos = new ByteArrayOutputStream();
  225.         try {
  226.             OutputStream out = null;
  227.             switch (type) {
  228.             case DEFLATER:
  229.                 out = new DeflaterOutputStream(baos);
  230.                 out.write(content);
  231.                 break;
  232.             case GZIP:
  233.                 out = new GZIPOutputStream(baos);
  234.                 out.write(content);
  235.                 break;
  236.             case ZIP:
  237.                 out = new ZipOutputStream(baos);
  238.                 ((ZipOutputStream)out).putNextEntry(new ZipEntry("dat"));
  239.                 out.write(content);
  240.                 ((ZipOutputStream)out).closeEntry();
  241.                 break;
  242.             }
  243.             if(out==null) {
  244.                 throw new UtilsException("OutputStream undefined");
  245.             }
  246.             out.flush();
  247.             out.close();
  248.             baos.flush();
  249.             baos.close();
  250.             return baos.toByteArray();
  251.         } catch (Exception e) {
  252.             throw new UtilsException(e.getMessage(),e);
  253.         }
  254.     }
  255.     
  256.     public static byte[] archive(List<Entry> entries, ArchiveType type) throws UtilsException{
  257.         try {
  258.             ByteArrayOutputStream bout = new ByteArrayOutputStream();
  259.             
  260.             org.apache.commons.compress.archivers.ArchiveOutputStream<?>  out = null;
  261.             org.apache.commons.compress.compressors.CompressorOutputStream compressorOut = null;
  262.             switch (type) {
  263.             case TAR:
  264.                 out = new TarArchiveOutputStream(bout);
  265.                 break;
  266.             case TGZ:
  267.                 compressorOut = new GzipCompressorOutputStream(bout);
  268.                 out = new TarArchiveOutputStream(compressorOut);
  269.                 break;
  270.             case ZIP:
  271.                 out = new ZipArchiveOutputStream(bout);
  272.                 break;
  273.             }
  274.             if(out==null) {
  275.                 throw new UtilsException("OutputStream undefined");
  276.             }
  277.             for (Entry entry : entries) {
  278.                 String name = entry.getName();
  279.                 ArchiveEntry archiveEntry = null;
  280.                 switch (type) {
  281.                 case TAR:
  282.                 case TGZ:
  283.                     archiveEntry = new TarArchiveEntry(name);
  284.                     ((TarArchiveEntry)archiveEntry).setSize(entry.getContent().length); 
  285.                     break;
  286.                 case ZIP:
  287.                     archiveEntry = new ZipArchiveEntry(name);
  288.                     break;
  289.                 }
  290.                 switch (type) {
  291.                 case TAR:
  292.                 case TGZ:
  293.                     ((TarArchiveOutputStream)out).putArchiveEntry((TarArchiveEntry) archiveEntry);
  294.                     break;
  295.                 case ZIP:
  296.                     ((ZipArchiveOutputStream)out).putArchiveEntry((ZipArchiveEntry)archiveEntry);
  297.                     break;
  298.                 }
  299.                 out.write(entry.getContent());
  300.                 out.closeArchiveEntry();
  301.             }
  302.             out.flush();
  303.             out.close();
  304.             if(compressorOut!=null) {
  305.                 compressorOut.flush();
  306.                 compressorOut.close();
  307.             }
  308.             bout.flush();
  309.             bout.close();
  310.             return bout.toByteArray();
  311.         }catch(Exception e){
  312.             throw new UtilsException("Errore durante la scrittura '"+type+"': "+e.getMessage(),e);
  313.         }
  314.     }

  316.     public static byte [] decompress(byte[] bytes, CompressorType type) throws UtilsException {
  317.         InputStream in = null;
  318.         ByteArrayInputStream bin = null;
  319.         ByteArrayOutputStream baos = new ByteArrayOutputStream();
  320.         try {
  321.             bin = new ByteArrayInputStream(bytes);
  322.             byte[] buffer = new byte[8192];
  323.             int len;
  324.             switch (type) {
  325.             case DEFLATER:
  326.                 in = new InflaterInputStream(bin);
  327.                 while((len = in.read(buffer))>0)
  328.                     baos.write(buffer, 0, len);
  329.                 break;
  330.             case GZIP:
  331.                 in = new GZIPInputStream(bin);
  332.                 while((len = in.read(buffer))>0)
  333.                     baos.write(buffer, 0, len);
  334.                 break;
  335.             case ZIP:
  336.                 File f = FileSystemUtilities.createTempFile("unzip", "zip");
  337.                 ZipFile zf = null;
  338.                 try{
  339.                     FileSystemUtilities.writeFile(f, bytes);
  340.                     zf = new ZipFile(f);
  341.                     ZipEntry ze = zf.entries().nextElement();
  342.                     in = zf.getInputStream(ze);
  343.                     while((len = in.read(buffer))>0)
  344.                         baos.write(buffer, 0, len);
  345.                 }finally{
  346.                     try{
  347.                         if(f!=null) {
  348.                             java.nio.file.Files.delete(f.toPath());
  349.                         }
  350.                     }catch(Exception eClose){
  351.                         // ignore
  352.                     }
  353.                     try{
  354.                         if(zf!=null){
  355.                             zf.close();
  356.                         }
  357.                     }catch(Exception eClose){
  358.                         // close
  359.                     }
  360.                 }
  361.                 break;
  362.             }
  363.             baos.flush();
  364.             baos.close();
  365.             return baos.toByteArray();
  366.         }  catch (Exception e) {
  367.             throw new UtilsException(e.getMessage(),e);
  368.         }
  369.     }
  370.     
  371.     public static List<Entry> read(byte[] archiveContent, ArchiveType type) throws UtilsException{
  372.         try {
  373.             List<Entry> list = new ArrayList<>();
  374.             
  375.             ByteArrayInputStream bin = new ByteArrayInputStream(archiveContent);
  376.             ArchiveInputStream<?> in = null;
  377.             CompressorInputStream compressorIn = null;
  378.             switch (type) {
  379.             case TAR:
  380.                 in = new TarArchiveInputStream(bin);
  381.                 break;
  382.             case TGZ:
  383.                 compressorIn = new GzipCompressorInputStream(bin);
  384.                 in = new TarArchiveInputStream(compressorIn);
  385.                 break;
  386.             case ZIP:
  387.                 in = new ZipArchiveInputStream(bin);
  388.                 break;
  389.             }
  390.             if(in==null) {
  391.                 throw new UtilsException("InputStream undefined");
  392.             }
  393.             ArchiveEntry entry;
  394.             while ((entry = in.getNextEntry()) != null) {
  395.                 String name = entry.getName();
  396.                 /**print(name);*/
  397.                 
  398.                 if(name!=null && !( name.endsWith("/") || name.endsWith("\\") ) ){
  399.                     Entry zentry = new Entry();
  400.                     zentry.setName(name);
  401.                     
  402.                     ByteArrayOutputStream bout = new ByteArrayOutputStream();
  403.                     byte [] contents = new byte[4096];
  404.                     int direct;
  405.                     while ((direct = in.read(contents, 0, contents.length)) >= 0) {
  406.                         /**print("Read " + direct + "bytes content.");*/
  407.                         bout.write(contents, 0, direct);
  408.                     }
  409.                     bout.flush();
  410.                     bout.close();
  411.                     
  412.                     zentry.setContent(bout.toByteArray());
  413.                     list.add(zentry);
  414.                 }
  415.                 
  416.                /** in.closeEntry(); */
  417.             }
  418.             if(compressorIn!=null) {
  419.                 compressorIn.close();
  420.             }
  421.             in.close();
  422.             bin.close();

  424.             return list;
  425.             
  426.         }catch(Exception e){
  427.             throw new UtilsException("Errore durante la lettura '"+type+"': "+e.getMessage(),e);
  428.         }
  429.     }
  430. }

Created with JaCoCo 0.8.8.202204050719