mirror of
https://github.com/lightningnetwork/lnd.git
synced 2024-11-19 01:43:16 +01:00
7919b3f204
This commit updates `scripts/release.sh` to include a check for the correct Go version before executing the release build. This ensures that the release binaries are built with the specified Go version, maintaining consistency and integrity for developer signatures.
469 lines
17 KiB
Makefile
469 lines
17 KiB
Makefile
PKG := github.com/lightningnetwork/lnd
|
|
ESCPKG := github.com\/lightningnetwork\/lnd
|
|
MOBILE_PKG := $(PKG)/mobile
|
|
TOOLS_DIR := tools
|
|
|
|
PREFIX ?= /usr/local
|
|
|
|
BTCD_PKG := github.com/btcsuite/btcd
|
|
GOACC_PKG := github.com/ory/go-acc
|
|
GOIMPORTS_PKG := github.com/rinchsan/gosimports/cmd/gosimports
|
|
|
|
GO_BIN := ${GOPATH}/bin
|
|
BTCD_BIN := $(GO_BIN)/btcd
|
|
GOIMPORTS_BIN := $(GO_BIN)/gosimports
|
|
GOMOBILE_BIN := $(GO_BIN)/gomobile
|
|
GOACC_BIN := $(GO_BIN)/go-acc
|
|
|
|
MOBILE_BUILD_DIR :=${GOPATH}/src/$(MOBILE_PKG)/build
|
|
IOS_BUILD_DIR := $(MOBILE_BUILD_DIR)/ios
|
|
IOS_BUILD := $(IOS_BUILD_DIR)/Lndmobile.xcframework
|
|
ANDROID_BUILD_DIR := $(MOBILE_BUILD_DIR)/android
|
|
ANDROID_BUILD := $(ANDROID_BUILD_DIR)/Lndmobile.aar
|
|
|
|
COMMIT := $(shell git describe --tags --dirty)
|
|
|
|
# Determine the minor version of the active Go installation.
|
|
ACTIVE_GO_VERSION := $(shell go version | sed -nre 's/^[^0-9]*(([0-9]+\.)*[0-9]+).*/\1/p')
|
|
ACTIVE_GO_VERSION_MINOR := $(shell echo $(ACTIVE_GO_VERSION) | cut -d. -f2)
|
|
|
|
LOOPVARFIX :=
|
|
ifeq ($(shell expr $(ACTIVE_GO_VERSION_MINOR) \>= 21), 1)
|
|
LOOPVARFIX := GOEXPERIMENT=loopvar
|
|
endif
|
|
|
|
# GO_VERSION is the Go version used for the release build, docker files, and
|
|
# GitHub Actions. This is the reference version for the project. All other Go
|
|
# versions are checked against this version.
|
|
GO_VERSION = 1.22.6
|
|
|
|
GOBUILD := $(LOOPVARFIX) go build -v
|
|
GOINSTALL := $(LOOPVARFIX) go install -v
|
|
GOTEST := $(LOOPVARFIX) go test
|
|
|
|
GOFILES_NOVENDOR = $(shell find . -type f -name '*.go' -not -path "./vendor/*" -not -name "*pb.go" -not -name "*pb.gw.go" -not -name "*.pb.json.go")
|
|
|
|
RM := rm -f
|
|
CP := cp
|
|
MAKE := make
|
|
XARGS := xargs -L 1
|
|
|
|
include make/testing_flags.mk
|
|
include make/release_flags.mk
|
|
include make/fuzz_flags.mk
|
|
|
|
DEV_TAGS := $(if ${tags},$(DEV_TAGS) ${tags},$(DEV_TAGS))
|
|
|
|
# We only return the part inside the double quote here to avoid escape issues
|
|
# when calling the external release script. The second parameter can be used to
|
|
# add additional ldflags if needed (currently only used for the release).
|
|
make_ldflags = $(1) -X $(PKG)/build.Commit=$(COMMIT)
|
|
|
|
DEV_GCFLAGS := -gcflags "all=-N -l"
|
|
DEV_LDFLAGS := -ldflags "$(call make_ldflags)"
|
|
# For the release, we want to remove the symbol table and debug information (-s)
|
|
# and omit the DWARF symbol table (-w). Also we clear the build ID.
|
|
RELEASE_LDFLAGS := $(call make_ldflags, -s -w -buildid=)
|
|
|
|
# Linting uses a lot of memory, so keep it under control by limiting the number
|
|
# of workers if requested.
|
|
ifneq ($(workers),)
|
|
LINT_WORKERS = --concurrency=$(workers)
|
|
endif
|
|
|
|
DOCKER_TOOLS = docker run \
|
|
--rm \
|
|
-v $(shell bash -c "go env GOCACHE || (mkdir -p /tmp/go-cache; echo /tmp/go-cache)"):/tmp/build/.cache \
|
|
-v $(shell bash -c "go env GOMODCACHE || (mkdir -p /tmp/go-modcache; echo /tmp/go-modcache)"):/tmp/build/.modcache \
|
|
-v $(shell bash -c "mkdir -p /tmp/go-lint-cache; echo /tmp/go-lint-cache"):/root/.cache/golangci-lint \
|
|
-v $$(pwd):/build lnd-tools
|
|
|
|
GREEN := "\\033[0;32m"
|
|
NC := "\\033[0m"
|
|
define print
|
|
echo $(GREEN)$1$(NC)
|
|
endef
|
|
|
|
default: scratch
|
|
|
|
all: scratch check install
|
|
|
|
# ============
|
|
# DEPENDENCIES
|
|
# ============
|
|
$(GOACC_BIN):
|
|
@$(call print, "Installing go-acc.")
|
|
cd $(TOOLS_DIR); go install -trimpath -tags=tools $(GOACC_PKG)
|
|
|
|
$(BTCD_BIN):
|
|
@$(call print, "Installing btcd.")
|
|
cd $(TOOLS_DIR); go install -trimpath $(BTCD_PKG)
|
|
|
|
$(GOIMPORTS_BIN):
|
|
@$(call print, "Installing goimports.")
|
|
cd $(TOOLS_DIR); go install -trimpath $(GOIMPORTS_PKG)
|
|
|
|
# ============
|
|
# INSTALLATION
|
|
# ============
|
|
|
|
#? build: Build lnd and lncli binaries, place them in project directory
|
|
build:
|
|
@$(call print, "Building debug lnd and lncli.")
|
|
$(GOBUILD) -tags="$(DEV_TAGS)" -o lnd-debug $(DEV_GCFLAGS) $(DEV_LDFLAGS) $(PKG)/cmd/lnd
|
|
$(GOBUILD) -tags="$(DEV_TAGS)" -o lncli-debug $(DEV_GCFLAGS) $(DEV_LDFLAGS) $(PKG)/cmd/lncli
|
|
|
|
#? build-itest: Build integration test binaries, place them in itest directory
|
|
build-itest:
|
|
@$(call print, "Building itest btcd and lnd.")
|
|
CGO_ENABLED=0 $(GOBUILD) -tags="integration" -o itest/btcd-itest$(EXEC_SUFFIX) $(DEV_LDFLAGS) $(BTCD_PKG)
|
|
CGO_ENABLED=0 $(GOBUILD) -tags="$(ITEST_TAGS)" $(ITEST_COVERAGE) -o itest/lnd-itest$(EXEC_SUFFIX) $(DEV_LDFLAGS) $(PKG)/cmd/lnd
|
|
|
|
@$(call print, "Building itest binary for ${backend} backend.")
|
|
CGO_ENABLED=0 $(GOTEST) -v ./itest -tags="$(DEV_TAGS) $(RPC_TAGS) integration $(backend)" -c -o itest/itest.test$(EXEC_SUFFIX)
|
|
|
|
#? build-itest-race: Build integration test binaries in race detector mode, place them in itest directory
|
|
build-itest-race:
|
|
@$(call print, "Building itest btcd and lnd with race detector.")
|
|
CGO_ENABLED=0 $(GOBUILD) -tags="integration" -o itest/btcd-itest$(EXEC_SUFFIX) $(DEV_LDFLAGS) $(BTCD_PKG)
|
|
CGO_ENABLED=1 $(GOBUILD) -race -tags="$(ITEST_TAGS)" -o itest/lnd-itest$(EXEC_SUFFIX) $(DEV_LDFLAGS) $(PKG)/cmd/lnd
|
|
|
|
@$(call print, "Building itest binary for ${backend} backend.")
|
|
CGO_ENABLED=0 $(GOTEST) -v ./itest -tags="$(DEV_TAGS) $(RPC_TAGS) integration $(backend)" -c -o itest/itest.test$(EXEC_SUFFIX)
|
|
|
|
#? install-binaries: Build and install lnd and lncli binaries, place them in $GOPATH/bin
|
|
install-binaries:
|
|
@$(call print, "Installing lnd and lncli.")
|
|
$(GOINSTALL) -tags="${tags}" -ldflags="$(RELEASE_LDFLAGS)" $(PKG)/cmd/lnd
|
|
$(GOINSTALL) -tags="${tags}" -ldflags="$(RELEASE_LDFLAGS)" $(PKG)/cmd/lncli
|
|
|
|
#? manpages: generate and install man pages
|
|
manpages:
|
|
@$(call print, "Generating man pages lncli.1 and lnd.1.")
|
|
./scripts/gen_man_pages.sh $(DESTDIR) $(PREFIX)
|
|
|
|
#? install: Build and install lnd and lncli binaries and place them in $GOPATH/bin.
|
|
install: install-binaries
|
|
|
|
#? install-all: Performs all the same tasks as the install command along with generating and
|
|
# installing the man pages for the lnd and lncli binaries. This command is useful in an
|
|
# environment where a user has root access and so has write access to the man page directory.
|
|
install-all: install manpages
|
|
|
|
#? release-install: Build and install lnd and lncli release binaries, place them in $GOPATH/bin
|
|
release-install:
|
|
@$(call print, "Installing release lnd and lncli.")
|
|
env CGO_ENABLED=0 $(GOINSTALL) -v -trimpath -ldflags="$(RELEASE_LDFLAGS)" -tags="$(RELEASE_TAGS)" $(PKG)/cmd/lnd
|
|
env CGO_ENABLED=0 $(GOINSTALL) -v -trimpath -ldflags="$(RELEASE_LDFLAGS)" -tags="$(RELEASE_TAGS)" $(PKG)/cmd/lncli
|
|
|
|
#? release: Build the full set of reproducible release binaries for all supported platforms
|
|
# Make sure the generated mobile RPC stubs don't influence our vendor package
|
|
# by removing them first in the clean-mobile target.
|
|
release: clean-mobile
|
|
@$(call print, "Releasing lnd and lncli binaries.")
|
|
$(VERSION_CHECK)
|
|
./scripts/release.sh build-release "$(VERSION_TAG)" "$(BUILD_SYSTEM)" "$(RELEASE_TAGS)" "$(RELEASE_LDFLAGS)" "$(GO_VERSION)"
|
|
|
|
#? docker-release: Same as release but within a docker container to support reproducible builds on BSD/MacOS platforms
|
|
docker-release:
|
|
@$(call print, "Building release helper docker image.")
|
|
if [ "$(tag)" = "" ]; then echo "Must specify tag=<commit_or_tag>!"; exit 1; fi
|
|
|
|
docker build -t lnd-release-helper -f make/builder.Dockerfile make/
|
|
|
|
# Run the actual compilation inside the docker image. We pass in all flags
|
|
# that we might want to overwrite in manual tests.
|
|
$(DOCKER_RELEASE_HELPER) make release tag="$(tag)" sys="$(sys)" COMMIT="$(COMMIT)"
|
|
|
|
docker-tools:
|
|
@$(call print, "Building tools docker image.")
|
|
docker build -q -t lnd-tools $(TOOLS_DIR)
|
|
|
|
scratch: build
|
|
|
|
|
|
# =======
|
|
# TESTING
|
|
# =======
|
|
|
|
#? check: Run unit and integration tests
|
|
check: unit itest
|
|
|
|
db-instance:
|
|
ifeq ($(dbbackend),postgres)
|
|
# Remove a previous postgres instance if it exists.
|
|
docker rm lnd-postgres --force || echo "Starting new postgres container"
|
|
|
|
# Start a fresh postgres instance. Allow a maximum of 500 connections so
|
|
# that multiple lnd instances with a maximum number of connections of 50
|
|
# each can run concurrently.
|
|
docker run --name lnd-postgres -e POSTGRES_PASSWORD=postgres -p 6432:5432 -d postgres:13-alpine -N 500
|
|
docker logs -f lnd-postgres &
|
|
|
|
# Wait for the instance to be started.
|
|
sleep $(POSTGRES_START_DELAY)
|
|
endif
|
|
|
|
#? itest-only: Only run integration tests without re-building binaries
|
|
itest-only: db-instance
|
|
@$(call print, "Running integration tests with ${backend} backend.")
|
|
rm -rf itest/*.log itest/.logs-*; date
|
|
EXEC_SUFFIX=$(EXEC_SUFFIX) scripts/itest_part.sh 0 1 $(TEST_FLAGS) $(ITEST_FLAGS) -test.v
|
|
$(COLLECT_ITEST_COVERAGE)
|
|
|
|
#? itest: Build and run integration tests
|
|
itest: build-itest itest-only
|
|
|
|
#? itest-race: Build and run integration tests in race detector mode
|
|
itest-race: build-itest-race itest-only
|
|
|
|
#? itest-parallel: Build and run integration tests in parallel mode, running up to ITEST_PARALLELISM test tranches in parallel (default 4)
|
|
itest-parallel: build-itest db-instance
|
|
@$(call print, "Running tests")
|
|
rm -rf itest/*.log itest/.logs-*; date
|
|
EXEC_SUFFIX=$(EXEC_SUFFIX) scripts/itest_parallel.sh $(ITEST_PARALLELISM) $(NUM_ITEST_TRANCHES) $(TEST_FLAGS) $(ITEST_FLAGS)
|
|
$(COLLECT_ITEST_COVERAGE)
|
|
|
|
#? itest-clean: Kill all running itest processes
|
|
itest-clean:
|
|
@$(call print, "Cleaning old itest processes")
|
|
killall lnd-itest || echo "no running lnd-itest process found";
|
|
|
|
#? unit: Run unit tests
|
|
unit: $(BTCD_BIN)
|
|
@$(call print, "Running unit tests.")
|
|
$(UNIT)
|
|
|
|
#? unit-module: Run unit tests of all submodules
|
|
unit-module:
|
|
@$(call print, "Running submodule unit tests.")
|
|
scripts/unit_test_modules.sh
|
|
|
|
#? unit-debug: Run unit tests with debug log output enabled
|
|
unit-debug: $(BTCD_BIN)
|
|
@$(call print, "Running debug unit tests.")
|
|
$(UNIT_DEBUG)
|
|
|
|
#? unit-cover: Run unit tests in coverage mode
|
|
unit-cover: $(GOACC_BIN)
|
|
@$(call print, "Running unit coverage tests.")
|
|
$(GOACC)
|
|
|
|
#? unit-race: Run unit tests in race detector mode
|
|
unit-race:
|
|
@$(call print, "Running unit race tests.")
|
|
env CGO_ENABLED=1 GORACE="history_size=7 halt_on_errors=1" $(UNIT_RACE)
|
|
|
|
#? unit-bench: Run benchmark tests
|
|
unit-bench: $(BTCD_BIN)
|
|
@$(call print, "Running benchmark tests.")
|
|
$(UNIT_BENCH)
|
|
|
|
# =============
|
|
# FLAKE HUNTING
|
|
# =============
|
|
|
|
#? flakehunter: Run the integration tests continuously until one fails
|
|
flakehunter: build-itest
|
|
@$(call print, "Flake hunting ${backend} integration tests.")
|
|
while [ $$? -eq 0 ]; do make itest-only icase='${icase}' backend='${backend}'; done
|
|
|
|
#? flake-unit: Run the unit tests continuously until one fails
|
|
flake-unit:
|
|
@$(call print, "Flake hunting unit tests.")
|
|
while [ $$? -eq 0 ]; do GOTRACEBACK=all $(UNIT) -count=1; done
|
|
|
|
#? flakehunter-parallel: Run the integration tests continuously until one fails, running up to ITEST_PARALLELISM test tranches in parallel (default 4)
|
|
flakehunter-parallel:
|
|
@$(call print, "Flake hunting ${backend} integration tests in parallel.")
|
|
while [ $$? -eq 0 ]; do make itest-parallel tranches=1 parallel=${ITEST_PARALLELISM} icase='${icase}' backend='${backend}'; done
|
|
|
|
# =============
|
|
# FUZZING
|
|
# =============
|
|
|
|
#? fuzz: Run the fuzzing tests
|
|
fuzz:
|
|
@$(call print, "Fuzzing packages '$(FUZZPKG)'.")
|
|
scripts/fuzz.sh run "$(FUZZPKG)" "$(FUZZ_TEST_RUN_TIME)" "$(FUZZ_NUM_PROCESSES)"
|
|
|
|
# =========
|
|
# UTILITIES
|
|
# =========
|
|
|
|
#? fmt: Format source code and fix imports
|
|
fmt: $(GOIMPORTS_BIN)
|
|
@$(call print, "Fixing imports.")
|
|
gosimports -w $(GOFILES_NOVENDOR)
|
|
@$(call print, "Formatting source.")
|
|
gofmt -l -w -s $(GOFILES_NOVENDOR)
|
|
|
|
#? fmt-check: Make sure source code is formatted and imports are correct
|
|
fmt-check: fmt
|
|
@$(call print, "Checking fmt results.")
|
|
if test -n "$$(git status --porcelain)"; then echo "code not formatted correctly, please run `make fmt` again!"; git status; git diff; exit 1; fi
|
|
|
|
#? check-go-version-yaml: Verify that the Go version is correct in all YAML files
|
|
check-go-version-yaml:
|
|
@$(call print, "Checking for target Go version (v$(GO_VERSION)) in YAML files (*.yaml, *.yml)")
|
|
./scripts/check-go-version-yaml.sh $(GO_VERSION)
|
|
|
|
#? check-go-version-dockerfile: Verify that the Go version is correct in all Dockerfile files
|
|
check-go-version-dockerfile:
|
|
@$(call print, "Checking for target Go version (v$(GO_VERSION)) in Dockerfile files (*Dockerfile)")
|
|
./scripts/check-go-version-dockerfile.sh $(GO_VERSION)
|
|
|
|
#? check-go-version: Verify that the Go version is correct in all project files
|
|
check-go-version: check-go-version-dockerfile check-go-version-yaml
|
|
|
|
#? lint-source: Run static code analysis
|
|
lint-source: docker-tools
|
|
@$(call print, "Linting source.")
|
|
$(DOCKER_TOOLS) golangci-lint run -v $(LINT_WORKERS)
|
|
|
|
#? lint: Run static code analysis
|
|
lint: check-go-version lint-source
|
|
|
|
#? protolint: Lint proto files using protolint
|
|
protolint:
|
|
@$(call print, "Linting proto files.")
|
|
docker run --rm --volume "$$(pwd):/workspace" --workdir /workspace yoheimuta/protolint lint lnrpc/
|
|
|
|
#? tidy-module: Run `go mod` tidy for all modules
|
|
tidy-module:
|
|
echo "Running 'go mod tidy' for all modules"
|
|
scripts/tidy_modules.sh
|
|
|
|
#? tidy-module-check: Make sure all modules are up to date
|
|
tidy-module-check: tidy-module
|
|
if test -n "$$(git status --porcelain)"; then echo "modules not updated, please run `make tidy-module` again!"; git status; exit 1; fi
|
|
|
|
#? list: List all available make targets
|
|
list:
|
|
@$(call print, "Listing commands:")
|
|
@$(MAKE) -qp | \
|
|
awk -F':' '/^[a-zA-Z0-9][^$$#\/\t=]*:([^=]|$$)/ {split($$1,A,/ /);for(i in A)print A[i]}' | \
|
|
grep -v Makefile | \
|
|
sort
|
|
|
|
#? help: List all available make targets with their descriptions
|
|
help: Makefile
|
|
@$(call print, "Listing commands:")
|
|
@sed -n 's/^#?//p' $< | column -t -s ':' | sort | sed -e 's/^/ /'
|
|
|
|
#? sqlc: Generate sql models and queries in Go
|
|
sqlc:
|
|
@$(call print, "Generating sql models and queries in Go")
|
|
./scripts/gen_sqlc_docker.sh
|
|
|
|
#? sqlc-check: Make sure sql models and queries are up to date
|
|
sqlc-check: sqlc
|
|
@$(call print, "Verifying sql code generation.")
|
|
if test -n "$$(git status --porcelain '*.go')"; then echo "SQL models not properly generated!"; git status --porcelain '*.go'; exit 1; fi
|
|
|
|
#? rpc: Compile protobuf definitions and generate REST proxy stubs
|
|
rpc:
|
|
@$(call print, "Compiling protos.")
|
|
cd ./lnrpc; ./gen_protos_docker.sh
|
|
|
|
#? rpc-format: Format protobuf definition files
|
|
rpc-format:
|
|
@$(call print, "Formatting protos.")
|
|
cd ./lnrpc; find . -name "*.proto" | xargs clang-format --style=file -i
|
|
|
|
#? rpc-check: Make sure protobuf definitions are up to date
|
|
rpc-check: rpc
|
|
@$(call print, "Verifying protos.")
|
|
cd ./lnrpc; ../scripts/check-rest-annotations.sh
|
|
if test -n "$$(git status --porcelain)"; then echo "Protos not properly formatted or not compiled with v3.4.0"; git status; git diff; exit 1; fi
|
|
|
|
#? rpc-js-compile: Compile protobuf definitions and generate JSON/WASM stubs
|
|
rpc-js-compile:
|
|
@$(call print, "Compiling JSON/WASM stubs.")
|
|
GOOS=js GOARCH=wasm $(GOBUILD) -tags="$(WASM_RELEASE_TAGS)" $(PKG)/lnrpc/...
|
|
|
|
#? sample-conf-check: Make sure default values in the sample-lnd.conf file are set correctly
|
|
sample-conf-check:
|
|
@$(call print, "Checking that default values in the sample-lnd.conf file are set correctly")
|
|
scripts/check-sample-lnd-conf.sh "$(RELEASE_TAGS)"
|
|
|
|
#? mobile-rpc: Compile mobile RPC stubs from the protobuf definitions
|
|
mobile-rpc:
|
|
@$(call print, "Creating mobile RPC from protos.")
|
|
cd ./lnrpc; COMPILE_MOBILE=1 SUBSERVER_PREFIX=1 ./gen_protos_docker.sh
|
|
|
|
#? vendor: Create a vendor directory with all dependencies
|
|
vendor:
|
|
@$(call print, "Re-creating vendor directory.")
|
|
rm -r vendor/; go mod vendor
|
|
|
|
#? apple: Build mobile RPC stubs and project template for iOS and macOS
|
|
apple: mobile-rpc
|
|
@$(call print, "Building iOS and macOS cxframework ($(IOS_BUILD)).")
|
|
mkdir -p $(IOS_BUILD_DIR)
|
|
$(GOMOBILE_BIN) bind -target=ios,iossimulator,macos -tags="mobile $(DEV_TAGS) $(RPC_TAGS)" -ldflags "$(RELEASE_LDFLAGS)" -v -o $(IOS_BUILD) $(MOBILE_PKG)
|
|
|
|
#? ios: Build mobile RPC stubs and project template for iOS
|
|
ios: mobile-rpc
|
|
@$(call print, "Building iOS cxframework ($(IOS_BUILD)).")
|
|
mkdir -p $(IOS_BUILD_DIR)
|
|
$(GOMOBILE_BIN) bind -target=ios,iossimulator -tags="mobile $(DEV_TAGS) $(RPC_TAGS)" -ldflags "$(RELEASE_LDFLAGS)" -v -o $(IOS_BUILD) $(MOBILE_PKG)
|
|
|
|
#? macos: Build mobile RPC stubs and project template for macOS
|
|
macos: mobile-rpc
|
|
@$(call print, "Building macOS cxframework ($(IOS_BUILD)).")
|
|
mkdir -p $(IOS_BUILD_DIR)
|
|
$(GOMOBILE_BIN) bind -target=macos -tags="mobile $(DEV_TAGS) $(RPC_TAGS)" -ldflags "$(RELEASE_LDFLAGS)" -v -o $(IOS_BUILD) $(MOBILE_PKG)
|
|
|
|
#? android: Build mobile RPC stubs and project template for Android
|
|
android: mobile-rpc
|
|
@$(call print, "Building Android library ($(ANDROID_BUILD)).")
|
|
mkdir -p $(ANDROID_BUILD_DIR)
|
|
$(GOMOBILE_BIN) bind -target=android -androidapi 21 -tags="mobile $(DEV_TAGS) $(RPC_TAGS)" -ldflags "$(RELEASE_LDFLAGS)" -v -o $(ANDROID_BUILD) $(MOBILE_PKG)
|
|
|
|
#? mobile: Build mobile RPC stubs and project templates for iOS and Android
|
|
mobile: ios android
|
|
|
|
#? clean: Remove all generated files
|
|
clean:
|
|
@$(call print, "Cleaning source.$(NC)")
|
|
$(RM) ./lnd-debug ./lncli-debug
|
|
$(RM) ./lnd-itest ./lncli-itest
|
|
$(RM) -r ./vendor .vendor-new
|
|
|
|
#? clean-mobile: Remove all generated mobile files
|
|
clean-mobile:
|
|
@$(call print, "Cleaning autogenerated mobile RPC stubs.")
|
|
$(RM) -r mobile/build
|
|
$(RM) mobile/*_generated.go
|
|
|
|
.PHONY: all \
|
|
btcd \
|
|
default \
|
|
build \
|
|
install \
|
|
scratch \
|
|
check \
|
|
help \
|
|
itest-only \
|
|
itest \
|
|
unit \
|
|
unit-debug \
|
|
unit-cover \
|
|
unit-race \
|
|
flakehunter \
|
|
flake-unit \
|
|
fmt \
|
|
lint \
|
|
list \
|
|
rpc \
|
|
rpc-format \
|
|
rpc-check \
|
|
rpc-js-compile \
|
|
mobile-rpc \
|
|
vendor \
|
|
ios \
|
|
android \
|
|
mobile \
|
|
clean
|