csip.utils.Binaries Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of csip-core Show documentation
The Cloud Services Integration Platform is a SoA implementation to offer a Model-as-a-Service framework, Application Programming Interface, deployment infrastructure, and service implementations for environmental modeling.
There is a newer version: 2.6.30
Show newest version
/*
 * $Id: Binaries.java c4b9d8c126c7 2020-07-28 [email protected] $
 *
 * This file is part of the Cloud Services Integration Platform (CSIP),
 * a Model-as-a-Service framework, API and application suite.
 *
 * 2012-2019, Olaf David and others, OMSLab, Colorado State University.
 *
 * OMSLab licenses this file to you under the MIT license.
 * See the LICENSE file in the project root for more information.
 */
package csip.utils;

import csip.Config;
import static csip.Config.CSIP_DIR;
import static csip.Config.CSIP_JDBC_CHECKVALID;
import csip.Executable;
import csip.ServiceException;
import csip.SessionLogger;
import csip.Utils;
import csip.annotations.Resource;
import csip.annotations.ResourceType;
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileWriter;
import java.io.FilenameFilter;
import java.io.IOException;
import java.io.InputStream;
import java.io.StringWriter;
import java.io.Writer;
import java.lang.reflect.InvocationTargetException;
import java.net.URL;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.concurrent.TimeUnit;
import java.util.logging.Level;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.sql.DataSource;
import org.apache.commons.beanutils.BeanUtils;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.IOCase;
import org.apache.commons.io.filefilter.WildcardFileFilter;
import org.apache.tomcat.jdbc.pool.DataSourceProxy;
import org.apache.tomcat.jdbc.pool.PoolProperties;

/**
 *
 * @author od
 */
public class Binaries {

  public static final String STDOUT = "-stdout.txt";
  public static final String STDERR = "-stderr.txt";

  public static final String AUTO_RUN = "auto";

  public static final String DRIVER = "driverClassName";

  /**
   * JDBC Pool class.
   */
  private static class JDBCPool {

    DataSource datasource;
    String url;
    String resolved_url = "";
    Map env;


    /**
     * Create a pool
     * @param url
     * @param env
     */
    JDBCPool(String url, Map env) {
      this.url = url;
      this.env = env;
    }


    /**
     * Get the pool connection.
     *
     * @param logger
     * @return
     * @throws ServiceException
     */
    Connection getConnection(SessionLogger logger) throws ServiceException {
      try {
        // probe for configuration change.
        String res_url = Utils.resolve(url);
        if (datasource == null || !res_url.equals(resolved_url)) {
          //Close previous datasource if it exists
          if (datasource != null) {
            shutdown();
          }

          //Remember this connection string in case it has changed.
          resolved_url = res_url;
          PoolProperties p = new PoolProperties();
          defaultProperties(p);
          p.setUrl(resolved_url);
          logger.info(" JDBC pool property:  url:" + resolved_url);

          // load the driver if not already done do
          if (!env.containsKey(DRIVER)) {
            String rurl = resolved_url.toLowerCase();
            if (rurl.contains(":postgresql:")) {
              env.put(DRIVER, "org.postgresql.Driver");
            } else if (rurl.contains(":sqlserver:")) {
              env.put(DRIVER, "com.microsoft.sqlserver.jdbc.SQLServerDriver");
            } else if (rurl.contains(":mysql:")) {
              env.put(DRIVER, "com.mysql.jdbc.Driver");
            } else if (rurl.contains(":sqlite:")) {
              env.put(DRIVER, "org.sqlite.JDBC");
            } else if (rurl.contains(":oracle:")) {
              env.put(DRIVER, "oracle.jdbc.driver.OracleDriver");
            } else if (rurl.contains(":db2:")) {
              env.put(DRIVER, "com.ibm.db2.jcc.DB2Driver");
            } else if (rurl.contains(":sdm:")) {
              env.put(DRIVER, "csip.sdm.SDMDriver");
            }
          }

          // overwrite the defaults.
          Properties dbp = new Properties();
          for (String key : env.keySet()) {
            String val = env.get(key);
            try {
              BeanUtils.setProperty(p, key, val);
              logger.info("Set JDBC pool property: " + key + ": " + val);
            } catch (IllegalAccessException | InvocationTargetException E) {
              dbp.setProperty(key, val);
              logger.info("Set DB property: " + key + ": " + val);
            }
          }
          if (!dbp.isEmpty()) {
            p.setDbProperties(dbp);
          }

          logger.info("JDBC Pool properties:" + p.toString());
          datasource = new org.apache.tomcat.jdbc.pool.DataSource(p);
          logger.info("Created JDBC datasource: " + datasource.toString());
        }
        return datasource.getConnection();
      } catch (SQLException ex) {
        logger.log(Level.SEVERE, null, ex);
        throw new ServiceException("Unable to connect..  Please check the configuration parameter");
      }
    }


