gobblin.aws.GobblinAWSUtils.java Source code

Introduction

Here is the source code for gobblin.aws.GobblinAWSUtils.java

Source

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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
 *
 *    http://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 gobblin.aws;

import java.io.File;
import java.util.List;
import java.util.concurrent.ExecutorService;

import java.util.concurrent.TimeUnit;
import org.apache.commons.codec.binary.Base64;
import org.apache.commons.io.filefilter.FileFileFilter;
import org.apache.commons.lang.StringUtils;
import org.quartz.utils.FindbugsSuppressWarnings;
import org.slf4j.Logger;

import com.google.common.base.Joiner;
import com.google.common.base.Preconditions;

import gobblin.annotation.Alpha;

/**
 * An util class for Gobblin on AWS misc functionality.
 *
 * @author Abhishek Tiwari
 */
@Alpha
public class GobblinAWSUtils {
    private static final long DEFAULT_EXECUTOR_SERVICE_SHUTDOWN_TIME_IN_MINUTES = 2;

    /***
     * Append a slash ie / at the end of input string.
     *
     * @param inputString Input string to append a slash to
     * @return String with slash appened
     */
    public static String appendSlash(String inputString) {
        Preconditions.checkNotNull(inputString);

        if (inputString.endsWith("/")) {
            return inputString;
        }

        return inputString + "/";
    }

    /***
     * List and generate classpath string from paths.
     *
     * Note: This is currently unused, and will be brought in to use with custom Gobblin AMI
     *
     * @param paths Paths to list
     * @return Classpath string
     */
    public static String getClasspathFromPaths(File... paths) {
        Preconditions.checkNotNull(paths);

        final StringBuilder classpath = new StringBuilder();
        boolean isFirst = true;
        for (File path : paths) {
            if (!isFirst) {
                classpath.append(":");
            }
            final String subClasspath = getClasspathFromPath(path);
            if (subClasspath.length() > 0) {
                classpath.append(subClasspath);
                isFirst = false;
            }
        }

        return classpath.toString();
    }

    private static String getClasspathFromPath(File path) {
        if (null == path) {
            return StringUtils.EMPTY;
        }
        if (!path.isDirectory()) {
            return path.getAbsolutePath();
        }

        return Joiner.on(":").skipNulls().join(path.list(FileFileFilter.FILE));
    }

    /***
     * Encodes String data using the base64 algorithm and does not chunk the output.
     *
     * @param data String to be encoded.
     * @return Encoded String.
     */
    @FindbugsSuppressWarnings("DM_DEFAULT_ENCODING")
    public static String encodeBase64(String data) {
        final byte[] encodedBytes = Base64.encodeBase64(data.getBytes());

        return new String(encodedBytes);
    }

    /***
     * Initiates an orderly shutdown in which previously submitted
     * tasks are executed, but no new tasks are accepted.
     * Invocation has no additional effect if already shut down.
     *
     * This also blocks until all tasks have completed execution
     * request, or the timeout occurs, or the current thread is
     * interrupted, whichever happens first.
     * @param clazz {@link Class} that invokes shutdown on the {@link ExecutorService}.
     * @param executorService {@link ExecutorService} to shutdown.
     * @param logger {@link Logger} to log shutdown for invoking class.
     * @throws InterruptedException if shutdown is interrupted.
     */
    public static void shutdownExecutorService(Class clazz, ExecutorService executorService, Logger logger)
            throws InterruptedException {
        executorService.shutdown();
        if (!executorService.awaitTermination(DEFAULT_EXECUTOR_SERVICE_SHUTDOWN_TIME_IN_MINUTES,
                TimeUnit.MINUTES)) {
            logger.warn("Executor service shutdown timed out.");
            List<Runnable> pendingTasks = executorService.shutdownNow();
            logger.warn(String.format("%s was shutdown instantly. %s tasks were not executed: %s", clazz.getName(),
                    pendingTasks.size(), StringUtils.join(pendingTasks, ",")));
        }
    }
}