PipedUnblockedStream.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.  */
  20. package org.openspcoop2.utils.io.notifier.unblocked;

  22. import java.io.ByteArrayOutputStream;
  23. import java.io.IOException;
  24. import java.util.concurrent.CompletableFuture;
  25. import java.util.concurrent.TimeUnit;

  27. import org.openspcoop2.utils.SemaphoreLock;
  28. import org.openspcoop2.utils.Utilities;
  29. import org.slf4j.Logger;

  31. /**
  32.  * PipedUnblockedStream
  33.  *
  34.  * @author Poli Andrea (apoli@link.it)
  35.  * @author $Author$
  36.  * @version $Rev$, $Date$
  37.  */
  38. public class PipedUnblockedStream extends IPipedUnblockedStream {

  40.     protected Logger log = null;
  41.     private long sizeBuffer;
  42.     private int timeoutMs;
  43.     
  44.     @Override
  45.     public void init(Logger log, long sizeBuffer, int timeoutMs, String source) {
  46.         this.log = log;
  47.         // In memoria esistono 2 buffer, 
  48.         // - [bytesReceived] uno che contiene i bytes gia' consolidati pronti a essere consumati
  49.         // - [bout] buffer utilizzato per scrivere i dati
  50.         // Quindi puo' succedere che entrambi i buffer siano "pieni". La dimensione massima richiesta in memoria viene quindi divisa per 2.
  51.         // NOTA: La dimensione di ogni buffer potra' essere this.sizeBuffer + eventualmente ;a dimensione del byte[] fornita con l'ultima write che ha superato il controllo di waitSpaceAvailable 
  52.         if(sizeBuffer<=0) {
  53.             sizeBuffer = Utilities.DIMENSIONE_BUFFER;
  54.         }
  55.         this.sizeBuffer = sizeBuffer / 2; 
  56.         this.timeoutMs = timeoutMs;
  57.         this.source = source;
  58.     }
  59.     @Override
  60.     public void setTimeout(int timeoutMs) {
  61.         this.timeoutMs = timeoutMs;
  62.     }
  63.     
  64.     //private final Integer semaphore = 1;
  65.     private final org.openspcoop2.utils.Semaphore lockPIPE = new org.openspcoop2.utils.Semaphore("PipedUnblockedStream");
  66.     private ByteArrayOutputStream bout = new ByteArrayOutputStream();
  67.     private byte [] bytesReceived = null;
  68.     private int indexNextByteReceivedForRead = -1;
  69.     
  70.     private boolean stop = false;

  72.     private boolean useThreadSleep = false;
  73.     private static final int ITERAZIONI_WAIT = 128;
  74.     private CompletableFuture<Boolean> asyncReadTask = null;
  75.     private CompletableFuture<Boolean> asyncWriteTask = null;
  76.     
  77.     private String source = null;
  78.     public String getPrefixSource() {
  79.         return this.source!=null ? "["+this.source+"] " : "";
  80.     }
  81.     
  82.     // INPUT STREAM
  83.     

  85.     private void readWaitBytes() throws IOException{
  86.         try {
  87.             if(this.useThreadSleep) {
  88.                 int i = 0;
  89.                 while(this.stop==false && this.bout!=null && this.bout.size()==0 && i<ITERAZIONI_WAIT){
  90.                     Utilities.sleep((i+1));
  91.                     i = i + i;
  92.                 }
  93.                 if(i>=ITERAZIONI_WAIT){
  94.                     throw new IOException(getPrefixSource()+"Timeout, no bytes available for read");
  95.                 }
  96.             }
  97.             else {
  98.                 boolean wait = false;
  99.                 SemaphoreLock lock = this.lockPIPE.acquireThrowRuntime("readWaitBytes");
  100.                 try {
  101.                     if(this.stop==false && this.bout!=null && this.bout.size()==0) {
  102.                         this.asyncReadTask = new CompletableFuture<Boolean>();
  103.                         wait = true;
  104.                     }
  105.                 }finally {
  106.                     this.lockPIPE.release(lock, "readWaitBytes");
  107.                 }
  108.                 
  109.                 if(wait) {
  110.                     try {
  111.                         //System.out.println("["+this.source+"] ASPETTO READ...");
  112.                         if(this.timeoutMs>0) {
  113.                             this.asyncReadTask.get(this.timeoutMs,TimeUnit.MILLISECONDS );
  114.                         }
  115.                         else {
  116.                             this.asyncReadTask.get();
  117.                         }
  118.                         //System.out.println("["+this.source+"] READ OK");
  119.                     }catch(InterruptedException timeout) {
  120.                         Thread.currentThread().interrupt();
  121.                         throw new IOException(getPrefixSource()+"Timeout, no bytes available for read: "+timeout.getMessage(),timeout);
  122.                     }
  123.                     catch(Exception timeout) {
  124.                         throw new IOException(getPrefixSource()+"Timeout, no bytes available for read: "+timeout.getMessage(),timeout);
  125.                     }
  126.                 }
  127.             }
  128.         }
  129.         catch(IOException io) {
  130.             throw io;
  131.         }
  132.         catch(Throwable t) {
  133.             if(t !=null && t instanceof InterruptedException) {
  134.                 Thread.currentThread().interrupt();
  135.             }
  136.             throw new IOException(t.getMessage(),t);
  137.         }
  138.     }
  139.     
  140.     @Override
  141.     public int read(byte[] b) throws IOException {
  142.         
  143.         return this.read(b, 0, b.length);
  144.         
  145.     }

  147.     @Override
  148.     public int read(byte[] b, int off, int len) throws IOException {
  149.         
  150.         try {
  151.         
  152.             //System.out.println("########### READ b["+b.length+"] off["+off+"] len["+len+"] .....");
  153.             //this.log.debug("########### READ b["+b.length+"] off["+off+"] len["+len+"] .....");
  154.             
  155.             if(this.bytesReceived==null){
  156.                 if(this.stop){      
  157.                     if(this.bout==null){
  158.                         //this.log.debug("########### READ b["+b.length+"] off["+off+"] len["+len+"] STOP BOUT NULL return -1");
  159.                         if(this.asyncWriteTask!=null) {
  160.                             //System.out.println("["+this.source+"] READ for WRITE COMPLETE 1");
  161.                             this.asyncWriteTask.complete(true);
  162.                         }
  163.                         return -1;
  164.                     }
  165.                     if(this.bout.size()<=0){
  166.                         this.bout.close();
  167.                         this.bout = null;
  168.                         //this.log.debug("########### READ b["+b.length+"] off["+off+"] len["+len+"] STOP BOUT SIZE<0 return -1");
  169.                         if(this.asyncWriteTask!=null) {
  170.                             //System.out.println("["+this.source+"] READ for WRITE COMPLETE 2");
  171.                             this.asyncWriteTask.complete(true);
  172.                         }
  173.                         return -1;
  174.                     }
  175.                 }
  176.                 else{
  177.                     if(this.bout.size()==0){
  178.                         //this.log.debug("########### READ b["+b.length+"] off["+off+"] len["+len+"] WAIT BYTES ...");
  179.                         readWaitBytes();
  180.                         if(this.bout==null) {
  181.                             // Viene reso null dal metodo close() che puo' essere chiamato mentre la read e' in corso
  182.                             //this.log.debug("########### READ b["+b.length+"] off["+off+"] len["+len+"] WAIT BYTES FOUND BOUT NULL ON EXIT");
  183.                             if(this.asyncWriteTask!=null) {
  184.                                 //System.out.println("["+this.source+"] READ for WRITE COMPLETE 3");
  185.                                 this.asyncWriteTask.complete(true);
  186.                             }
  187.                             return -1;
  188.                         }
  189.                     }
  190.                 }
  191.             }
  192.             
  193.             //this.log.debug("########### READ b["+b.length+"] off["+off+"] len["+len+"] BYTES AVAILABLE ...");
  194.             
  195.             if(this.bytesReceived==null){
  196.                 if(this.stop){
  197.                     // garantita dal codice sopra essere not null quando si entra nell'if this.bytesReceived==null && this.stop
  198.                     /*if(this.bout==null){
  199.                         //this.log.debug("########### READ b["+b.length+"] off["+off+"] len["+len+"] BYTES AVAILABLE RETURN -1");
  200.                         if(this.asyncWriteTask!=null) {
  201.                             //System.out.println("["+this.source+"] READ for WRITE COMPLETE 4");
  202.                             this.asyncWriteTask.complete(true);
  203.                         }
  204.                         return -1;
  205.                     }*/
  206.                     if(this.bout.size()<=0){
  207.                         this.bout.close();
  208.                         this.bout = null;
  209.                         //this.log.debug("########### READ b["+b.length+"] off["+off+"] len["+len+"] BYTES AVAILABLE RETURN -1 (CASO B)");
  210.                         if(this.asyncWriteTask!=null) {
  211.                             //System.out.println("["+this.source+"] READ for WRITE COMPLETE 5");
  212.                             this.asyncWriteTask.complete(true);
  213.                         }
  214.                         return -1;
  215.                     }
  216.                 }
  217.             }
  218.             
  219.                     
  220.             
  221.             
  222.             if(this.bytesReceived==null){
  223.                 //this.log.debug("########### READ b["+b.length+"] off["+off+"] len["+len+"] BYTES AVAILABLE FROM PRECEDENT BUFFERING IS NULL ...");
  224.                 //this.log.debug("########### READ b["+b.length+"] off["+off+"] len["+len+"] SYNC ...");
  225.                 //synchronized (this.semaphore) {
  226.                 SemaphoreLock lock = this.lockPIPE.acquireThrowRuntime("read");
  227.                 try {
  228.                     //this.log.debug("########### READ b["+b.length+"] off["+off+"] len["+len+"] SYNC A1 ...");
  229.                     this.bout.flush();
  230.                     //this.log.debug("########### READ b["+b.length+"] off["+off+"] len["+len+"] SYNC A2 ...");
  231.                     this.bytesReceived = this.bout.toByteArray();
  232.                     //this.log.debug("########### READ b["+b.length+"] off["+off+"] len["+len+"] SYNC A3 ...");
  233.                     this.indexNextByteReceivedForRead = 0;
  234.                     //this.log.debug("########### READ b["+b.length+"] off["+off+"] len["+len+"] SYNC A4 ...");
  235.                     //System.out.println("########### RESET ATTUALE DIMENSIONE IN MEMORIA ["+this.bytesReceived.length+"]");
  236.                     this.bout.reset();
  237.                     if(this.asyncWriteTask!=null) {
  238.                         //System.out.println("["+this.source+"] READ for WRITE COMPLETE IN SEMAPHORE");
  239.                         this.asyncWriteTask.complete(true);
  240.                     }
  241.                 }finally {
  242.                     this.lockPIPE.release(lock, "read");
  243.                 }
  244.                 //this.log.debug("########### READ b["+b.length+"] off["+off+"] len["+len+"] SYNC OK");
  245.             }
  246.             
  247.             int bytesAvailableForRead = this.bytesReceived.length - this.indexNextByteReceivedForRead;
  248.             if(bytesAvailableForRead==len){         
  249.                 for (int i = 0; i < len; i++) {
  250.                     b[off+i]=this.bytesReceived[this.indexNextByteReceivedForRead];
  251.                     this.indexNextByteReceivedForRead++;
  252.                 }   
  253.                 this.bytesReceived = null;
  254.                 this.indexNextByteReceivedForRead = -1;
  255.                 //this.log.debug("########### READ b["+b.length+"] off["+off+"] len["+len+"] NEXT INDEX["+this.indexNextByteReceivedForRead+"] RETURN LETTI("+len+") EXIT A");
  256.                 return len;
  257.             }
  258.             else if(bytesAvailableForRead>len){
  259.                 int i = 0;
  260.                 for (i = 0; i < len; i++) {
  261.                     b[off+i]=this.bytesReceived[this.indexNextByteReceivedForRead];
  262.                     this.indexNextByteReceivedForRead++;
  263.                 }
  264.                 //this.log.debug("########### READ b["+b.length+"] off["+off+"] len["+len+"] NEXT INDEX["+this.indexNextByteReceivedForRead+"] RETURN LETTI("+len+") EXIT B");
  265.                 return len;
  266.             }
  267.             else{
  268.                 for (int i = 0; i < bytesAvailableForRead; i++) {
  269.                     b[off+i]=this.bytesReceived[this.indexNextByteReceivedForRead];
  270.                     this.indexNextByteReceivedForRead++;
  271.                 }
  272.                 this.bytesReceived = null;
  273.                 this.indexNextByteReceivedForRead = -1;
  274.                 //this.log.debug("########### READ b["+b.length+"] off["+off+"] len["+len+"] NEXT INDEX["+this.indexNextByteReceivedForRead+"] RETURN LETTI("+bytesAvailableForRead+") EXIT C");
  275.                 return bytesAvailableForRead;
  276.             }
  277.             
  278.             
  279.             
  280.     //      this.log.debug("########### READ b["+b.length+"] off["+off+"] len["+len+"] SYNC ...");
  281.     //      byte[] buffer = null;
  282.     //      synchronized (this.semaphore) {
  283.     //          
  284.     //          this.log.debug("########### READ b["+b.length+"] off["+off+"] len["+len+"] SYNC A1 ...");
  285.     //          
  286.     //          this.bout.flush();
  287.     //          
  288.     //          this.log.debug("########### READ b["+b.length+"] off["+off+"] len["+len+"] SYNC A2 ...");
  289.     //          
  290.     //          buffer = this.bout.toByteArray();
  291.     //          
  292.     //          this.log.debug("########### READ b["+b.length+"] off["+off+"] len["+len+"] SYNC A3 ...");
  293.     //          
  294.     //          this.bout.reset();
  295.     //          
  296.     //          this.log.debug("########### READ b["+b.length+"] off["+off+"] len["+len+"] SYNC A4 ...");
  297.     //          
  298.     //          // Se il buffer possiede piu' bytes di quanti richiesti, vengono risalvati quelli che non verranno ritornati con questa chiamata.
  299.     //          if(buffer.length>len){
  300.     //              this.log.debug("########### READ b["+b.length+"] off["+off+"] len["+len+"] SYNC A5 ...");
  301.     //              this.bout.write(buffer, len, buffer.length-len);
  302.     //          }
  303.     //          this.log.debug("########### READ b["+b.length+"] off["+off+"] len["+len+"] SYNC A6 ...");
  304.     //      }
  305.     //           
  306.     //      this.log.debug("########### READ b["+b.length+"] off["+off+"] len["+len+"] SYNC OK");
  307.     //      
  308.     //      if(buffer.length==len){         
  309.     //          for (int i = 0; i < buffer.length; i++) {
  310.     //              b[off+i]=buffer[i];
  311.     //          }       
  312.     //          this.log.debug("########### READ b["+b.length+"] off["+off+"] len["+len+"] EXIT A");
  313.     //          return b.length;
  314.     //      }
  315.     //      else if(buffer.length>len){
  316.     //          int i = 0;
  317.     //          for (i = 0; i < len; i++) {
  318.     //              b[off+i]=buffer[i];
  319.     //          }
  320.     //          this.log.debug("########### READ b["+b.length+"] off["+off+"] len["+len+"] EXIT B");
  321.     //          return b.length;
  322.     //      }
  323.     //      else{
  324.     //          for (int i = 0; i < buffer.length; i++) {
  325.     //              b[off+i]=buffer[i];
  326.     //          }
  327.     //          this.log.debug("########### READ b["+b.length+"] off["+off+"] len["+len+"] EXIT C");
  328.     //          return buffer.length;
  329.     //      }
  330.     //          
  331.         }
  332.         catch(IOException io) {
  333.             throw io;
  334.         }
  335.         catch(Throwable t) {
  336.             throw new IOException(t.getMessage(),t);
  337.         }
  338.     }

  340.     @Override
  341.     public int read() throws IOException {
  342.         byte[]b = new byte[1];
  343.         int len = this.read(b);
  344.         if ( len == 1 )
  345.             return b[0] & 0xFF;
  346.         if ( len == -1 )
  347.             return -1;
  348.         throw new IOException( "Cannot read single byte" );
  349.     }

  351.     
  352.     @Override
  353.     public void close() throws IOException {    
  354.         try {
  355.             SemaphoreLock lock = this.lockPIPE.acquireThrowRuntime("close");
  356.             try {
  357.                 if(this.stop==false){
  358.                     if(! (this.bout.size()>0) ){
  359.                         this.bout.flush();
  360.                         this.bout.close();
  361.                         //this.bout = null; se si annulla, la read lo trovera' null
  362.                     }
  363.                     this.stop = true;
  364.                 }
  365.             }finally{
  366.                 this.lockPIPE.release(lock, "close");
  367.             }
  368.             if(this.asyncWriteTask!=null) {
  369.                 //System.out.println("["+this.source+"] CLOSE for WRITE COMPLETE");
  370.                 this.asyncWriteTask.complete(true);
  371.             }
  372.             if(this.asyncReadTask!=null) {
  373.                 //System.out.println("["+this.source+"] CLOSE for READ COMPLETE");
  374.                 this.asyncReadTask.complete(true);
  375.             }
  376.             
  377.         }
  378.         catch(IOException io) {
  379.             throw io;
  380.         }
  381.         catch(Throwable t) {
  382.             throw new IOException(t.getMessage(),t);
  383.         }
  384.     }

  386.     
  387.     // ALIMENTAZIONE
  388.     
  389.     private void writeWaitEmptyBuffer() throws IOException{
  390.         try {
  391.             if(this.useThreadSleep) {
  392.                 if(this.bout.size()>this.sizeBuffer){
  393.                     int i = 0;
  394.                     while(this.stop==false && this.bout.size()>0 && i<ITERAZIONI_WAIT){
  395.                         Utilities.sleep((i+1));
  396.                         i = i + i;
  397.                     }
  398.                     if(i>=ITERAZIONI_WAIT){
  399.                         throw new IOException(getPrefixSource()+"Timeout, no buffer available for write");
  400.                     }
  401.                 }
  402.             }
  403.             else {
  404.                 boolean wait = false;
  405.                 SemaphoreLock lock = this.lockPIPE.acquireThrowRuntime("writeWaitEmptyBuffer");
  406.                 try {
  407.                     if(this.bout.size()>this.sizeBuffer){
  408.                         if(this.stop==false && this.bout.size()>0 ) {
  409.                             this.asyncWriteTask = new CompletableFuture<Boolean>();
  410.                             wait = true;
  411.                         }
  412.                     }
  413.                 }finally{
  414.                     this.lockPIPE.release(lock, "writeWaitEmptyBuffer");
  415.                 }
  416.                 if(wait) {
  417.                     try {
  418.                         //System.out.println("["+this.source+"] ASPETTO WRITE ...");
  419.                         if(this.timeoutMs>0) {
  420.                             this.asyncWriteTask.get(this.timeoutMs,TimeUnit.MILLISECONDS );
  421.                         }
  422.                         else {
  423.                             this.asyncWriteTask.get();
  424.                         }
  425.                         //System.out.println("["+this.source+"] WRITE OK");
  426.                     }catch(InterruptedException timeout) {
  427.                         Thread.currentThread().interrupt();
  428.                         throw new IOException(getPrefixSource()+"Timeout, no bytes available for read: "+timeout.getMessage(),timeout);
  429.                     }
  430.                     catch(Exception timeout) {
  431.                         throw new IOException(getPrefixSource()+"Timeout, no bytes available for read: "+timeout.getMessage(),timeout);
  432.                     }
  433.                 }
  434.             }
  435.         }
  436.         catch(IOException io) {
  437.             throw io;
  438.         }
  439.         catch(Throwable t) {
  440.             if(t !=null && t instanceof InterruptedException) {
  441.                 Thread.currentThread().interrupt();
  442.             }
  443.             throw new IOException(t.getMessage(),t);
  444.         }
  445.     }
  446.     
  447.     @Override
  448.     public void write(byte b) throws IOException{
  449.         
  450.         try {
  451.         
  452.             //this.log.debug("########### WRITE byte .....");
  453.             
  454.             if(this.bout==null){
  455.                 throw new IOException(getPrefixSource()+"Stream already closed");
  456.             }
  457.             
  458.             this.writeWaitEmptyBuffer();
  459.                     
  460.             //this.log.debug("########### WRITE byte SYNC ...");
  461.             //synchronized (this.semaphore) {
  462.             SemaphoreLock lock = this.lockPIPE.acquireThrowRuntime("write(b)");
  463.             try {
  464.                 this.bout.write(b);
  465.                 if(this.asyncReadTask!=null) {
  466.                     //System.out.println("["+this.source+"] WRITE for READ COMPLETE 1");
  467.                     this.asyncReadTask.complete(true);
  468.                 }
  469.                 //this.log.debug("########### WRITE byte SYNC OK");
  470.                 //System.out.println("########### WRITE byte SYNC OK ADD[1] SIZE_ATTUALE["+this.bout.size()+"]");
  471.             }finally{
  472.                 this.lockPIPE.release(lock, "write(b)");
  473.             }
  474.             
  475.         }
  476.         catch(IOException io) {
  477.             throw io;
  478.         }
  479.         catch(Throwable t) {
  480.             throw new IOException(t.getMessage(),t);
  481.         }

  483.     }
  484.     
  485.     @Override
  486.     public void write(byte [] b) throws IOException{
  487.         
  488.         try {
  489.         
  490.             //this.log.debug("########### WRITE byte ["+b.length+"] .....");
  491.             
  492.             if(this.bout==null){
  493.                 throw new IOException(getPrefixSource()+"Stream already closed");
  494.             }
  495.             
  496.             this.writeWaitEmptyBuffer();
  497.                     
  498.             //this.log.debug("########### WRITE byte ["+b.length+"] SYNC ...");
  499.             //synchronized (this.semaphore) {
  500.             SemaphoreLock lock = this.lockPIPE.acquireThrowRuntime("write(b[])");
  501.             try {
  502.                 this.bout.write(b);
  503.                 if(this.asyncReadTask!=null) {
  504.                     //System.out.println("["+this.source+"] WRITE for READ COMPLETE 2");
  505.                     this.asyncReadTask.complete(true);
  506.                 }
  507.                 //this.log.debug("########### WRITE byte ["+b.length+"] SYNC OK");
  508.                 //System.out.println("########### WRITE byte SYNC OK ADD["+b.length+"] SIZE_ATTUALE["+this.bout.size()+"]");
  509.             }finally {
  510.                 this.lockPIPE.release(lock, "write(b[])");
  511.             }
  512.             
  513.         }
  514.         catch(IOException io) {
  515.             throw io;
  516.         }
  517.         catch(Throwable t) {
  518.             throw new IOException(t.getMessage(),t);
  519.         }

  521.     }
  522.     
  523.     @Override
  524.     public void write(byte[] b, int off, int len) throws IOException{
  525.         
  526.         try {
  527.         
  528.             //this.log.debug("########### WRITE byte ["+b.length+"] off:"+off+" len:"+len+" .....");
  529.             
  530.             if(this.bout==null){
  531.                 throw new IOException(getPrefixSource()+"Stream already closed");
  532.             }
  533.             
  534.             this.writeWaitEmptyBuffer();
  535.                     
  536.             //this.log.debug("########### WRITE byte ["+b.length+"] off:"+off+" len:"+len+" SYNC ...");
  537.             //synchronized (this.semaphore) {
  538.             SemaphoreLock lock = this.lockPIPE.acquireThrowRuntime("write(b[],off,len)");
  539.             try {
  540.                 this.bout.write(b, off, len);
  541.                 if(this.asyncReadTask!=null) {
  542.                     //System.out.println("["+this.source+"] WRITE for READ COMPLETE 3");
  543.                     this.asyncReadTask.complete(true);
  544.                 }
  545.                 //this.log.debug("########### WRITE byte ["+b.length+"] off:"+off+" len:"+len+" SYNC OK");
  546.                 //System.out.println("########### WRITE byte SYNC OK ADD["+b.length+"] SIZE_ATTUALE["+this.bout.size()+"]");
  547.             }finally {
  548.                 this.lockPIPE.release(lock, "write(b[],off,len)");
  549.             }
  550.             
  551.         }
  552.         catch(IOException io) {
  553.             throw io;
  554.         }
  555.         catch(Throwable t) {
  556.             throw new IOException(t.getMessage(),t);
  557.         }

  559.     }

  561. }
Created with JaCoCo 0.8.8.202204050719