BaseCommand.java

/*
 *    Copyright 2010-2023 the original author or authors.
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *       https://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */
package org.apache.ibatis.migration.commands;

import static org.apache.ibatis.migration.utils.Util.file;

import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.LineNumberReader;
import java.io.OutputStream;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.io.Reader;
import java.net.URL;
import java.net.URLClassLoader;
import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Properties;
import java.util.ServiceLoader;
import java.util.TimeZone;

import org.apache.ibatis.migration.Change;
import org.apache.ibatis.migration.ConnectionProvider;
import org.apache.ibatis.migration.Environment;
import org.apache.ibatis.migration.FileMigrationLoader;
import org.apache.ibatis.migration.FileMigrationLoaderFactory;
import org.apache.ibatis.migration.JdbcConnectionProvider;
import org.apache.ibatis.migration.MigrationException;
import org.apache.ibatis.migration.MigrationLoader;
import org.apache.ibatis.migration.VariableReplacer;
import org.apache.ibatis.migration.hook.FileHookScriptFactory;
import org.apache.ibatis.migration.hook.FileMigrationHook;
import org.apache.ibatis.migration.hook.HookScriptFactory;
import org.apache.ibatis.migration.hook.MigrationHook;
import org.apache.ibatis.migration.io.Resources;
import org.apache.ibatis.migration.options.DatabaseOperationOption;
import org.apache.ibatis.migration.options.Options;
import org.apache.ibatis.migration.options.SelectedOptions;
import org.apache.ibatis.migration.options.SelectedPaths;
import org.apache.ibatis.migration.utils.Util;

public abstract class BaseCommand implements Command {
  private static final String DATE_FORMAT = "yyyyMMddHHmmss";
  protected static final String DESC_CREATE_CHANGELOG = "create changelog";

  private ClassLoader driverClassLoader;
  private Environment environment;

  protected PrintStream printStream = System.out;

  protected final SelectedOptions options;
  protected final SelectedPaths paths;

  protected BaseCommand(SelectedOptions selectedOptions) {
    this.options = selectedOptions;
    this.paths = selectedOptions.getPaths();
    if (options.isQuiet()) {
      this.printStream = new PrintStream(new OutputStream() {
        @Override
        public void write(int b) {
          // throw away output
        }
      });
    }
  }

  public void setDriverClassLoader(ClassLoader aDriverClassLoader) {
    driverClassLoader = aDriverClassLoader;
  }

  public void setPrintStream(PrintStream aPrintStream) {
    if (options.isQuiet()) {
      aPrintStream.println("You selected to suppress output but a PrintStream is being set");
    }
    printStream = aPrintStream;
  }

  protected boolean paramsEmpty(String... params) {
    return params == null || params.length < 1 || params[0] == null || params[0].length() < 1;
  }

  protected String changelogTable() {
    return environment().getVariables().getProperty(Environment.CHANGELOG, "CHANGELOG");
  }

  protected String getNextIDAsString() {
    try {
      // Ensure that two subsequent calls are less likely to return the same value.
      Thread.sleep(1000);
    } catch (InterruptedException e) {
      // Ignore and Restore interrupted state...
      Thread.currentThread().interrupt();
    }
    String idPattern = options.getIdPattern();
    if (idPattern == null) {
      idPattern = Util.getPropertyOption(Options.IDPATTERN.toString().toLowerCase());
    }
    if (idPattern != null && !idPattern.isEmpty()) {
      return generatePatternedId(idPattern);
    }
    return generateTimestampId();
  }

  private String generatePatternedId(String pattern) {
    DecimalFormat fmt = new DecimalFormat(pattern);
    List<Change> migrations = getMigrationLoader().getMigrations();
    if (migrations.isEmpty()) {
      return fmt.format(1);
    }
    Change lastChange = migrations.get(migrations.size() - 1);
    try {
      long lastId = (Long) fmt.parse(lastChange.getId().toString());
      lastId++;
      return fmt.format(lastId);
    } catch (ParseException e) {
      throw new MigrationException(
          "Failed to parse last id '" + lastChange.getId() + "' using the specified idPattern '" + pattern + "'");
    }
  }

  private String generateTimestampId() {
    final SimpleDateFormat dateFormat = new SimpleDateFormat(DATE_FORMAT);
    final Date now = new Date();
    dateFormat.setTimeZone(TimeZone.getTimeZone(environment().getTimeZone()));
    return dateFormat.format(now);
  }

  protected void copyResourceTo(String resource, File toFile) {
    copyResourceTo(resource, toFile, null);
  }

  protected void copyResourceTo(String resource, File toFile, Properties variables) {
    printStream.println("Creating: " + toFile.getName());
    try (Reader reader = Resources.getResourceAsReader(this.getClass().getClassLoader(), resource)) {
      copyTemplate(reader, toFile, variables);
    } catch (IOException e) {
      throw new MigrationException("Error copying " + resource + " to " + toFile.getAbsolutePath() + ".  Cause: " + e,
          e);
    }
  }

  protected void copyExternalResourceTo(String resource, File toFile, Properties variables) {
    printStream.println("Creating: " + toFile.getName());
    try {
      File sourceFile = new File(resource);
      copyTemplate(sourceFile, toFile, variables);
    } catch (Exception e) {
      throw new MigrationException("Error copying " + resource + " to " + toFile.getAbsolutePath() + ".  Cause: " + e,
          e);
    }
  }