    /**
     * set the default properties.
     *
     * @param p
     */
    private void defaultProperties(PoolProperties p) {
      p.setDefaultAutoCommit(false);
      p.setJmxEnabled(false);
      p.setTestOnBorrow(true);
      p.setValidationQuery("SELECT 1");
      p.setTestOnReturn(false);
      p.setValidationInterval(30000);
      p.setMaxWait(10000);
      p.setRemoveAbandonedTimeout(60);
      p.setRemoveAbandoned(true);
      p.setInitialSize(10);
      p.setMaxActive(250);
      p.setMaxIdle(100);
      p.setMinIdle(10);
      p.setSuspectTimeout(60);
      p.setTimeBetweenEvictionRunsMillis(30000);
      p.setMinEvictableIdleTimeMillis(60000);
    }


    /**
     * Shutdown this pool.
     */
    void shutdown() {
      if (datasource != null && datasource instanceof DataSourceProxy) {
        ((DataSourceProxy) datasource).close(true);
        System.out.println("Closed datasource " + datasource.toString());
      }
      datasource = null;
    }
  }

  /**
   * Map of JDBCPools.
   */
  private static final Map jdbcPools = new HashMap<>();
  private static final List NO_RES = new ArrayList<>();

  private static final Object resource_lock = new Object();

  private static final long DATE_AT_STARTUP = new Date().getTime();
  private static final long DATE_AT_STARTUP_SEC = DATE_AT_STARTUP / 1000l;

  private static SimpleCache, List> rc = new SimpleCache<>();
  private static SimpleCache, Boolean> extractCache = new SimpleCache<>();


  /**
   * Shuts down all JDBC pools.
   */
  public static void shutdownJDBC() {
    synchronized (jdbcPools) {
      for (JDBCPool pool : jdbcPools.values()) {
        pool.shutdown();
      }
      jdbcPools.clear();
    }
  }


  /**
   * Get the architecture
   * @return the architecture
   */
  public static String getArch() {
    String os = System.getProperty("os.name").toLowerCase();
    if (os.contains("bsd")) {
      os = "bsd";
    } else {
      os = os.substring(0, 3);
    }
    return os + "-" + System.getProperty("os.arch").toLowerCase();
  }


  /**
   *
   * @param p1
   * @param workspace
   * @param LOG
   * @return
   */
  private static Executable asExecutable(final Execution p1, final File workspace, final SessionLogger LOG) {

    return new Executable() {
      File stdout = new File(workspace, p1.getFile().getName() + "-" + p1.hashCode() + STDOUT);
      File stderr = new File(workspace, p1.getFile().getName() + "-" + p1.hashCode() + STDERR);

      Writer out;
      Writer err;


      @Override
      public File stdout() {
        return stdout;
      }


      @Override
      public File stderr() {
        return stderr;
      }


      @Override
      public String getName() {
        return p1.getFile().toString();
      }


      @Override
      public void setArguments(Object... args) {
        List