forked from temporalio/temporal
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Makefile
420 lines (331 loc) · 18.3 KB
/
Makefile
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
############################# Main targets #############################
# Install all tools and builds binaries.
install: update-tools bins
# Rebuild binaries.
bins: clean-bins temporal-server tctl temporal-cassandra-tool temporal-sql-tool
# Install all tools, recompile proto files, run all possible checks and tests (long but comprehensive).
all: update-tools clean proto bins check test
# Delete all build artefacts.
clean: clean-bins clean-test-results
# Recompile proto files.
proto: clean-proto install-proto-submodule buf-lint api-linter protoc fix-proto-path proto-mock goimports-proto copyright-proto
# Update proto submodule from remote and recompile proto files.
update-proto: clean-proto update-proto-submodule buf-lint api-linter protoc fix-proto-path update-go-api proto-mock goimports-proto copyright-proto gomodtidy
# Build all docker images.
docker-images:
docker build --build-arg "TARGET=server" -t temporalio/server:$(DOCKER_IMAGE_TAG) .
docker build --build-arg "TARGET=tctl" -t temporalio/tctl:$(DOCKER_IMAGE_TAG) .
docker build --build-arg "TARGET=auto-setup" -t temporalio/auto-setup:$(DOCKER_IMAGE_TAG) .
docker build --build-arg "TARGET=admin-tools" -t temporalio/admin-tools:$(DOCKER_IMAGE_TAG) .
########################################################################
.PHONY: proto
##### Variables ######
ifndef GOOS
GOOS := $(shell go env GOOS)
endif
ifndef GOARCH
GOARCH := $(shell go env GOARCH)
endif
ifndef GOPATH
GOPATH := $(shell go env GOPATH)
endif
GOBIN := $(if $(shell go env GOBIN),$(shell go env GOBIN),$(GOPATH)/bin)
export PATH := $(GOBIN):$(PATH)
MODULE_ROOT := go.temporal.io/server
BUILD := ./build
COLOR := "\e[1;36m%s\e[0m\n"
define NEWLINE
endef
TEST_TIMEOUT := 20m
TEST_ARG ?= -race -v -timeout $(TEST_TIMEOUT)
INTEG_TEST_ROOT := ./host
INTEG_TEST_OUT_DIR := host
INTEG_TEST_XDC_ROOT := ./host/xdc
INTEG_TEST_XDC_OUT_DIR := hostxdc
INTEG_TEST_NDC_ROOT := ./host/ndc
INTEG_TEST_NDC_OUT_DIR := hostndc
GO_BUILD_LDFLAGS_CMD := $(abspath ./scripts/go-build-ldflags.sh)
GO_BUILD_LDFLAGS := $(shell $(GO_BUILD_LDFLAGS_CMD) LDFLAG)
DOCKER_IMAGE_TAG := $(shell whoami | tr -d " ")-local
ifndef PERSISTENCE_TYPE
override PERSISTENCE_TYPE := cassandra
endif
ifndef TEST_RUN_COUNT
override TEST_RUN_COUNT := 1
endif
ifdef TEST_TAG
override TEST_TAG := -tags $(TEST_TAG)
endif
PROTO_ROOT := proto
PROTO_FILES = $(shell find ./$(PROTO_ROOT)/internal -name "*.proto")
PROTO_DIRS = $(sort $(dir $(PROTO_FILES)))
PROTO_IMPORTS := -I=$(PROTO_ROOT)/internal -I=$(PROTO_ROOT)/api -I=$(GOPATH)/src/github.com/temporalio/gogo-protobuf/protobuf
PROTO_OUT := api
ALL_SRC := $(shell find . -name "*.go" | grep -v -e "^$(PROTO_OUT)")
TEST_DIRS := $(sort $(dir $(filter %_test.go,$(ALL_SRC))))
INTEG_TEST_DIRS := $(filter $(INTEG_TEST_ROOT)/ $(INTEG_TEST_NDC_ROOT)/,$(TEST_DIRS))
UNIT_TEST_DIRS := $(filter-out $(INTEG_TEST_ROOT)% $(INTEG_TEST_XDC_ROOT)% $(INTEG_TEST_NDC_ROOT)%,$(TEST_DIRS))
# Code coverage output files.
COVER_ROOT := $(BUILD)/coverage
UNIT_COVER_FILE := $(COVER_ROOT)/unit_cover.out
INTEG_COVER_FILE := $(COVER_ROOT)/integ_$(PERSISTENCE_TYPE)_cover.out
INTEG_XDC_COVER_FILE := $(COVER_ROOT)/integ_xdc_$(PERSISTENCE_TYPE)_cover.out
INTEG_CASS_COVER_FILE := $(COVER_ROOT)/integ_cassandra_cover.out
INTEG_XDC_CASS_COVER_FILE := $(COVER_ROOT)/integ_xdc_cassandra_cover.out
INTEG_SQL_COVER_FILE := $(COVER_ROOT)/integ_sql_cover.out
INTEG_XDC_SQL_COVER_FILE := $(COVER_ROOT)/integ_xdc_sql_cover.out
INTEG_NDC_COVER_FILE := $(COVER_ROOT)/integ_ndc_$(PERSISTENCE_TYPE)_cover.out
INTEG_NDC_CASS_COVER_FILE := $(COVER_ROOT)/integ_ndc_cassandra_cover.out
INTEG_NDC_SQL_COVER_FILE := $(COVER_ROOT)/integ_ndc_sql_cover.out
# Need the following option to have integration tests count towards coverage. godoc below:
# -coverpkg pkg1,pkg2,pkg3
# Apply coverage analysis in each test to the given list of packages.
# The default is for each test to analyze only the package being tested.
# Packages are specified as import paths.
GOCOVERPKG_ARG := -coverpkg="$(MODULE_ROOT)/common/...,$(MODULE_ROOT)/service/...,$(MODULE_ROOT)/client/...,$(MODULE_ROOT)/tools/..."
##### Tools #####
update-checkers:
@printf $(COLOR) "Install/update check tools..."
GO111MODULE=off go get -u golang.org/x/tools/cmd/goimports
GO111MODULE=off go get -u golang.org/x/lint/golint
GO111MODULE=off go get -u honnef.co/go/tools/cmd/staticcheck
GO111MODULE=off go get -u github.com/kisielk/errcheck
GO111MODULE=off go get -u github.com/googleapis/api-linter/cmd/api-linter
GO111MODULE=off go get -u github.com/bufbuild/buf/cmd/buf
update-mockgen:
@printf $(COLOR) "Install/update mockgen tool..."
GO111MODULE=off go get -u github.com/golang/mock/mockgen
update-proto-plugins:
@printf $(COLOR) "Install/update proto plugins..."
GO111MODULE=off go get -u github.com/temporalio/gogo-protobuf/protoc-gen-gogoslick
GO111MODULE=off go get -u google.golang.org/grpc
update-tools: update-checkers update-mockgen update-proto-plugins
##### Proto #####
$(PROTO_OUT):
@mkdir -p $(PROTO_OUT)
clean-proto:
@rm -rf $(PROTO_OUT)/*
update-proto-submodule:
@printf $(COLOR) "Update proto submodule from remote..."
git submodule update --force --remote $(PROTO_ROOT)/api
install-proto-submodule:
@printf $(COLOR) "Install proto submodule..."
git submodule update --init $(PROTO_ROOT)/api
protoc: $(PROTO_OUT)
@printf $(COLOR) "Build proto files..."
# Run protoc separately for each directory because of different package names.
$(foreach PROTO_DIR,$(PROTO_DIRS),protoc $(PROTO_IMPORTS) --gogoslick_out=Mgoogle/protobuf/descriptor.proto=github.com/golang/protobuf/protoc-gen-go/descriptor,Mgoogle/protobuf/duration.proto=github.com/gogo/protobuf/types,Mgoogle/protobuf/wrappers.proto=github.com/gogo/protobuf/types,Mgoogle/protobuf/timestamp.proto=github.com/gogo/protobuf/types,plugins=grpc,paths=source_relative:$(PROTO_OUT) $(PROTO_DIR)*.proto$(NEWLINE))
fix-proto-path:
mv -f $(PROTO_OUT)/temporal/server/api/* $(PROTO_OUT) && rm -rf $(PROTO_OUT)/temporal
# All gRPC generated service files pathes relative to PROTO_OUT.
PROTO_GRPC_SERVICES = $(patsubst $(PROTO_OUT)/%,%,$(shell find $(PROTO_OUT) -name "service.pb.go"))
service_name = $(firstword $(subst /, ,$(1)))
mock_file_name = $(call service_name,$(1))mock/$(subst $(call service_name,$(1))/,,$(1:go=mock.go))
proto-mock: $(PROTO_OUT)
@printf $(COLOR) "Generate proto mocks..."
$(foreach PROTO_GRPC_SERVICE,$(PROTO_GRPC_SERVICES),cd $(PROTO_OUT) && mockgen -package $(call service_name,$(PROTO_GRPC_SERVICE))mock -source $(PROTO_GRPC_SERVICE) -destination $(call mock_file_name,$(PROTO_GRPC_SERVICE))$(NEWLINE) )
update-go-api:
@printf $(COLOR) "Update go.temporal.io/api..."
@go get -u go.temporal.io/api@master
goimports-proto:
@printf $(COLOR) "Run goimports..."
@goimports -w $(PROTO_OUT)
copyright-proto:
@printf $(COLOR) "Update license headers..."
@go run ./cmd/tools/copyright/licensegen.go --scanDir $(PROTO_OUT)
##### Binaries #####
clean-bins:
@printf $(COLOR) "Delete old binaries..."
@rm -f tctl
@rm -f temporal-server
@rm -f temporal-cassandra-tool
@rm -f temporal-sql-tool
temporal-server:
@printf $(COLOR) "Build temporal-server with OS: $(GOOS), ARCH: $(GOARCH)..."
go build -ldflags '$(GO_BUILD_LDFLAGS)' -o temporal-server cmd/server/main.go
tctl:
@printf $(COLOR) "Build tctl with OS: $(GOOS), ARCH: $(GOARCH)..."
go build -o tctl cmd/tools/cli/main.go
temporal-cassandra-tool:
@printf $(COLOR) "Build temporal-cassandra-tool with OS: $(GOOS), ARCH: $(GOARCH)..."
go build -o temporal-cassandra-tool cmd/tools/cassandra/main.go
temporal-sql-tool:
@printf $(COLOR) "Build temporal-sql-tool with OS: $(GOOS), ARCH: $(GOARCH)..."
go build -o temporal-sql-tool cmd/tools/sql/main.go
##### Checks #####
copyright:
@printf $(COLOR) "Check license header..."
@go run ./cmd/tools/copyright/licensegen.go --verifyOnly
lint:
@printf $(COLOR) "Run linter..."
@golint ./...
vet:
@printf $(COLOR) "Run go vet..."
@go vet ./... || true
goimports-check:
@printf $(COLOR) "Run goimports checks..."
# Use $(ALL_SRC) here to avoid checking generated files.
@goimports -l $(ALL_SRC) || true
goimports:
@printf $(COLOR) "Run goimports..."
@goimports -local "go.temporal.io" -w $(ALL_SRC)
staticcheck:
@printf $(COLOR) "Run staticcheck..."
@staticcheck -fail none ./...
errcheck:
@printf $(COLOR) "Run errcheck..."
@errcheck ./... || true
api-linter:
@printf $(COLOR) "Run api-linter..."
@api-linter --set-exit-status --output-format=summary $(PROTO_IMPORTS) --config=$(PROTO_ROOT)/api-linter.yaml $(PROTO_FILES)
buf-lint:
@printf $(COLOR) "Run buf linter..."
@(cd $(PROTO_ROOT) && buf check lint)
buf-build:
@printf $(COLOR) "Build image.bin with buf..."
@(cd $(PROTO_ROOT) && buf image build -o image.bin)
buf-breaking:
@printf $(COLOR) "Run buf breaking changes check against image.bin..."
@(cd $(PROTO_ROOT) && buf check breaking --against-input image.bin)
check: copyright goimports-check lint vet staticcheck errcheck
##### Tests #####
clean-test-results:
@rm -f test.log
unit-test: clean-test-results
@printf $(COLOR) "Run unit tests..."
$(foreach UNIT_TEST_DIR,$(UNIT_TEST_DIRS), @go test -timeout $(TEST_TIMEOUT) -race $(UNIT_TEST_DIR) $(TEST_TAG) | tee -a test.log$(NEWLINE))
@! grep -q "^--- FAIL" test.log
integration-test: clean-test-results
@printf $(COLOR) "Run integration tests..."
$(foreach INTEG_TEST_DIR,$(INTEG_TEST_DIRS), @go test -timeout $(TEST_TIMEOUT) -race $(INTEG_TEST_DIR) $(TEST_TAG) | tee -a test.log$(NEWLINE))
# Need to run xdc tests with race detector off because of ringpop bug causing data race issue.
@go test -timeout $(TEST_TIMEOUT) $(INTEG_TEST_XDC_ROOT) $(TEST_TAG) | tee -a test.log
@! grep -q "^--- FAIL" test.log
test: unit-test integration-test
##### Coverage #####
clean-build-results:
@rm -rf $(BUILD)
@mkdir -p $(BUILD)
@mkdir -p $(COVER_ROOT)
cover_profile: clean-build-results
@echo "mode: atomic" > $(UNIT_COVER_FILE)
@echo Running package tests:
@for dir in $(UNIT_TEST_DIRS); do \
mkdir -p $(BUILD)/"$$dir"; \
go test "$$dir" $(TEST_ARG) -coverprofile=$(BUILD)/"$$dir"/coverage.out || exit 1; \
cat $(BUILD)/"$$dir"/coverage.out | grep -v "^mode: \w\+" >> $(UNIT_COVER_FILE); \
done;
cover_integration_profile: clean-build-results
@echo "mode: atomic" > $(INTEG_COVER_FILE)
@echo Running integration test with $(PERSISTENCE_TYPE)
@mkdir -p $(BUILD)/$(INTEG_TEST_OUT_DIR)
@time go test $(INTEG_TEST_ROOT) $(TEST_ARG) $(TEST_TAG) -persistenceType=$(PERSISTENCE_TYPE) $(GOCOVERPKG_ARG) -coverprofile=$(BUILD)/$(INTEG_TEST_OUT_DIR)/coverage.out || exit 1;
@cat $(BUILD)/$(INTEG_TEST_OUT_DIR)/coverage.out | grep -v "^mode: \w\+" >> $(INTEG_COVER_FILE)
cover_xdc_profile: clean-build-results
@echo "mode: atomic" > $(INTEG_XDC_COVER_FILE)
@echo Running integration test for cross dc with $(PERSISTENCE_TYPE)
@mkdir -p $(BUILD)/$(INTEG_TEST_XDC_OUT_DIR)
@time go test -v -timeout $(TEST_TIMEOUT) $(INTEG_TEST_XDC_ROOT) $(TEST_TAG) -persistenceType=$(PERSISTENCE_TYPE) $(GOCOVERPKG_ARG) -coverprofile=$(BUILD)/$(INTEG_TEST_XDC_OUT_DIR)/coverage.out || exit 1;
@cat $(BUILD)/$(INTEG_TEST_XDC_OUT_DIR)/coverage.out | grep -v "^mode: \w\+" | grep -v "mode: set" >> $(INTEG_XDC_COVER_FILE)
cover_ndc_profile: clean-build-results
@mkdir -p $(BUILD)
@mkdir -p $(COVER_ROOT)
@echo "mode: atomic" > $(INTEG_NDC_COVER_FILE)
@echo Running integration test for 3+ dc with $(PERSISTENCE_TYPE)
@mkdir -p $(BUILD)/$(INTEG_TEST_NDC_OUT_DIR)
@time go test -v -timeout $(TEST_TIMEOUT) $(INTEG_TEST_NDC_ROOT) $(TEST_TAG) -persistenceType=$(PERSISTENCE_TYPE) $(GOCOVERPKG_ARG) -coverprofile=$(BUILD)/$(INTEG_TEST_NDC_OUT_DIR)/coverage.out -count=$(TEST_RUN_COUNT) || exit 1;
@cat $(BUILD)/$(INTEG_TEST_NDC_OUT_DIR)/coverage.out | grep -v "^mode: \w\+" | grep -v "mode: set" >> $(INTEG_NDC_COVER_FILE)
$(COVER_ROOT)/cover.out: $(UNIT_COVER_FILE) $(INTEG_CASS_COVER_FILE) $(INTEG_XDC_CASS_COVER_FILE) $(INTEG_SQL_COVER_FILE) $(INTEG_XDC_SQL_COVER_FILE)
@echo "mode: atomic" > $(COVER_ROOT)/cover.out
cat $(UNIT_COVER_FILE) | grep -v "^mode: \w\+" | grep -vP "$(PROTO_OUT)|[Mm]ock[s]?" >> $(COVER_ROOT)/cover.out
cat $(INTEG_CASS_COVER_FILE) | grep -v "^mode: \w\+" | grep -vP "$(PROTO_OUT)|[Mm]ock[s]?" >> $(COVER_ROOT)/cover.out
cat $(INTEG_XDC_CASS_COVER_FILE) | grep -v "^mode: \w\+" | grep -vP "$(PROTO_OUT)|[Mm]ock[s]?" >> $(COVER_ROOT)/cover.out
cat $(INTEG_SQL_COVER_FILE) | grep -v "^mode: \w\+" | grep -vP "$(PROTO_OUT)|[Mm]ock[s]?" >> $(COVER_ROOT)/cover.out
cat $(INTEG_XDC_SQL_COVER_FILE) | grep -v "^mode: \w\+" | grep -vP "$(PROTO_OUT)|[Mm]ock[s]?" >> $(COVER_ROOT)/cover.out
cover: $(COVER_ROOT)/cover.out
go tool cover -html=$(COVER_ROOT)/cover.out;
cover_ci: $(COVER_ROOT)/cover.out
goveralls -coverprofile=$(COVER_ROOT)/cover.out -service=buildkite || echo Coveralls failed;
##### Schema #####
install-schema: temporal-cassandra-tool
@printf $(COLOR) "Install Cassandra schema..."
./temporal-cassandra-tool --ep 127.0.0.1 create -k temporal --rf 1
./temporal-cassandra-tool --ep 127.0.0.1 -k temporal setup-schema -v 0.0
./temporal-cassandra-tool --ep 127.0.0.1 -k temporal update-schema -d ./schema/cassandra/temporal/versioned
./temporal-cassandra-tool --ep 127.0.0.1 create -k temporal_visibility --rf 1
./temporal-cassandra-tool --ep 127.0.0.1 -k temporal_visibility setup-schema -v 0.0
./temporal-cassandra-tool --ep 127.0.0.1 -k temporal_visibility update-schema -d ./schema/cassandra/visibility/versioned
install-schema-mysql-pre5720: temporal-sql-tool
@printf $(COLOR) "Install MySQL schema..."
./temporal-sql-tool --ep 127.0.0.1 --ca tx_isolation='READ-COMMITTED' create --db temporal
./temporal-sql-tool --ep 127.0.0.1 --ca tx_isolation='READ-COMMITTED' --db temporal setup-schema -v 0.0
./temporal-sql-tool --ep 127.0.0.1 --ca tx_isolation='READ-COMMITTED' --db temporal update-schema -d ./schema/mysql/v57/temporal/versioned
./temporal-sql-tool --ep 127.0.0.1 --ca tx_isolation='READ-COMMITTED' create --db temporal_visibility
./temporal-sql-tool --ep 127.0.0.1 --ca tx_isolation='READ-COMMITTED' --db temporal_visibility setup-schema -v 0.0
./temporal-sql-tool --ep 127.0.0.1 --ca tx_isolation='READ-COMMITTED' --db temporal_visibility update-schema -d ./schema/mysql/v57/visibility/versioned
install-schema-mysql: temporal-sql-tool
@printf $(COLOR) "Install MySQL schema..."
./temporal-sql-tool --ep 127.0.0.1 -u root --pw root create --db temporal
./temporal-sql-tool --ep 127.0.0.1 -u root --pw root --db temporal setup-schema -v 0.0
./temporal-sql-tool --ep 127.0.0.1 -u root --pw root --db temporal update-schema -d ./schema/mysql/v57/temporal/versioned
./temporal-sql-tool --ep 127.0.0.1 -u root --pw root create --db temporal_visibility
./temporal-sql-tool --ep 127.0.0.1 -u root --pw root --db temporal_visibility setup-schema -v 0.0
./temporal-sql-tool --ep 127.0.0.1 -u root --pw root --db temporal_visibility update-schema -d ./schema/mysql/v57/visibility/versioned
install-schema-postgres: temporal-sql-tool
@printf $(COLOR) "Install Postgres schema..."
./temporal-sql-tool --ep 127.0.0.1 -p 5432 -u temporal -pw temporal --pl postgres --db temporal setup -v 0.0
./temporal-sql-tool --ep 127.0.0.1 -p 5432 -u temporal -pw temporal --pl postgres --db temporal update-schema -d ./schema/postgres/temporal/versioned
./temporal-sql-tool --ep 127.0.0.1 -p 5432 -u temporal -pw temporal --pl postgres create --db temporal_visibility
./temporal-sql-tool --ep 127.0.0.1 -p 5432 -u temporal -pw temporal --pl postgres --db temporal_visibility setup-schema -v 0.0
./temporal-sql-tool --ep 127.0.0.1 -p 5432 -u temporal -pw temporal --pl postgres --db temporal_visibility update-schema -d ./schema/postgres/visibility/versioned
install-schema-cdc: temporal-cassandra-tool
@printf $(COLOR) "Set up temporal_active key space..."
./temporal-cassandra-tool --ep 127.0.0.1 create -k temporal_active --rf 1
./temporal-cassandra-tool --ep 127.0.0.1 -k temporal_active setup-schema -v 0.0
./temporal-cassandra-tool --ep 127.0.0.1 -k temporal_active update-schema -d ./schema/cassandra/temporal/versioned
./temporal-cassandra-tool --ep 127.0.0.1 create -k temporal_visibility_active --rf 1
./temporal-cassandra-tool --ep 127.0.0.1 -k temporal_visibility_active setup-schema -v 0.0
./temporal-cassandra-tool --ep 127.0.0.1 -k temporal_visibility_active update-schema -d ./schema/cassandra/visibility/versioned
@printf $(COLOR) "Set up temporal_standby key space..."
./temporal-cassandra-tool --ep 127.0.0.1 create -k temporal_standby --rf 1
./temporal-cassandra-tool --ep 127.0.0.1 -k temporal_standby setup-schema -v 0.0
./temporal-cassandra-tool --ep 127.0.0.1 -k temporal_standby update-schema -d ./schema/cassandra/temporal/versioned
./temporal-cassandra-tool --ep 127.0.0.1 create -k temporal_visibility_standby --rf 1
./temporal-cassandra-tool --ep 127.0.0.1 -k temporal_visibility_standby setup-schema -v 0.0
./temporal-cassandra-tool --ep 127.0.0.1 -k temporal_visibility_standby update-schema -d ./schema/cassandra/visibility/versioned
@printf $(COLOR) "Set up temporal_other key space..."
./temporal-cassandra-tool --ep 127.0.0.1 create -k temporal_other --rf 1
./temporal-cassandra-tool --ep 127.0.0.1 -k temporal_other setup-schema -v 0.0
./temporal-cassandra-tool --ep 127.0.0.1 -k temporal_other update-schema -d ./schema/cassandra/temporal/versioned
./temporal-cassandra-tool --ep 127.0.0.1 create -k temporal_visibility_other --rf 1
./temporal-cassandra-tool --ep 127.0.0.1 -k temporal_visibility_other setup-schema -v 0.0
./temporal-cassandra-tool --ep 127.0.0.1 -k temporal_visibility_other update-schema -d ./schema/cassandra/visibility/versioned
##### Run server #####
start-dependencies:
ifeq ($(GOOS),darwin)
docker-compose -f docker/dependencies/docker-compose.yml -f docker/dependencies/docker-compose.mac.yml up
else
docker-compose -f docker/dependencies/docker-compose.yml up
endif
stop-dependencies:
ifeq ($(GOOS),darwin)
docker-compose -f docker/dependencies/docker-compose.yml -f docker/dependencies/docker-compose.mac.yml down
else
docker-compose -f docker/dependencies/docker-compose.yml down
endif
start: temporal-server
./temporal-server start
start-cdc-active: temporal-server
./temporal-server --zone active start
start-cdc-standby: temporal-server
./temporal-server --zone standby start
start-cdc-other: temporal-server
./temporal-server --zone other start
##### Auxilary #####
go-generate:
@printf $(COLOR) "Regenerate everything..."
@go generate ./...
@goimports -w $(ALL_SRC)
gomodtidy:
@printf $(COLOR) "go mod tidy..."
@go mod tidy