From 0f5ab61ccfa07a08c46ac5d8685e2b36b4e5af92 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kriszti=C3=A1n=20G=C3=B6drei?= Date: Thu, 24 Jun 2021 13:06:04 +0200 Subject: [PATCH] Wait for daemon start if it is down When we get adb restart "error" we'd like to keep polling as it is a recoverable state. * Migrate to go modules and remove legacy code. * Implement new bitrise.yml structure. * Restructure e2e tests and add daemon_restart workflow. * Wire in stepconf package for Step Input handling. * Do not fail on adb daemon restart error. * Fix emulator params. * Fix device boot check loop. --- .gitignore | 2 +- CHANGELOG.md | 35 -- Godeps/Godeps.json | 38 -- Godeps/Readme | 5 - bitrise.yml | 86 +-- e2e/bitrise.yml | 106 ++++ go.mod | 9 + go.sum | 49 ++ gows.yml | 1 - main.go | 83 +-- release_config.yml | 13 - step.sh | 15 - step.yml | 6 - .../go-android/adbmanager/adbmanager.go | 2 +- .../bitrise-io/go-android/sdk/sdk.go | 176 ++++++ .../go-steputils/stepconf/stepconf.go | 572 ++++++++++++++++++ .../bitrise-io/go-utils/command/command.go | 36 +- .../bitrise-io/go-utils/command/file.go | 22 +- .../go-utils/errorutil/errorutil.go | 36 -- .../bitrise-io/go-utils/log/defaultlogger.go | 57 ++ .../bitrise-io/go-utils/log/dummylogger.go | 30 + .../go-utils/log/internal_logger.go | 76 +++ .../bitrise-io/go-utils/log/json_logger.go | 4 +- .../github.com/bitrise-io/go-utils/log/log.go | 88 +-- .../bitrise-io/go-utils/log/print.go | 115 ++++ .../bitrise-io/go-utils/log/raw_logger.go | 4 +- .../bitrise-io/go-utils/log/severity.go | 35 ++ .../go-utils/parseutil/parseutil.go | 95 +++ .../bitrise-io/go-utils/pathutil/glob.go | 13 + .../go-utils/pathutil/path_filter.go | 143 +++++ .../bitrise-io/go-utils/pathutil/pathutil.go | 120 +++- .../go-utils/pathutil/sortable_path.go | 88 +++ .../bitrise-io/go-utils/pointers/pointers.go | 98 +++ .../bitrise-tools/go-android/sdk/sdk.go | 39 -- .../hashicorp/go-version/CHANGELOG.md | 25 + .../github.com/hashicorp/go-version/LICENSE | 354 +++++++++++ .../github.com/hashicorp/go-version/README.md | 66 ++ .../hashicorp/go-version/constraint.go | 204 +++++++ vendor/github.com/hashicorp/go-version/go.mod | 1 + .../hashicorp/go-version/version.go | 392 ++++++++++++ .../go-version/version_collection.go | 17 + vendor/modules.txt | 17 + 42 files changed, 2950 insertions(+), 423 deletions(-) delete mode 100644 CHANGELOG.md delete mode 100644 Godeps/Godeps.json delete mode 100644 Godeps/Readme create mode 100644 e2e/bitrise.yml create mode 100644 go.mod create mode 100644 go.sum delete mode 100644 gows.yml delete mode 100644 release_config.yml delete mode 100755 step.sh rename vendor/github.com/{bitrise-tools => bitrise-io}/go-android/adbmanager/adbmanager.go (97%) create mode 100644 vendor/github.com/bitrise-io/go-android/sdk/sdk.go create mode 100644 vendor/github.com/bitrise-io/go-steputils/stepconf/stepconf.go delete mode 100644 vendor/github.com/bitrise-io/go-utils/errorutil/errorutil.go create mode 100644 vendor/github.com/bitrise-io/go-utils/log/defaultlogger.go create mode 100644 vendor/github.com/bitrise-io/go-utils/log/dummylogger.go create mode 100644 vendor/github.com/bitrise-io/go-utils/log/internal_logger.go create mode 100644 vendor/github.com/bitrise-io/go-utils/log/print.go create mode 100644 vendor/github.com/bitrise-io/go-utils/log/severity.go create mode 100644 vendor/github.com/bitrise-io/go-utils/parseutil/parseutil.go create mode 100644 vendor/github.com/bitrise-io/go-utils/pathutil/glob.go create mode 100644 vendor/github.com/bitrise-io/go-utils/pathutil/path_filter.go create mode 100644 vendor/github.com/bitrise-io/go-utils/pathutil/sortable_path.go create mode 100644 vendor/github.com/bitrise-io/go-utils/pointers/pointers.go delete mode 100644 vendor/github.com/bitrise-tools/go-android/sdk/sdk.go create mode 100644 vendor/github.com/hashicorp/go-version/CHANGELOG.md create mode 100644 vendor/github.com/hashicorp/go-version/LICENSE create mode 100644 vendor/github.com/hashicorp/go-version/README.md create mode 100644 vendor/github.com/hashicorp/go-version/constraint.go create mode 100644 vendor/github.com/hashicorp/go-version/go.mod create mode 100644 vendor/github.com/hashicorp/go-version/version.go create mode 100644 vendor/github.com/hashicorp/go-version/version_collection.go create mode 100644 vendor/modules.txt diff --git a/.gitignore b/.gitignore index f30a430..c8a1139 100755 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,3 @@ .bitrise* .gows* -_tmp \ No newline at end of file +_tmp diff --git a/CHANGELOG.md b/CHANGELOG.md deleted file mode 100644 index 68c2b39..0000000 --- a/CHANGELOG.md +++ /dev/null @@ -1,35 +0,0 @@ -## Changelog (Current version: 1.0.4) - ------------------ - -### 1.0.4 (2018 Feb 01) - -* [52097ff] Prepare for 1.0.4 -* [eb9cc20] updated command calls (#9) - -### 1.0.3 (2017 Dec 22) - -* [843034a] Prepare for 1.0.3 -* [80ec5d2] updated adb calls with timeout (#7) - -### 1.0.2 (2017 May 08) - -* [a9e29f7] Prepare for 1.0.2 -* [81bf532] Fix for timeout being prolonged (#6) - -### 1.0.1 (2017 Mar 28) - -* [df2172c] Prepare for 1.0.1 -* [9b18f00] godeps-update (#5) - -### 1.0.0 (2017 Mar 22) - -* [d272056] prepare for 1.0.0 -* [c7cd2fb] bitrise.yml updates -* [d166fb0] go-android packages (#4) -* [32f138c] Merge pull request #3 from bitrise-steplib/develop -* [4501379] Fix CI test - ------------------ - -Updated: 2018 Feb 01 \ No newline at end of file diff --git a/Godeps/Godeps.json b/Godeps/Godeps.json deleted file mode 100644 index 7c62195..0000000 --- a/Godeps/Godeps.json +++ /dev/null @@ -1,38 +0,0 @@ -{ - "ImportPath": "github.com/bitrise-steplib/steps-wait-for-android-emulator", - "GoVersion": "go1.7", - "GodepVersion": "v79", - "Packages": [ - "./..." - ], - "Deps": [ - { - "ImportPath": "github.com/bitrise-io/go-utils/colorstring", - "Rev": "5863e947430502abe15cb53a93e955259728ff66" - }, - { - "ImportPath": "github.com/bitrise-io/go-utils/command", - "Rev": "5863e947430502abe15cb53a93e955259728ff66" - }, - { - "ImportPath": "github.com/bitrise-io/go-utils/errorutil", - "Rev": "5863e947430502abe15cb53a93e955259728ff66" - }, - { - "ImportPath": "github.com/bitrise-io/go-utils/log", - "Rev": "5863e947430502abe15cb53a93e955259728ff66" - }, - { - "ImportPath": "github.com/bitrise-io/go-utils/pathutil", - "Rev": "5863e947430502abe15cb53a93e955259728ff66" - }, - { - "ImportPath": "github.com/bitrise-tools/go-android/adbmanager", - "Rev": "e5ba0b957d033f5e03bdaac0787baa1d476527c4" - }, - { - "ImportPath": "github.com/bitrise-tools/go-android/sdk", - "Rev": "e5ba0b957d033f5e03bdaac0787baa1d476527c4" - } - ] -} diff --git a/Godeps/Readme b/Godeps/Readme deleted file mode 100644 index 4cdaa53..0000000 --- a/Godeps/Readme +++ /dev/null @@ -1,5 +0,0 @@ -This directory tree is generated automatically by godep. - -Please do not edit. - -See https://github.com/tools/godep for more information. diff --git a/bitrise.yml b/bitrise.yml index 1003815..605d9ca 100755 --- a/bitrise.yml +++ b/bitrise.yml @@ -1,86 +1,30 @@ -format_version: 9 +format_version: "11" default_step_lib_source: https://github.com/bitrise-io/bitrise-steplib.git workflows: - test: - before_run: - - audit-this-step + sample: steps: - - go-list: - - golint: - - errcheck: - - go-test: - - change-workdir: - inputs: - - path: _tmp - avd-manager: + title: Start Android Emulator - path::./: - title: Wait for the emulator to boot + title: Wait for the Emulator boot is_always_run: false - script: title: Stop Android Emulator inputs: - content: pkill -f qemu-system-i386 - - script: - title: Create hanging adb - inputs: - - content: |- - #!/usr/bin/env bash - set -e - mkdir -p platform-tools - cat /dev/null > adb_log - cat /dev/null > platform-tools/adb - cat >> platform-tools/adb <<'EOF' - #!/usr/bin/env bash - echo "$@" >> adb_log - [[ "$1" == "kill-server" ]] && exit 0 - sleep 120 - EOF - chmod +x platform-tools/adb - - path::./: - title: Should fail with timeout - Wait for the emulator to boot - is_always_run: false - is_skippable: true - inputs: - - boot_timeout: 60 - - android_home: ./ - - script: - title: check if commands are called - is_always_run: false - is_skippable: false - inputs: - - content: |- - #!/usr/bin/env bash - set -ex - [[ $(grep -c "kill-server" ./adb_log) == "3" ]] && - [[ $(grep -c -- '-s emulator-5554 shell getprop dev.bootcomplete' ./adb_log) == "3" ]] || - exit 1 - - # ---------------------------------------------------------------- - # --- Utility workflows - dep-update: - title: Dep update - description: | - Used for updating bitrise dependencies with dep + check: steps: - - script: - title: Dependency update - inputs: - - content: |- - #!/bin/bash - set -ex - go get -u -v github.com/golang/dep/cmd/dep - dep ensure -v - dep ensure -v -update + - git::https://github.com/bitrise-steplib/steps-check.git: - # ---------------------------------------------------------------- - # --- workflows to Share this step into a Step Library - audit-this-step: + e2e: steps: - - script: - inputs: - - content: |- - #!/usr/bin/env bash - set -ex - stepman audit --step-yml ./step.yml + - git::https://github.com/bitrise-steplib/steps-check.git: + inputs: + - workflow: e2e + + test: + before_run: + - check + - e2e diff --git a/e2e/bitrise.yml b/e2e/bitrise.yml new file mode 100644 index 0000000..43d24c8 --- /dev/null +++ b/e2e/bitrise.yml @@ -0,0 +1,106 @@ +format_version: "11" +default_step_lib_source: https://github.com/bitrise-io/bitrise-steplib.git + +workflows: + test_smoke: + before_run: + - _start_emulator + steps: + - path::./: + title: Wait for the Emulator boot + is_always_run: false + after_run: + - _stop_emulators + + test_hanging_adb: + steps: + - script: + title: Start a failing workflow, wrapped in a script + inputs: + - content: |- + #!/bin/env bash + set -x # Do not set -e as bitrise command is excepted to fail + bitrise run -c ./e2e/bitrise.yml utility_test_hanging_adb + if [ $? -ne 1 ] ; then + echo "Workflow was excepted to fail, but exit code is not 1" + exit 1 + fi + + utility_test_hanging_adb: + before_run: + - _start_emulator + steps: + - change-workdir: + title: Chnage workdir to ./_tmp + inputs: + - path: _tmp + - script: + title: Create hanging adb + inputs: + - content: |- + #!/usr/bin/env bash + set -e + mkdir -p platform-tools + cat /dev/null > adb_log + cat /dev/null > platform-tools/adb + cat >> platform-tools/adb <<'EOF' + #!/usr/bin/env bash + + echo "$@" >> adb_log + [[ "$1" == "kill-server" ]] && exit 0 + sleep 120 + EOF + chmod +x platform-tools/adb + - path::./: + title: Wait for the emulator to boot - should fail with timeout + is_always_run: false + is_skippable: false + inputs: + - boot_timeout: 60 + - android_home: ./ + - script: + title: check if commands are called + is_always_run: false + is_skippable: false + inputs: + - content: |- + #!/usr/bin/env bash + set -ex + [[ $(grep -c "kill-server" ./adb_log) == "3" ]] && + [[ $(grep -c -- '-s emulator-5554 shell getprop dev.bootcomplete' ./adb_log) == "3" ]] || + exit 1 + after_run: + - _stop_emulators + + test_daemon_restart: + before_run: + - _start_emulator + steps: + - script: + title: Stop Gradle daemon + inputs: + - content: |- + #!/bin/env bash + set -ex + $ANDROID_HOME/platform-tools/adb kill-server + - path::./: + title: Wait for the Emulator boot + after_run: + - _stop_emulators + + _stop_emulators: + steps: + - script: + inputs: + - content: |- + #!/bin/env bash + adb devices | grep emulator | cut -f1 | while read line; do adb -s $line emu kill; done + + _start_emulator: + steps: + - avd-manager: + title: Start Android Emulator + inputs: + - tag: default + - abi: x86_64 + - api_level: 29 diff --git a/go.mod b/go.mod new file mode 100644 index 0000000..8784c42 --- /dev/null +++ b/go.mod @@ -0,0 +1,9 @@ +module github.com/bitrise-steplib/steps-wait-for-android-emulator + +go 1.16 + +require ( + github.com/bitrise-io/go-android v0.0.0-20210527143215-3ad22ad02e2e + github.com/bitrise-io/go-steputils v0.0.0-20210527075147-910ce7a105a1 + github.com/bitrise-io/go-utils v0.0.0-20210520073355-367fa34178f5 +) diff --git a/go.sum b/go.sum new file mode 100644 index 0000000..80ececf --- /dev/null +++ b/go.sum @@ -0,0 +1,49 @@ +github.com/bitrise-io/go-android v0.0.0-20210527143215-3ad22ad02e2e h1:lkJnz+yXbIqFGpDTdRBBshqxeX0UCndJmEOp0yy2GRQ= +github.com/bitrise-io/go-android v0.0.0-20210527143215-3ad22ad02e2e/go.mod h1:gGXmY8hJ1x44AC98TIvZZvxP7o+hs4VI6wgmO4JMfEg= +github.com/bitrise-io/go-steputils v0.0.0-20210514150206-5b6261447e77/go.mod h1:H0iZjgsAR5NA6pnlD/zKB6AbxEsskq55pwJ9klVmP8w= +github.com/bitrise-io/go-steputils v0.0.0-20210527075147-910ce7a105a1 h1:gi29hTdxGXAGQvZckPZ9V8BAEfP3eK/tiZgTC5s6h1c= +github.com/bitrise-io/go-steputils v0.0.0-20210527075147-910ce7a105a1/go.mod h1:H0iZjgsAR5NA6pnlD/zKB6AbxEsskq55pwJ9klVmP8w= +github.com/bitrise-io/go-utils v0.0.0-20210507100250-37de47dfa6ce/go.mod h1:15EZZf02noI5nWFqXMZEoyb1CyqYRXTMz5Fyu4CWFzI= +github.com/bitrise-io/go-utils v0.0.0-20210520073355-367fa34178f5 h1:kclxBfygfNK6kWUB+9xcsfPLBen8Us9gubhitfL/Z6c= +github.com/bitrise-io/go-utils v0.0.0-20210520073355-367fa34178f5/go.mod h1:DRx7oFuAqk0dbKpAKCqWl0TgrowfJUb/MqYPRscxJOQ= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/hashicorp/go-cleanhttp v0.5.1/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtngrth3wmdIIUrZ80= +github.com/hashicorp/go-hclog v0.9.2/go.mod h1:5CU+agLiy3J7N7QjHK5d05KxGsuXiQLrjA0H7acj2lQ= +github.com/hashicorp/go-retryablehttp v0.6.6/go.mod h1:vAew36LZh98gCBJNLH42IQ1ER/9wtLZZ8meHqQvEYWY= +github.com/hashicorp/go-version v1.3.0 h1:McDWVJIU/y+u1BRV06dPaLfLCaT7fUTJLp5r04x7iNw= +github.com/hashicorp/go-version v1.3.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/ryanuber/go-glob v1.0.0/go.mod h1:807d1WSdnB0XRJzKNil9Om6lcp/3a0v4qIHxIXzX/Yc= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/objx v0.3.0/go.mod h1:qt09Ya8vawLte6SNmTgCsAVtYtaKzEcn8ATUoHMkEqE= +github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= +github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= +github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA= +github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY= +github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/crypto v0.0.0-20200220183623-bac4c82f6975/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= +golang.org/x/crypto v0.0.0-20210513164829-c07d793c2f9a/go.mod h1:P+XmwS30IXTQdn5tA2iutPOUgjI07+tq3H3K9MVA1s8= +golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200219091948-cb0a6d8edb6c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210511113859-b0526f3d8744/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= +golang.org/x/term v0.0.0-20210503060354-a79de5458b56/go.mod h1:tfny5GFUkzUvx4ps4ajbZsCe5lw1metzhBm9T3x7oIY= +golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY= +gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b h1:h8qDotaEPuJATrMmW04NCwg7v22aHH28wwpauUhK9Oo= +gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/gows.yml b/gows.yml deleted file mode 100644 index 814313e..0000000 --- a/gows.yml +++ /dev/null @@ -1 +0,0 @@ -package_name: github.com/bitrise-steplib/steps-wait-for-android-emulator diff --git a/main.go b/main.go index 20bbfec..ea23828 100644 --- a/main.go +++ b/main.go @@ -11,52 +11,19 @@ import ( "strings" "time" + "github.com/bitrise-io/go-android/adbmanager" + "github.com/bitrise-io/go-android/sdk" + "github.com/bitrise-io/go-steputils/stepconf" "github.com/bitrise-io/go-utils/log" - "github.com/bitrise-tools/go-android/adbmanager" - "github.com/bitrise-tools/go-android/sdk" ) var errTimedOut = errors.New("running command timed out") -// ConfigsModel ... -type ConfigsModel struct { - EmulatorSerial string - BootTimeout string - AndroidHome string -} - -// ----------------------- -// --- Functions -// ----------------------- - -func createConfigsModelFromEnvs() ConfigsModel { - return ConfigsModel{ - EmulatorSerial: os.Getenv("emulator_serial"), - BootTimeout: os.Getenv("boot_timeout"), - AndroidHome: os.Getenv("android_home"), - } -} - -func (configs ConfigsModel) validate() error { - if configs.EmulatorSerial == "" { - return errors.New("no EmulatorSerial parameter specified") - } - if configs.AndroidHome == "" { - return errors.New("no AndroidHome parameter specified") - } - if configs.BootTimeout == "" { - return errors.New("no BootTimeout parameter specified") - } - - return nil -} - -func (configs ConfigsModel) print() { - log.Infof("Configs:") - - log.Printf("- emulatorSerial: %s", configs.EmulatorSerial) - log.Printf("- bootTimeout: %s", configs.BootTimeout) - log.Printf("- AndroidHome: %s", configs.AndroidHome) +// Inputs ... +type Inputs struct { + EmulatorSerial string `env:"emulator_serial,required"` + BootTimeout string `env:"boot_timeout,required"` + AndroidHome string `env:"android_home,dir"` } func failf(format string, v ...interface{}) { @@ -117,24 +84,18 @@ func isDeviceBooted(androidHome, serial string) (bool, error) { return (dev == "1" && sys == "1" && init == "stopped"), nil } -// ----------------------- -// --- Main -// ----------------------- - func main() { - config := createConfigsModelFromEnvs() - - fmt.Println() - config.print() - - if err := config.validate(); err != nil { - failf("Issue with input: %s", err) + var inputs Inputs + if err := stepconf.Parse(&inputs); err != nil { + failf("Issue with inputs: %s", err) } + stepconf.Print(inputs) + fmt.Println() log.Infof("Waiting for emulator boot") - sdk, err := sdk.New(config.AndroidHome) + sdk, err := sdk.New(inputs.AndroidHome) if err != nil { failf("Failed to create sdk, error: %s", err) } @@ -144,7 +105,7 @@ func main() { failf("Failed to create adb model, error: %s", err) } - timeout, err := strconv.ParseInt(config.BootTimeout, 10, 64) + timeout, err := strconv.ParseInt(inputs.BootTimeout, 10, 64) if err != nil { failf("Failed to parse BootTimeout parameter, error: %s", err) } @@ -154,12 +115,16 @@ func main() { for !emulatorBootDone { log.Printf("> Checking if device booted...") - if emulatorBootDone, err = isDeviceBooted(config.AndroidHome, config.EmulatorSerial); err != nil { - if err != errTimedOut { + if emulatorBootDone, err = isDeviceBooted(inputs.AndroidHome, inputs.EmulatorSerial); err != nil { + if strings.Contains(err.Error(), "daemon not running; starting now at") { + log.Warnf("adb daemon being restarted") + log.Printf(err.Error()) + } else if err != errTimedOut { failf("Failed to check emulator boot status, error: %s", err) } + log.Warnf("Running command timed out, retry...") - if err := killADBDaemon(config.AndroidHome); err != nil { + if err := killADBDaemon(inputs.AndroidHome); err != nil { if err != errTimedOut { failf("unable to kill ADB daemon, error: %s", err) } @@ -169,14 +134,14 @@ func main() { break } - if time.Now().Sub(startTime) >= time.Duration(timeout)*time.Second { + if time.Since(startTime) >= time.Duration(timeout)*time.Second { failf("Waiting for emulator boot timed out after %d seconds", timeout) } time.Sleep(5 * time.Second) } - if err := adb.UnlockDevice(config.EmulatorSerial); err != nil { + if err := adb.UnlockDevice(inputs.EmulatorSerial); err != nil { failf("UnlockDevice command failed, error: %s", err) } diff --git a/release_config.yml b/release_config.yml deleted file mode 100644 index 4a1f737..0000000 --- a/release_config.yml +++ /dev/null @@ -1,13 +0,0 @@ -release: - development_branch: master - release_branch: master -changelog: - path: CHANGELOG.md - content_template: |- - {{range .ContentItems}}### {{.EndTaggedCommit.Tag}} ({{.EndTaggedCommit.Date.Format "2006 Jan 02"}}) - - {{range .Commits}}* [{{firstChars .Hash 7}}] {{.Message}} - {{end}} - {{end}} - header_template: '## Changelog (Current version: {{.Version}})' - footer_template: 'Updated: {{.CurrentDate.Format "2006 Jan 02"}}' diff --git a/step.sh b/step.sh deleted file mode 100755 index 06ac93d..0000000 --- a/step.sh +++ /dev/null @@ -1,15 +0,0 @@ -#!/bin/bash -set -ex -THIS_SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )" - -tmp_gopath_dir="$(mktemp -d)" - -go_package_name="github.com/bitrise-steplib/steps-wait-for-android-emulator" -full_package_path="${tmp_gopath_dir}/src/${go_package_name}" -mkdir -p "${full_package_path}" - -rsync -avh --quiet "${THIS_SCRIPT_DIR}/" "${full_package_path}/" - -export GOPATH="${tmp_gopath_dir}" -export GO15VENDOREXPERIMENT=1 -go run "${full_package_path}/main.go" \ No newline at end of file diff --git a/step.yml b/step.yml index d1ee3f1..d28e5d6 100755 --- a/step.yml +++ b/step.yml @@ -17,12 +17,6 @@ is_skippable: false toolkit: go: package_name: github.com/bitrise-steplib/steps-wait-for-android-emulator -deps: - brew: - - name: go - apt_get: - - name: golang - bin_name: go inputs: - emulator_serial: $BITRISE_EMULATOR_SERIAL opts: diff --git a/vendor/github.com/bitrise-tools/go-android/adbmanager/adbmanager.go b/vendor/github.com/bitrise-io/go-android/adbmanager/adbmanager.go similarity index 97% rename from vendor/github.com/bitrise-tools/go-android/adbmanager/adbmanager.go rename to vendor/github.com/bitrise-io/go-android/adbmanager/adbmanager.go index fe68858..8a6187c 100644 --- a/vendor/github.com/bitrise-tools/go-android/adbmanager/adbmanager.go +++ b/vendor/github.com/bitrise-io/go-android/adbmanager/adbmanager.go @@ -6,7 +6,7 @@ import ( "github.com/bitrise-io/go-utils/command" "github.com/bitrise-io/go-utils/pathutil" - "github.com/bitrise-tools/go-android/sdk" + "github.com/bitrise-io/go-android/sdk" ) // Model ... diff --git a/vendor/github.com/bitrise-io/go-android/sdk/sdk.go b/vendor/github.com/bitrise-io/go-android/sdk/sdk.go new file mode 100644 index 0000000..5698b88 --- /dev/null +++ b/vendor/github.com/bitrise-io/go-android/sdk/sdk.go @@ -0,0 +1,176 @@ +package sdk + +import ( + "errors" + "fmt" + "os" + "path/filepath" + "strings" + + "github.com/bitrise-io/go-utils/pathutil" + "github.com/hashicorp/go-version" +) + +// Model ... +type Model struct { + androidHome string +} + +// Environment is used to pass in environment variables used to locate Android SDK +type Environment struct { + AndroidHome string // ANDROID_HOME + AndroidSDKRoot string // ANDROID_SDK_ROOT +} + +// NewEnvironment gets needed environment variables +func NewEnvironment() *Environment { + return &Environment{ + AndroidHome: os.Getenv("ANDROID_HOME"), + AndroidSDKRoot: os.Getenv("ANDROID_SDK_ROOT"), + } +} + +// AndroidSdkInterface ... +type AndroidSdkInterface interface { + GetAndroidHome() string + CmdlineToolsPath() (string, error) +} + +// New creates a Model with a supplied Android SDK path +func New(androidHome string) (*Model, error) { + evaluatedSDKRoot, err := validateAndroidSDKRoot(androidHome) + if err != nil { + return nil, err + } + + return &Model{androidHome: evaluatedSDKRoot}, nil +} + +// NewDefaultModel locates Android SDK based on environement variables +func NewDefaultModel(envs Environment) (*Model, error) { + // https://developer.android.com/studio/command-line/variables#envar + // Sets the path to the SDK installation directory. + // ANDROID_HOME, which also points to the SDK installation directory, is deprecated. + // If you continue to use it, the following rules apply: + // If ANDROID_HOME is defined and contains a valid SDK installation, its value is used instead of the value in ANDROID_SDK_ROOT. + // If ANDROID_HOME is not defined, the value in ANDROID_SDK_ROOT is used. + var warnings []string + for _, SDKdir := range []string{envs.AndroidHome, envs.AndroidSDKRoot} { + if SDKdir == "" { + warnings = append(warnings, "environment variable is unset or empty") + continue + } + + evaluatedSDKRoot, err := validateAndroidSDKRoot(SDKdir) + if err != nil { + warnings = append(warnings, err.Error()) + continue + } + + return &Model{androidHome: evaluatedSDKRoot}, nil + } + + return nil, fmt.Errorf("could not locate Android SDK root directory: %s", warnings) +} + +func validateAndroidSDKRoot(androidSDKRoot string) (string, error) { + evaluatedSDKRoot, err := filepath.EvalSymlinks(androidSDKRoot) + if err != nil { + return "", err + } + + if exist, err := pathutil.IsDirExists(evaluatedSDKRoot); err != nil { + return "", err + } else if !exist { + return "", fmt.Errorf("(%s) is not a valid Android SDK root", evaluatedSDKRoot) + } + + return evaluatedSDKRoot, nil +} + +// GetAndroidHome ... +func (model *Model) GetAndroidHome() string { + return model.androidHome +} + +// LatestBuildToolsDir ... +func (model *Model) LatestBuildToolsDir() (string, error) { + buildTools := filepath.Join(model.androidHome, "build-tools") + pattern := filepath.Join(buildTools, "*") + + buildToolsDirs, err := filepath.Glob(pattern) + if err != nil { + return "", err + } + + var latestVersion *version.Version + for _, buildToolsDir := range buildToolsDirs { + versionStr := strings.TrimPrefix(buildToolsDir, buildTools+"/") + version, err := version.NewVersion(versionStr) + if err != nil { + continue + } + + if latestVersion == nil || version.GreaterThan(latestVersion) { + latestVersion = version + } + } + + if latestVersion == nil || latestVersion.String() == "" { + return "", errors.New("failed to find latest build-tools dir") + } + + return filepath.Join(buildTools, latestVersion.String()), nil +} + +// LatestBuildToolPath ... +func (model *Model) LatestBuildToolPath(name string) (string, error) { + buildToolsDir, err := model.LatestBuildToolsDir() + if err != nil { + return "", err + } + + pth := filepath.Join(buildToolsDir, name) + if exist, err := pathutil.IsPathExists(pth); err != nil { + return "", err + } else if !exist { + return "", fmt.Errorf("tool (%s) not found at: %s", name, buildToolsDir) + } + + return pth, nil +} + +// CmdlineToolsPath locates the command-line tools directory +func (model *Model) CmdlineToolsPath() (string, error) { + toolPaths := []string{ + filepath.Join(model.GetAndroidHome(), "cmdline-tools", "latest", "bin"), + filepath.Join(model.GetAndroidHome(), "cmdline-tools", "*", "bin"), + filepath.Join(model.GetAndroidHome(), "tools", "bin"), + filepath.Join(model.GetAndroidHome(), "tools"), // legacy + } + + var warnings []string + for _, dirPattern := range toolPaths { + matches, err := filepath.Glob(dirPattern) + if err != nil { + return "", fmt.Errorf("failed to locate Android command-line tools directory, invalid patterns specified (%s): %s", toolPaths, err) + } + + if len(matches) == 0 { + continue + } + + sdkmanagerPath := matches[0] + if exists, err := pathutil.IsDirExists(sdkmanagerPath); err != nil { + warnings = append(warnings, fmt.Sprintf("failed to validate path (%s): %v", sdkmanagerPath, err)) + continue + } else if !exists { + warnings = append(warnings, "path (%s) does not exist or it is not a directory") + continue + } + + return sdkmanagerPath, nil + } + + return "", fmt.Errorf("failed to locate Android command-line tools directory on paths (%s), warnings: %s", toolPaths, warnings) +} diff --git a/vendor/github.com/bitrise-io/go-steputils/stepconf/stepconf.go b/vendor/github.com/bitrise-io/go-steputils/stepconf/stepconf.go new file mode 100644 index 0000000..da06ab3 --- /dev/null +++ b/vendor/github.com/bitrise-io/go-steputils/stepconf/stepconf.go @@ -0,0 +1,572 @@ +package stepconf + +import ( + "errors" + "fmt" + "os" + "reflect" + "regexp" + "strconv" + "strings" + + "github.com/bitrise-io/go-utils/colorstring" + "github.com/bitrise-io/go-utils/parseutil" +) + +// ErrNotStructPtr indicates a type is not a pointer to a struct. +var ErrNotStructPtr = errors.New("must be a pointer to a struct") + +// ParseError occurs when a struct field cannot be set. +type ParseError struct { + Field string + Value string + Err error +} + +const rangeMinimumGroupName = "min" +const rangeMaximumGroupName = "max" +const rangeMinBracketGroupName = "minbr" +const rangeMaxBracketGroupName = "maxbr" +const rangeRegex = `range(?P<` + rangeMinBracketGroupName + `>\[|\])(?P<` + rangeMinimumGroupName + `>.*?)\.\.(?P<` + rangeMaximumGroupName + `>.*?)(?P<` + rangeMaxBracketGroupName + `>\[|\])` +const multilineConstraintName = "multiline" + +// Error implements builtin errors.Error. +func (e *ParseError) Error() string { + segments := []string{e.Field} + if e.Value != "" { + segments = append(segments, e.Value) + } + segments = append(segments, e.Err.Error()) + return strings.Join(segments, ": ") +} + +// Secret variables are not shown in the printed output. +type Secret string + +const secret = "*****" + +// String implements fmt.Stringer.String. +// When a Secret is printed, it's masking the underlying string with asterisks. +func (s Secret) String() string { + if s == "" { + return "" + } + return secret +} + +// Print the name of the struct with Title case in blue color with followed by a newline, +// then print all fields formatted as '- field name: field value` separated by newline. +func Print(config interface{}) { + fmt.Print(toString(config)) +} + +func valueString(v reflect.Value) string { + if v.Kind() != reflect.Ptr { + return fmt.Sprintf("%v", v.Interface()) + } + + if !v.IsNil() { + return fmt.Sprintf("%v", v.Elem().Interface()) + } + + return "" +} + +// returns the name of the struct with Title case in blue color followed by a newline, +// then print all fields formatted as '- field name: field value` separated by newline. +func toString(config interface{}) string { + v := reflect.ValueOf(config) + t := reflect.TypeOf(config) + + if v.Kind() == reflect.Ptr { + v = v.Elem() + } + + if t.Kind() == reflect.Ptr { + t = t.Elem() + } + + str := fmt.Sprint(colorstring.Bluef("%s:\n", strings.Title(t.Name()))) + for i := 0; i < t.NumField(); i++ { + str += fmt.Sprintf("- %s: %s\n", t.Field(i).Name, valueString(v.Field(i))) + } + + return str +} + +// parseTag splits a struct field's env tag into its name and option. +func parseTag(tag string) (string, string) { + if idx := strings.Index(tag, ","); idx != -1 { + return tag[:idx], tag[idx+1:] + } + return tag, "" +} + +// EnvProvider ... +type EnvProvider interface { + Getenv(key string) string +} + +// OSEnvProvider ... +type OSEnvProvider struct{} + +// NewOSEnvProvider ... +func NewOSEnvProvider() EnvProvider { + return OSEnvProvider{} +} + +// Getenv ... +func (p OSEnvProvider) Getenv(key string) string { + return os.Getenv(key) +} + +// EnvParser ... +type EnvParser struct { + envProvider EnvProvider +} + +// NewDefaultEnvParser ... +func NewDefaultEnvParser() EnvParser { + return NewEnvParser(NewOSEnvProvider()) +} + +// NewEnvParser ... +func NewEnvParser(envProvider EnvProvider) EnvParser { + return EnvParser{ + envProvider: envProvider, + } +} + +// Parse ... +func (p EnvParser) Parse(conf interface{}) error { + c := reflect.ValueOf(conf) + if c.Kind() != reflect.Ptr { + return ErrNotStructPtr + } + c = c.Elem() + if c.Kind() != reflect.Struct { + return ErrNotStructPtr + } + t := c.Type() + + var errs []*ParseError + for i := 0; i < c.NumField(); i++ { + tag, ok := t.Field(i).Tag.Lookup("env") + if !ok { + continue + } + key, constraint := parseTag(tag) + value := p.envProvider.Getenv(key) + + if err := setField(c.Field(i), value, constraint); err != nil { + errs = append(errs, &ParseError{t.Field(i).Name, value, err}) + } + } + if len(errs) > 0 { + errorString := "failed to parse config:" + for _, err := range errs { + errorString += fmt.Sprintf("\n- %s", err) + } + + errorString += fmt.Sprintf("\n\n%s", toString(conf)) + return errors.New(errorString) + } + + return nil +} + +var defaultEnvParser *EnvParser + +func getDefaultEnvParser() EnvParser { + if defaultEnvParser == nil { + parser := NewDefaultEnvParser() + defaultEnvParser = &parser + } + return *defaultEnvParser +} + +// Parse populates a struct with the retrieved values from environment variables +// described by struct tags and applies the defined validations. +func Parse(conf interface{}) error { + return getDefaultEnvParser().Parse(conf) +} + +func setField(field reflect.Value, value, constraint string) error { + if err := validateConstraint(value, constraint); err != nil { + return err + } + + if value == "" { + return nil + } + + if field.Kind() == reflect.Ptr { + // If field is a pointer type, then set its value to be a pointer to a new zero value, matching field underlying type. + var dePtrdType = field.Type().Elem() // get the type field can point to + var newPtrType = reflect.New(dePtrdType) // create new ptr address for type with non-nil zero value + field.Set(newPtrType) // assign value to pointer + field = field.Elem() + } + + switch field.Kind() { + case reflect.String: + field.SetString(value) + case reflect.Bool: + b, err := parseutil.ParseBool(value) + if err != nil { + return errors.New("can't convert to bool") + } + field.SetBool(b) + case reflect.Int: + n, err := strconv.ParseInt(value, 10, 32) + if err != nil { + return errors.New("can't convert to int") + } + field.SetInt(n) + case reflect.Float64: + value = strings.TrimSpace(value) + f, err := strconv.ParseFloat(value, 64) + if err != nil { + return errors.New("can't convert to float") + } + field.SetFloat(f) + case reflect.Slice: + if constraint == multilineConstraintName { + field.Set(reflect.ValueOf(strings.Split(value, "\n"))) + } else { + field.Set(reflect.ValueOf(strings.Split(value, "|"))) + } + default: + return fmt.Errorf("type is not supported (%s)", field.Kind()) + } + return nil +} + +func validateConstraint(value, constraint string) error { + switch constraint { + case "": + break + case "required": + if value == "" { + return errors.New("required variable is not present") + } + case "file", "dir": + if err := checkPath(value, constraint == "dir"); err != nil { + return err + } + // TODO: use FindStringSubmatch to distinguish no match and match for empty string. + case regexp.MustCompile(`^opt\[.*\]$`).FindString(constraint): + if !contains(value, constraint) { + // TODO: print only the value options, not the whole string. + return fmt.Errorf("value is not in value options (%s)", constraint) + } + case regexp.MustCompile(rangeRegex).FindString(constraint): + if err := ValidateRangeFields(value, constraint); err != nil { + return err + } + case multilineConstraintName: + break + default: + return fmt.Errorf("invalid constraint (%s)", constraint) + } + return nil +} + +//ValidateRangeFields validates if the given range is proper. Ranges are optional, empty values are valid. +func ValidateRangeFields(valueStr, constraint string) error { + if valueStr == "" { + return nil + } + constraintMin, constraintMax, constraintMinBr, constraintMaxBr, err := GetRangeValues(constraint) + if err != nil { + return err + } + min, err := parseValueStr(constraintMin) + if err != nil { + return fmt.Errorf("failed to parse min value %s: %s", constraintMin, err) + } + max, err := parseValueStr(constraintMax) + if err != nil { + return fmt.Errorf("failed to parse max value %s: %s", constraintMax, err) + } + value, err := parseValueStr(valueStr) + if err != nil { + return fmt.Errorf("failed to parse value %s: %s", valueStr, err) + } + isMinInclusiveBool, err := isMinInclusive(constraintMinBr) + if err != nil { + return err + } + isMaxInclusiveBool, err := isMaxInclusive(constraintMaxBr) + if err != nil { + return err + } + + if err := validateRangeFieldValues(min, max, isMinInclusiveBool, isMaxInclusiveBool, value); err != nil { + return err + } + if err := validateRangeFieldTypes(min, max, value); err != nil { + return err + } + + return nil +} + +func isMinInclusive(bracket string) (bool, error) { + switch bracket { + case "[": + return true, nil + case "]": + return false, nil + default: + return false, fmt.Errorf("invalid string found for bracket: %s", bracket) + } +} + +func isMaxInclusive(bracket string) (bool, error) { + switch bracket { + case "[": + return false, nil + case "]": + return true, nil + default: + return false, fmt.Errorf("invalid string found for bracket: %s", bracket) + } +} + +func validateRangeFieldValues(min interface{}, max interface{}, minInclusive bool, maxInclusive bool, value interface{}) error { + if value == nil { + return fmt.Errorf("value is not present") + } + var err error + var valueFloat float64 + if valueFloat, err = getFloatValue(value); err != nil { + return err + } + + var minErr error + var minFloat float64 + if min != nil { + if minFloat, err = getFloatValue(min); err != nil { + return err + } + minErr = validateRangeMinFieldValue(minFloat, valueFloat, minInclusive) + } + + var maxErr error + var maxFloat float64 + if max != nil { + var err error + if maxFloat, err = getFloatValue(max); err != nil { + return err + } + maxErr = validateRangeMaxFieldValue(maxFloat, valueFloat, maxInclusive) + } + + if min != nil && max != nil { + if minFloat > maxFloat { + return fmt.Errorf("constraint logic is wrong, minimum value %f is bigger than maximum %f", minFloat, maxFloat) + } + if minFloat == maxFloat { + return fmt.Errorf("minimum value %f is equal to maximum %f, for this case use optional value", minFloat, maxFloat) + } + } + + if min == nil { + return maxErr + } else if max == nil { + return minErr + } + if minErr != nil || maxErr != nil { + return fmt.Errorf("value %f is out of range %f-%f", value, minFloat, maxFloat) + } + return nil +} + +func validateRangeFieldTypes(min interface{}, max interface{}, value interface{}) error { + if value == nil { + return fmt.Errorf("value cannot be nil") + } + var minType string + var maxType string + var valueType string + var err error + + if valueType, err = getTypeOf(value); err != nil { + return err + } + if min != nil { + if minType, err = getTypeOf(min); err != nil { + return err + } + } + if max != nil { + if maxType, err = getTypeOf(max); err != nil { + return err + } + } + + if maxType != "" && minType != "" && !hasSameContent(minType, maxType, valueType) { + return fmt.Errorf("invalid constraint and value combination, minimum is %s, maximum is %s, value is %s, but they should be the same", minType, maxType, valueType) + } + + if maxType != "" && !hasSameContent(maxType, valueType) { + return fmt.Errorf("invalid constraint and value combination, maximum is %s, value is %s, but they should be the same", maxType, valueType) + } + + if minType != "" && !hasSameContent(minType, valueType) { + return fmt.Errorf("invalid constraint and value combination, minimum is %s, value is %s, but they should be the same", minType, valueType) + } + return nil +} + +func hasSameContent(strs ...string) bool { + length := len(strs) + if length == 1 { + return true + } + firstItem := strs[0] + for i := 1; i < length; i++ { + if strings.Compare(firstItem, strs[i]) != 0 { + return false + } + } + return true +} + +func getTypeOf(v interface{}) (string, error) { + switch v.(type) { + case int64: + return "int64", nil + case float64: + return "float64", nil + default: + return "unknown", fmt.Errorf("could not find type for %v", v) + } +} + +func parseValueStr(value string) (interface{}, error) { + var err error + var parsedInt int64 + var parsedFloat float64 + if parsedInt, err = strconv.ParseInt(value, 10, 64); err != nil { + // Could be float + if parsedFloat, err = strconv.ParseFloat(value, 64); err != nil { + // It is invalid. + return nil, fmt.Errorf("value %s is could not be parsed", value) + } + return parsedFloat, nil + } + return parsedInt, nil +} + +func getFloatValue(value interface{}) (float64, error) { + switch i := value.(type) { + case int64: + return float64(i), nil + case float64: + return i, nil + case string: + var parsedValue interface{} + var err error + if parsedValue, err = parseValueStr(i); err != nil { + return 0, err + } + return getFloatValue(parsedValue) + default: + return 0, fmt.Errorf("not supported type %T", value) + } +} + +func validateRangeMinFieldValue(min float64, value float64, inclusive bool) error { + if inclusive && min > value { + return fmt.Errorf("value %f is out of range, less than minimum %f", value, min) + } else if !inclusive && min >= value { + return fmt.Errorf("value %f is out of range, greater or equal than maximum %f", value, min) + } + return nil +} + +func validateRangeMaxFieldValue(max float64, value float64, inclusive bool) error { + if inclusive && max < value { + return fmt.Errorf("value %f is out of range, greater than maximum %f", value, max) + + } else if !inclusive && max <= value { + return fmt.Errorf("value %f is out of range, greater or equal than maximum %f", value, max) + } + return nil +} + +// GetRangeValues reads up the given range constraint and returns the values, or an error if the constraint is malformed or could not be parsed. +func GetRangeValues(value string) (min string, max string, minBracket string, maxBracket string, err error) { + regex := regexp.MustCompile(rangeRegex) + groups := regex.FindStringSubmatch(value) + if len(groups) < 1 { + return "", "", "", "", fmt.Errorf("value in value options is malformed (%s)", value) + } + + groupMap := getRegexGroupMap(groups, regex) + minStr := groupMap[rangeMinimumGroupName] + maxStr := groupMap[rangeMaximumGroupName] + minBr := groupMap[rangeMinBracketGroupName] + maxBr := groupMap[rangeMaxBracketGroupName] + if minStr == "" && maxStr == "" { + return "", "", "", "", fmt.Errorf("constraint contains no limits") + } + return minStr, maxStr, minBr, maxBr, nil +} + +func getRegexGroupMap(groups []string, regex *regexp.Regexp) map[string]string { + result := make(map[string]string) + for i, value := range regex.SubexpNames() { + if i != 0 && value != "" { + result[value] = groups[i] + } + } + return result +} + +func checkPath(path string, dir bool) error { + file, err := os.Stat(path) + if err != nil { + // TODO: check case when file exist but os.Stat fails. + return os.ErrNotExist + } + if dir && !file.IsDir() { + return errors.New("not a directory") + } + return nil +} + +// contains reports whether s is within the value options, where value options +// are parsed from opt, which format's is opt[item1,item2,item3]. If an option +// contains commas, it should be single quoted (eg. opt[item1,'item2,item3']). +func contains(s, opt string) bool { + opt = strings.TrimSuffix(strings.TrimPrefix(opt, "opt["), "]") + var valueOpts []string + if strings.Contains(opt, "'") { + // The single quotes separate the options with comma and without comma + // Eg. "a,b,'c,d',e" will results "a,b," "c,d" and ",e" strings. + for _, s := range strings.Split(opt, "'") { + switch { + case s == "," || s == "": + case !strings.HasPrefix(s, ",") && !strings.HasSuffix(s, ","): + // If a string doesn't starts nor ends with a comma it means it's an option which + // contains comma, so we just append it to valueOpts as it is. Eg. "c,d" from above. + valueOpts = append(valueOpts, s) + default: + // If a string starts or ends with comma it means that it contains options without comma. + // So we split the string at commas to get the options. Eg. "a,b," and ",e" from above. + valueOpts = append(valueOpts, strings.Split(strings.Trim(s, ","), ",")...) + } + } + } else { + valueOpts = strings.Split(opt, ",") + } + for _, valOpt := range valueOpts { + if valOpt == s { + return true + } + } + return false +} diff --git a/vendor/github.com/bitrise-io/go-utils/command/command.go b/vendor/github.com/bitrise-io/go-utils/command/command.go index 040dbaf..c068490 100644 --- a/vendor/github.com/bitrise-io/go-utils/command/command.go +++ b/vendor/github.com/bitrise-io/go-utils/command/command.go @@ -2,14 +2,11 @@ package command import ( "errors" - "fmt" "io" "os" "os/exec" "strconv" "strings" - - "github.com/bitrise-io/go-utils/errorutil" ) // ---------- @@ -32,15 +29,20 @@ func NewWithStandardOuts(name string, args ...string) *Model { return New(name, args...).SetStdout(os.Stdout).SetStderr(os.Stderr) } -// NewFromSlice ... -func NewFromSlice(slice ...string) (*Model, error) { - if len(slice) == 0 { +// NewWithParams ... +func NewWithParams(params ...string) (*Model, error) { + if len(params) == 0 { return nil, errors.New("no command provided") - } else if len(slice) == 1 { - return New(slice[0]), nil + } else if len(params) == 1 { + return New(params[0]), nil } - return New(slice[0], slice[1:]...), nil + return New(params[0], params[1:]...), nil +} + +// NewFromSlice ... +func NewFromSlice(slice []string) (*Model, error) { + return NewWithParams(slice...) } // NewWithCmd ... @@ -134,18 +136,10 @@ func PrintableCommandArgs(isQuoteFirst bool, fullCommandArgs []string) string { } // RunCmdAndReturnExitCode ... -func RunCmdAndReturnExitCode(cmd *exec.Cmd) (int, error) { - err := cmd.Run() - if err != nil { - exitCode, castErr := errorutil.CmdExitCodeFromError(err) - if castErr != nil { - return 1, fmt.Errorf("failed get exit code from error: %s, error: %s", err, castErr) - } - - return exitCode, err - } - - return 0, nil +func RunCmdAndReturnExitCode(cmd *exec.Cmd) (exitCode int, err error) { + err = cmd.Run() + exitCode = cmd.ProcessState.ExitCode() + return } // RunCmdAndReturnTrimmedOutput ... diff --git a/vendor/github.com/bitrise-io/go-utils/command/file.go b/vendor/github.com/bitrise-io/go-utils/command/file.go index eaa0809..6b22172 100644 --- a/vendor/github.com/bitrise-io/go-utils/command/file.go +++ b/vendor/github.com/bitrise-io/go-utils/command/file.go @@ -1,6 +1,7 @@ package command import ( + "errors" "os" "strings" @@ -10,7 +11,14 @@ import ( // CopyFile ... func CopyFile(src, dst string) error { // replace with a pure Go implementation? - // Golang proposal was: https://go-review.googlesource.com/#/c/1591/5/src/io/ioutil/ioutil.go + // Golang proposal was: https://go-review.googlesource.com/#/c/1591/5/src/io/ioutil/ioutil.go + isDir, err := pathutil.IsDirExists(src) + if err != nil { + return err + } + if isDir { + return errors.New("Source is a directory: " + src) + } args := []string{src, dst} return RunCommand("rsync", args...) } @@ -25,6 +33,7 @@ func CopyDir(src, dst string, isOnlyContent bool) error { } // RemoveDir ... +// Deprecated: use RemoveAll instead. func RemoveDir(dirPth string) error { if exist, err := pathutil.IsPathExists(dirPth); err != nil { return err @@ -37,6 +46,7 @@ func RemoveDir(dirPth string) error { } // RemoveFile ... +// Deprecated: use RemoveAll instead. func RemoveFile(pth string) error { if exist, err := pathutil.IsPathExists(pth); err != nil { return err @@ -47,3 +57,13 @@ func RemoveFile(pth string) error { } return nil } + +// RemoveAll removes recursively every file on the given paths. +func RemoveAll(pths ...string) error { + for _, pth := range pths { + if err := os.RemoveAll(pth); err != nil { + return err + } + } + return nil +} diff --git a/vendor/github.com/bitrise-io/go-utils/errorutil/errorutil.go b/vendor/github.com/bitrise-io/go-utils/errorutil/errorutil.go deleted file mode 100644 index 1128416..0000000 --- a/vendor/github.com/bitrise-io/go-utils/errorutil/errorutil.go +++ /dev/null @@ -1,36 +0,0 @@ -package errorutil - -import ( - "errors" - "os/exec" - "regexp" - "syscall" -) - -// IsExitStatusError ... -func IsExitStatusError(err error) bool { - return IsExitStatusErrorStr(err.Error()) -} - -// IsExitStatusErrorStr ... -func IsExitStatusErrorStr(errString string) bool { - // example exit status error string: exit status 1 - var rex = regexp.MustCompile(`^exit status [0-9]{1,3}$`) - return rex.MatchString(errString) -} - -// CmdExitCodeFromError ... -func CmdExitCodeFromError(err error) (int, error) { - cmdExitCode := 0 - if err != nil { - if exitError, ok := err.(*exec.ExitError); ok { - waitStatus, ok := exitError.Sys().(syscall.WaitStatus) - if !ok { - return 1, errors.New("Failed to cast exit status") - } - cmdExitCode = waitStatus.ExitStatus() - } - return cmdExitCode, nil - } - return 0, nil -} diff --git a/vendor/github.com/bitrise-io/go-utils/log/defaultlogger.go b/vendor/github.com/bitrise-io/go-utils/log/defaultlogger.go new file mode 100644 index 0000000..0d2a307 --- /dev/null +++ b/vendor/github.com/bitrise-io/go-utils/log/defaultlogger.go @@ -0,0 +1,57 @@ +package log + +// DefaultLogger ... +type DefaultLogger struct { + ts bool +} + +// NewDefaultLogger ... +func NewDefaultLogger(withTimestamp bool) DefaultLogger { + return DefaultLogger{withTimestamp} +} + +// Donef ... +func (dl DefaultLogger) Donef(format string, v ...interface{}) { + fSelect(dl.ts, TDonef, Donef)(format, v...) +} + +// Successf ... +func (dl DefaultLogger) Successf(format string, v ...interface{}) { + fSelect(dl.ts, TSuccessf, Successf)(format, v...) +} + +// Infof ... +func (dl DefaultLogger) Infof(format string, v ...interface{}) { + fSelect(dl.ts, TInfof, Infof)(format, v...) +} + +// Printf ... +func (dl DefaultLogger) Printf(format string, v ...interface{}) { + fSelect(dl.ts, TPrintf, Printf)(format, v...) +} + +// Warnf ... +func (dl DefaultLogger) Warnf(format string, v ...interface{}) { + fSelect(dl.ts, TWarnf, Warnf)(format, v...) +} + +// Errorf ... +func (dl DefaultLogger) Errorf(format string, v ...interface{}) { + fSelect(dl.ts, TErrorf, Errorf)(format, v...) +} + +// Debugf ... +func (dl DefaultLogger) Debugf(format string, v ...interface{}) { + if enableDebugLog { + fSelect(dl.ts, TDebugf, Debugf)(format, v...) + } +} + +type logfunc func(string, ...interface{}) + +func fSelect(t bool, tf logfunc, f logfunc) logfunc { + if t { + return tf + } + return f +} diff --git a/vendor/github.com/bitrise-io/go-utils/log/dummylogger.go b/vendor/github.com/bitrise-io/go-utils/log/dummylogger.go new file mode 100644 index 0000000..54b0bb9 --- /dev/null +++ b/vendor/github.com/bitrise-io/go-utils/log/dummylogger.go @@ -0,0 +1,30 @@ +package log + +// DummyLogger ... +type DummyLogger struct{} + +// NewDummyLogger ... +func NewDummyLogger() DummyLogger { + return DummyLogger{} +} + +// Donef ... +func (dl DummyLogger) Donef(format string, v ...interface{}) {} + +// Successf ... +func (dl DummyLogger) Successf(format string, v ...interface{}) {} + +// Infof ... +func (dl DummyLogger) Infof(format string, v ...interface{}) {} + +// Printf ... +func (dl DummyLogger) Printf(format string, v ...interface{}) {} + +// Debugf ... +func (dl DummyLogger) Debugf(format string, v ...interface{}) {} + +// Warnf ... +func (dl DummyLogger) Warnf(format string, v ...interface{}) {} + +// Errorf ... +func (dl DummyLogger) Errorf(format string, v ...interface{}) {} diff --git a/vendor/github.com/bitrise-io/go-utils/log/internal_logger.go b/vendor/github.com/bitrise-io/go-utils/log/internal_logger.go new file mode 100644 index 0000000..245f995 --- /dev/null +++ b/vendor/github.com/bitrise-io/go-utils/log/internal_logger.go @@ -0,0 +1,76 @@ +package log + +import ( + "bytes" + "context" + "encoding/json" + "fmt" + "net/http" + "time" +) + +var ( + analyticsServerURL = "https://bitrise-step-analytics.herokuapp.com" + httpClient = http.Client{ + Timeout: time.Second * 5, + } +) + +// Entry represents a line in a log +type Entry struct { + LogLevel string `json:"log_level"` + Message string `json:"message"` + Data map[string]interface{} `json:"data"` +} + +// SetAnalyticsServerURL updates the the analytics server collecting the +// logs. It is intended for use during tests. Warning: current implementation +// is not thread safe, do not call the function during runtime. +func SetAnalyticsServerURL(url string) { + analyticsServerURL = url +} + +// Internal sends the log message to the configured analytics server +func rprintf(logLevel string, stepID string, tag string, data map[string]interface{}, format string, v ...interface{}) { + e := Entry{ + Message: fmt.Sprintf(format, v...), + LogLevel: logLevel, + } + + e.Data = make(map[string]interface{}) + for k, v := range data { + e.Data[k] = v + } + + if v, ok := e.Data["step_id"]; ok { + fmt.Printf("internal logger: data.step_id (%s) will be overriden with (%s) ", v, stepID) + } + if v, ok := e.Data["tag"]; ok { + fmt.Printf("internal logger: data.tag (%s) will be overriden with (%s) ", v, tag) + } + + e.Data["step_id"] = stepID + e.Data["tag"] = tag + + var b bytes.Buffer + if err := json.NewEncoder(&b).Encode(e); err != nil { + return + } + + ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second) + defer cancel() + + req, err := http.NewRequest(http.MethodPost, analyticsServerURL+"/logs", &b) + if err != nil { + // deliberately not writing into users log + return + } + req = req.WithContext(ctx) + req.Header.Add("Content-Type", "application/json") + + if _, err := httpClient.Do(req); err != nil { + // deliberately not writing into users log + return + } + +} diff --git a/vendor/github.com/bitrise-io/go-utils/log/json_logger.go b/vendor/github.com/bitrise-io/go-utils/log/json_logger.go index 43b8bfb..31148b3 100644 --- a/vendor/github.com/bitrise-io/go-utils/log/json_logger.go +++ b/vendor/github.com/bitrise-io/go-utils/log/json_logger.go @@ -27,5 +27,7 @@ func NewDefaultJSONLoger() JSONLoger { // Print ... func (l JSONLoger) Print(f Formatable) { - fmt.Fprint(l.writer, f.JSON()) + if _, err := fmt.Fprint(l.writer, f.JSON()); err != nil { + fmt.Printf("failed to print message: %s, error: %s\n", f.JSON(), err) + } } diff --git a/vendor/github.com/bitrise-io/go-utils/log/log.go b/vendor/github.com/bitrise-io/go-utils/log/log.go index bc1af2f..1b69028 100644 --- a/vendor/github.com/bitrise-io/go-utils/log/log.go +++ b/vendor/github.com/bitrise-io/go-utils/log/log.go @@ -2,24 +2,11 @@ package log import ( "fmt" - "time" - "io" "os" - - "github.com/bitrise-io/go-utils/colorstring" + "time" ) -// -// Log configuration - -var timestampLayout = "15:04:05" - -// SetTimestampLayout ... -func SetTimestampLayout(layout string) { - timestampLayout = layout -} - var outWriter io.Writer = os.Stdout // SetOutWriter ... @@ -27,74 +14,21 @@ func SetOutWriter(writer io.Writer) { outWriter = writer } -// -// Print with color - -func printfWithColor(color colorstring.ColorfFunc, format string, v ...interface{}) { - strWithColor := color(format, v...) - fmt.Fprintln(outWriter, strWithColor) -} - -// Printf ... -func Printf(format string, v ...interface{}) { - printfWithColor(colorstring.NoColorf, format, v...) -} - -// Infof ... -func Infof(format string, v ...interface{}) { - printfWithColor(colorstring.Bluef, format, v...) -} +var enableDebugLog = false -// Donef ... -func Donef(format string, v ...interface{}) { - printfWithColor(colorstring.Greenf, format, v...) +// SetEnableDebugLog ... +func SetEnableDebugLog(enable bool) { + enableDebugLog = enable } -// Errorf ... -func Errorf(format string, v ...interface{}) { - printfWithColor(colorstring.Redf, format, v...) -} +var timestampLayout = "15:04:05" -// Warnf ... -func Warnf(format string, v ...interface{}) { - printfWithColor(colorstring.Yellowf, format, v...) +// SetTimestampLayout ... +func SetTimestampLayout(layout string) { + timestampLayout = layout } -// -// Print with color and timestamp - -func timestamp() string { +func timestampField() string { currentTime := time.Now() - return currentTime.Format(timestampLayout) -} - -func printfWithColorAndTime(color colorstring.ColorfFunc, format string, v ...interface{}) { - strWithColor := color(format, v...) - strWithColorAndTime := fmt.Sprintf("[%s] %s", timestamp(), strWithColor) - fmt.Fprintln(outWriter, strWithColorAndTime) -} - -// Printft ... -func Printft(format string, v ...interface{}) { - printfWithColorAndTime(colorstring.NoColorf, format, v...) -} - -// Infoft ... -func Infoft(format string, v ...interface{}) { - printfWithColorAndTime(colorstring.Bluef, format, v...) -} - -// Doneft ... -func Doneft(format string, v ...interface{}) { - printfWithColorAndTime(colorstring.Greenf, format, v...) -} - -// Errorft ... -func Errorft(format string, v ...interface{}) { - printfWithColorAndTime(colorstring.Redf, format, v...) -} - -// Warnft ... -func Warnft(format string, v ...interface{}) { - printfWithColorAndTime(colorstring.Yellowf, format, v...) + return fmt.Sprintf("[%s]", currentTime.Format(timestampLayout)) } diff --git a/vendor/github.com/bitrise-io/go-utils/log/print.go b/vendor/github.com/bitrise-io/go-utils/log/print.go new file mode 100644 index 0000000..1c817c4 --- /dev/null +++ b/vendor/github.com/bitrise-io/go-utils/log/print.go @@ -0,0 +1,115 @@ +package log + +import ( + "fmt" +) + +func printf(severity Severity, withTime bool, format string, v ...interface{}) { + message := createLogMsg(severity, withTime, format, v...) + if _, err := fmt.Fprintln(outWriter, message); err != nil { + fmt.Printf("failed to print message: %s, error: %s\n", message, err) + } +} + +func createLogMsg(severity Severity, withTime bool, format string, v ...interface{}) string { + colorFunc := severityColorFuncMap[severity] + message := colorFunc(format, v...) + if withTime { + message = prefixCurrentTime(message) + } + + return message +} + +func prefixCurrentTime(message string) string { + return fmt.Sprintf("%s %s", timestampField(), message) +} + +// Successf ... +func Successf(format string, v ...interface{}) { + printf(successSeverity, false, format, v...) +} + +// Donef ... +func Donef(format string, v ...interface{}) { + Successf(format, v...) +} + +// Infof ... +func Infof(format string, v ...interface{}) { + printf(infoSeverity, false, format, v...) +} + +// Printf ... +func Printf(format string, v ...interface{}) { + printf(normalSeverity, false, format, v...) +} + +// Debugf ... +func Debugf(format string, v ...interface{}) { + if enableDebugLog { + printf(debugSeverity, false, format, v...) + } +} + +// Warnf ... +func Warnf(format string, v ...interface{}) { + printf(warnSeverity, false, format, v...) +} + +// Errorf ... +func Errorf(format string, v ...interface{}) { + printf(errorSeverity, false, format, v...) +} + +// TSuccessf ... +func TSuccessf(format string, v ...interface{}) { + printf(successSeverity, true, format, v...) +} + +// TDonef ... +func TDonef(format string, v ...interface{}) { + TSuccessf(format, v...) +} + +// TInfof ... +func TInfof(format string, v ...interface{}) { + printf(infoSeverity, true, format, v...) +} + +// TPrintf ... +func TPrintf(format string, v ...interface{}) { + printf(normalSeverity, true, format, v...) +} + +// TDebugf ... +func TDebugf(format string, v ...interface{}) { + if enableDebugLog { + printf(debugSeverity, true, format, v...) + } +} + +// TWarnf ... +func TWarnf(format string, v ...interface{}) { + printf(warnSeverity, true, format, v...) +} + +// TErrorf ... +func TErrorf(format string, v ...interface{}) { + printf(errorSeverity, true, format, v...) +} + +// RInfof ... +func RInfof(stepID string, tag string, data map[string]interface{}, format string, v ...interface{}) { + rprintf("info", stepID, tag, data, format, v...) +} + +// RWarnf ... +func RWarnf(stepID string, tag string, data map[string]interface{}, format string, v ...interface{}) { + rprintf("warn", stepID, tag, data, format, v...) +} + +// RErrorf ... +func RErrorf(stepID string, tag string, data map[string]interface{}, format string, v ...interface{}) { + rprintf("error", stepID, tag, data, format, v...) +} diff --git a/vendor/github.com/bitrise-io/go-utils/log/raw_logger.go b/vendor/github.com/bitrise-io/go-utils/log/raw_logger.go index 82dc54e..a673380 100644 --- a/vendor/github.com/bitrise-io/go-utils/log/raw_logger.go +++ b/vendor/github.com/bitrise-io/go-utils/log/raw_logger.go @@ -27,5 +27,7 @@ func NewDefaultRawLogger() RawLogger { // Print ... func (l RawLogger) Print(f Formatable) { - fmt.Fprintln(l.writer, f.String()) + if _, err := fmt.Fprintln(l.writer, f.String()); err != nil { + fmt.Printf("failed to print message: %s, error: %s\n", f.String(), err) + } } diff --git a/vendor/github.com/bitrise-io/go-utils/log/severity.go b/vendor/github.com/bitrise-io/go-utils/log/severity.go new file mode 100644 index 0000000..4e7786d --- /dev/null +++ b/vendor/github.com/bitrise-io/go-utils/log/severity.go @@ -0,0 +1,35 @@ +package log + +import "github.com/bitrise-io/go-utils/colorstring" + +// Severity ... +type Severity uint8 + +const ( + errorSeverity Severity = iota + warnSeverity + normalSeverity + infoSeverity + successSeverity + debugSeverity +) + +type severityColorFunc colorstring.ColorfFunc + +var ( + successSeverityColorFunc severityColorFunc = colorstring.Greenf + infoSeverityColorFunc severityColorFunc = colorstring.Bluef + normalSeverityColorFunc severityColorFunc = colorstring.NoColorf + debugSeverityColorFunc severityColorFunc = colorstring.Magentaf + warnSeverityColorFunc severityColorFunc = colorstring.Yellowf + errorSeverityColorFunc severityColorFunc = colorstring.Redf +) + +var severityColorFuncMap = map[Severity]severityColorFunc{ + successSeverity: successSeverityColorFunc, + infoSeverity: infoSeverityColorFunc, + normalSeverity: normalSeverityColorFunc, + debugSeverity: debugSeverityColorFunc, + warnSeverity: warnSeverityColorFunc, + errorSeverity: errorSeverityColorFunc, +} diff --git a/vendor/github.com/bitrise-io/go-utils/parseutil/parseutil.go b/vendor/github.com/bitrise-io/go-utils/parseutil/parseutil.go new file mode 100644 index 0000000..08cec36 --- /dev/null +++ b/vendor/github.com/bitrise-io/go-utils/parseutil/parseutil.go @@ -0,0 +1,95 @@ +package parseutil + +import ( + "errors" + "fmt" + "strconv" + "strings" + + "github.com/bitrise-io/go-utils/pointers" +) + +// ParseBool ... +func ParseBool(userInputStr string) (bool, error) { + if userInputStr == "" { + return false, errors.New("No string to parse") + } + userInputStr = strings.TrimSpace(userInputStr) + + lowercased := strings.ToLower(userInputStr) + if lowercased == "yes" || lowercased == "y" { + return true, nil + } + if lowercased == "no" || lowercased == "n" { + return false, nil + } + return strconv.ParseBool(lowercased) +} + +// CastToString ... +func CastToString(value interface{}) string { + casted, ok := value.(string) + + if !ok { + castedStr := fmt.Sprintf("%v", value) + casted = castedStr + } + + return casted +} + +// CastToStringPtr ... +func CastToStringPtr(value interface{}) *string { + castedValue := CastToString(value) + return pointers.NewStringPtr(castedValue) +} + +// CastToBool ... +func CastToBool(value interface{}) (bool, bool) { + casted, ok := value.(bool) + + if !ok { + castedStr := CastToString(value) + + castedBool, err := ParseBool(castedStr) + if err != nil { + return false, false + } + + casted = castedBool + } + + return casted, true +} + +// CastToBoolPtr ... +func CastToBoolPtr(value interface{}) (*bool, bool) { + castedValue, ok := CastToBool(value) + if !ok { + return nil, false + } + return pointers.NewBoolPtr(castedValue), true +} + +// CastToMapStringInterface ... +func CastToMapStringInterface(value interface{}) (map[string]interface{}, bool) { + castedValue, ok := value.(map[interface{}]interface{}) + desiredMap := map[string]interface{}{} + for key, value := range castedValue { + keyStr, ok := key.(string) + if !ok { + return map[string]interface{}{}, false + } + desiredMap[keyStr] = value + } + return desiredMap, ok +} + +// CastToMapStringInterfacePtr ... +func CastToMapStringInterfacePtr(value interface{}) (*map[string]interface{}, bool) { + casted, ok := CastToMapStringInterface(value) + if !ok { + return nil, false + } + return pointers.NewMapStringInterfacePtr(casted), true +} diff --git a/vendor/github.com/bitrise-io/go-utils/pathutil/glob.go b/vendor/github.com/bitrise-io/go-utils/pathutil/glob.go new file mode 100644 index 0000000..232dd51 --- /dev/null +++ b/vendor/github.com/bitrise-io/go-utils/pathutil/glob.go @@ -0,0 +1,13 @@ +package pathutil + +// EscapeGlobPath escapes a partial path, determined at runtime, used as a parameter for filepath.Glob +func EscapeGlobPath(path string) string { + var escaped string + for _, ch := range path { + if ch == '[' || ch == ']' || ch == '-' || ch == '*' || ch == '?' || ch == '\\' { + escaped += "\\" + } + escaped += string(ch) + } + return escaped +} diff --git a/vendor/github.com/bitrise-io/go-utils/pathutil/path_filter.go b/vendor/github.com/bitrise-io/go-utils/pathutil/path_filter.go new file mode 100644 index 0000000..0bfd0fc --- /dev/null +++ b/vendor/github.com/bitrise-io/go-utils/pathutil/path_filter.go @@ -0,0 +1,143 @@ +package pathutil + +import ( + "errors" + "io/ioutil" + "os" + "path/filepath" + "regexp" + "strings" +) + +// FilterPaths ... +func FilterPaths(fileList []string, filters ...FilterFunc) ([]string, error) { + var filtered []string + + for _, pth := range fileList { + allowed := true + for _, filter := range filters { + if allows, err := filter(pth); err != nil { + return []string{}, err + } else if !allows { + allowed = false + break + } + } + if allowed { + filtered = append(filtered, pth) + } + } + + return filtered, nil +} + +// FilterFunc ... +type FilterFunc func(string) (bool, error) + +// BaseFilter ... +func BaseFilter(base string, allowed bool) FilterFunc { + return func(pth string) (bool, error) { + b := filepath.Base(pth) + return allowed == strings.EqualFold(base, b), nil + } +} + +// ExtensionFilter ... +func ExtensionFilter(ext string, allowed bool) FilterFunc { + return func(pth string) (bool, error) { + e := filepath.Ext(pth) + return allowed == strings.EqualFold(ext, e), nil + } +} + +// RegexpFilter ... +func RegexpFilter(pattern string, allowed bool) FilterFunc { + return func(pth string) (bool, error) { + re := regexp.MustCompile(pattern) + found := re.FindString(pth) != "" + return allowed == found, nil + } +} + +// ComponentFilter ... +func ComponentFilter(component string, allowed bool) FilterFunc { + return func(pth string) (bool, error) { + found := false + pathComponents := strings.Split(pth, string(filepath.Separator)) + for _, c := range pathComponents { + if c == component { + found = true + } + } + return allowed == found, nil + } +} + +// ComponentWithExtensionFilter ... +func ComponentWithExtensionFilter(ext string, allowed bool) FilterFunc { + return func(pth string) (bool, error) { + found := false + pathComponents := strings.Split(pth, string(filepath.Separator)) + for _, c := range pathComponents { + e := filepath.Ext(c) + if e == ext { + found = true + } + } + return allowed == found, nil + } +} + +// IsDirectoryFilter ... +func IsDirectoryFilter(allowed bool) FilterFunc { + return func(pth string) (bool, error) { + fileInf, err := os.Lstat(pth) + if err != nil { + return false, err + } + if fileInf == nil { + return false, errors.New("no file info available") + } + return allowed == fileInf.IsDir(), nil + } +} + +// InDirectoryFilter ... +func InDirectoryFilter(dir string, allowed bool) FilterFunc { + return func(pth string) (bool, error) { + in := filepath.Dir(pth) == dir + return allowed == in, nil + } +} + +// DirectoryContainsFileFilter returns a FilterFunc that checks if a directory contains a file +func DirectoryContainsFileFilter(fileName string) FilterFunc { + return func(pth string) (bool, error) { + isDir, err := IsDirectoryFilter(true)(pth) + if err != nil { + return false, err + } + if !isDir { + return false, nil + } + + absPath := filepath.Join(pth, fileName) + if _, err := os.Lstat(absPath); err != nil { + if !os.IsNotExist(err) { + return false, err + } + return false, nil + } + return true, nil + } +} + +// FileContainsFilter ... +func FileContainsFilter(pth, str string) (bool, error) { + bytes, err := ioutil.ReadFile(pth) + if err != nil { + return false, err + } + + return strings.Contains(string(bytes), str), nil +} diff --git a/vendor/github.com/bitrise-io/go-utils/pathutil/pathutil.go b/vendor/github.com/bitrise-io/go-utils/pathutil/pathutil.go index a0b0866..db577e3 100644 --- a/vendor/github.com/bitrise-io/go-utils/pathutil/pathutil.go +++ b/vendor/github.com/bitrise-io/go-utils/pathutil/pathutil.go @@ -4,11 +4,38 @@ import ( "errors" "io/ioutil" "os" + "os/user" "path/filepath" "runtime" "strings" ) +// RevokableChangeDir ... +func RevokableChangeDir(dir string) (func() error, error) { + origDir, err := CurrentWorkingDirectoryAbsolutePath() + if err != nil { + return nil, err + } + + revokeFn := func() error { + return os.Chdir(origDir) + } + + return revokeFn, os.Chdir(dir) +} + +// ChangeDirForFunction ... +func ChangeDirForFunction(dir string, fn func()) error { + revokeFn, err := RevokableChangeDir(dir) + if err != nil { + return err + } + + fn() + + return revokeFn() +} + // IsRelativePath ... func IsRelativePath(pth string) bool { if strings.HasPrefix(pth, "./") { @@ -85,12 +112,44 @@ func AbsPath(pth string) (string, error) { if pth == "" { return "", errors.New("No Path provided") } - if len(pth) >= 2 && pth[:2] == "~/" { - pth = strings.Replace(pth, "~/", "$HOME/", 1) + + pth, err := ExpandTilde(pth) + if err != nil { + return "", err } + return filepath.Abs(os.ExpandEnv(pth)) } +// ExpandTilde ... +func ExpandTilde(pth string) (string, error) { + if pth == "" { + return "", errors.New("No Path provided") + } + + if strings.HasPrefix(pth, "~") { + pth = strings.TrimPrefix(pth, "~") + + if len(pth) == 0 || strings.HasPrefix(pth, "/") { + return os.ExpandEnv("$HOME" + pth), nil + } + + splitPth := strings.Split(pth, "/") + username := splitPth[0] + + usr, err := user.Lookup(username) + if err != nil { + return "", err + } + + pathInUsrHome := strings.Join(splitPth[1:], "/") + + return filepath.Join(usr.HomeDir, pathInUsrHome), nil + } + + return pth, nil +} + // CurrentWorkingDirectoryAbsolutePath ... func CurrentWorkingDirectoryAbsolutePath() (string, error) { return filepath.Abs("./") @@ -120,3 +179,60 @@ func NormalizedOSTempDirPath(tmpDirNamePrefix string) (retPth string, err error) } return } + +// GetFileName returns the name of the file from a given path or the name of the directory if it is a directory +func GetFileName(path string) string { + return strings.TrimSuffix(filepath.Base(path), filepath.Ext(path)) +} + +// ListPathInDirSortedByComponents ... +func ListPathInDirSortedByComponents(searchDir string, relPath bool) ([]string, error) { + searchDir, err := filepath.Abs(searchDir) + if err != nil { + return []string{}, err + } + + var fileList []string + + if err := filepath.Walk(searchDir, func(path string, _ os.FileInfo, walkErr error) error { + if walkErr != nil { + return walkErr + } + + if relPath { + rel, err := filepath.Rel(searchDir, path) + if err != nil { + return err + } + path = rel + } + + fileList = append(fileList, path) + + return nil + }); err != nil { + return []string{}, err + } + return SortPathsByComponents(fileList) +} + +// ListEntries filters contents of a directory using the provided filters +func ListEntries(dir string, filters ...FilterFunc) ([]string, error) { + absDir, err := filepath.Abs(dir) + if err != nil { + return []string{}, err + } + + entries, err := ioutil.ReadDir(absDir) + if err != nil { + return []string{}, err + } + + var paths []string + for _, entry := range entries { + pth := filepath.Join(absDir, entry.Name()) + paths = append(paths, pth) + } + + return FilterPaths(paths, filters...) +} diff --git a/vendor/github.com/bitrise-io/go-utils/pathutil/sortable_path.go b/vendor/github.com/bitrise-io/go-utils/pathutil/sortable_path.go new file mode 100644 index 0000000..4bed6bf --- /dev/null +++ b/vendor/github.com/bitrise-io/go-utils/pathutil/sortable_path.go @@ -0,0 +1,88 @@ +package pathutil + +import ( + "os" + "path/filepath" + "sort" + "strings" +) + +// SortablePath ... +type SortablePath struct { + Pth string + AbsPth string + Components []string +} + +// NewSortablePath ... +func NewSortablePath(pth string) (SortablePath, error) { + absPth, err := AbsPath(pth) + if err != nil { + return SortablePath{}, err + } + + components := strings.Split(absPth, string(os.PathSeparator)) + fixedComponents := []string{} + for _, comp := range components { + if comp != "" { + fixedComponents = append(fixedComponents, comp) + } + } + + return SortablePath{ + Pth: pth, + AbsPth: absPth, + Components: fixedComponents, + }, nil +} + +// BySortablePathComponents .. +type BySortablePathComponents []SortablePath + +func (s BySortablePathComponents) Len() int { + return len(s) +} +func (s BySortablePathComponents) Swap(i, j int) { + s[i], s[j] = s[j], s[i] +} +func (s BySortablePathComponents) Less(i, j int) bool { + path1 := s[i] + path2 := s[j] + + d1 := len(path1.Components) + d2 := len(path2.Components) + + if d1 < d2 { + return true + } else if d1 > d2 { + return false + } + + // if same component size, + // do alphabetic sort based on the last component + base1 := filepath.Base(path1.AbsPth) + base2 := filepath.Base(path2.AbsPth) + + return base1 < base2 +} + +// SortPathsByComponents ... +func SortPathsByComponents(paths []string) ([]string, error) { + sortableFiles := []SortablePath{} + for _, pth := range paths { + sortable, err := NewSortablePath(pth) + if err != nil { + return []string{}, err + } + sortableFiles = append(sortableFiles, sortable) + } + + sort.Sort(BySortablePathComponents(sortableFiles)) + + sortedFiles := []string{} + for _, pth := range sortableFiles { + sortedFiles = append(sortedFiles, pth.Pth) + } + + return sortedFiles, nil +} diff --git a/vendor/github.com/bitrise-io/go-utils/pointers/pointers.go b/vendor/github.com/bitrise-io/go-utils/pointers/pointers.go new file mode 100644 index 0000000..e26647d --- /dev/null +++ b/vendor/github.com/bitrise-io/go-utils/pointers/pointers.go @@ -0,0 +1,98 @@ +package pointers + +import "time" + +// NewBoolPtr ... +func NewBoolPtr(val bool) *bool { + ptrValue := new(bool) + *ptrValue = val + return ptrValue +} + +// NewStringPtr ... +func NewStringPtr(val string) *string { + ptrValue := new(string) + *ptrValue = val + return ptrValue +} + +// NewTimePtr ... +func NewTimePtr(val time.Time) *time.Time { + ptrValue := new(time.Time) + *ptrValue = val + return ptrValue +} + +// NewIntPtr ... +func NewIntPtr(val int) *int { + ptrValue := new(int) + *ptrValue = val + return ptrValue +} + +// NewInt64Ptr ... +func NewInt64Ptr(val int64) *int64 { + ptrValue := new(int64) + *ptrValue = val + return ptrValue +} + +// NewMapStringInterfacePtr ... +func NewMapStringInterfacePtr(val map[string]interface{}) *map[string]interface{} { + ptrValue := new(map[string]interface{}) + *ptrValue = map[string]interface{}{} + for key, value := range val { + (*ptrValue)[key] = value + } + return ptrValue +} + +// ------------------------------------------------------ +// --- Safe Getters + +// Bool ... +func Bool(val *bool) bool { + return BoolWithDefault(val, false) +} + +// BoolWithDefault ... +func BoolWithDefault(val *bool, defaultValue bool) bool { + if val == nil { + return defaultValue + } + return *val +} + +// String ... +func String(val *string) string { + return StringWithDefault(val, "") +} + +// StringWithDefault ... +func StringWithDefault(val *string, defaultValue string) string { + if val == nil { + return defaultValue + } + return *val +} + +// TimeWithDefault ... +func TimeWithDefault(val *time.Time, defaultValue time.Time) time.Time { + if val == nil { + return defaultValue + } + return *val +} + +// Int ... +func Int(val *int) int { + return IntWithDefault(val, 0) +} + +// IntWithDefault ... +func IntWithDefault(val *int, defaultValue int) int { + if val == nil { + return defaultValue + } + return *val +} diff --git a/vendor/github.com/bitrise-tools/go-android/sdk/sdk.go b/vendor/github.com/bitrise-tools/go-android/sdk/sdk.go deleted file mode 100644 index 36dd8c4..0000000 --- a/vendor/github.com/bitrise-tools/go-android/sdk/sdk.go +++ /dev/null @@ -1,39 +0,0 @@ -package sdk - -import ( - "fmt" - "path/filepath" - - "github.com/bitrise-io/go-utils/pathutil" -) - -// Model ... -type Model struct { - androidHome string -} - -// AndroidSdkInterface ... -type AndroidSdkInterface interface { - GetAndroidHome() string -} - -// New ... -func New(androidHome string) (*Model, error) { - evaluatedAndroidHome, err := filepath.EvalSymlinks(androidHome) - if err != nil { - return nil, err - } - - if exist, err := pathutil.IsDirExists(evaluatedAndroidHome); err != nil { - return nil, err - } else if !exist { - return nil, fmt.Errorf("android home not exists at: %s", evaluatedAndroidHome) - } - - return &Model{androidHome: evaluatedAndroidHome}, nil -} - -// GetAndroidHome ... -func (model *Model) GetAndroidHome() string { - return model.androidHome -} diff --git a/vendor/github.com/hashicorp/go-version/CHANGELOG.md b/vendor/github.com/hashicorp/go-version/CHANGELOG.md new file mode 100644 index 0000000..dbae7f7 --- /dev/null +++ b/vendor/github.com/hashicorp/go-version/CHANGELOG.md @@ -0,0 +1,25 @@ +# 1.3.0 (March 31, 2021) + +Please note that CHANGELOG.md does not exist in the source code prior to this release. + +FEATURES: + - Add `Core` function to return a version without prerelease or metadata ([#85](https://github.com/hashicorp/go-version/pull/85)) + +# 1.2.1 (June 17, 2020) + +BUG FIXES: + - Prevent `Version.Equal` method from panicking on `nil` encounter ([#73](https://github.com/hashicorp/go-version/pull/73)) + +# 1.2.0 (April 23, 2019) + +FEATURES: + - Add `GreaterThanOrEqual` and `LessThanOrEqual` helper methods ([#53](https://github.com/hashicorp/go-version/pull/53)) + +# 1.1.0 (Jan 07, 2019) + +FEATURES: + - Add `NewSemver` constructor ([#45](https://github.com/hashicorp/go-version/pull/45)) + +# 1.0.0 (August 24, 2018) + +Initial release. diff --git a/vendor/github.com/hashicorp/go-version/LICENSE b/vendor/github.com/hashicorp/go-version/LICENSE new file mode 100644 index 0000000..c33dcc7 --- /dev/null +++ b/vendor/github.com/hashicorp/go-version/LICENSE @@ -0,0 +1,354 @@ +Mozilla Public License, version 2.0 + +1. Definitions + +1.1. “Contributor” + + means each individual or legal entity that creates, contributes to the + creation of, or owns Covered Software. + +1.2. “Contributor Version” + + means the combination of the Contributions of others (if any) used by a + Contributor and that particular Contributor’s Contribution. + +1.3. “Contribution” + + means Covered Software of a particular Contributor. + +1.4. “Covered Software” + + means Source Code Form to which the initial Contributor has attached the + notice in Exhibit A, the Executable Form of such Source Code Form, and + Modifications of such Source Code Form, in each case including portions + thereof. + +1.5. “Incompatible With Secondary Licenses” + means + + a. that the initial Contributor has attached the notice described in + Exhibit B to the Covered Software; or + + b. that the Covered Software was made available under the terms of version + 1.1 or earlier of the License, but not also under the terms of a + Secondary License. + +1.6. “Executable Form” + + means any form of the work other than Source Code Form. + +1.7. “Larger Work” + + means a work that combines Covered Software with other material, in a separate + file or files, that is not Covered Software. + +1.8. “License” + + means this document. + +1.9. “Licensable” + + means having the right to grant, to the maximum extent possible, whether at the + time of the initial grant or subsequently, any and all of the rights conveyed by + this License. + +1.10. “Modifications” + + means any of the following: + + a. any file in Source Code Form that results from an addition to, deletion + from, or modification of the contents of Covered Software; or + + b. any new file in Source Code Form that contains any Covered Software. + +1.11. “Patent Claims” of a Contributor + + means any patent claim(s), including without limitation, method, process, + and apparatus claims, in any patent Licensable by such Contributor that + would be infringed, but for the grant of the License, by the making, + using, selling, offering for sale, having made, import, or transfer of + either its Contributions or its Contributor Version. + +1.12. “Secondary License” + + means either the GNU General Public License, Version 2.0, the GNU Lesser + General Public License, Version 2.1, the GNU Affero General Public + License, Version 3.0, or any later versions of those licenses. + +1.13. “Source Code Form” + + means the form of the work preferred for making modifications. + +1.14. “You” (or “Your”) + + means an individual or a legal entity exercising rights under this + License. For legal entities, “You” includes any entity that controls, is + controlled by, or is under common control with You. For purposes of this + definition, “control” means (a) the power, direct or indirect, to cause + the direction or management of such entity, whether by contract or + otherwise, or (b) ownership of more than fifty percent (50%) of the + outstanding shares or beneficial ownership of such entity. + + +2. License Grants and Conditions + +2.1. Grants + + Each Contributor hereby grants You a world-wide, royalty-free, + non-exclusive license: + + a. under intellectual property rights (other than patent or trademark) + Licensable by such Contributor to use, reproduce, make available, + modify, display, perform, distribute, and otherwise exploit its + Contributions, either on an unmodified basis, with Modifications, or as + part of a Larger Work; and + + b. under Patent Claims of such Contributor to make, use, sell, offer for + sale, have made, import, and otherwise transfer either its Contributions + or its Contributor Version. + +2.2. Effective Date + + The licenses granted in Section 2.1 with respect to any Contribution become + effective for each Contribution on the date the Contributor first distributes + such Contribution. + +2.3. Limitations on Grant Scope + + The licenses granted in this Section 2 are the only rights granted under this + License. No additional rights or licenses will be implied from the distribution + or licensing of Covered Software under this License. Notwithstanding Section + 2.1(b) above, no patent license is granted by a Contributor: + + a. for any code that a Contributor has removed from Covered Software; or + + b. for infringements caused by: (i) Your and any other third party’s + modifications of Covered Software, or (ii) the combination of its + Contributions with other software (except as part of its Contributor + Version); or + + c. under Patent Claims infringed by Covered Software in the absence of its + Contributions. + + This License does not grant any rights in the trademarks, service marks, or + logos of any Contributor (except as may be necessary to comply with the + notice requirements in Section 3.4). + +2.4. Subsequent Licenses + + No Contributor makes additional grants as a result of Your choice to + distribute the Covered Software under a subsequent version of this License + (see Section 10.2) or under the terms of a Secondary License (if permitted + under the terms of Section 3.3). + +2.5. Representation + + Each Contributor represents that the Contributor believes its Contributions + are its original creation(s) or it has sufficient rights to grant the + rights to its Contributions conveyed by this License. + +2.6. Fair Use + + This License is not intended to limit any rights You have under applicable + copyright doctrines of fair use, fair dealing, or other equivalents. + +2.7. Conditions + + Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted in + Section 2.1. + + +3. Responsibilities + +3.1. Distribution of Source Form + + All distribution of Covered Software in Source Code Form, including any + Modifications that You create or to which You contribute, must be under the + terms of this License. You must inform recipients that the Source Code Form + of the Covered Software is governed by the terms of this License, and how + they can obtain a copy of this License. You may not attempt to alter or + restrict the recipients’ rights in the Source Code Form. + +3.2. Distribution of Executable Form + + If You distribute Covered Software in Executable Form then: + + a. such Covered Software must also be made available in Source Code Form, + as described in Section 3.1, and You must inform recipients of the + Executable Form how they can obtain a copy of such Source Code Form by + reasonable means in a timely manner, at a charge no more than the cost + of distribution to the recipient; and + + b. You may distribute such Executable Form under the terms of this License, + or sublicense it under different terms, provided that the license for + the Executable Form does not attempt to limit or alter the recipients’ + rights in the Source Code Form under this License. + +3.3. Distribution of a Larger Work + + You may create and distribute a Larger Work under terms of Your choice, + provided that You also comply with the requirements of this License for the + Covered Software. If the Larger Work is a combination of Covered Software + with a work governed by one or more Secondary Licenses, and the Covered + Software is not Incompatible With Secondary Licenses, this License permits + You to additionally distribute such Covered Software under the terms of + such Secondary License(s), so that the recipient of the Larger Work may, at + their option, further distribute the Covered Software under the terms of + either this License or such Secondary License(s). + +3.4. Notices + + You may not remove or alter the substance of any license notices (including + copyright notices, patent notices, disclaimers of warranty, or limitations + of liability) contained within the Source Code Form of the Covered + Software, except that You may alter any license notices to the extent + required to remedy known factual inaccuracies. + +3.5. Application of Additional Terms + + You may choose to offer, and to charge a fee for, warranty, support, + indemnity or liability obligations to one or more recipients of Covered + Software. However, You may do so only on Your own behalf, and not on behalf + of any Contributor. You must make it absolutely clear that any such + warranty, support, indemnity, or liability obligation is offered by You + alone, and You hereby agree to indemnify every Contributor for any + liability incurred by such Contributor as a result of warranty, support, + indemnity or liability terms You offer. You may include additional + disclaimers of warranty and limitations of liability specific to any + jurisdiction. + +4. Inability to Comply Due to Statute or Regulation + + If it is impossible for You to comply with any of the terms of this License + with respect to some or all of the Covered Software due to statute, judicial + order, or regulation then You must: (a) comply with the terms of this License + to the maximum extent possible; and (b) describe the limitations and the code + they affect. Such description must be placed in a text file included with all + distributions of the Covered Software under this License. Except to the + extent prohibited by statute or regulation, such description must be + sufficiently detailed for a recipient of ordinary skill to be able to + understand it. + +5. Termination + +5.1. The rights granted under this License will terminate automatically if You + fail to comply with any of its terms. However, if You become compliant, + then the rights granted under this License from a particular Contributor + are reinstated (a) provisionally, unless and until such Contributor + explicitly and finally terminates Your grants, and (b) on an ongoing basis, + if such Contributor fails to notify You of the non-compliance by some + reasonable means prior to 60 days after You have come back into compliance. + Moreover, Your grants from a particular Contributor are reinstated on an + ongoing basis if such Contributor notifies You of the non-compliance by + some reasonable means, this is the first time You have received notice of + non-compliance with this License from such Contributor, and You become + compliant prior to 30 days after Your receipt of the notice. + +5.2. If You initiate litigation against any entity by asserting a patent + infringement claim (excluding declaratory judgment actions, counter-claims, + and cross-claims) alleging that a Contributor Version directly or + indirectly infringes any patent, then the rights granted to You by any and + all Contributors for the Covered Software under Section 2.1 of this License + shall terminate. + +5.3. In the event of termination under Sections 5.1 or 5.2 above, all end user + license agreements (excluding distributors and resellers) which have been + validly granted by You or Your distributors under this License prior to + termination shall survive termination. + +6. Disclaimer of Warranty + + Covered Software is provided under this License on an “as is” basis, without + warranty of any kind, either expressed, implied, or statutory, including, + without limitation, warranties that the Covered Software is free of defects, + merchantable, fit for a particular purpose or non-infringing. The entire + risk as to the quality and performance of the Covered Software is with You. + Should any Covered Software prove defective in any respect, You (not any + Contributor) assume the cost of any necessary servicing, repair, or + correction. This disclaimer of warranty constitutes an essential part of this + License. No use of any Covered Software is authorized under this License + except under this disclaimer. + +7. Limitation of Liability + + Under no circumstances and under no legal theory, whether tort (including + negligence), contract, or otherwise, shall any Contributor, or anyone who + distributes Covered Software as permitted above, be liable to You for any + direct, indirect, special, incidental, or consequential damages of any + character including, without limitation, damages for lost profits, loss of + goodwill, work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses, even if such party shall have been + informed of the possibility of such damages. This limitation of liability + shall not apply to liability for death or personal injury resulting from such + party’s negligence to the extent applicable law prohibits such limitation. + Some jurisdictions do not allow the exclusion or limitation of incidental or + consequential damages, so this exclusion and limitation may not apply to You. + +8. Litigation + + Any litigation relating to this License may be brought only in the courts of + a jurisdiction where the defendant maintains its principal place of business + and such litigation shall be governed by laws of that jurisdiction, without + reference to its conflict-of-law provisions. Nothing in this Section shall + prevent a party’s ability to bring cross-claims or counter-claims. + +9. Miscellaneous + + This License represents the complete agreement concerning the subject matter + hereof. If any provision of this License is held to be unenforceable, such + provision shall be reformed only to the extent necessary to make it + enforceable. Any law or regulation which provides that the language of a + contract shall be construed against the drafter shall not be used to construe + this License against a Contributor. + + +10. Versions of the License + +10.1. New Versions + + Mozilla Foundation is the license steward. Except as provided in Section + 10.3, no one other than the license steward has the right to modify or + publish new versions of this License. Each version will be given a + distinguishing version number. + +10.2. Effect of New Versions + + You may distribute the Covered Software under the terms of the version of + the License under which You originally received the Covered Software, or + under the terms of any subsequent version published by the license + steward. + +10.3. Modified Versions + + If you create software not governed by this License, and you want to + create a new license for such software, you may create and use a modified + version of this License if you rename the license and remove any + references to the name of the license steward (except to note that such + modified license differs from this License). + +10.4. Distributing Source Code Form that is Incompatible With Secondary Licenses + If You choose to distribute Source Code Form that is Incompatible With + Secondary Licenses under the terms of this version of the License, the + notice described in Exhibit B of this License must be attached. + +Exhibit A - Source Code Form License Notice + + This Source Code Form is subject to the + terms of the Mozilla Public License, v. + 2.0. If a copy of the MPL was not + distributed with this file, You can + obtain one at + http://mozilla.org/MPL/2.0/. + +If it is not possible or desirable to put the notice in a particular file, then +You may include the notice in a location (such as a LICENSE file in a relevant +directory) where a recipient would be likely to look for such a notice. + +You may add additional accurate notices of copyright ownership. + +Exhibit B - “Incompatible With Secondary Licenses” Notice + + This Source Code Form is “Incompatible + With Secondary Licenses”, as defined by + the Mozilla Public License, v. 2.0. + diff --git a/vendor/github.com/hashicorp/go-version/README.md b/vendor/github.com/hashicorp/go-version/README.md new file mode 100644 index 0000000..851a337 --- /dev/null +++ b/vendor/github.com/hashicorp/go-version/README.md @@ -0,0 +1,66 @@ +# Versioning Library for Go +[![Build Status](https://circleci.com/gh/hashicorp/go-version/tree/master.svg?style=svg)](https://circleci.com/gh/hashicorp/go-version/tree/master) +[![GoDoc](https://godoc.org/github.com/hashicorp/go-version?status.svg)](https://godoc.org/github.com/hashicorp/go-version) + +go-version is a library for parsing versions and version constraints, +and verifying versions against a set of constraints. go-version +can sort a collection of versions properly, handles prerelease/beta +versions, can increment versions, etc. + +Versions used with go-version must follow [SemVer](http://semver.org/). + +## Installation and Usage + +Package documentation can be found on +[GoDoc](http://godoc.org/github.com/hashicorp/go-version). + +Installation can be done with a normal `go get`: + +``` +$ go get github.com/hashicorp/go-version +``` + +#### Version Parsing and Comparison + +```go +v1, err := version.NewVersion("1.2") +v2, err := version.NewVersion("1.5+metadata") + +// Comparison example. There is also GreaterThan, Equal, and just +// a simple Compare that returns an int allowing easy >=, <=, etc. +if v1.LessThan(v2) { + fmt.Printf("%s is less than %s", v1, v2) +} +``` + +#### Version Constraints + +```go +v1, err := version.NewVersion("1.2") + +// Constraints example. +constraints, err := version.NewConstraint(">= 1.0, < 1.4") +if constraints.Check(v1) { + fmt.Printf("%s satisfies constraints %s", v1, constraints) +} +``` + +#### Version Sorting + +```go +versionsRaw := []string{"1.1", "0.7.1", "1.4-beta", "1.4", "2"} +versions := make([]*version.Version, len(versionsRaw)) +for i, raw := range versionsRaw { + v, _ := version.NewVersion(raw) + versions[i] = v +} + +// After this, the versions are properly sorted +sort.Sort(version.Collection(versions)) +``` + +## Issues and Contributing + +If you find an issue with this library, please report an issue. If you'd +like, we welcome any contributions. Fork this library and submit a pull +request. diff --git a/vendor/github.com/hashicorp/go-version/constraint.go b/vendor/github.com/hashicorp/go-version/constraint.go new file mode 100644 index 0000000..d055759 --- /dev/null +++ b/vendor/github.com/hashicorp/go-version/constraint.go @@ -0,0 +1,204 @@ +package version + +import ( + "fmt" + "reflect" + "regexp" + "strings" +) + +// Constraint represents a single constraint for a version, such as +// ">= 1.0". +type Constraint struct { + f constraintFunc + check *Version + original string +} + +// Constraints is a slice of constraints. We make a custom type so that +// we can add methods to it. +type Constraints []*Constraint + +type constraintFunc func(v, c *Version) bool + +var constraintOperators map[string]constraintFunc + +var constraintRegexp *regexp.Regexp + +func init() { + constraintOperators = map[string]constraintFunc{ + "": constraintEqual, + "=": constraintEqual, + "!=": constraintNotEqual, + ">": constraintGreaterThan, + "<": constraintLessThan, + ">=": constraintGreaterThanEqual, + "<=": constraintLessThanEqual, + "~>": constraintPessimistic, + } + + ops := make([]string, 0, len(constraintOperators)) + for k := range constraintOperators { + ops = append(ops, regexp.QuoteMeta(k)) + } + + constraintRegexp = regexp.MustCompile(fmt.Sprintf( + `^\s*(%s)\s*(%s)\s*$`, + strings.Join(ops, "|"), + VersionRegexpRaw)) +} + +// NewConstraint will parse one or more constraints from the given +// constraint string. The string must be a comma-separated list of +// constraints. +func NewConstraint(v string) (Constraints, error) { + vs := strings.Split(v, ",") + result := make([]*Constraint, len(vs)) + for i, single := range vs { + c, err := parseSingle(single) + if err != nil { + return nil, err + } + + result[i] = c + } + + return Constraints(result), nil +} + +// Check tests if a version satisfies all the constraints. +func (cs Constraints) Check(v *Version) bool { + for _, c := range cs { + if !c.Check(v) { + return false + } + } + + return true +} + +// Returns the string format of the constraints +func (cs Constraints) String() string { + csStr := make([]string, len(cs)) + for i, c := range cs { + csStr[i] = c.String() + } + + return strings.Join(csStr, ",") +} + +// Check tests if a constraint is validated by the given version. +func (c *Constraint) Check(v *Version) bool { + return c.f(v, c.check) +} + +func (c *Constraint) String() string { + return c.original +} + +func parseSingle(v string) (*Constraint, error) { + matches := constraintRegexp.FindStringSubmatch(v) + if matches == nil { + return nil, fmt.Errorf("Malformed constraint: %s", v) + } + + check, err := NewVersion(matches[2]) + if err != nil { + return nil, err + } + + return &Constraint{ + f: constraintOperators[matches[1]], + check: check, + original: v, + }, nil +} + +func prereleaseCheck(v, c *Version) bool { + switch vPre, cPre := v.Prerelease() != "", c.Prerelease() != ""; { + case cPre && vPre: + // A constraint with a pre-release can only match a pre-release version + // with the same base segments. + return reflect.DeepEqual(c.Segments64(), v.Segments64()) + + case !cPre && vPre: + // A constraint without a pre-release can only match a version without a + // pre-release. + return false + + case cPre && !vPre: + // OK, except with the pessimistic operator + case !cPre && !vPre: + // OK + } + return true +} + +//------------------------------------------------------------------- +// Constraint functions +//------------------------------------------------------------------- + +func constraintEqual(v, c *Version) bool { + return v.Equal(c) +} + +func constraintNotEqual(v, c *Version) bool { + return !v.Equal(c) +} + +func constraintGreaterThan(v, c *Version) bool { + return prereleaseCheck(v, c) && v.Compare(c) == 1 +} + +func constraintLessThan(v, c *Version) bool { + return prereleaseCheck(v, c) && v.Compare(c) == -1 +} + +func constraintGreaterThanEqual(v, c *Version) bool { + return prereleaseCheck(v, c) && v.Compare(c) >= 0 +} + +func constraintLessThanEqual(v, c *Version) bool { + return prereleaseCheck(v, c) && v.Compare(c) <= 0 +} + +func constraintPessimistic(v, c *Version) bool { + // Using a pessimistic constraint with a pre-release, restricts versions to pre-releases + if !prereleaseCheck(v, c) || (c.Prerelease() != "" && v.Prerelease() == "") { + return false + } + + // If the version being checked is naturally less than the constraint, then there + // is no way for the version to be valid against the constraint + if v.LessThan(c) { + return false + } + // We'll use this more than once, so grab the length now so it's a little cleaner + // to write the later checks + cs := len(c.segments) + + // If the version being checked has less specificity than the constraint, then there + // is no way for the version to be valid against the constraint + if cs > len(v.segments) { + return false + } + + // Check the segments in the constraint against those in the version. If the version + // being checked, at any point, does not have the same values in each index of the + // constraints segments, then it cannot be valid against the constraint. + for i := 0; i < c.si-1; i++ { + if v.segments[i] != c.segments[i] { + return false + } + } + + // Check the last part of the segment in the constraint. If the version segment at + // this index is less than the constraints segment at this index, then it cannot + // be valid against the constraint + if c.segments[cs-1] > v.segments[cs-1] { + return false + } + + // If nothing has rejected the version by now, it's valid + return true +} diff --git a/vendor/github.com/hashicorp/go-version/go.mod b/vendor/github.com/hashicorp/go-version/go.mod new file mode 100644 index 0000000..f528555 --- /dev/null +++ b/vendor/github.com/hashicorp/go-version/go.mod @@ -0,0 +1 @@ +module github.com/hashicorp/go-version diff --git a/vendor/github.com/hashicorp/go-version/version.go b/vendor/github.com/hashicorp/go-version/version.go new file mode 100644 index 0000000..8068834 --- /dev/null +++ b/vendor/github.com/hashicorp/go-version/version.go @@ -0,0 +1,392 @@ +package version + +import ( + "bytes" + "fmt" + "reflect" + "regexp" + "strconv" + "strings" +) + +// The compiled regular expression used to test the validity of a version. +var ( + versionRegexp *regexp.Regexp + semverRegexp *regexp.Regexp +) + +// The raw regular expression string used for testing the validity +// of a version. +const ( + VersionRegexpRaw string = `v?([0-9]+(\.[0-9]+)*?)` + + `(-([0-9]+[0-9A-Za-z\-~]*(\.[0-9A-Za-z\-~]+)*)|(-?([A-Za-z\-~]+[0-9A-Za-z\-~]*(\.[0-9A-Za-z\-~]+)*)))?` + + `(\+([0-9A-Za-z\-~]+(\.[0-9A-Za-z\-~]+)*))?` + + `?` + + // SemverRegexpRaw requires a separator between version and prerelease + SemverRegexpRaw string = `v?([0-9]+(\.[0-9]+)*?)` + + `(-([0-9]+[0-9A-Za-z\-~]*(\.[0-9A-Za-z\-~]+)*)|(-([A-Za-z\-~]+[0-9A-Za-z\-~]*(\.[0-9A-Za-z\-~]+)*)))?` + + `(\+([0-9A-Za-z\-~]+(\.[0-9A-Za-z\-~]+)*))?` + + `?` +) + +// Version represents a single version. +type Version struct { + metadata string + pre string + segments []int64 + si int + original string +} + +func init() { + versionRegexp = regexp.MustCompile("^" + VersionRegexpRaw + "$") + semverRegexp = regexp.MustCompile("^" + SemverRegexpRaw + "$") +} + +// NewVersion parses the given version and returns a new +// Version. +func NewVersion(v string) (*Version, error) { + return newVersion(v, versionRegexp) +} + +// NewSemver parses the given version and returns a new +// Version that adheres strictly to SemVer specs +// https://semver.org/ +func NewSemver(v string) (*Version, error) { + return newVersion(v, semverRegexp) +} + +func newVersion(v string, pattern *regexp.Regexp) (*Version, error) { + matches := pattern.FindStringSubmatch(v) + if matches == nil { + return nil, fmt.Errorf("Malformed version: %s", v) + } + segmentsStr := strings.Split(matches[1], ".") + segments := make([]int64, len(segmentsStr)) + si := 0 + for i, str := range segmentsStr { + val, err := strconv.ParseInt(str, 10, 64) + if err != nil { + return nil, fmt.Errorf( + "Error parsing version: %s", err) + } + + segments[i] = int64(val) + si++ + } + + // Even though we could support more than three segments, if we + // got less than three, pad it with 0s. This is to cover the basic + // default usecase of semver, which is MAJOR.MINOR.PATCH at the minimum + for i := len(segments); i < 3; i++ { + segments = append(segments, 0) + } + + pre := matches[7] + if pre == "" { + pre = matches[4] + } + + return &Version{ + metadata: matches[10], + pre: pre, + segments: segments, + si: si, + original: v, + }, nil +} + +// Must is a helper that wraps a call to a function returning (*Version, error) +// and panics if error is non-nil. +func Must(v *Version, err error) *Version { + if err != nil { + panic(err) + } + + return v +} + +// Compare compares this version to another version. This +// returns -1, 0, or 1 if this version is smaller, equal, +// or larger than the other version, respectively. +// +// If you want boolean results, use the LessThan, Equal, +// GreaterThan, GreaterThanOrEqual or LessThanOrEqual methods. +func (v *Version) Compare(other *Version) int { + // A quick, efficient equality check + if v.String() == other.String() { + return 0 + } + + segmentsSelf := v.Segments64() + segmentsOther := other.Segments64() + + // If the segments are the same, we must compare on prerelease info + if reflect.DeepEqual(segmentsSelf, segmentsOther) { + preSelf := v.Prerelease() + preOther := other.Prerelease() + if preSelf == "" && preOther == "" { + return 0 + } + if preSelf == "" { + return 1 + } + if preOther == "" { + return -1 + } + + return comparePrereleases(preSelf, preOther) + } + + // Get the highest specificity (hS), or if they're equal, just use segmentSelf length + lenSelf := len(segmentsSelf) + lenOther := len(segmentsOther) + hS := lenSelf + if lenSelf < lenOther { + hS = lenOther + } + // Compare the segments + // Because a constraint could have more/less specificity than the version it's + // checking, we need to account for a lopsided or jagged comparison + for i := 0; i < hS; i++ { + if i > lenSelf-1 { + // This means Self had the lower specificity + // Check to see if the remaining segments in Other are all zeros + if !allZero(segmentsOther[i:]) { + // if not, it means that Other has to be greater than Self + return -1 + } + break + } else if i > lenOther-1 { + // this means Other had the lower specificity + // Check to see if the remaining segments in Self are all zeros - + if !allZero(segmentsSelf[i:]) { + //if not, it means that Self has to be greater than Other + return 1 + } + break + } + lhs := segmentsSelf[i] + rhs := segmentsOther[i] + if lhs == rhs { + continue + } else if lhs < rhs { + return -1 + } + // Otherwis, rhs was > lhs, they're not equal + return 1 + } + + // if we got this far, they're equal + return 0 +} + +func allZero(segs []int64) bool { + for _, s := range segs { + if s != 0 { + return false + } + } + return true +} + +func comparePart(preSelf string, preOther string) int { + if preSelf == preOther { + return 0 + } + + var selfInt int64 + selfNumeric := true + selfInt, err := strconv.ParseInt(preSelf, 10, 64) + if err != nil { + selfNumeric = false + } + + var otherInt int64 + otherNumeric := true + otherInt, err = strconv.ParseInt(preOther, 10, 64) + if err != nil { + otherNumeric = false + } + + // if a part is empty, we use the other to decide + if preSelf == "" { + if otherNumeric { + return -1 + } + return 1 + } + + if preOther == "" { + if selfNumeric { + return 1 + } + return -1 + } + + if selfNumeric && !otherNumeric { + return -1 + } else if !selfNumeric && otherNumeric { + return 1 + } else if !selfNumeric && !otherNumeric && preSelf > preOther { + return 1 + } else if selfInt > otherInt { + return 1 + } + + return -1 +} + +func comparePrereleases(v string, other string) int { + // the same pre release! + if v == other { + return 0 + } + + // split both pre releases for analyse their parts + selfPreReleaseMeta := strings.Split(v, ".") + otherPreReleaseMeta := strings.Split(other, ".") + + selfPreReleaseLen := len(selfPreReleaseMeta) + otherPreReleaseLen := len(otherPreReleaseMeta) + + biggestLen := otherPreReleaseLen + if selfPreReleaseLen > otherPreReleaseLen { + biggestLen = selfPreReleaseLen + } + + // loop for parts to find the first difference + for i := 0; i < biggestLen; i = i + 1 { + partSelfPre := "" + if i < selfPreReleaseLen { + partSelfPre = selfPreReleaseMeta[i] + } + + partOtherPre := "" + if i < otherPreReleaseLen { + partOtherPre = otherPreReleaseMeta[i] + } + + compare := comparePart(partSelfPre, partOtherPre) + // if parts are equals, continue the loop + if compare != 0 { + return compare + } + } + + return 0 +} + +// Core returns a new version constructed from only the MAJOR.MINOR.PATCH +// segments of the version, without prerelease or metadata. +func (v *Version) Core() *Version { + segments := v.Segments64() + segmentsOnly := fmt.Sprintf("%d.%d.%d", segments[0], segments[1], segments[2]) + return Must(NewVersion(segmentsOnly)) +} + +// Equal tests if two versions are equal. +func (v *Version) Equal(o *Version) bool { + if v == nil || o == nil { + return v == o + } + + return v.Compare(o) == 0 +} + +// GreaterThan tests if this version is greater than another version. +func (v *Version) GreaterThan(o *Version) bool { + return v.Compare(o) > 0 +} + +// GreaterThanOrEqual tests if this version is greater than or equal to another version. +func (v *Version) GreaterThanOrEqual(o *Version) bool { + return v.Compare(o) >= 0 +} + +// LessThan tests if this version is less than another version. +func (v *Version) LessThan(o *Version) bool { + return v.Compare(o) < 0 +} + +// LessThanOrEqual tests if this version is less than or equal to another version. +func (v *Version) LessThanOrEqual(o *Version) bool { + return v.Compare(o) <= 0 +} + +// Metadata returns any metadata that was part of the version +// string. +// +// Metadata is anything that comes after the "+" in the version. +// For example, with "1.2.3+beta", the metadata is "beta". +func (v *Version) Metadata() string { + return v.metadata +} + +// Prerelease returns any prerelease data that is part of the version, +// or blank if there is no prerelease data. +// +// Prerelease information is anything that comes after the "-" in the +// version (but before any metadata). For example, with "1.2.3-beta", +// the prerelease information is "beta". +func (v *Version) Prerelease() string { + return v.pre +} + +// Segments returns the numeric segments of the version as a slice of ints. +// +// This excludes any metadata or pre-release information. For example, +// for a version "1.2.3-beta", segments will return a slice of +// 1, 2, 3. +func (v *Version) Segments() []int { + segmentSlice := make([]int, len(v.segments)) + for i, v := range v.segments { + segmentSlice[i] = int(v) + } + return segmentSlice +} + +// Segments64 returns the numeric segments of the version as a slice of int64s. +// +// This excludes any metadata or pre-release information. For example, +// for a version "1.2.3-beta", segments will return a slice of +// 1, 2, 3. +func (v *Version) Segments64() []int64 { + result := make([]int64, len(v.segments)) + copy(result, v.segments) + return result +} + +// String returns the full version string included pre-release +// and metadata information. +// +// This value is rebuilt according to the parsed segments and other +// information. Therefore, ambiguities in the version string such as +// prefixed zeroes (1.04.0 => 1.4.0), `v` prefix (v1.0.0 => 1.0.0), and +// missing parts (1.0 => 1.0.0) will be made into a canonicalized form +// as shown in the parenthesized examples. +func (v *Version) String() string { + var buf bytes.Buffer + fmtParts := make([]string, len(v.segments)) + for i, s := range v.segments { + // We can ignore err here since we've pre-parsed the values in segments + str := strconv.FormatInt(s, 10) + fmtParts[i] = str + } + fmt.Fprintf(&buf, strings.Join(fmtParts, ".")) + if v.pre != "" { + fmt.Fprintf(&buf, "-%s", v.pre) + } + if v.metadata != "" { + fmt.Fprintf(&buf, "+%s", v.metadata) + } + + return buf.String() +} + +// Original returns the original parsed version as-is, including any +// potential whitespace, `v` prefix, etc. +func (v *Version) Original() string { + return v.original +} diff --git a/vendor/github.com/hashicorp/go-version/version_collection.go b/vendor/github.com/hashicorp/go-version/version_collection.go new file mode 100644 index 0000000..cc888d4 --- /dev/null +++ b/vendor/github.com/hashicorp/go-version/version_collection.go @@ -0,0 +1,17 @@ +package version + +// Collection is a type that implements the sort.Interface interface +// so that versions can be sorted. +type Collection []*Version + +func (v Collection) Len() int { + return len(v) +} + +func (v Collection) Less(i, j int) bool { + return v[i].LessThan(v[j]) +} + +func (v Collection) Swap(i, j int) { + v[i], v[j] = v[j], v[i] +} diff --git a/vendor/modules.txt b/vendor/modules.txt new file mode 100644 index 0000000..eb5cb49 --- /dev/null +++ b/vendor/modules.txt @@ -0,0 +1,17 @@ +# github.com/bitrise-io/go-android v0.0.0-20210527143215-3ad22ad02e2e +## explicit +github.com/bitrise-io/go-android/adbmanager +github.com/bitrise-io/go-android/sdk +# github.com/bitrise-io/go-steputils v0.0.0-20210527075147-910ce7a105a1 +## explicit +github.com/bitrise-io/go-steputils/stepconf +# github.com/bitrise-io/go-utils v0.0.0-20210520073355-367fa34178f5 +## explicit +github.com/bitrise-io/go-utils/colorstring +github.com/bitrise-io/go-utils/command +github.com/bitrise-io/go-utils/log +github.com/bitrise-io/go-utils/parseutil +github.com/bitrise-io/go-utils/pathutil +github.com/bitrise-io/go-utils/pointers +# github.com/hashicorp/go-version v1.3.0 +github.com/hashicorp/go-version