  protected static void copyTemplate(File templateFile, File toFile, Properties variables) throws IOException {
    try (FileReader reader = new FileReader(templateFile)) {
      copyTemplate(reader, toFile, variables);
    }
  }

  protected static void copyTemplate(Reader templateReader, File toFile, Properties variables) throws IOException {
    VariableReplacer replacer = new VariableReplacer(variables);
    try (LineNumberReader reader = new LineNumberReader(templateReader);
        PrintWriter writer = new PrintWriter(new FileWriter(toFile))) {
      String line;
      while ((line = reader.readLine()) != null) {
        line = replacer.replace(line);
        writer.println(line);
      }
    }
  }

  protected File environmentFile() {
    return file(paths.getEnvPath(), options.getEnvironment() + ".properties");
  }

  protected File existingEnvironmentFile() {
    File envFile = environmentFile();
    if (!envFile.exists()) {
      throw new MigrationException("Environment file missing: " + envFile.getAbsolutePath());
    }
    return envFile;
  }

  protected Environment environment() {
    if (environment != null) {
      return environment;
    }
    environment = new Environment(existingEnvironmentFile());
    return environment;
  }

  protected int getStepCountParameter(int defaultSteps, String... params) {
    final String stringParam = params.length > 0 ? params[0] : null;
    if (stringParam == null || "".equals(stringParam)) {
      return defaultSteps;
    }
    try {
      return Integer.parseInt(stringParam);
    } catch (NumberFormatException e) {
      throw new MigrationException("Invalid parameter passed to command: " + params[0]);
    }
  }

  protected ConnectionProvider getConnectionProvider() {
    try {
      return new JdbcConnectionProvider(getDriverClassLoader(), environment().getDriver(), environment().getUrl(),
          environment().getUsername(), environment().getPassword());
    } catch (Exception e) {
      throw new MigrationException("Error creating ScriptRunner.  Cause: " + e, e);
    }
  }

  private ClassLoader getDriverClassLoader() {
    File localDriverPath = getCustomDriverPath();
    if (driverClassLoader != null) {
      return driverClassLoader;
    }
    if (localDriverPath.exists()) {
      try {
        List<URL> urlList = new ArrayList<>();
        File[] files = localDriverPath.listFiles();
        if (files != null) {
          for (File file : files) {
            String filename = file.getCanonicalPath();
            if (!filename.startsWith("/")) {
              filename = '/' + filename;
            }
            urlList.add(new URL("jar:file:" + filename + "!/"));
            urlList.add(new URL("file:" + filename));
          }
        }
        URL[] urls = urlList.toArray(new URL[0]);
        return new URLClassLoader(urls);
      } catch (Exception e) {
        throw new MigrationException("Error creating a driver ClassLoader. Cause: " + e, e);
      }
    }
    return null;
  }

  private File getCustomDriverPath() {
    String customDriverPath = environment().getDriverPath();
    if (customDriverPath != null && customDriverPath.length() > 0) {
      return new File(customDriverPath);
    }
    return options.getPaths().getDriverPath();
  }

  protected MigrationLoader getMigrationLoader() {
    Environment env = environment();
    MigrationLoader migrationLoader = null;
    for (FileMigrationLoaderFactory factory : ServiceLoader.load(FileMigrationLoaderFactory.class)) {
      if (migrationLoader != null) {
        throw new MigrationException("Found multiple implementations of FileMigrationLoaderFactory via SPI.");
      }
      migrationLoader = factory.create(paths, env);
    }
    return migrationLoader != null ? migrationLoader
        : new FileMigrationLoader(paths.getScriptPath(), env.getScriptCharset(), env.getVariables());
  }

  protected MigrationHook createUpHook() {
    String before = environment().getHookBeforeUp();
    String beforeEach = environment().getHookBeforeEachUp();
    String afterEach = environment().getHookAfterEachUp();
    String after = environment().getHookAfterUp();
    if (before == null && beforeEach == null && afterEach == null && after == null) {
      return null;
    }
    return createFileMigrationHook(before, beforeEach, afterEach, after);
  }

  protected MigrationHook createDownHook() {
    String before = environment().getHookBeforeDown();
    String beforeEach = environment().getHookBeforeEachDown();
    String afterEach = environment().getHookAfterEachDown();
    String after = environment().getHookAfterDown();
    if (before == null && beforeEach == null && afterEach == null && after == null) {
      return null;
    }
    return createFileMigrationHook(before, beforeEach, afterEach, after);
  }

  protected MigrationHook createFileMigrationHook(String before, String beforeEach, String afterEach, String after) {
    HookScriptFactory factory = new FileHookScriptFactory(options.getPaths(), environment(), printStream);
    return new FileMigrationHook(factory.create(before), factory.create(beforeEach), factory.create(afterEach),
        factory.create(after));
  }

  protected DatabaseOperationOption getDatabaseOperationOption() {
    DatabaseOperationOption option = new DatabaseOperationOption();
    option.setChangelogTable(changelogTable());
    option.setStopOnError(!options.isForce());
    option.setThrowWarning(!options.isForce() && !environment().isIgnoreWarnings());
    option.setEscapeProcessing(false);
    option.setAutoCommit(environment().isAutoCommit());
    option.setFullLineDelimiter(environment().isFullLineDelimiter());
    option.setSendFullScript(environment().isSendFullScript());
    option.setRemoveCRs(environment().isRemoveCrs());
    option.setDelimiter(environment().getDelimiter());
    return option;
  }
}