Changeset 6860


Ignore:
Timestamp:
Apr 15, 2015, 9:15:25 AM (7 years ago)
Author:
Nicklas Nordborg
Message:

Fixes warnings about not closing resources (eg. files/streams) in all cases.

Location:
branches/3.5-stable/src
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • branches/3.5-stable/src/core/net/sf/basedb/core/HibernateUtil.java

    r6853 r6860  
    265265  {
    266266    assert cfg != null : "cfg == null";
     267    JarFile jarFile = null;
    267268    try
    268269    {
     
    276277        String jarPath = corePath.substring("file:".length(), corePath.length()-"/base.version".length()-1);
    277278        log.info("Loading mappings files from jar: " + jarPath);
    278         JarFile jarFile = new JarFile(jarPath);
     279        jarFile = new JarFile(jarPath);
    279280        Enumeration<JarEntry> jarEntries = jarFile.entries();
    280281        while (jarEntries.hasMoreElements())
     
    317318      log.error("Exception while loading mapping files", ex);
    318319      throw new BaseException(ex);
     320    }
     321    finally
     322    {
     323      FileUtil.close(jarFile);
    319324    }
    320325  }
  • branches/3.5-stable/src/core/net/sf/basedb/core/query/Restrictions.java

    r6844 r6860  
    8585 
    8686    @param restrictions The restrictions to combine
    87     @return The new restriction
    8887    @return The new restriction, or null if the collection was null
    8988      or didn't contain any not-null elements
  • branches/3.5-stable/src/core/net/sf/basedb/util/FileUtil.java

    r5384 r6860  
    4444import java.io.BufferedInputStream;
    4545import java.io.BufferedOutputStream;
     46import java.io.Closeable;
    4647import java.io.File;
    4748import java.io.FileFilter;
     
    226227 
    227228  /**
     229    Close a {@link Closeable} without throwing an exception.
     230    @param c The object to close
     231    @since 3.5
     232  */
     233  public static void close(Closeable c)
     234  {
     235    if (c == null) return;
     236    try
     237    {
     238      c.close();
     239    }
     240    catch (Throwable t)
     241    {}
     242  }
     243
     244 
     245  /**
    228246    Get a buffered <code>InputStream</code> object reading from
    229247    the specified file.
  • branches/3.5-stable/src/core/net/sf/basedb/util/JarClassLoader.java

    r6853 r6860  
    503503    }
    504504    JarFile jarFile = new JarFile(file);
    505     Manifest manifest = jarFile.getManifest();
    506     info.manifest = manifest;
    507     Enumeration<JarEntry> entries = jarFile.entries();
    508     while (entries.hasMoreElements())
    509     {
    510       JarEntry jarEntry = entries.nextElement();
    511       if (jarEntry.isDirectory())
    512       {
    513         /* #### CONTINUE-STATEMENT #### */
    514         continue;
    515       }
    516       String name = jarEntry.getName();
    517       log.trace("Adding: " + name);
    518       List<File> list = classPath.get(name);
    519       if (list == null)
    520       {
    521         list = new ArrayList<File>();
    522         classPath.put(name, list);
    523       }
    524       list.add(file);
    525     }
    526     if (followClassPath && manifest != null)
    527     {
    528       Attributes attr = manifest.getMainAttributes();
    529       if (attr != null)
    530       {
    531         String cp = attr.getValue(Attributes.Name.CLASS_PATH);
    532         log.debug("Class path of JAR file '" + file + "': " + cp);
    533         if (cp != null)
     505    try
     506    {
     507      Manifest manifest = jarFile.getManifest();
     508      info.manifest = manifest;
     509      Enumeration<JarEntry> entries = jarFile.entries();
     510      while (entries.hasMoreElements())
     511      {
     512        JarEntry jarEntry = entries.nextElement();
     513        if (jarEntry.isDirectory())
    534514        {
    535           String[] cps = cp.split("\\s+");
    536           for (int i = 0; i < cps.length; ++i)
     515          /* #### CONTINUE-STATEMENT #### */
     516          continue;
     517        }
     518        String name = jarEntry.getName();
     519        log.trace("Adding: " + name);
     520        List<File> list = classPath.get(name);
     521        if (list == null)
     522        {
     523          list = new ArrayList<File>();
     524          classPath.put(name, list);
     525        }
     526        list.add(file);
     527      }
     528      if (followClassPath && manifest != null)
     529      {
     530        Attributes attr = manifest.getMainAttributes();
     531        if (attr != null)
     532        {
     533          String cp = attr.getValue(Attributes.Name.CLASS_PATH);
     534          log.debug("Class path of JAR file '" + file + "': " + cp);
     535          if (cp != null)
    537536          {
    538             if (cps[i] != null && !cps[i].trim().equals(""))
     537            String[] cps = cp.split("\\s+");
     538            for (int i = 0; i < cps.length; ++i)
    539539            {
    540               File classPathFile = new File(file.getParent(), cps[i]);
    541               if (!classPathFile.exists())
     540              if (cps[i] != null && !cps[i].trim().equals(""))
    542541              {
    543                 log.debug("Referenced JAR file doesn't exist: '" + cps[i]);
    544                 // See if the requested file exists under META-INF
    545                 JarEntry entry = jarFile.getJarEntry("META-INF/" + cps[i]);
    546                 if (entry != null)
     542                File classPathFile = new File(file.getParent(), cps[i]);
     543                if (!classPathFile.exists())
    547544                {
    548                   log.debug("Extracting JAR from META-INF/" + cps[i] + " to jar.cache");
    549                   // Extract it to userfiles directory (if we have to)
    550                   classPathFile = new File(Application.getUserFilesDirectory(),
    551                       "jar.cache/" + file.getName() + "/" + classPathFile.getName());
    552                   boolean exists = classPathFile.exists();
    553                   boolean sameTime = exists && classPathFile.lastModified() == entry.getTime();
    554                   boolean sameSize = exists && classPathFile.length() == entry.getSize();
    555                   if (!exists || !sameTime || !sameSize)
     545                  log.debug("Referenced JAR file doesn't exist: '" + cps[i]);
     546                  // See if the requested file exists under META-INF
     547                  JarEntry entry = jarFile.getJarEntry("META-INF/" + cps[i]);
     548                  if (entry != null)
    556549                  {
    557                     classPathFile.getParentFile().mkdirs();
    558                     InputStream in = null;
    559                     OutputStream out = null;
    560                     try
     550                    log.debug("Extracting JAR from META-INF/" + cps[i] + " to jar.cache");
     551                    // Extract it to userfiles directory (if we have to)
     552                    classPathFile = new File(Application.getUserFilesDirectory(),
     553                        "jar.cache/" + file.getName() + "/" + classPathFile.getName());
     554                    boolean exists = classPathFile.exists();
     555                    boolean sameTime = exists && classPathFile.lastModified() == entry.getTime();
     556                    boolean sameSize = exists && classPathFile.length() == entry.getSize();
     557                    if (!exists || !sameTime || !sameSize)
    561558                    {
    562                       in = jarFile.getInputStream(entry);
    563                       out = FileUtil.getOutputStream(classPathFile);
    564                       FileUtil.copy(in, out);
    565                     }
    566                     finally
    567                     {
    568                       FileUtil.close(in);
    569                       FileUtil.close(out);
     559                      classPathFile.getParentFile().mkdirs();
     560                      InputStream in = null;
     561                      OutputStream out = null;
     562                      try
     563                      {
     564                        in = jarFile.getInputStream(entry);
     565                        out = FileUtil.getOutputStream(classPathFile);
     566                        FileUtil.copy(in, out);
     567                      }
     568                      finally
     569                      {
     570                        FileUtil.close(in);
     571                        FileUtil.close(out);
     572                      }
    570573                    }
    571574                  }
    572575                }
     576                loadJarFile(classPathFile, false);
    573577              }
    574               loadJarFile(classPathFile, false);
    575578            }
    576579          }
     580          if (file == mainJarFile)
     581          {
     582            delegateFirst = Values.getBoolean(attr.getValue("X-Delegate-First"), delegateFirst);
     583          }
    577584        }
    578         if (file == mainJarFile)
    579         {
    580           delegateFirst = Values.getBoolean(attr.getValue("X-Delegate-First"), delegateFirst);
    581         }
    582       }
     585      }
     586    }
     587    finally
     588    {
     589      FileUtil.close(jarFile);
    583590    }
    584591  }
     
    597604    log.debug("loadClassData: " + name + " from file: " + file);
    598605    InputStream in = null;
     606    JarFile jarFile = null;
    599607    try
    600608    {
    601       JarFile jarFile = new JarFile(file);
     609      jarFile = new JarFile(file);
    602610      // Get the jar entry and open an input stream to read the file
    603611      JarEntry jarEntry = jarFile.getJarEntry(classNameToPath(name));
     
    631639    {
    632640      FileUtil.close(in);
     641      FileUtil.close(jarFile);
    633642    }
    634643  }
  • branches/3.5-stable/src/core/net/sf/basedb/util/extensions/manager/ExtensionsFile.java

    r6444 r6860  
    2222package net.sf.basedb.util.extensions.manager;
    2323
    24 import java.io.Closeable;
    2524import java.io.File;
    2625import java.io.FileNotFoundException;
     
    357356    if (isJar())
    358357    {
    359       final ZipFile zipFile = new ZipFile(getFile());
    360       ZipEntry zipEntry = zipFile.getEntry("META-INF/extensions.xml");
    361       if (zipEntry == null)
    362       {
    363         throw new FileNotFoundException("META-INF/extensions.xml");
    364       }
    365      
    366       in = new CloseResourceInputStream(zipFile.getInputStream(zipEntry),
    367           new Closeable()
    368           {
    369             // Make sure the zip file is closed when the returned stream is closed
    370             @Override
    371             public void close()
    372               throws IOException
    373             {
    374               zipFile.close();
    375             }
    376           }
    377         );
     358      ZipFile zipFile = null;
     359      try
     360      {
     361        zipFile = new ZipFile(getFile());
     362        ZipEntry zipEntry = zipFile.getEntry("META-INF/extensions.xml");
     363        if (zipEntry == null)
     364        {
     365          throw new FileNotFoundException("META-INF/extensions.xml");
     366        }
     367        in = new CloseResourceInputStream(zipFile.getInputStream(zipEntry), zipFile);
     368      }
     369      finally
     370      {
     371        if (in == null) FileUtil.close(zipFile);
     372      }
    378373    }
    379374    else
     
    397392    if (isJar())
    398393    {
    399       final ZipFile zipFile = new ZipFile(getFile());
    400       ZipEntry zipEntry = zipFile.getEntry(path);
    401       if (zipEntry != null)
    402       {
    403         in = new CloseResourceInputStream(zipFile.getInputStream(zipEntry),
    404           new Closeable()
    405           {
    406             // Make sure the zip file is closed when the returned stream is closed
    407             @Override
    408             public void close()
    409               throws IOException
    410             {
    411               zipFile.close();
    412             }
    413           }
    414         );
     394      ZipFile zipFile = null;
     395      try
     396      {
     397        zipFile = new ZipFile(getFile());
     398        ZipEntry zipEntry = zipFile.getEntry(path);
     399        if (zipEntry != null)
     400        {
     401          in = new CloseResourceInputStream(zipFile.getInputStream(zipEntry), zipFile);
     402        }
     403      }
     404      finally
     405      {
     406        if (in == null) FileUtil.close(zipFile);
    415407      }
    416408    }
  • branches/3.5-stable/src/core/net/sf/basedb/util/gtf/GtfValidationAction.java

    r5764 r6860  
    3434import net.sf.basedb.core.InvalidDataException;
    3535import net.sf.basedb.core.InvalidRelationException;
     36import net.sf.basedb.util.FileUtil;
    3637import net.sf.basedb.util.fileset.SingleFileValidationAction;
    3738
     
    8586    File gtf = gtfMember.getFile();
    8687   
    87     InputStream in = gtf.getDownloadStream(0);
     88    InputStream in = null;
     89    BufferedReader reader = null;
    8890    String charset = gtf.getCharacterSet();
    8991    if (charset == null) charset = "ISO-8859-1";
    9092    try
    9193    {
     94      in = gtf.getDownloadStream(0);
    9295      GtfInputStream gtfStream = new GtfInputStream(in, charset, false);
    93       BufferedReader reader = new BufferedReader(new InputStreamReader(gtfStream, charset));
     96      reader = new BufferedReader(new InputStreamReader(gtfStream, charset));
    9497
    9598      // Read 10 lines
     
    108111      throw new InvalidDataException(ex);
    109112    }
     113    finally
     114    {
     115      FileUtil.close(reader);
     116      FileUtil.close(in);
     117    }
    110118  }
    111119
  • branches/3.5-stable/src/plugins/core/net/sf/basedb/plugins/PluginConfigurationImporter.java

    r6858 r6860  
    437437    this.configurationMap = configurations;
    438438   
    439     JarFile jar = new JarFile(jarPath);
    440     InputStream is = jar.getInputStream(new JarEntry(xmlPath));
    441     doImport(is, null);
    442     is.close();
     439    JarFile jar = null;
     440    InputStream is = null;
     441    try
     442    {
     443      jar = new JarFile(jarPath);
     444      is = jar.getInputStream(new JarEntry(xmlPath));
     445      doImport(is, null);
     446      is.close();
     447    }
     448    finally
     449    {
     450      FileUtil.close(is);
     451      FileUtil.close(jar);
     452    }
    443453  }
    444454 
  • branches/3.5-stable/src/test/net/sf/basedb/test/FileUtil.java

    r5778 r6860  
    8888    {
    8989      dc.saveItem(file);
    90       InputStream toUpload = TestUtil.class.getResourceAsStream(path);
    91       if (toUpload == null)
     90      InputStream toUpload = null;
     91      try
    9292      {
    93         TestUtil.write("--NOT FOUND - skipping upload\n");
     93        toUpload = TestUtil.class.getResourceAsStream(path);
     94        if (toUpload == null)
     95        {
     96          TestUtil.write("--NOT FOUND - skipping upload\n");
     97        }
     98        else
     99        {
     100          if (isBzip)
     101          {
     102            // Remove 'BZ' marker at start of file
     103            toUpload.read();
     104            toUpload.read();
     105            toUpload = new CBZip2InputStream(toUpload);
     106          }
     107          if (isTar)
     108          {
     109            // Assume that the TAR only contains a single file
     110            TarInputStream tar = new TarInputStream(toUpload);
     111            tar.getNextEntry();
     112            toUpload = tar;
     113          }
     114          file.upload(toUpload, false, true);
     115        }
    94116      }
    95       else
     117      finally
    96118      {
    97         if (isBzip)
    98         {
    99           // Remove 'BZ' marker at start of file
    100           toUpload.read();
    101           toUpload.read();
    102           toUpload = new CBZip2InputStream(toUpload);
    103         }
    104         if (isTar)
    105         {
    106           // Assume that the TAR only contains a single file
    107           TarInputStream tar = new TarInputStream(toUpload);
    108           tar.getNextEntry();
    109           toUpload = tar;
    110         }
    111         file.upload(toUpload, false, true);
     119        net.sf.basedb.util.FileUtil.close(toUpload);
    112120      }
    113121    }
Note: See TracChangeset for help on using the changeset viewer.