Rename batch into scanner

1 files changed, 274 insertions, 0 deletions

diff --git a/sonar-scanner-engine/src/main/java/org/sonar/batch/bootstrapper/Batch.java b/sonar-scanner-engine/src/main/java/org/sonar/batch/bootstrapper/Batch.java
new file mode 100644
index 00000000000..d5d3da13087
--- /dev/null
+++ b/sonar-scanner-engine/src/main/java/org/sonar/batch/bootstrapper/Batch.java
@@ -0,0 +1,274 @@
+/*
+ * SonarQube
+ * Copyright (C) 2009-2016 SonarSource SA
+ * mailto:contact AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+package org.sonar.batch.bootstrapper;
+
+import org.sonar.api.utils.MessageException;
+
+import com.google.common.base.Throwables;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+import org.picocontainer.annotations.Nullable;
+import org.sonar.batch.bootstrap.GlobalContainer;
+
+/**
+ * Entry point for sonar-runner 2.1.
+ *
+ * @since 2.14
+ */
+public final class Batch {
+
+  private boolean started = false;
+  private LoggingConfiguration loggingConfig;
+  private List<Object> components;
+  private Map<String, String> bootstrapProperties = Maps.newHashMap();
+  private GlobalContainer bootstrapContainer;
+
+  private Batch(Builder builder) {
+    components = Lists.newArrayList();
+    components.addAll(builder.components);
+    if (builder.environment != null) {
+      components.add(builder.environment);
+    }
+    if (builder.bootstrapProperties != null) {
+      bootstrapProperties.putAll(builder.bootstrapProperties);
+    }
+    if (builder.isEnableLoggingConfiguration()) {
+      loggingConfig = new LoggingConfiguration(builder.environment).setProperties(bootstrapProperties);
+
+      if (builder.logOutput != null) {
+        loggingConfig.setLogOutput(builder.logOutput);
+      }
+    }
+  }
+
+  public LoggingConfiguration getLoggingConfiguration() {
+    return loggingConfig;
+  }
+
+  /**
+   * @deprecated since 4.4 use {@link #start()}, {@link #executeTask(Map)} and then {@link #stop()}
+   */
+  @Deprecated
+  public synchronized Batch execute() {
+    configureLogging();
+    start();
+    boolean threw = true;
+    try {
+      executeTask(bootstrapProperties);
+      threw = false;
+    } finally {
+      doStop(threw);
+    }
+
+    return this;
+  }
+
+  /**
+   * @since 4.4
+   */
+  public synchronized Batch start() {
+    return start(false);
+  }
+
+  public synchronized Batch start(boolean preferCache) {
+    if (started) {
+      throw new IllegalStateException("Batch is already started");
+    }
+
+    configureLogging();
+    try {
+      bootstrapContainer = GlobalContainer.create(bootstrapProperties, components, preferCache);
+      bootstrapContainer.startComponents();
+    } catch (RuntimeException e) {
+      throw handleException(e);
+    }
+    this.started = true;
+
+    return this;
+  }
+
+  /**
+   * @since 4.4
+   */
+  public Batch executeTask(Map<String, String> analysisProperties, Object... components) {
+    checkStarted();
+    configureTaskLogging(analysisProperties);
+    try {
+      bootstrapContainer.executeTask(analysisProperties, components);
+    } catch (RuntimeException e) {
+      throw handleException(e);
+    }
+    return this;
+  }
+
+  /**
+   * @since 5.2
+   */
+  public Batch executeTask(Map<String, String> analysisProperties, IssueListener issueListener) {
+    checkStarted();
+    configureTaskLogging(analysisProperties);
+    try {
+      bootstrapContainer.executeTask(analysisProperties, components, issueListener);
+    } catch (RuntimeException e) {
+      throw handleException(e);
+    }
+    return this;
+  }
+
+  private void checkStarted() {
+    if (!started) {
+      throw new IllegalStateException("Batch is not started. Unable to execute task.");
+    }
+  }
+
+  private RuntimeException handleException(RuntimeException t) {
+    if (loggingConfig.isVerbose()) {
+      return t;
+    }
+
+    for (Throwable y : Throwables.getCausalChain(t)) {
+      if (y instanceof MessageException) {
+        return (MessageException) y;
+      }
+    }
+
+    return t;
+  }
+
+  /**
+   * @since 5.2
+   */
+  public Batch syncProject(String projectKey) {
+    checkStarted();
+    bootstrapContainer.syncProject(projectKey, true);
+    return this;
+  }
+
+  /**
+   * @since 4.4
+   */
+  public synchronized void stop() {
+    doStop(false);
+  }
+
+  private void doStop(boolean swallowException) {
+    checkStarted();
+    configureLogging();
+    try {
+      bootstrapContainer.stopComponents(swallowException);
+    } catch (RuntimeException e) {
+      throw handleException(e);
+    }
+    this.started = false;
+  }
+
+  private void configureLogging() {
+    if (loggingConfig != null) {
+      loggingConfig.setProperties(bootstrapProperties);
+      LoggingConfigurator.apply(loggingConfig);
+    }
+  }
+
+  private void configureTaskLogging(Map<String, String> taskProperties) {
+    if (loggingConfig != null) {
+      loggingConfig.setProperties(taskProperties, bootstrapProperties);
+      LoggingConfigurator.apply(loggingConfig);
+    }
+  }
+
+  public static Builder builder() {
+    return new Builder();
+  }
+
+  public static final class Builder {
+    private Map<String, String> bootstrapProperties;
+    private EnvironmentInformation environment;
+    private List<Object> components = Lists.newArrayList();
+    private boolean enableLoggingConfiguration = true;
+    private LogOutput logOutput;
+
+    private Builder() {
+    }
+
+    public Builder setEnvironment(EnvironmentInformation env) {
+      this.environment = env;
+      return this;
+    }
+
+    public Builder setComponents(List<Object> l) {
+      this.components = l;
+      return this;
+    }
+
+    public Builder setLogOutput(@Nullable LogOutput logOutput) {
+      this.logOutput = logOutput;
+      return this;
+    }
+
+    /**
+     * @deprecated since 3.7 use {@link #setBootstrapProperties(Map)}
+     */
+    @Deprecated
+    public Builder setGlobalProperties(Map<String, String> globalProperties) {
+      this.bootstrapProperties = globalProperties;
+      return this;
+    }
+
+    public Builder setBootstrapProperties(Map<String, String> bootstrapProperties) {
+      this.bootstrapProperties = bootstrapProperties;
+      return this;
+    }
+
+    public Builder addComponents(Object... components) {
+      Collections.addAll(this.components, components);
+      return this;
+    }
+
+    public Builder addComponent(Object component) {
+      this.components.add(component);
+      return this;
+    }
+
+    public boolean isEnableLoggingConfiguration() {
+      return enableLoggingConfiguration;
+    }
+
+    /**
+     * Logback is configured by default. It can be disabled, but n this case the batch bootstrapper must provide its
+     * own implementation of SLF4J.
+     */
+    public Builder setEnableLoggingConfiguration(boolean b) {
+      this.enableLoggingConfiguration = b;
+      return this;
+    }
+
+    public Batch build() {
+      if (components == null) {
+        throw new IllegalStateException("Batch components are not set");
+      }
+      return new Batch(this);
+    }
+  }
+}