remove docker build from this repo, link to new image; readme on validation

Author: tomzo

CHANGELOG.md

@@ -1,6 +1,7 @@
 ### 0.3.8 - Unreleased
 
  * switch build system to use open source openjdk-dojo image \#17574
+ * remove docker image from this repo, use [new image](https://github.com/gocd-contrib/docker-gocd-cli-dojo) with gocd-cli
 
 ### 0.3.7 (2019-Feb-12)
 

README.md

@@ -71,77 +71,32 @@ This server version also supports `format_version` of `2`. Using a newer `format
 Supports `format_version` value of `2`. In this version [pipeline locking](#pipeline-locking) behavior was changed.
 
 
-# Syntax checking
+# Validation
 
-Since `0.3.2` plugin is an executable and supports basic syntax checking.
+There is an ongoing effort to allow in-depth validation of configuration **before pushing configuration to the source control**. This is provided by [GoCD's preflight API](https://api.gocd.org/current/#preflight-check-of-config-repo-configurations) and [gocd-cli][https://github.com/gocd-contrib/gocd-cli](https://github.com/gocd-contrib/gocd-cli).
 
-## Usage with java installed
+You have several options to configure validation tools on your workstation:
+ * If you have a local docker daemon, use the [gocd-cli-dojo](https://github.com/gocd-contrib/docker-gocd-cli-dojo) image. Follow the [setup instructions](https://github.com/gocd-contrib/docker-gocd-cli-dojo#setup) in the image readme.
+ * If you don't want to use docker, you'll need to [setup `gocd-cli` on your host](https://github.com/gocd-contrib/gocd-cli).
 
-You need to download the `jar` from releases page and place it somewhere convenient.
-For example `/usr/lib/gocd-json-plugin/json-config-plugin.jar`.
-Then to validate your `gopipeline.json` file run something like:
-```
-java -jar /usr/lib/gocd-json-plugin/json-config-plugin.jar syntax mypipe.gopipeline.json
-```
-
-## Usage with `gocd` command-line helper
-
-This is a product in development, so its command syntax is not stable and there are no distributed binaries yet.
-
-The `gocd` tool is built in [golang](https://golang.org/) so you will need to familiarize yourself with how to set up your [go workspace](https://golang.org/doc/code.html#Workspaces).
-
-Build the `gocd` binary:
+Either way you'll have `gocd` binary in your `PATH` or inside the docker container.
 
-```bash
-go get github.com/gocd-contrib/gocd-cli
-cd ${GOPATH:-~/go}/src/github.com/gocd-contrib/gocd-cli
-./build.sh
-```
-
-Follow the steps on [https://github.com/gocd-contrib/gocd-cli](https://github.com/gocd-contrib/gocd-cli) to install the plugin jar to the correct place.
-
-Then:
+## Syntax validation
 
+This will check general validity of the yaml file, without talking to the GoCD server:
 ```bash
-./gocd configrepo syntax -i json.config.plugin /path/to/your-pipeline.gopipeline.json
-```
-
-## Usage with IDE and docker
-
-[IDE](https://github.com/ai-traders/ide) is a bash script, a cli wrapper around docker to help with running development tasks in docker.
-You can install the `ide` script so that it is available on the PATH with:
-```
-sudo bash -c "`curl -L https://raw.githubusercontent.com/ai-traders/ide/master/install.sh`"
-```
-
-Add `Idefile` in your project with following content
-```
-IDE_DOCKER_IMAGE=tomzo/gocd-json-ide:<plugin-version>
-```
-
-To validate files run:
-```
-ide gocd-json syntax mypipe.gopipeline.json
+gocd configrepo --json syntax ci.gopipeline.json
 ```
 
-Personally, I recommend the following project structure:
-
- * `gocd/` directory for all your GoCD configuration files.
- * `gocd/Idefile` file pointing which docker image can be used to validate configuration.
+## Preflight validation
 
-Then when working with gocd pipelines config, you can run from the root of your project
+This command will parse and submit your json file to the configured GoCD server.
 ```
-cd gocd
-ide      # will open interactive shell
-watch gocd-json syntax mypipe.gopipeline.json
+gocd configrepo preflight --json -r gocd-json-config-example *.gopipeline.json
 ```
+Where `-r` is the configuration repository id, which you have earlier configured on GoCD server. You can check it on config repos page of your GoCD server, at `/go/admin/config_repos`. It in the upper left corner of each config repo.
+![config repo id](json_config_repo_id.png)
 
-## Usage with docker only
-
-```
-docker run -ti --rm --volume $(pwd):/ide/work tomzo/gocd-json-ide:<plugin-version> bash
-```
-Then you have an interactive shell as above.
 
 #### Implementation note
 

ci.gocd.yaml

@@ -1,3 +1,4 @@
+format_version: 3
 pipelines:
   "gocd-json-plugin":
     group: gocd
@@ -19,30 +20,6 @@ pipelines:
                command: dojo
                arguments:
                 - gradle test jar
-      - docker:
-          clean_workspace: true
-          resources:
-            - docker_builder
-          artifacts:
-            - build:
-                source: "docker/imagerc*"
-                destination:
-          tasks:
-            - fetch:
-                stage: build
-                job: build
-                source: build/libs
-                destination: docker
-            - exec:
-                command: /bin/bash
-                arguments:
-                  - ./tasks.sh
-                  - build_docker
-            - exec:
-                command: /bin/bash
-                arguments:
-                  - -c
-                  - "ops_docker_push=true ./tasks.sh build_docker"
       - release:
           approval: manual
           clean_workspace: true
@@ -62,23 +39,6 @@ pipelines:
                     arguments:
                       - ./tasks.sh
                       - github_release
-            dockerhub:
-              resources:
-                - docker_builder
-              secure_variables:
-                DOCKERHUB_PASSWORD: "AES:Q/TQoBrYjWDf43TbbUzSUQ==:2w9UDmYJPgEU2bmuzuehjw=="
-              tasks:
-                - fetch:
-                   stage: docker
-                   job: docker
-                   source: imagerc
-                   destination: docker/
-                   is_file: true
-                - exec:
-                    command: /bin/bash
-                    arguments:
-                      - -c
-                      - ./tasks.sh publish_docker_public
       - bump:
           clean_workspace: true
           jobs:

docker/Dockerfile

@@ -10,12 +10,6 @@ source .build/releaser
 
 releaser_init
 
-image_name_no_registry="gocd-json-ide"
-private_image_name="docker-registry.ai-traders.com/${image_name_no_registry}"
-public_image_name="tomzo/${image_name_no_registry}"
-image_dir="./docker"
-imagerc_filename="imagerc"
-
 function get_version_tag {
   changelog_first_line=$(cat ${changelog_file} | head -1)
   changelog_version=$(get_last_version_from_changelog "${changelog_file}")
@@ -50,55 +44,6 @@ case "${command}" in
     set_version_in_changelog "${changelog_file}" "${next_version}" "false"
     set_version_in_file "version " "build.gradle" "${next_version}"
     ;;
-  build_docker)
-    changelog_version=$(get_last_version_from_changelog "${changelog_file}")
-    docker_build_options="--build-arg this_image_tag_arg=${changelog_version}"
-    image_tag=$2
-    docker_build "${image_dir}" "${imagerc_filename}" "${private_image_name}" "$image_tag"
-    exit $?
-    ;;
-  test_docker)
-    source_imagerc "${image_dir}"  "${imagerc_filename}"
-    echo "Testing image: ${AIT_DOCKER_IMAGE_NAME}:${AIT_DOCKER_IMAGE_TAG}"
-    echo "IDE_DOCKER_IMAGE=\"${AIT_DOCKER_IMAGE_NAME}:${AIT_DOCKER_IMAGE_TAG}\"" > Idefile.to_be_tested
-    echo "IDE_WORK=$(pwd)/test/integration/test_ide_work" >> Idefile.to_be_tested
-    time bats "$(pwd)/test/integration/end_user/bats"
-    exit $?
-    ;;
-  publish_docker_private)
-    source_imagerc "${image_dir}"  "${imagerc_filename}"
-    production_image_tag=$(get_version_tag)
-    docker_push "${AIT_DOCKER_IMAGE_NAME}" "${AIT_DOCKER_IMAGE_TAG}" "${production_image_tag}"
-    exit $?
-    ;;
-  publish_docker_public)
-    source_imagerc "${image_dir}"  "${imagerc_filename}"
-    production_image_tag=$(get_version_tag)
-    docker login --username tomzo --password ${DOCKERHUB_PASSWORD}
-    testing_image_tag="${AIT_DOCKER_IMAGE_TAG}"
-
-    log_info "testing_image_tag set to: ${testing_image_tag}"
-    log_info "production_image_tag set to: ${production_image_tag}"
-    if ! docker images ${AIT_DOCKER_IMAGE_NAME} | awk '{print $2}' | grep ${testing_image_tag} 1>/dev/null ; then
-      # if docker image does not exist locally, then "docker tag" will fail,
-      # so pull it. However, do not always pull it, the image may be not pushed
-      # and only available locally.
-      set -x -e
-      docker pull "${AIT_DOCKER_IMAGE_NAME}:${testing_image_tag}"
-    fi
-    set -x -e
-    # When tagging a docker image using docker 1.8.3, we can use `docker tag -f`.
-    # When using docker 1.12, there is no `-f` option, but `docker tag`
-    # always works as if force was used.
-    docker tag -f "${AIT_DOCKER_IMAGE_NAME}:${testing_image_tag}" "${public_image_name}:${production_image_tag}" || docker tag "${AIT_DOCKER_IMAGE_NAME}:${testing_image_tag}" "${public_image_name}:${production_image_tag}"
-    docker tag -f "${AIT_DOCKER_IMAGE_NAME}:${testing_image_tag}" "${public_image_name}:latest" || docker tag "${AIT_DOCKER_IMAGE_NAME}:${testing_image_tag}" "${public_image_name}:latest"
-    if [[ "${dryrun}" != "true" ]];then
-      docker push "${public_image_name}:${production_image_tag}"
-      docker push "${public_image_name}:latest"
-    fi
-    set +x +e
-    exit $?
-    ;;
   github_release)
     if [ -z "$GITHUB_TOKEN" ]; then
         echo "GITHUB_TOKEN is unset";
@@ -124,7 +69,7 @@ case "${command}" in
       --repo gocd-json-config-plugin \
       --tag $VERSION \
       --name $VERSION \
-      --description "$changelog_version<br>docker image tomzo/gocd-json-ide:$VERSION" \
+      --description "$changelog_version<br>docker image kudulab/gocd-cli-dojo:json-$VERSION" \
       --pre-release
 
     $GHRELEASE_BIN upload \