diff --git a/README.md b/README.md index b4b2539..bf88dcc 100644 --- a/README.md +++ b/README.md @@ -4,7 +4,7 @@ Using [Apache Gradle](www.gradle.org), we can easily build shaded JAR files with ``` cd examples/simple-jar -./gradlew shadowJar +./gradlew build ``` But this JAR would still have to be uploaded to a stage in Snowflake, and the UDF would have to be created or possibly recreated if it's signature changed. @@ -34,7 +34,51 @@ plugins { } ``` -The plugin provides a configuration closure called `snowflake` that we can now use. +When the plugin is added, we now get a new task in our Gradle project: + +``` +❯ ./gradlew help --task snowflakePublish + +> Task :help +Detailed task information for snowflakePublish + +Path + :snowflakePublish + +Type + SnowflakePublish (io.noumenal.SnowflakePublish) + +Options + --account Override the URL of the Snowflake account. + + --database Override the Snowflake database to connect to. + + --jar Optional: manually pass a JAR file path to upload instead of relying on Gradle metadata. + + --password Override the Snowflake password to connect with. + + --role The Snowflake role to use. + + --schema Override the Snowflake schema to connect with. + + --stage The Snowflake external stage to publish to. + + --user Override the Snowflake user to connect as. + + --warehouse Override the Snowflake role to connect with. + +Description + Publish a Java artifact to an external stage and create Snowflake Functions and Procedures. + +Group + publishing + +BUILD SUCCESSFUL in 597ms +1 actionable task: 1 executed +``` + +There are a number of command-line options that mention *overriding* other configuration values. +This is because the plugin also provides a configuration closure called `snowflake` that we can now use to set all these values in our build file. The specific options for this closure are documented in the [API docs](https://s3.amazonaws.com/docs.noumenal.io/gradle-snowflake/latest/io/noumenal/SnowflakeExtension.html): ``` @@ -57,16 +101,135 @@ snowflake { } ``` -The first thing you'll notice is that I'm not hard-coding the sensitive credentials. -Instead, they are in my local `gradle.properties` file, and it's worth mentioning that any of the plugin configs can be provided this way, or any [number of ways](https://docs.gradle.org/current/userguide/build_environment.html#sec:gradle_configuration_properties) using Gradle project properties: +Notice that I'm not hard-coding sensitive credentials. +Instead, they are in my local `gradle.properties` file, and any of the plugin configs can be provided this way, or any [number of ways](https://docs.gradle.org/current/userguide/build_environment.html#sec:gradle_configuration_properties) using Gradle project properties: ``` -snowflake.url = https://my-org.snowflakecomputing.com:443 +snowflake.url = https://myorg.snowflakecomputing.com:443 snowflake.user = myusername +snowflake.password = mypassword ``` The nested `applications` closure might seem a bit more daunting. -This is simply a way to configure using DSL all the different UDFs we want to automatically create (or recreate) each time we publish the JAR file. +This is a simple way to use DSL to configure all the different UDFs we want to automatically create (or recreate) each time we publish the JAR file. This example will generate the command: ``` +CREATE OR REPLACE function add_numbers (a integer, b integer) + returns string + language JAVA + handler = 'Sample.addNum' + imports = ('@upload/libs/internal-stage-0.1.0-all.jar') +``` + +With our configuration complete, we can execute the `snowflakePublish` command, which will run any unit tests and then publish our JAR and create our function: + +``` +❯ ./gradlew snowflakePublish --rerun-tasks + +> Task :snowflakePublish +File internal-stage-0.1.0-all.jar: UPLOADED +Deploying ==> +CREATE OR REPLACE function add_numbers (a integer, b integer) + returns string + language JAVA + handler = 'Sample.addNum' + imports = ('@upload/libs/internal-stage-0.1.0-all.jar') + + +BUILD SUCCESSFUL in 10s +3 actionable tasks: 3 executed +``` + +Our function now exists in Snowflake: + +``` +select add_numbers(1,2); +``` + +The `snowflakePublish` task was also written to be [incremental](https://docs.gradle.org/current/userguide/more_about_tasks.html#sec:up_to_date_checks) and [*cacheable*](https://docs.gradle.org/current/userguide/build_cache.html#sec:task_output_caching_details). +If I run the task again without making any changes to my code, then the execution is avoided, which we know because of the *up-to-date* keyworld. + +``` +❯ ./gradlew snowflakePublish + +BUILD SUCCESSFUL in 624ms +3 actionable tasks: 3 up-to-date +``` + +# Auto-configuration of `maven-plugin` with External Stages +This option is useful when you want to make your artifacts availablle to more consumers than just Snowflake and you aren't interested in publishing them to a bunch of disparate locations. +Gradle has [built-in support](https://docs.gradle.org/current/userguide/declaring_repositories.html#sec:s3-repositories) for S3 as a Maven repository, and Snowflake has support for S3 external stages. +If you look at the [sample project](examples/external-stage-auto/), you will notice we've populated a few additional properties: + +``` +groupId = 'io.noumenal' +artifactId = 'sample-udfs' +``` + +These, plus the built-in `version` property that exists for all Gradle builds, provide the [Maven coordinates](https://maven.apache.org/pom.html#Maven_Coordinates) for publishing externally to S3. +I've also created a property in my local `gradle.properties` file for the bucket: + +``` +snowflake.publishUrl = 's3://myrepo/release' +``` + +The plugin doesn't create the stage, but it does do a check to ensure that the Snowflake stage metadata matches the value in `publishUrl`. We get a few new tasks added to our project: + +``` +❯ gradle tasks --group publishing + +> Task :tasks + +------------------------------------------------------------ +Tasks runnable from root project 'external-stage-auto' +------------------------------------------------------------ + +Publishing tasks +---------------- +generateMetadataFileForSnowflakePublication - Generates the Gradle metadata file for publication 'snowflake'. +generatePomFileForSnowflakePublication - Generates the Maven POM file for publication 'snowflake'. +publish - Publishes all publications produced by this project. +publishAllPublicationsToMavenRepository - Publishes all Maven publications produced by this project to the maven repository. +publishSnowflakePublicationToMavenLocal - Publishes Maven publication 'snowflake' to the local Maven repository. +publishSnowflakePublicationToMavenRepository - Publishes Maven publication 'snowflake' to Maven repository 'maven'. +publishToMavenLocal - Publishes all Maven publications produced by this project to the local Maven cache. +snowflakePublish - Publish a Java artifact to an external stage and create Snowflake Functions and Procedures. + +To see all tasks and more detail, run gradle tasks --all + +To see more detail about a task, run gradle help --task + +BUILD SUCCESSFUL in 600ms +1 actionable task: 1 executed +``` + +These are a bunch of granular tasks for building metadata and POM files, and publishing that along with the artifacts to S3. +But the `snowflakePublish` task manages initating all these dependent tasks, including `publishSnowflakePublicationToMavenRepository` which actually uploads the artifact: + +``` +❯ gradle snowflakePublish --console=plain +> Task :compileJava +> Task :processResources NO-SOURCE +> Task :classes +> Task :shadowJar +> Task :compileTestJava NO-SOURCE +> Task :processTestResources NO-SOURCE +> Task :testClasses UP-TO-DATE +> Task :test NO-SOURCE +> Task :generatePomFileForSnowflakePublication +> Task :publishSnowflakePublicationToMavenRepository + +> Task :snowflakePublish +Deploying ==> +CREATE OR REPLACE function add_numbers (a integer, b integer) + returns string + language JAVA + handler = 'Sample.addNum' + imports = ('@maven/io/noumenal/sample-udfs/0.1.0/sample-udfs-0.1.0-all.jar') + + +BUILD SUCCESSFUL in 12s +5 actionable tasks: 5 executed +``` + diff --git a/examples/external-stage-auto/build.gradle b/examples/external-stage-auto/build.gradle new file mode 100644 index 0000000..1d48029 --- /dev/null +++ b/examples/external-stage-auto/build.gradle @@ -0,0 +1,43 @@ +plugins { + id 'java' + id 'com.github.ben-manes.versions' version '0.42.0' + id 'io.noumenal.gradle.snowflake' version '0.1.12' +} + +repositories { + mavenCentral() +} + +dependencies { + implementation 'org.apache.logging.log4j:log4j-api:2.18.0' + implementation 'org.apache.logging.log4j:log4j-core:2.18.0' +} + +java { + toolchain { + languageVersion = JavaLanguageVersion.of(11) + } +} + +snowflake { + // All the following options are provided in my local gradle.properties file + // url = + // user = + // password = + // publishUrl = + role = 'stewart_role' + database = 'stewart_db' + schema = 'developer' + stage = 'maven' + groupId = 'io.noumenal' + artifactId = 'sample-udfs' + applications { + add_numbers { + inputs = ["a integer", "b integer"] + returns = "string" + handler = "Sample.addNum" + } + } +} + +version='0.1.0' diff --git a/examples/external-stage-auto/gradle/wrapper/gradle-wrapper.jar b/examples/external-stage-auto/gradle/wrapper/gradle-wrapper.jar new file mode 100644 index 0000000..249e583 Binary files /dev/null and b/examples/external-stage-auto/gradle/wrapper/gradle-wrapper.jar differ diff --git a/examples/external-stage-auto/gradle/wrapper/gradle-wrapper.properties b/examples/external-stage-auto/gradle/wrapper/gradle-wrapper.properties new file mode 100644 index 0000000..ae04661 --- /dev/null +++ b/examples/external-stage-auto/gradle/wrapper/gradle-wrapper.properties @@ -0,0 +1,5 @@ +distributionBase=GRADLE_USER_HOME +distributionPath=wrapper/dists +distributionUrl=https\://services.gradle.org/distributions/gradle-7.5.1-bin.zip +zipStoreBase=GRADLE_USER_HOME +zipStorePath=wrapper/dists diff --git a/examples/external-stage-auto/gradlew b/examples/external-stage-auto/gradlew new file mode 100755 index 0000000..a69d9cb --- /dev/null +++ b/examples/external-stage-auto/gradlew @@ -0,0 +1,240 @@ +#!/bin/sh + +# +# Copyright © 2015-2021 the original 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. +# + +############################################################################## +# +# Gradle start up script for POSIX generated by Gradle. +# +# Important for running: +# +# (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is +# noncompliant, but you have some other compliant shell such as ksh or +# bash, then to run this script, type that shell name before the whole +# command line, like: +# +# ksh Gradle +# +# Busybox and similar reduced shells will NOT work, because this script +# requires all of these POSIX shell features: +# * functions; +# * expansions «$var», «${var}», «${var:-default}», «${var+SET}», +# «${var#prefix}», «${var%suffix}», and «$( cmd )»; +# * compound commands having a testable exit status, especially «case»; +# * various built-in commands including «command», «set», and «ulimit». +# +# Important for patching: +# +# (2) This script targets any POSIX shell, so it avoids extensions provided +# by Bash, Ksh, etc; in particular arrays are avoided. +# +# The "traditional" practice of packing multiple parameters into a +# space-separated string is a well documented source of bugs and security +# problems, so this is (mostly) avoided, by progressively accumulating +# options in "$@", and eventually passing that to Java. +# +# Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS, +# and GRADLE_OPTS) rely on word-splitting, this is performed explicitly; +# see the in-line comments for details. +# +# There are tweaks for specific operating systems such as AIX, CygWin, +# Darwin, MinGW, and NonStop. +# +# (3) This script is generated from the Groovy template +# https://github.com/gradle/gradle/blob/master/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt +# within the Gradle project. +# +# You can find Gradle at https://github.com/gradle/gradle/. +# +############################################################################## + +# Attempt to set APP_HOME + +# Resolve links: $0 may be a link +app_path=$0 + +# Need this for daisy-chained symlinks. +while + APP_HOME=${app_path%"${app_path##*/}"} # leaves a trailing /; empty if no leading path + [ -h "$app_path" ] +do + ls=$( ls -ld "$app_path" ) + link=${ls#*' -> '} + case $link in #( + /*) app_path=$link ;; #( + *) app_path=$APP_HOME$link ;; + esac +done + +APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit + +APP_NAME="Gradle" +APP_BASE_NAME=${0##*/} + +# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"' + +# Use the maximum available, or set MAX_FD != -1 to use that value. +MAX_FD=maximum + +warn () { + echo "$*" +} >&2 + +die () { + echo + echo "$*" + echo + exit 1 +} >&2 + +# OS specific support (must be 'true' or 'false'). +cygwin=false +msys=false +darwin=false +nonstop=false +case "$( uname )" in #( + CYGWIN* ) cygwin=true ;; #( + Darwin* ) darwin=true ;; #( + MSYS* | MINGW* ) msys=true ;; #( + NONSTOP* ) nonstop=true ;; +esac + +CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar + + +# Determine the Java command to use to start the JVM. +if [ -n "$JAVA_HOME" ] ; then + if [ -x "$JAVA_HOME/jre/sh/java" ] ; then + # IBM's JDK on AIX uses strange locations for the executables + JAVACMD=$JAVA_HOME/jre/sh/java + else + JAVACMD=$JAVA_HOME/bin/java + fi + if [ ! -x "$JAVACMD" ] ; then + die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." + fi +else + JAVACMD=java + which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." +fi + +# Increase the maximum file descriptors if we can. +if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then + case $MAX_FD in #( + max*) + MAX_FD=$( ulimit -H -n ) || + warn "Could not query maximum file descriptor limit" + esac + case $MAX_FD in #( + '' | soft) :;; #( + *) + ulimit -n "$MAX_FD" || + warn "Could not set maximum file descriptor limit to $MAX_FD" + esac +fi + +# Collect all arguments for the java command, stacking in reverse order: +# * args from the command line +# * the main class name +# * -classpath +# * -D...appname settings +# * --module-path (only if needed) +# * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables. + +# For Cygwin or MSYS, switch paths to Windows format before running java +if "$cygwin" || "$msys" ; then + APP_HOME=$( cygpath --path --mixed "$APP_HOME" ) + CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" ) + + JAVACMD=$( cygpath --unix "$JAVACMD" ) + + # Now convert the arguments - kludge to limit ourselves to /bin/sh + for arg do + if + case $arg in #( + -*) false ;; # don't mess with options #( + /?*) t=${arg#/} t=/${t%%/*} # looks like a POSIX filepath + [ -e "$t" ] ;; #( + *) false ;; + esac + then + arg=$( cygpath --path --ignore --mixed "$arg" ) + fi + # Roll the args list around exactly as many times as the number of + # args, so each arg winds up back in the position where it started, but + # possibly modified. + # + # NB: a `for` loop captures its iteration list before it begins, so + # changing the positional parameters here affects neither the number of + # iterations, nor the values presented in `arg`. + shift # remove old arg + set -- "$@" "$arg" # push replacement arg + done +fi + +# Collect all arguments for the java command; +# * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of +# shell script including quotes and variable substitutions, so put them in +# double quotes to make sure that they get re-expanded; and +# * put everything else in single quotes, so that it's not re-expanded. + +set -- \ + "-Dorg.gradle.appname=$APP_BASE_NAME" \ + -classpath "$CLASSPATH" \ + org.gradle.wrapper.GradleWrapperMain \ + "$@" + +# Stop when "xargs" is not available. +if ! command -v xargs >/dev/null 2>&1 +then + die "xargs is not available" +fi + +# Use "xargs" to parse quoted args. +# +# With -n1 it outputs one arg per line, with the quotes and backslashes removed. +# +# In Bash we could simply go: +# +# readarray ARGS < <( xargs -n1 <<<"$var" ) && +# set -- "${ARGS[@]}" "$@" +# +# but POSIX shell has neither arrays nor command substitution, so instead we +# post-process each arg (as a line of input to sed) to backslash-escape any +# character that might be a shell metacharacter, then use eval to reverse +# that process (while maintaining the separation between arguments), and wrap +# the whole thing up as a single "set" statement. +# +# This will of course break if any of these variables contains a newline or +# an unmatched quote. +# + +eval "set -- $( + printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" | + xargs -n1 | + sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' | + tr '\n' ' ' + )" '"$@"' + +exec "$JAVACMD" "$@" diff --git a/examples/external-stage-auto/gradlew.bat b/examples/external-stage-auto/gradlew.bat new file mode 100644 index 0000000..f127cfd --- /dev/null +++ b/examples/external-stage-auto/gradlew.bat @@ -0,0 +1,91 @@ +@rem +@rem Copyright 2015 the original author or authors. +@rem +@rem Licensed under the Apache License, Version 2.0 (the "License"); +@rem you may not use this file except in compliance with the License. +@rem You may obtain a copy of the License at +@rem +@rem https://www.apache.org/licenses/LICENSE-2.0 +@rem +@rem Unless required by applicable law or agreed to in writing, software +@rem distributed under the License is distributed on an "AS IS" BASIS, +@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +@rem See the License for the specific language governing permissions and +@rem limitations under the License. +@rem + +@if "%DEBUG%"=="" @echo off +@rem ########################################################################## +@rem +@rem Gradle startup script for Windows +@rem +@rem ########################################################################## + +@rem Set local scope for the variables with windows NT shell +if "%OS%"=="Windows_NT" setlocal + +set DIRNAME=%~dp0 +if "%DIRNAME%"=="" set DIRNAME=. +set APP_BASE_NAME=%~n0 +set APP_HOME=%DIRNAME% + +@rem Resolve any "." and ".." in APP_HOME to make it shorter. +for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi + +@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m" + +@rem Find java.exe +if defined JAVA_HOME goto findJavaFromJavaHome + +set JAVA_EXE=java.exe +%JAVA_EXE% -version >NUL 2>&1 +if %ERRORLEVEL% equ 0 goto execute + +echo. +echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. +echo. +echo Please set the JAVA_HOME variable in your environment to match the +echo location of your Java installation. + +goto fail + +:findJavaFromJavaHome +set JAVA_HOME=%JAVA_HOME:"=% +set JAVA_EXE=%JAVA_HOME%/bin/java.exe + +if exist "%JAVA_EXE%" goto execute + +echo. +echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% +echo. +echo Please set the JAVA_HOME variable in your environment to match the +echo location of your Java installation. + +goto fail + +:execute +@rem Setup the command line + +set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar + + +@rem Execute Gradle +"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %* + +:end +@rem End local scope for the variables with windows NT shell +if %ERRORLEVEL% equ 0 goto mainEnd + +:fail +rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of +rem the _cmd.exe /c_ return code! +set EXIT_CODE=%ERRORLEVEL% +if %EXIT_CODE% equ 0 set EXIT_CODE=1 +if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE% +exit /b %EXIT_CODE% + +:mainEnd +if "%OS%"=="Windows_NT" endlocal + +:omega diff --git a/examples/external-stage-auto/settings.gradle b/examples/external-stage-auto/settings.gradle new file mode 100644 index 0000000..5837403 --- /dev/null +++ b/examples/external-stage-auto/settings.gradle @@ -0,0 +1,12 @@ +pluginManagement { + repositories { + maven { + url "s3://nio-maven" + authentication { + awsIm(AwsImAuthentication) + } + } + gradlePluginPortal() + } +} +rootProject.name = 'external-stage-auto' diff --git a/examples/simple-jar/src/main/java/AddNumbers.java b/examples/external-stage-auto/src/main/java/Sample.java similarity index 54% rename from examples/simple-jar/src/main/java/AddNumbers.java rename to examples/external-stage-auto/src/main/java/Sample.java index 3991293..2c46136 100644 --- a/examples/simple-jar/src/main/java/AddNumbers.java +++ b/examples/external-stage-auto/src/main/java/Sample.java @@ -1,16 +1,10 @@ -import org.apache.logging.log4j.LogManager; -import org.apache.logging.log4j.Logger; - -public class AddNumbers { - - private static final Logger logger = LogManager.getLogger(); +public class Sample { public String addNum(int num1, int num2) { try { int sum = num1 + num2; return ("Sum is: " + sum); } catch (Exception e) { - logger.warn("Error: " + e.toString()); return null; } } diff --git a/examples/internal-stage/build.gradle b/examples/internal-stage/build.gradle index e6b9ebb..c965054 100644 --- a/examples/internal-stage/build.gradle +++ b/examples/internal-stage/build.gradle @@ -1,7 +1,7 @@ plugins { id 'java' id 'com.github.ben-manes.versions' version '0.42.0' - id 'io.noumenal.gradle.snowflake' version '0.1.11' + id 'io.noumenal.gradle.snowflake' version '0.1.12' } repositories { diff --git a/examples/internal-stage/src/main/java/Sample.java b/examples/internal-stage/src/main/java/Sample.java index 3c7dd0f..2c46136 100644 --- a/examples/internal-stage/src/main/java/Sample.java +++ b/examples/internal-stage/src/main/java/Sample.java @@ -1,16 +1,10 @@ -// import org.apache.logging.log4j.LogManager; -// import org.apache.logging.log4j.Logger; - public class Sample { - //private static final Logger logger = LogManager.getLogger(); - public String addNum(int num1, int num2) { try { int sum = num1 + num2; return ("Sum is: " + sum); } catch (Exception e) { - //logger.warn("Error: " + e.toString()); return null; } } diff --git a/examples/simple-jar/build.gradle b/examples/simple-jar/build.gradle index 59349ad..d737aa7 100644 --- a/examples/simple-jar/build.gradle +++ b/examples/simple-jar/build.gradle @@ -19,4 +19,6 @@ java { } } -version='0.1.0' \ No newline at end of file +version='0.1.0' + +build.dependsOn shadowJar \ No newline at end of file diff --git a/examples/simple-jar/src/main/java/Sample.java b/examples/simple-jar/src/main/java/Sample.java new file mode 100644 index 0000000..5f14576 --- /dev/null +++ b/examples/simple-jar/src/main/java/Sample.java @@ -0,0 +1,15 @@ +public class Sample { + + public String addNum(int num1, int num2) { + try { + int sum = num1 + num2; + return ("Sum is: " + sum); + } catch (Exception e) { + return null; + } + } + + public static void main(String[] args) { + System.out.println("Hello World"); + } +} \ No newline at end of file diff --git a/plugin/src/main/groovy/io/noumenal/SnowflakePlugin.groovy b/plugin/src/main/groovy/io/noumenal/SnowflakePlugin.groovy index e15fa3a..8021bae 100644 --- a/plugin/src/main/groovy/io/noumenal/SnowflakePlugin.groovy +++ b/plugin/src/main/groovy/io/noumenal/SnowflakePlugin.groovy @@ -31,11 +31,13 @@ class SnowflakePlugin implements Plugin { // add shadowJar to build project.tasks.build.dependsOn project.tasks.shadowJar - // create maven publishing - if (!extension.useCustomMaven && extension.publishUrl) { - + if (extension.useCustomMaven || extension.publishUrl) { // assert that we have artifact and group assert (extension.artifactId && extension.groupId) + } + + // create maven publishing + if (!extension.useCustomMaven && extension.publishUrl) { // apply the maven-publish plugin for the user project.apply plugin: 'maven-publish' diff --git a/plugin/src/main/groovy/io/noumenal/SnowflakePublish.groovy b/plugin/src/main/groovy/io/noumenal/SnowflakePublish.groovy index 04fe0d9..1c068f0 100644 --- a/plugin/src/main/groovy/io/noumenal/SnowflakePublish.groovy +++ b/plugin/src/main/groovy/io/noumenal/SnowflakePublish.groovy @@ -207,19 +207,18 @@ abstract class SnowflakePublish extends DefaultTask { //Session session = this.session String jar = project.tasks.shadowJar.archiveFile.get() - if (!extension.publishUrl) { + if (!extension.publishUrl && !extension.useCustomMaven) { def options = [ AUTO_COMPRESS: 'FALSE', PARALLEL : '4', - OVERWRITE: 'TRUE' + OVERWRITE : 'TRUE' ] PutResult[] pr = session.file().put(jar, "$stage/libs", options) pr.each { log.warn "File ${it.sourceFileName}: ${it.status}" } - } else { + } else if (extension.publishUrl) { // ensure that the stage and the publishUrl are aligned - //assert snowflake.assertStage(stage, schema, extension.publishUrl.toString()) Statement statement = session.jdbcConnection().createStatement() String sql = "select stage_url from information_schema.stages where stage_name=upper('$stage') and stage_schema=upper('$schema') and stage_type='External Named'" ResultSet rs = statement.executeQuery(sql)