fastlane-plugin-waldo 1.2.2 → 2.0.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
checksums.yaml
CHANGED
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
---
|
|
2
|
-
|
|
3
|
-
metadata.gz:
|
|
4
|
-
data.tar.gz:
|
|
2
|
+
SHA256:
|
|
3
|
+
metadata.gz: 2fe9bf2266ddb25b5f97e60900275c9619e8dedd8723e1ac14bbb6c37939ae2a
|
|
4
|
+
data.tar.gz: dae94679633cfcafc9a71bf5e683ed9097af91619df4443d00b6bf879b927089
|
|
5
5
|
SHA512:
|
|
6
|
-
metadata.gz:
|
|
7
|
-
data.tar.gz:
|
|
6
|
+
metadata.gz: e93282d73cf4d764db41e40727265447b1b5feb7830bda0b2d7d4643826595a748f186336efa3cf5f30a890e637054a042283f78edd865e8c5cb569608b1db27
|
|
7
|
+
data.tar.gz: e22adde22bef309cd6cb43ed6b9bd58b80f3ff43785c0c28cfa04b1bf70d5d111f78dea00b104df6bea3105b8023854fcbf101570cd0e5e520dd1c3b4f104efa
|
data/README.md
CHANGED
|
@@ -22,26 +22,6 @@ which allows you to upload an iOS or Android build to Waldo for processing.
|
|
|
22
22
|
To get started, first obtain an upload token from Waldo for your app. These are
|
|
23
23
|
used to authenticate with the Waldo backend on each call.
|
|
24
24
|
|
|
25
|
-
### Uploading an iOS Device Build
|
|
26
|
-
|
|
27
|
-
Build a new IPA for your app. If you use `gym` (aka `build_ios_app`) to build
|
|
28
|
-
your IPA, `waldo` will automatically find and upload the generated IPA.
|
|
29
|
-
|
|
30
|
-
```ruby
|
|
31
|
-
gym(export_method: 'development') # or 'ad-hoc'
|
|
32
|
-
waldo(upload_token: '0123456789abcdef0123456789abcdef')
|
|
33
|
-
```
|
|
34
|
-
|
|
35
|
-
> **Note:** You _must_ specify the Waldo upload token.
|
|
36
|
-
|
|
37
|
-
If you do _not_ use `gym` to build your IPA, you will need to explicitly
|
|
38
|
-
specify the IPA path to `waldo`:
|
|
39
|
-
|
|
40
|
-
```ruby
|
|
41
|
-
waldo(ipa_path: '/path/to/YourApp.ipa',
|
|
42
|
-
upload_token: '0123456789abcdef0123456789abcdef')
|
|
43
|
-
```
|
|
44
|
-
|
|
45
25
|
### Uploading an iOS Simulator Build
|
|
46
26
|
|
|
47
27
|
Create a new simulator build for your app.
|
|
@@ -58,19 +38,53 @@ gym(configuration: 'Release',
|
|
|
58
38
|
destination: 'generic/platform=iOS Simulator')
|
|
59
39
|
```
|
|
60
40
|
|
|
61
|
-
You can then find your app relative to the derived
|
|
62
|
-
|
|
41
|
+
You can then find your app (and associated symbols) relative to the derived
|
|
42
|
+
data path:
|
|
43
|
+
|
|
44
|
+
```ruby
|
|
45
|
+
app_path = File.join(derived_data_path,
|
|
46
|
+
'Build',
|
|
47
|
+
'Products',
|
|
48
|
+
'ReleaseSim-iphonesimulator',
|
|
49
|
+
'YourApp.app')
|
|
50
|
+
```
|
|
63
51
|
|
|
64
52
|
Regardless of how you create the actual simulator build for your app, the
|
|
65
53
|
upload itself is very simple:
|
|
66
54
|
|
|
67
55
|
```ruby
|
|
68
|
-
waldo(
|
|
69
|
-
|
|
56
|
+
waldo(upload_token: '0123456789abcdef0123456789abcdef',
|
|
57
|
+
app_path: '/path/to/YourApp.app',
|
|
58
|
+
include_symbols: true)
|
|
59
|
+
```
|
|
60
|
+
|
|
61
|
+
> **Note:** You _must_ specify _both_ the Waldo upload token _and_ the path of
|
|
62
|
+
> the `.app`. The `include_symbols` parameter is optional but we highly
|
|
63
|
+
> recommend supplying it.
|
|
64
|
+
|
|
65
|
+
### Uploading an iOS Device Build
|
|
66
|
+
|
|
67
|
+
Build a new IPA for your app. If you use `gym` (aka `build_ios_app`) to build
|
|
68
|
+
your IPA, `waldo` will automatically find and upload the generated IPA.
|
|
69
|
+
|
|
70
|
+
```ruby
|
|
71
|
+
gym(export_method: 'ad-hoc') # or 'development'
|
|
72
|
+
|
|
73
|
+
waldo(upload_token: '0123456789abcdef0123456789abcdef',
|
|
74
|
+
dsym_path: lane_context[SharedValues::DSYM_OUTPUT_PATH])
|
|
70
75
|
```
|
|
71
76
|
|
|
72
|
-
> **Note:** You _must_ specify
|
|
73
|
-
>
|
|
77
|
+
> **Note:** You _must_ specify the Waldo upload token. The `dsym_path`
|
|
78
|
+
> parameter is optional but we highly recommend supplying it.
|
|
79
|
+
|
|
80
|
+
If you do _not_ use `gym` to build your IPA, you will need to explicitly
|
|
81
|
+
specify the IPA path to `waldo`:
|
|
82
|
+
|
|
83
|
+
```ruby
|
|
84
|
+
waldo(upload_token: '0123456789abcdef0123456789abcdef',
|
|
85
|
+
ipa_path: '/path/to/YourApp.ipa',
|
|
86
|
+
dsym_path: '/path/to/YourApp.app.dSYM.zip')
|
|
87
|
+
```
|
|
74
88
|
|
|
75
89
|
### Uploading an Android Build
|
|
76
90
|
|
|
@@ -80,6 +94,7 @@ will automatically find and upload the generated APK.
|
|
|
80
94
|
```ruby
|
|
81
95
|
gradle(task: 'assemble',
|
|
82
96
|
build_type: 'Release')
|
|
97
|
+
|
|
83
98
|
waldo(upload_token: '0123456789abcdef0123456789abcdef')
|
|
84
99
|
```
|
|
85
100
|
|
|
@@ -89,8 +104,8 @@ If you do _not_ use `gradle` to build your APK, you will need to explicitly
|
|
|
89
104
|
specify the APK path to `waldo`:
|
|
90
105
|
|
|
91
106
|
```ruby
|
|
92
|
-
waldo(
|
|
93
|
-
|
|
107
|
+
waldo(upload_token: '0123456789abcdef0123456789abcdef',
|
|
108
|
+
apk_path: '/path/to/YourApp.apk')
|
|
94
109
|
```
|
|
95
110
|
|
|
96
111
|
## Issues and Feedback
|
|
@@ -4,12 +4,10 @@ module Fastlane
|
|
|
4
4
|
def self.run(params)
|
|
5
5
|
mparams = Helper::WaldoHelper.filter_parameters(params)
|
|
6
6
|
|
|
7
|
-
return unless Helper::WaldoHelper.validate_parameters(mparams)
|
|
8
|
-
|
|
9
7
|
FastlaneCore::PrintTable.print_values(config: mparams,
|
|
10
8
|
title: "Summary for waldo #{Fastlane::Waldo::VERSION.to_s}")
|
|
11
9
|
|
|
12
|
-
Helper::WaldoHelper.
|
|
10
|
+
Helper::WaldoHelper.upload_build_with_symbols(mparams)
|
|
13
11
|
end
|
|
14
12
|
|
|
15
13
|
def self.authors
|
|
@@ -39,6 +37,16 @@ module Fastlane
|
|
|
39
37
|
default_value: Actions.lane_context[Actions::SharedValues::IPA_OUTPUT_PATH] || ipa_path_default,
|
|
40
38
|
default_value_dynamic: true,
|
|
41
39
|
optional: true),
|
|
40
|
+
FastlaneCore::ConfigItem.new(key: :dsym_path,
|
|
41
|
+
env_name: 'WALDO_DSYM_PATH',
|
|
42
|
+
description: 'Path to your dSYM file(s)',
|
|
43
|
+
optional: true),
|
|
44
|
+
FastlaneCore::ConfigItem.new(key: :include_symbols,
|
|
45
|
+
env_name: 'WALDO_INCLUDE_SYMBOLS',
|
|
46
|
+
description: 'Include symbols in upload if true',
|
|
47
|
+
optional: true,
|
|
48
|
+
default_value: false,
|
|
49
|
+
is_string: false),
|
|
42
50
|
# Android-specific
|
|
43
51
|
FastlaneCore::ConfigItem.new(key: :apk_path,
|
|
44
52
|
env_name: 'WALDO_APK_PATH',
|
|
@@ -0,0 +1,672 @@
|
|
|
1
|
+
#!/usr/bin/env bash
|
|
2
|
+
|
|
3
|
+
set -eu -o pipefail
|
|
4
|
+
|
|
5
|
+
waldo_api_build_endpoint=${WALDO_API_BUILD_ENDPOINT:-https://api.waldo.io/versions}
|
|
6
|
+
waldo_api_error_endpoint=${WALDO_API_ERROR_ENDPOINT:-https://api.waldo.io/uploadError}
|
|
7
|
+
waldo_api_symbols_endpoint=${WALDO_API_SYMBOLS_ENDPOINT:-https://api.waldo.io/versions/__ID__/symbols}
|
|
8
|
+
waldo_user_agent_override=${WALDO_USER_AGENT_OVERRIDE:-}
|
|
9
|
+
|
|
10
|
+
waldo_cli_version="1.6.6"
|
|
11
|
+
|
|
12
|
+
waldo_build_flavor=""
|
|
13
|
+
waldo_build_path=""
|
|
14
|
+
waldo_build_payload_path=""
|
|
15
|
+
waldo_build_suffix=""
|
|
16
|
+
waldo_build_upload_id=""
|
|
17
|
+
waldo_extra_args="--show-error --silent"
|
|
18
|
+
waldo_history=""
|
|
19
|
+
waldo_history_error=""
|
|
20
|
+
waldo_include_symbols=false
|
|
21
|
+
waldo_platform=""
|
|
22
|
+
waldo_symbols_path=""
|
|
23
|
+
waldo_symbols_payload_path=""
|
|
24
|
+
waldo_symbols_suffix=""
|
|
25
|
+
waldo_upload_token=""
|
|
26
|
+
waldo_variant_name=""
|
|
27
|
+
waldo_working_path=""
|
|
28
|
+
|
|
29
|
+
function abs_path() {
|
|
30
|
+
local _rel_path=$1
|
|
31
|
+
|
|
32
|
+
[[ -n $_rel_path ]] || _rel_path="."
|
|
33
|
+
|
|
34
|
+
case "$_rel_path" in
|
|
35
|
+
.) pwd ;;
|
|
36
|
+
..) (unset CDPATH && cd .. &>/dev/null && pwd) ;;
|
|
37
|
+
/*) echo $_rel_path ;;
|
|
38
|
+
*) local _dirname=$(dirname "$_rel_path")
|
|
39
|
+
|
|
40
|
+
_dirname=$(unset CDPATH && cd "$_dirname" &>/dev/null && pwd)
|
|
41
|
+
|
|
42
|
+
if [[ -n $_dirname ]]; then
|
|
43
|
+
echo ${_dirname}/$(basename "$_rel_path")
|
|
44
|
+
else
|
|
45
|
+
echo $_rel_path
|
|
46
|
+
fi
|
|
47
|
+
;;
|
|
48
|
+
esac
|
|
49
|
+
}
|
|
50
|
+
|
|
51
|
+
function check_build_path() {
|
|
52
|
+
[[ -n $waldo_build_path ]] || fail_usage "Missing required argument: ‘path’"
|
|
53
|
+
|
|
54
|
+
waldo_build_path=$(abs_path "$waldo_build_path")
|
|
55
|
+
waldo_build_suffix=${waldo_build_path##*.}
|
|
56
|
+
|
|
57
|
+
case $waldo_build_suffix in
|
|
58
|
+
apk) waldo_build_flavor="Android" ;;
|
|
59
|
+
app|ipa) waldo_build_flavor="iOS" ;;
|
|
60
|
+
*) fail "File extension of build at ‘${waldo_build_path}’ is not recognized" ;;
|
|
61
|
+
esac
|
|
62
|
+
}
|
|
63
|
+
|
|
64
|
+
function check_build_status() {
|
|
65
|
+
local _response=$1
|
|
66
|
+
|
|
67
|
+
local _status_regex='"status":([0-9]+)'
|
|
68
|
+
|
|
69
|
+
if [[ $_response =~ $_status_regex ]]; then
|
|
70
|
+
local _status=${BASH_REMATCH[1]}
|
|
71
|
+
|
|
72
|
+
if (( $_status == 401 )); then
|
|
73
|
+
fail "Upload token is invalid or missing!"
|
|
74
|
+
elif (( $_status < 200 || $_status > 299 )); then
|
|
75
|
+
fail "Unable to upload build to Waldo, HTTP status: $_status"
|
|
76
|
+
fi
|
|
77
|
+
fi
|
|
78
|
+
|
|
79
|
+
local _id_regex='"id":"(appv-[0-9a-f]+)"'
|
|
80
|
+
|
|
81
|
+
if [[ $_response =~ $_id_regex ]]; then
|
|
82
|
+
waldo_build_upload_id=${BASH_REMATCH[1]}
|
|
83
|
+
fi
|
|
84
|
+
}
|
|
85
|
+
|
|
86
|
+
function check_history() {
|
|
87
|
+
if [[ -z $(which base64) ]]; then
|
|
88
|
+
waldo_history_error="noBase64CommandFound"
|
|
89
|
+
elif [[ -z $(which git) ]]; then
|
|
90
|
+
waldo_history_error="noGitCommandFound"
|
|
91
|
+
elif [[ -z $(which grep) ]]; then
|
|
92
|
+
waldo_history_error="noGrepCommandFound"
|
|
93
|
+
elif [[ -z $(which sed) ]]; then
|
|
94
|
+
waldo_history_error="noSedCommandFound"
|
|
95
|
+
elif [[ -z $(which tr) ]]; then
|
|
96
|
+
waldo_history_error="noTrCommandFound"
|
|
97
|
+
elif ! git rev-parse >& /dev/null; then
|
|
98
|
+
waldo_history_error="notGitRepository"
|
|
99
|
+
else
|
|
100
|
+
waldo_history=$(get_history)
|
|
101
|
+
fi
|
|
102
|
+
}
|
|
103
|
+
|
|
104
|
+
function check_platform() {
|
|
105
|
+
if [[ -z $(which curl) ]]; then
|
|
106
|
+
fail "No ‘curl’ command found"
|
|
107
|
+
fi
|
|
108
|
+
}
|
|
109
|
+
|
|
110
|
+
function check_symbols_path() {
|
|
111
|
+
case $waldo_build_suffix in
|
|
112
|
+
app)
|
|
113
|
+
if [[ -z $waldo_symbols_path && $waldo_include_symbols == true ]]; then
|
|
114
|
+
waldo_symbols_path=$(find_symbols_path)
|
|
115
|
+
fi
|
|
116
|
+
;;
|
|
117
|
+
ipa) ;;
|
|
118
|
+
*) waldo_symbols_path="" ;; # not applicable
|
|
119
|
+
esac
|
|
120
|
+
|
|
121
|
+
[[ -n $waldo_symbols_path ]] || return 0
|
|
122
|
+
|
|
123
|
+
waldo_symbols_path=$(abs_path "$waldo_symbols_path")
|
|
124
|
+
waldo_symbols_suffix=${waldo_symbols_path##*.}
|
|
125
|
+
|
|
126
|
+
case $waldo_symbols_suffix in
|
|
127
|
+
dSYM|xcarchive|zip) ;; # OK
|
|
128
|
+
*) fail "File extension of symbols at ‘${waldo_symbols_path}’ is not recognized" ;;
|
|
129
|
+
esac
|
|
130
|
+
}
|
|
131
|
+
|
|
132
|
+
function check_symbols_status() {
|
|
133
|
+
local _response=$1
|
|
134
|
+
|
|
135
|
+
local _status_regex='"status":([0-9]+)'
|
|
136
|
+
|
|
137
|
+
if [[ $_response =~ $_status_regex ]]; then
|
|
138
|
+
local _status=${BASH_REMATCH[1]}
|
|
139
|
+
|
|
140
|
+
if (( $_status == 401 )); then
|
|
141
|
+
fail "Upload token is invalid or missing!"
|
|
142
|
+
elif (( $_status < 200 || $_status > 299 )); then
|
|
143
|
+
fail "Unable to upload symbols to Waldo, HTTP status: $_status"
|
|
144
|
+
fi
|
|
145
|
+
fi
|
|
146
|
+
}
|
|
147
|
+
|
|
148
|
+
function check_upload_token() {
|
|
149
|
+
[[ -n $waldo_upload_token ]] || waldo_upload_token=${WALDO_UPLOAD_TOKEN:-}
|
|
150
|
+
[[ -n $waldo_upload_token ]] || fail_usage "Missing required option: ‘--upload_token’"
|
|
151
|
+
}
|
|
152
|
+
|
|
153
|
+
function check_variant_name() {
|
|
154
|
+
[[ -n $waldo_variant_name ]] || waldo_variant_name=${WALDO_VARIANT_NAME:-}
|
|
155
|
+
}
|
|
156
|
+
|
|
157
|
+
function convert_sha() {
|
|
158
|
+
local _full_sha=$1
|
|
159
|
+
local _full_name=$(git name-rev --refs='heads/*' --name-only "$_full_sha")
|
|
160
|
+
local _abbr_sha=${_full_sha:0:7}
|
|
161
|
+
local _abbr_name=$_full_name
|
|
162
|
+
local _prefix="remotes/origin/"
|
|
163
|
+
|
|
164
|
+
if [[ ${_full_name:0:${#_prefix}} == $_prefix ]]; then
|
|
165
|
+
_abbr_name=${_full_name#$_prefix}
|
|
166
|
+
else
|
|
167
|
+
_abbr_name="local:${_full_name}"
|
|
168
|
+
fi
|
|
169
|
+
|
|
170
|
+
echo "${_abbr_sha}-${_abbr_name}"
|
|
171
|
+
}
|
|
172
|
+
|
|
173
|
+
function convert_shas() {
|
|
174
|
+
local _list=
|
|
175
|
+
|
|
176
|
+
while (( $# )); do
|
|
177
|
+
local _item=$(convert_sha "$1")
|
|
178
|
+
|
|
179
|
+
_list+=",\"${_item}\""
|
|
180
|
+
|
|
181
|
+
shift
|
|
182
|
+
done
|
|
183
|
+
|
|
184
|
+
echo ${_list#?}
|
|
185
|
+
}
|
|
186
|
+
|
|
187
|
+
function create_build_payload() {
|
|
188
|
+
local _parent_path=$(dirname "$waldo_build_path")
|
|
189
|
+
local _build_name=$(basename "$waldo_build_path")
|
|
190
|
+
|
|
191
|
+
case $waldo_build_suffix in
|
|
192
|
+
app)
|
|
193
|
+
([[ -d $waldo_build_path && -r $waldo_build_path ]]) \
|
|
194
|
+
|| fail "Unable to read build at ‘${waldo_build_path}’"
|
|
195
|
+
|
|
196
|
+
if [[ -z $(which zip) ]]; then
|
|
197
|
+
fail "No ‘zip’ command found"
|
|
198
|
+
fi
|
|
199
|
+
|
|
200
|
+
waldo_build_payload_path="$waldo_working_path"/"$_build_name".zip
|
|
201
|
+
|
|
202
|
+
(cd "$_parent_path" &>/dev/null && zip -qry "$waldo_build_payload_path" "$_build_name") || return
|
|
203
|
+
;;
|
|
204
|
+
|
|
205
|
+
*)
|
|
206
|
+
([[ -f $waldo_build_path && -r $waldo_build_path ]]) \
|
|
207
|
+
|| fail "Unable to read build at ‘${waldo_build_path}’"
|
|
208
|
+
|
|
209
|
+
waldo_build_payload_path=$waldo_build_path
|
|
210
|
+
;;
|
|
211
|
+
esac
|
|
212
|
+
}
|
|
213
|
+
|
|
214
|
+
function create_symbols_payload() {
|
|
215
|
+
[[ -n $waldo_symbols_path ]] || return 0
|
|
216
|
+
|
|
217
|
+
local _parent_path=$(dirname "$waldo_symbols_path")
|
|
218
|
+
local _symbols_name=$(basename "$waldo_symbols_path")
|
|
219
|
+
|
|
220
|
+
case $waldo_symbols_suffix in
|
|
221
|
+
dSYM)
|
|
222
|
+
([[ -d $waldo_symbols_path && -r $waldo_symbols_path ]]) \
|
|
223
|
+
|| fail "Unable to read symbols at ‘${waldo_symbols_path}’"
|
|
224
|
+
|
|
225
|
+
if [[ -z $(which zip) ]]; then
|
|
226
|
+
fail "No ‘zip’ command found"
|
|
227
|
+
fi
|
|
228
|
+
|
|
229
|
+
waldo_symbols_payload_path="$waldo_working_path"/"$_symbols_name".zip
|
|
230
|
+
|
|
231
|
+
(cd "$_parent_path" &>/dev/null && zip -qry "$waldo_symbols_payload_path" "$_symbols_name") || return
|
|
232
|
+
;;
|
|
233
|
+
|
|
234
|
+
xcarchive)
|
|
235
|
+
([[ -d $waldo_symbols_path && -r $waldo_symbols_path ]]) \
|
|
236
|
+
|| fail "Unable to read symbols at ‘${waldo_symbols_path}’"
|
|
237
|
+
|
|
238
|
+
if [[ -z $(which zip) ]]; then
|
|
239
|
+
fail "No ‘zip’ command found"
|
|
240
|
+
fi
|
|
241
|
+
|
|
242
|
+
local _tmp_symbols_path="$waldo_working_path"/"$_symbols_name"
|
|
243
|
+
|
|
244
|
+
mkdir -p "$_tmp_symbols_path"
|
|
245
|
+
|
|
246
|
+
cp -r "$waldo_symbols_path"/BCSymbolMaps "$_tmp_symbols_path"
|
|
247
|
+
cp -r "$waldo_symbols_path"/dSYMs "$_tmp_symbols_path"
|
|
248
|
+
|
|
249
|
+
waldo_symbols_payload_path="$_tmp_symbols_path".zip
|
|
250
|
+
|
|
251
|
+
(cd "$waldo_working_path" &>/dev/null && zip -qry "$waldo_symbols_payload_path" "$_symbols_name") || return
|
|
252
|
+
;;
|
|
253
|
+
|
|
254
|
+
*)
|
|
255
|
+
([[ -f $waldo_symbols_path && -r $waldo_symbols_path ]]) \
|
|
256
|
+
|| fail "Unable to read symbols at ‘${waldo_symbols_path}’"
|
|
257
|
+
|
|
258
|
+
waldo_symbols_payload_path=$waldo_symbols_path
|
|
259
|
+
;;
|
|
260
|
+
esac
|
|
261
|
+
}
|
|
262
|
+
|
|
263
|
+
function create_working_path() {
|
|
264
|
+
waldo_working_path=/tmp/WaldoCLI-$$
|
|
265
|
+
|
|
266
|
+
rm -rf "$waldo_working_path"
|
|
267
|
+
mkdir -p "$waldo_working_path"
|
|
268
|
+
}
|
|
269
|
+
|
|
270
|
+
function curl_upload_build() {
|
|
271
|
+
local _output_path="$1"
|
|
272
|
+
local _authorization=$(get_authorization)
|
|
273
|
+
local _content_type=$(get_build_content_type)
|
|
274
|
+
local _user_agent=$(get_user_agent)
|
|
275
|
+
local _url=$(make_build_url)
|
|
276
|
+
|
|
277
|
+
curl $waldo_extra_args \
|
|
278
|
+
--data-binary @"$waldo_build_payload_path" \
|
|
279
|
+
--header "Authorization: $_authorization" \
|
|
280
|
+
--header "Content-Type: $_content_type" \
|
|
281
|
+
--header "User-Agent: $_user_agent" \
|
|
282
|
+
--output "$_output_path" \
|
|
283
|
+
"$_url"
|
|
284
|
+
|
|
285
|
+
local _curl_status=$?
|
|
286
|
+
|
|
287
|
+
if (( $_curl_status != 0 )); then
|
|
288
|
+
fail "Unable to upload build to Waldo, curl error: ${_curl_status}, url: ${_url}"
|
|
289
|
+
fi
|
|
290
|
+
}
|
|
291
|
+
|
|
292
|
+
function curl_upload_error() {
|
|
293
|
+
local _message=$(json_escape "$1")
|
|
294
|
+
local _ci=$(get_ci)
|
|
295
|
+
local _authorization=$(get_authorization)
|
|
296
|
+
local _content_type=$(get_error_content_type)
|
|
297
|
+
local _user_agent=$(get_user_agent)
|
|
298
|
+
local _url=$(make_error_url)
|
|
299
|
+
|
|
300
|
+
curl --silent \
|
|
301
|
+
--data "{\"message\":\"${_message}\",\"ci\":\"${_ci}\"}" \
|
|
302
|
+
--header "Authorization: $_authorization" \
|
|
303
|
+
--header "Content-Type: $_content_type" \
|
|
304
|
+
--header "User-Agent: $_user_agent" \
|
|
305
|
+
"$_url" &>/dev/null
|
|
306
|
+
}
|
|
307
|
+
|
|
308
|
+
function curl_upload_symbols() {
|
|
309
|
+
local _output_path="$1"
|
|
310
|
+
local _authorization=$(get_authorization)
|
|
311
|
+
local _content_type=$(get_symbols_content_type)
|
|
312
|
+
local _user_agent=$(get_user_agent)
|
|
313
|
+
local _url=$(make_symbols_url)
|
|
314
|
+
|
|
315
|
+
curl $waldo_extra_args \
|
|
316
|
+
--data-binary @"$waldo_symbols_payload_path" \
|
|
317
|
+
--header "Authorization: $_authorization" \
|
|
318
|
+
--header "Content-Type: $_content_type" \
|
|
319
|
+
--header "User-Agent: $_user_agent" \
|
|
320
|
+
--output "$_output_path" \
|
|
321
|
+
"$_url"
|
|
322
|
+
|
|
323
|
+
local _curl_status=$?
|
|
324
|
+
|
|
325
|
+
if (( $_curl_status != 0 )); then
|
|
326
|
+
fail "Unable to upload symbols to Waldo, curl error: ${_curl_status}, url: ${_url}"
|
|
327
|
+
fi
|
|
328
|
+
}
|
|
329
|
+
|
|
330
|
+
function delete_working_path() {
|
|
331
|
+
if [[ -n $waldo_working_path ]]; then
|
|
332
|
+
rm -rf "$waldo_working_path"
|
|
333
|
+
fi
|
|
334
|
+
}
|
|
335
|
+
|
|
336
|
+
function display_summary() {
|
|
337
|
+
echo ""
|
|
338
|
+
echo "Build path: $(summarize "$waldo_build_path")"
|
|
339
|
+
echo "Symbols path: $(summarize "$waldo_symbols_path")"
|
|
340
|
+
echo "Variant name: $(summarize "$waldo_variant_name")"
|
|
341
|
+
echo "Upload token: $(summarize_secure "$waldo_upload_token")"
|
|
342
|
+
echo ""
|
|
343
|
+
|
|
344
|
+
if [[ $waldo_extra_args == "--verbose" ]]; then
|
|
345
|
+
echo "Build payload path: $(summarize "$waldo_build_payload_path")"
|
|
346
|
+
echo "Symbols payload path: $(summarize "$waldo_symbols_payload_path")"
|
|
347
|
+
echo ""
|
|
348
|
+
fi
|
|
349
|
+
}
|
|
350
|
+
|
|
351
|
+
function display_usage() {
|
|
352
|
+
cat <<EOF
|
|
353
|
+
|
|
354
|
+
OVERVIEW: Upload build to Waldo
|
|
355
|
+
|
|
356
|
+
USAGE: waldo [options] <build-path> [<symbols-path>]
|
|
357
|
+
|
|
358
|
+
OPTIONS:
|
|
359
|
+
|
|
360
|
+
--help Display available options
|
|
361
|
+
--include_symbols Include symbols with the build upload
|
|
362
|
+
--upload_token <value> Waldo upload token (overrides WALDO_UPLOAD_TOKEN)
|
|
363
|
+
--variant_name <value> Waldo variant name (overrides WALDO_VARIANT_NAME)
|
|
364
|
+
--verbose Display extra verbiage
|
|
365
|
+
EOF
|
|
366
|
+
}
|
|
367
|
+
|
|
368
|
+
function display_version() {
|
|
369
|
+
waldo_platform=$(get_platform)
|
|
370
|
+
|
|
371
|
+
echo "Waldo CLI $waldo_cli_version ($waldo_platform)"
|
|
372
|
+
}
|
|
373
|
+
|
|
374
|
+
function fail() {
|
|
375
|
+
local _message="waldo: $1"
|
|
376
|
+
|
|
377
|
+
if [[ -n $waldo_upload_token ]]; then
|
|
378
|
+
curl_upload_error "$1"
|
|
379
|
+
|
|
380
|
+
local _curl_status=$?
|
|
381
|
+
|
|
382
|
+
if (( $_curl_status == 0)); then
|
|
383
|
+
_message+=" -- Waldo team has been informed"
|
|
384
|
+
fi
|
|
385
|
+
fi
|
|
386
|
+
|
|
387
|
+
echo "" # flush stdout
|
|
388
|
+
echo "$_message" 1>&2
|
|
389
|
+
exit 1
|
|
390
|
+
}
|
|
391
|
+
|
|
392
|
+
function fail_usage() {
|
|
393
|
+
[[ -z $waldo_upload_token ]] || curl_upload_error "$1"
|
|
394
|
+
|
|
395
|
+
echo "" # flush stdout
|
|
396
|
+
echo "waldo: $1" 1>&2
|
|
397
|
+
display_usage
|
|
398
|
+
exit 1
|
|
399
|
+
}
|
|
400
|
+
|
|
401
|
+
function find_symbols_path() {
|
|
402
|
+
if [[ -e ${waldo_build_path}.dSYM.zip ]]; then
|
|
403
|
+
echo "${waldo_build_path}.dSYM.zip"
|
|
404
|
+
elif [[ -e ${waldo_build_path}.dSYM ]]; then
|
|
405
|
+
echo "${waldo_build_path}.dSYM"
|
|
406
|
+
fi
|
|
407
|
+
}
|
|
408
|
+
|
|
409
|
+
function get_authorization() {
|
|
410
|
+
echo "Upload-Token $waldo_upload_token"
|
|
411
|
+
}
|
|
412
|
+
|
|
413
|
+
function get_build_content_type() {
|
|
414
|
+
case $waldo_build_suffix in
|
|
415
|
+
app) echo "application/zip" ;;
|
|
416
|
+
*) echo "application/octet-stream" ;;
|
|
417
|
+
esac
|
|
418
|
+
}
|
|
419
|
+
|
|
420
|
+
function get_ci() {
|
|
421
|
+
if [[ -n ${APPCENTER_BUILD_ID:-} ]]; then
|
|
422
|
+
echo "App Center"
|
|
423
|
+
elif [[ ${BITRISE_IO:-false} == true ]]; then
|
|
424
|
+
echo "Bitrise"
|
|
425
|
+
elif [[ -n ${BUDDYBUILD_BUILD_ID:-} ]]; then
|
|
426
|
+
echo "buddybuild"
|
|
427
|
+
elif [[ ${CIRCLECI:-false} == true ]]; then
|
|
428
|
+
echo "CircleCI"
|
|
429
|
+
elif [[ ${GITHUB_ACTIONS:-false} == true ]]; then
|
|
430
|
+
echo "GitHub Actions"
|
|
431
|
+
elif [[ ${TRAVIS:-false} == true ]]; then
|
|
432
|
+
echo "Travis CI"
|
|
433
|
+
else
|
|
434
|
+
echo "CLI"
|
|
435
|
+
fi
|
|
436
|
+
}
|
|
437
|
+
|
|
438
|
+
function get_error_content_type() {
|
|
439
|
+
echo "application/json"
|
|
440
|
+
}
|
|
441
|
+
|
|
442
|
+
function get_history() {
|
|
443
|
+
local _shas=$(git log --format='%H' --skip=$(get_skip_count) -50)
|
|
444
|
+
local _history=$(convert_shas $_shas)
|
|
445
|
+
|
|
446
|
+
echo "[${_history}]" | websafe_base64_encode
|
|
447
|
+
}
|
|
448
|
+
|
|
449
|
+
function get_platform() {
|
|
450
|
+
local _os_name=$(uname -s)
|
|
451
|
+
|
|
452
|
+
case $_os_name in
|
|
453
|
+
Darwin) echo "macOS" ;;
|
|
454
|
+
*) echo "$_os_name" ;;
|
|
455
|
+
esac
|
|
456
|
+
}
|
|
457
|
+
|
|
458
|
+
function get_skip_count() {
|
|
459
|
+
if [[ ${GITHUB_ACTIONS:-false} == true && ${GITHUB_EVENT_NAME:-} == "pull_request" ]]; then
|
|
460
|
+
echo "1"
|
|
461
|
+
else
|
|
462
|
+
echo "0"
|
|
463
|
+
fi
|
|
464
|
+
}
|
|
465
|
+
|
|
466
|
+
function get_symbols_content_type() {
|
|
467
|
+
echo "application/zip"
|
|
468
|
+
}
|
|
469
|
+
|
|
470
|
+
function get_user_agent() {
|
|
471
|
+
if [[ -n $waldo_user_agent_override ]]; then
|
|
472
|
+
echo "$waldo_user_agent_override"
|
|
473
|
+
else
|
|
474
|
+
echo "Waldo $(get_ci)/${waldo_build_flavor} v${waldo_cli_version}"
|
|
475
|
+
fi
|
|
476
|
+
}
|
|
477
|
+
|
|
478
|
+
function json_escape() {
|
|
479
|
+
local _result=${1//\\/\\\\} # \
|
|
480
|
+
|
|
481
|
+
_result=${_result//\//\\\/} # /
|
|
482
|
+
_result=${_result//\'/\\\'} # '
|
|
483
|
+
_result=${_result//\"/\\\"} # "
|
|
484
|
+
|
|
485
|
+
echo "$_result"
|
|
486
|
+
}
|
|
487
|
+
|
|
488
|
+
function make_build_url() {
|
|
489
|
+
local _query=
|
|
490
|
+
|
|
491
|
+
if [[ -n $waldo_history ]]; then
|
|
492
|
+
_query+="&history=$waldo_history"
|
|
493
|
+
fi
|
|
494
|
+
|
|
495
|
+
if [[ -n $waldo_history_error ]]; then
|
|
496
|
+
_query+="&historyError=$waldo_history_error"
|
|
497
|
+
fi
|
|
498
|
+
|
|
499
|
+
if [[ -n $waldo_variant_name ]]; then
|
|
500
|
+
_query+="&variantName=$waldo_variant_name"
|
|
501
|
+
fi
|
|
502
|
+
|
|
503
|
+
if [[ -n $_query ]]; then
|
|
504
|
+
echo "${waldo_api_build_endpoint}?${_query:1}"
|
|
505
|
+
else
|
|
506
|
+
echo "${waldo_api_build_endpoint}"
|
|
507
|
+
fi
|
|
508
|
+
}
|
|
509
|
+
|
|
510
|
+
function make_error_url() {
|
|
511
|
+
echo "${waldo_api_error_endpoint}"
|
|
512
|
+
}
|
|
513
|
+
|
|
514
|
+
function make_symbols_url() {
|
|
515
|
+
echo "${waldo_api_symbols_endpoint/__ID__/$waldo_build_upload_id}"
|
|
516
|
+
}
|
|
517
|
+
|
|
518
|
+
function summarize() {
|
|
519
|
+
local _value=$1
|
|
520
|
+
|
|
521
|
+
if [[ -n $_value ]]; then
|
|
522
|
+
echo "‘${_value}’"
|
|
523
|
+
else
|
|
524
|
+
echo "(none)"
|
|
525
|
+
fi
|
|
526
|
+
}
|
|
527
|
+
|
|
528
|
+
function summarize_secure() {
|
|
529
|
+
local _value=$1
|
|
530
|
+
|
|
531
|
+
if [[ $waldo_extra_args != "--verbose" ]]; then
|
|
532
|
+
local _prefix=${_value:0:6}
|
|
533
|
+
local _suffix_len=$(( ${#_value} - ${#_prefix} ))
|
|
534
|
+
local _secure='********************************'
|
|
535
|
+
|
|
536
|
+
_value="${_prefix}${_secure:0:$_suffix_len}"
|
|
537
|
+
fi
|
|
538
|
+
|
|
539
|
+
summarize "$_value"
|
|
540
|
+
}
|
|
541
|
+
|
|
542
|
+
function upload_build() {
|
|
543
|
+
local _build_name=$(basename "$waldo_build_path")
|
|
544
|
+
|
|
545
|
+
local _response_path=$waldo_working_path/build_response.json
|
|
546
|
+
|
|
547
|
+
echo "Uploading build to Waldo"
|
|
548
|
+
|
|
549
|
+
[[ $waldo_extra_args == "--verbose" ]] && echo ""
|
|
550
|
+
|
|
551
|
+
curl_upload_build "$_response_path"
|
|
552
|
+
|
|
553
|
+
local _curl_status=$?
|
|
554
|
+
local _response=$(cat "$_response_path" 2>/dev/null)
|
|
555
|
+
|
|
556
|
+
if [[ $waldo_extra_args == "--verbose" ]]; then
|
|
557
|
+
echo "$_response"
|
|
558
|
+
echo ""
|
|
559
|
+
fi
|
|
560
|
+
|
|
561
|
+
check_build_status "$_response"
|
|
562
|
+
|
|
563
|
+
if (( $_curl_status == 0 )); then
|
|
564
|
+
echo "Build ‘${_build_name}’ successfully uploaded to Waldo!"
|
|
565
|
+
fi
|
|
566
|
+
}
|
|
567
|
+
|
|
568
|
+
function upload_symbols() {
|
|
569
|
+
[[ -n $waldo_symbols_path ]] || return 0
|
|
570
|
+
|
|
571
|
+
local _symbols_name=$(basename "$waldo_symbols_path")
|
|
572
|
+
|
|
573
|
+
local _response_path=$waldo_working_path/symbols_response.json
|
|
574
|
+
|
|
575
|
+
echo "Uploading symbols to Waldo"
|
|
576
|
+
|
|
577
|
+
[[ $waldo_extra_args == "--verbose" ]] && echo ""
|
|
578
|
+
|
|
579
|
+
curl_upload_symbols "$_response_path"
|
|
580
|
+
|
|
581
|
+
local _curl_status=$?
|
|
582
|
+
local _response=$(cat "$_response_path" 2>/dev/null)
|
|
583
|
+
|
|
584
|
+
if [[ $waldo_extra_args == "--verbose" ]]; then
|
|
585
|
+
echo "$_response"
|
|
586
|
+
echo ""
|
|
587
|
+
fi
|
|
588
|
+
|
|
589
|
+
check_symbols_status "$_response"
|
|
590
|
+
|
|
591
|
+
if (( $_curl_status == 0 )); then
|
|
592
|
+
echo "Symbols in ‘${_symbols_name}’ successfully uploaded to Waldo!"
|
|
593
|
+
fi
|
|
594
|
+
}
|
|
595
|
+
|
|
596
|
+
function websafe_base64_encode() {
|
|
597
|
+
base64 | tr -d '\n' | tr '/+' '_-' | sed 's/=/%3D/g'
|
|
598
|
+
}
|
|
599
|
+
|
|
600
|
+
display_version
|
|
601
|
+
|
|
602
|
+
while (( $# )); do
|
|
603
|
+
case $1 in
|
|
604
|
+
--help)
|
|
605
|
+
display_usage
|
|
606
|
+
exit
|
|
607
|
+
;;
|
|
608
|
+
|
|
609
|
+
--include_symbols)
|
|
610
|
+
waldo_include_symbols=true
|
|
611
|
+
;;
|
|
612
|
+
|
|
613
|
+
--upload_token)
|
|
614
|
+
if (( $# < 2 )) || [[ -z $2 || ${2:0:1} == "-" ]]; then
|
|
615
|
+
fail_usage "Missing required value for option: ‘${1}’"
|
|
616
|
+
else
|
|
617
|
+
waldo_upload_token=$2
|
|
618
|
+
shift
|
|
619
|
+
fi
|
|
620
|
+
;;
|
|
621
|
+
|
|
622
|
+
--variant_name)
|
|
623
|
+
if (( $# < 2 )) || [[ -z $2 || ${2:0:1} == "-" ]]; then
|
|
624
|
+
fail_usage "Missing required value for option: ‘${1}’"
|
|
625
|
+
else
|
|
626
|
+
waldo_variant_name=$2
|
|
627
|
+
shift
|
|
628
|
+
fi
|
|
629
|
+
;;
|
|
630
|
+
|
|
631
|
+
--verbose)
|
|
632
|
+
waldo_extra_args="--verbose"
|
|
633
|
+
;;
|
|
634
|
+
|
|
635
|
+
-*)
|
|
636
|
+
fail_usage "Unknown option: ‘${1}’"
|
|
637
|
+
;;
|
|
638
|
+
|
|
639
|
+
*)
|
|
640
|
+
if [[ -z $waldo_build_path ]]; then
|
|
641
|
+
waldo_build_path=$1
|
|
642
|
+
elif [[ -z $waldo_symbols_path ]]; then
|
|
643
|
+
waldo_symbols_path=$1
|
|
644
|
+
else
|
|
645
|
+
fail_usage "Unknown argument: ‘${1}’"
|
|
646
|
+
fi
|
|
647
|
+
;;
|
|
648
|
+
esac
|
|
649
|
+
|
|
650
|
+
shift
|
|
651
|
+
done
|
|
652
|
+
|
|
653
|
+
check_platform || exit
|
|
654
|
+
check_build_path || exit
|
|
655
|
+
check_symbols_path || exit
|
|
656
|
+
check_history || exit
|
|
657
|
+
check_upload_token || exit
|
|
658
|
+
check_variant_name || exit
|
|
659
|
+
|
|
660
|
+
create_working_path || exit
|
|
661
|
+
|
|
662
|
+
create_build_payload || exit
|
|
663
|
+
create_symbols_payload || exit
|
|
664
|
+
|
|
665
|
+
display_summary
|
|
666
|
+
|
|
667
|
+
upload_build || exit
|
|
668
|
+
upload_symbols || exit
|
|
669
|
+
|
|
670
|
+
delete_working_path # failure is OK
|
|
671
|
+
|
|
672
|
+
exit
|
|
@@ -1,41 +1,20 @@
|
|
|
1
|
-
require 'net/http'
|
|
2
|
-
|
|
3
1
|
module Fastlane
|
|
4
2
|
module Helper
|
|
5
3
|
class WaldoHelper
|
|
6
|
-
def self.dump_request(request)
|
|
7
|
-
len = request.body ? request.body.length : 0
|
|
8
|
-
|
|
9
|
-
puts "Request: #{request.method} #{request.path} (#{len} bytes)"
|
|
10
|
-
|
|
11
|
-
request.each_capitalized do |key, value|
|
|
12
|
-
puts " #{key}: #{value}"
|
|
13
|
-
end
|
|
14
|
-
|
|
15
|
-
puts '-------'
|
|
16
|
-
end
|
|
17
|
-
|
|
18
|
-
def self.dump_response(response)
|
|
19
|
-
puts "Response: #{response.code} #{response.message} (#{response.body.length} bytes)"
|
|
20
|
-
|
|
21
|
-
response.each_capitalized do |key, value|
|
|
22
|
-
puts " #{key}: #{value}"
|
|
23
|
-
end
|
|
24
|
-
|
|
25
|
-
puts "#{response.body}"
|
|
26
|
-
end
|
|
27
|
-
|
|
28
4
|
def self.filter_parameters(in_params)
|
|
29
5
|
out_params = {}
|
|
30
6
|
|
|
31
7
|
apk_path = in_params[:apk_path]
|
|
32
8
|
app_path = in_params[:app_path]
|
|
9
|
+
dsym_path = in_params[:dsym_path]
|
|
10
|
+
include_symbols = in_params[:include_symbols]
|
|
33
11
|
ipa_path = in_params[:ipa_path]
|
|
34
12
|
upload_token = in_params[:upload_token]
|
|
35
|
-
variant_name = in_params[:variant_name]
|
|
13
|
+
variant_name = in_params[:variant_name] || Actions.lane_context[Actions::SharedValues::GRADLE_BUILD_TYPE]
|
|
36
14
|
|
|
37
15
|
apk_path.gsub!("\\ ", ' ') if apk_path
|
|
38
16
|
app_path.gsub!("\\ ", ' ') if app_path
|
|
17
|
+
dsym_path.gsub!("\\ ", ' ') if dsym_path
|
|
39
18
|
ipa_path.gsub!("\\ ", ' ') if ipa_path
|
|
40
19
|
|
|
41
20
|
out_params[:apk_path] = apk_path if apk_path
|
|
@@ -43,36 +22,47 @@ module Fastlane
|
|
|
43
22
|
if app_path && ipa_path
|
|
44
23
|
if !File.exist?(app_path)
|
|
45
24
|
out_params[:ipa_path] = ipa_path
|
|
25
|
+
|
|
26
|
+
app_path = nil
|
|
46
27
|
elsif !File.exist?(ipa_path)
|
|
47
28
|
out_params[:app_path] = app_path
|
|
29
|
+
|
|
30
|
+
ipa_path = nil
|
|
48
31
|
elsif File.mtime(app_path) < File.mtime(ipa_path)
|
|
49
32
|
out_params[:ipa_path] = ipa_path
|
|
33
|
+
|
|
34
|
+
app_path = nil
|
|
50
35
|
else
|
|
51
36
|
out_params[:app_path] = app_path
|
|
37
|
+
|
|
38
|
+
ipa_path = nil
|
|
52
39
|
end
|
|
53
40
|
else
|
|
54
41
|
out_params[:app_path] = app_path if app_path
|
|
55
42
|
out_params[:ipa_path] = ipa_path if ipa_path
|
|
56
43
|
end
|
|
57
44
|
|
|
58
|
-
|
|
45
|
+
if app_path
|
|
46
|
+
out_params[:dsym_path] = dsym_path if dsym_path
|
|
47
|
+
out_params[:include_symbols] = include_symbols if include_symbols
|
|
48
|
+
else
|
|
49
|
+
out_params[:dsym_path] = dsym_path if dsym_path && ipa_path
|
|
50
|
+
end
|
|
51
|
+
|
|
52
|
+
out_params[:upload_token] = upload_token if upload_token
|
|
59
53
|
out_params[:variant_name] = variant_name if variant_name
|
|
60
54
|
|
|
61
55
|
out_params
|
|
62
56
|
end
|
|
63
57
|
|
|
64
|
-
def self.get_authorization
|
|
65
|
-
"Upload-Token #{@upload_token}"
|
|
66
|
-
end
|
|
67
|
-
|
|
68
58
|
def self.get_flavor
|
|
69
59
|
case get_platform
|
|
70
60
|
when :android
|
|
71
|
-
|
|
61
|
+
'Android'
|
|
72
62
|
when :ios
|
|
73
|
-
|
|
63
|
+
'iOS'
|
|
74
64
|
else
|
|
75
|
-
|
|
65
|
+
'unknown'
|
|
76
66
|
end
|
|
77
67
|
end
|
|
78
68
|
|
|
@@ -80,268 +70,50 @@ module Fastlane
|
|
|
80
70
|
Actions.lane_context[Actions::SharedValues::PLATFORM_NAME] || :ios
|
|
81
71
|
end
|
|
82
72
|
|
|
83
|
-
def self.
|
|
84
|
-
|
|
85
|
-
end
|
|
86
|
-
|
|
87
|
-
def self.handle_error(message)
|
|
88
|
-
UI.error(message)
|
|
89
|
-
|
|
90
|
-
UI.error('No token for error report upload to Waldo!') unless @upload_token
|
|
91
|
-
|
|
92
|
-
upload_error(message) if @upload_token
|
|
93
|
-
end
|
|
94
|
-
|
|
95
|
-
def self.make_build_request(uri)
|
|
96
|
-
if @apk_path
|
|
97
|
-
body_path = @apk_path
|
|
98
|
-
elsif @ipa_path
|
|
99
|
-
body_path = @ipa_path
|
|
100
|
-
else
|
|
101
|
-
app_basename = File.basename(@app_path)
|
|
102
|
-
app_dirname = File.dirname(@app_path)
|
|
103
|
-
|
|
104
|
-
body_path = File.join(Dir.tmpdir, "#{app_basename}.zip")
|
|
105
|
-
|
|
106
|
-
unless zip(src_path: app_basename,
|
|
107
|
-
zip_path: body_path,
|
|
108
|
-
cd_path: app_dirname)
|
|
109
|
-
return nil
|
|
110
|
-
end
|
|
111
|
-
end
|
|
112
|
-
|
|
113
|
-
request = Net::HTTP::Post.new(uri.request_uri)
|
|
114
|
-
|
|
115
|
-
request['Authorization'] = get_authorization
|
|
116
|
-
request['Transfer-Encoding'] = 'chunked'
|
|
117
|
-
request['User-Agent'] = get_user_agent
|
|
118
|
-
|
|
119
|
-
request.body_stream = WaldoReadIO.new(body_path)
|
|
120
|
-
|
|
121
|
-
if @app_path
|
|
122
|
-
request.content_type = 'application/zip'
|
|
123
|
-
else
|
|
124
|
-
request.content_type = 'application/octet-stream'
|
|
125
|
-
end
|
|
126
|
-
|
|
127
|
-
request
|
|
128
|
-
end
|
|
129
|
-
|
|
130
|
-
def self.make_build_uri
|
|
131
|
-
uri_string = 'https://api.waldo.io/versions'
|
|
132
|
-
|
|
133
|
-
uri_string += "?variantName=#{@variant_name}" if @variant_name
|
|
134
|
-
|
|
135
|
-
URI(uri_string)
|
|
136
|
-
end
|
|
137
|
-
|
|
138
|
-
def self.make_error_request(uri, message)
|
|
139
|
-
request = Net::HTTP::Post.new(uri.request_uri)
|
|
140
|
-
|
|
141
|
-
request['Authorization'] = get_authorization
|
|
142
|
-
request['User-Agent'] = get_user_agent
|
|
143
|
-
|
|
144
|
-
request.body = { "message": message }.to_json
|
|
145
|
-
request.content_type = 'application/json'
|
|
146
|
-
|
|
147
|
-
request
|
|
148
|
-
end
|
|
149
|
-
|
|
150
|
-
def self.make_error_uri
|
|
151
|
-
uri_string = 'https://api.waldo.io/uploadError'
|
|
152
|
-
|
|
153
|
-
URI(uri_string)
|
|
154
|
-
end
|
|
155
|
-
|
|
156
|
-
def self.parse_build_response(response)
|
|
157
|
-
dump_response(response) if FastlaneCore::Globals.verbose?
|
|
158
|
-
|
|
159
|
-
case response.code.to_i
|
|
160
|
-
when 200..299
|
|
161
|
-
UI.success('Build successfully uploaded to Waldo!')
|
|
162
|
-
when 401
|
|
163
|
-
handle_error('Token is invalid or missing for build upload to Waldo!')
|
|
164
|
-
else
|
|
165
|
-
handle_error("Build failed to upload to Waldo: #{response.code} #{response.message}")
|
|
166
|
-
end
|
|
167
|
-
end
|
|
168
|
-
|
|
169
|
-
def self.parse_error_response(response)
|
|
170
|
-
dump_response(response) if FastlaneCore::Globals.verbose?
|
|
171
|
-
|
|
172
|
-
case response.code.to_i
|
|
173
|
-
when 200..299
|
|
174
|
-
UI.success('Error report successfully uploaded to Waldo!')
|
|
175
|
-
when 401
|
|
176
|
-
UI.error('Token is invalid or missing for error report upload to Waldo!')
|
|
177
|
-
else
|
|
178
|
-
UI.error("Error report failed to upload to Waldo: #{response.code} #{response.message}")
|
|
179
|
-
end
|
|
180
|
-
end
|
|
181
|
-
|
|
182
|
-
def self.upload_build
|
|
183
|
-
begin
|
|
184
|
-
@variant_name ||= Actions.lane_context[Actions::SharedValues::GRADLE_BUILD_TYPE]
|
|
185
|
-
|
|
186
|
-
uri = make_build_uri
|
|
187
|
-
|
|
188
|
-
request = make_build_request(uri)
|
|
189
|
-
|
|
190
|
-
return unless request
|
|
191
|
-
|
|
192
|
-
UI.success('Uploading the build to Waldo. This could take a while…')
|
|
73
|
+
def self.get_script_path
|
|
74
|
+
root = Pathname.new(File.expand_path('../../..', __FILE__))
|
|
193
75
|
|
|
194
|
-
|
|
195
|
-
|
|
196
|
-
Net::HTTP.start(uri.host, uri.port, :use_ssl => true) do |http|
|
|
197
|
-
http.read_timeout = 120 # 2 minutes
|
|
198
|
-
|
|
199
|
-
parse_build_response(http.request(request))
|
|
200
|
-
end
|
|
201
|
-
rescue Net::ReadTimeout => exc
|
|
202
|
-
handle_error('Build upload to Waldo timed out!')
|
|
203
|
-
rescue => exc
|
|
204
|
-
handle_error("Something went wrong uploading build to Waldo: #{exc.inspect.to_s}")
|
|
205
|
-
ensure
|
|
206
|
-
request.body_stream.close if request && request.body_stream
|
|
207
|
-
end
|
|
76
|
+
File.join(root, 'waldo', 'assets', 'WaldoCLI.sh')
|
|
208
77
|
end
|
|
209
78
|
|
|
210
|
-
def self.
|
|
211
|
-
|
|
212
|
-
uri = make_error_uri
|
|
213
|
-
|
|
214
|
-
request = make_error_request(uri, message)
|
|
215
|
-
|
|
216
|
-
UI.error('Uploading error report to Waldo…')
|
|
217
|
-
|
|
218
|
-
dump_request(request) if FastlaneCore::Globals.verbose?
|
|
219
|
-
|
|
220
|
-
Net::HTTP.start(uri.host, uri.port, :use_ssl => true) do |http|
|
|
221
|
-
http.read_timeout = 30 # seconds
|
|
222
|
-
|
|
223
|
-
parse_error_response(http.request(request))
|
|
224
|
-
end
|
|
225
|
-
rescue Net::ReadTimeout => exc
|
|
226
|
-
UI.error('Error report upload to Waldo timed out!')
|
|
227
|
-
rescue => exc
|
|
228
|
-
UI.error("Something went wrong uploading error report to Waldo: #{exc.inspect.to_s}")
|
|
229
|
-
end
|
|
79
|
+
def self.get_user_agent
|
|
80
|
+
"Waldo fastlane/#{get_flavor} v#{Fastlane::Waldo::VERSION}"
|
|
230
81
|
end
|
|
231
82
|
|
|
232
|
-
def self.
|
|
233
|
-
|
|
234
|
-
|
|
235
|
-
|
|
236
|
-
@upload_token = params[:upload_token]
|
|
237
|
-
@variant_name = params[:variant_name]
|
|
238
|
-
|
|
239
|
-
unless @upload_token
|
|
240
|
-
handle_error('You must pass a nonempty upload token to the Waldo action')
|
|
241
|
-
|
|
242
|
-
return false
|
|
243
|
-
end
|
|
83
|
+
def self.upload_build_with_symbols(params)
|
|
84
|
+
apk_path = params[:apk_path]
|
|
85
|
+
app_path = params[:app_path]
|
|
86
|
+
ipa_path = params[:ipa_path]
|
|
244
87
|
|
|
245
|
-
|
|
246
|
-
|
|
247
|
-
|
|
248
|
-
|
|
249
|
-
|
|
250
|
-
|
|
251
|
-
end
|
|
252
|
-
|
|
253
|
-
unless File.exist?(@apk_path)
|
|
254
|
-
handle_error("Unable to find APK at path '#{@apk_path.to_s}'")
|
|
255
|
-
|
|
256
|
-
return false
|
|
257
|
-
end
|
|
258
|
-
|
|
259
|
-
unless File.file?(@apk_path) && File.readable?(@apk_path)
|
|
260
|
-
handle_error("Unable to read APK at path '#{@apk_path.to_s}'")
|
|
261
|
-
|
|
262
|
-
return false
|
|
263
|
-
end
|
|
264
|
-
when :ios
|
|
265
|
-
unless @app_path || @ipa_path
|
|
266
|
-
handle_error('You must pass an IPA or app path to the Waldo action')
|
|
267
|
-
|
|
268
|
-
return false
|
|
269
|
-
end
|
|
270
|
-
|
|
271
|
-
if @app_path
|
|
272
|
-
unless File.exist?(@app_path)
|
|
273
|
-
handle_error("Unable to find app at path '#{@app_path.to_s}'")
|
|
274
|
-
|
|
275
|
-
return false
|
|
276
|
-
end
|
|
277
|
-
|
|
278
|
-
unless File.directory?(@app_path) && File.readable?(@app_path)
|
|
279
|
-
handle_error("Unable to read app at path '#{@app_path.to_s}'")
|
|
280
|
-
|
|
281
|
-
return false
|
|
282
|
-
end
|
|
283
|
-
elsif @ipa_path
|
|
284
|
-
unless File.exist?(@ipa_path)
|
|
285
|
-
handle_error("Unable to find IPA at path '#{@ipa_path.to_s}'")
|
|
286
|
-
|
|
287
|
-
return false
|
|
288
|
-
end
|
|
289
|
-
|
|
290
|
-
unless File.file?(@ipa_path) && File.readable?(@ipa_path)
|
|
291
|
-
handle_error("Unable to read IPA at path '#{@ipa_path.to_s}'")
|
|
292
|
-
|
|
293
|
-
return false
|
|
294
|
-
end
|
|
295
|
-
end
|
|
88
|
+
if apk_path
|
|
89
|
+
build_path = apk_path
|
|
90
|
+
elsif app_path
|
|
91
|
+
build_path = app_path
|
|
92
|
+
elsif ipa_path
|
|
93
|
+
build_path = ipa_path
|
|
296
94
|
else
|
|
297
|
-
|
|
298
|
-
|
|
299
|
-
return false
|
|
95
|
+
build_path = ""
|
|
300
96
|
end
|
|
301
97
|
|
|
302
|
-
|
|
303
|
-
handle_error('Empty variant name for Waldo given')
|
|
98
|
+
command = []
|
|
304
99
|
|
|
305
|
-
|
|
306
|
-
|
|
307
|
-
|
|
308
|
-
return true
|
|
309
|
-
end
|
|
100
|
+
command << "WALDO_UPLOAD_TOKEN='#{params[:upload_token]}'"
|
|
101
|
+
command << "WALDO_USER_AGENT_OVERRIDE='#{get_user_agent}'"
|
|
102
|
+
command << "WALDO_VARIANT_NAME='#{params[:variant_name]}'" if params[:variant_name]
|
|
310
103
|
|
|
311
|
-
|
|
312
|
-
unless FastlaneCore::CommandExecutor.which('zip')
|
|
313
|
-
handle_error("Command not found: 'zip'")
|
|
104
|
+
command << get_script_path.shellescape
|
|
314
105
|
|
|
315
|
-
|
|
316
|
-
|
|
106
|
+
command << '--include_symbols' if params[:include_symbols]
|
|
107
|
+
command << '--verbose' if FastlaneCore::Globals.verbose?
|
|
317
108
|
|
|
318
|
-
|
|
319
|
-
|
|
320
|
-
handle_error("Unable to zip app at path '#{src_path.to_s}' into '#{zip_path.to_s}'")
|
|
109
|
+
command << build_path.shellescape
|
|
110
|
+
command << params[:dsym_path].shellescape if params[:dsym_path]
|
|
321
111
|
|
|
322
|
-
|
|
323
|
-
|
|
112
|
+
Actions.sh_control_output(command.join(' '),
|
|
113
|
+
print_command: FastlaneCore::Globals.verbose?,
|
|
114
|
+
print_command_output: true) do |error|
|
|
115
|
+
# do nothing special, for now
|
|
324
116
|
end
|
|
325
|
-
|
|
326
|
-
return true
|
|
327
|
-
end
|
|
328
|
-
end
|
|
329
|
-
|
|
330
|
-
class WaldoReadIO
|
|
331
|
-
def initialize(path)
|
|
332
|
-
@fp = File.open(path)
|
|
333
|
-
end
|
|
334
|
-
|
|
335
|
-
def close
|
|
336
|
-
@fp.close
|
|
337
|
-
end
|
|
338
|
-
|
|
339
|
-
def read(length = nil, outbuf = nil)
|
|
340
|
-
if result = @fp.read(length, outbuf)
|
|
341
|
-
result.force_encoding('BINARY') if result.respond_to?(:force_encoding)
|
|
342
|
-
end
|
|
343
|
-
|
|
344
|
-
result
|
|
345
117
|
end
|
|
346
118
|
end
|
|
347
119
|
end
|
metadata
CHANGED
|
@@ -1,14 +1,14 @@
|
|
|
1
1
|
--- !ruby/object:Gem::Specification
|
|
2
2
|
name: fastlane-plugin-waldo
|
|
3
3
|
version: !ruby/object:Gem::Version
|
|
4
|
-
version:
|
|
4
|
+
version: 2.0.0
|
|
5
5
|
platform: ruby
|
|
6
6
|
authors:
|
|
7
7
|
- J. G. Pusey
|
|
8
8
|
autorequire:
|
|
9
9
|
bindir: bin
|
|
10
10
|
cert_chain: []
|
|
11
|
-
date:
|
|
11
|
+
date: 2021-08-30 00:00:00.000000000 Z
|
|
12
12
|
dependencies:
|
|
13
13
|
- !ruby/object:Gem::Dependency
|
|
14
14
|
name: bundler
|
|
@@ -30,14 +30,14 @@ dependencies:
|
|
|
30
30
|
requirements:
|
|
31
31
|
- - ">="
|
|
32
32
|
- !ruby/object:Gem::Version
|
|
33
|
-
version:
|
|
33
|
+
version: 2.192.0
|
|
34
34
|
type: :development
|
|
35
35
|
prerelease: false
|
|
36
36
|
version_requirements: !ruby/object:Gem::Requirement
|
|
37
37
|
requirements:
|
|
38
38
|
- - ">="
|
|
39
39
|
- !ruby/object:Gem::Version
|
|
40
|
-
version:
|
|
40
|
+
version: 2.192.0
|
|
41
41
|
- !ruby/object:Gem::Dependency
|
|
42
42
|
name: pry
|
|
43
43
|
requirement: !ruby/object:Gem::Requirement
|
|
@@ -76,6 +76,7 @@ files:
|
|
|
76
76
|
- README.md
|
|
77
77
|
- lib/fastlane/plugin/waldo.rb
|
|
78
78
|
- lib/fastlane/plugin/waldo/actions/waldo_action.rb
|
|
79
|
+
- lib/fastlane/plugin/waldo/assets/WaldoCLI.sh
|
|
79
80
|
- lib/fastlane/plugin/waldo/helper/waldo_helper.rb
|
|
80
81
|
- lib/fastlane/plugin/waldo/version.rb
|
|
81
82
|
homepage: https://github.com/waldoapp/fastlane-plugin-waldo
|
|
@@ -97,8 +98,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
|
|
|
97
98
|
- !ruby/object:Gem::Version
|
|
98
99
|
version: '0'
|
|
99
100
|
requirements: []
|
|
100
|
-
|
|
101
|
-
rubygems_version: 2.5.2.3
|
|
101
|
+
rubygems_version: 3.0.3
|
|
102
102
|
signing_key:
|
|
103
103
|
specification_version: 4
|
|
104
104
|
summary: Upload build to Waldo
|