SHELL = bash
GOTOOLS = \
github.com/elazarl/go-bindata-assetfs/... \
github.com/jteeuwen/go-bindata/... \
github.com/magiconair/vendorfmt/cmd/vendorfmt \
github.com/mitchellh/gox \
golang.org/x/tools/cmd/cover \
golang.org/x/tools/cmd/stringer \
github.com/axw/gocov/gocov \
gopkg.in/matm/v1/gocov-html
GOTAGS ?=
GOFILES ?= $( shell go list ./... | grep -v /vendor/)
GOOS = $( shell go env GOOS)
GOARCH = $( shell go env GOARCH)
# Get the git commit
GIT_COMMIT = $( shell git rev-parse --short HEAD)
GIT_DIRTY = $( shell test -n "`git status --porcelain`" && echo "+CHANGES" || true )
GIT_DESCRIBE = $( shell git describe --tags --always)
GIT_IMPORT = github.com/hashicorp/consul/version
GOLDFLAGS = -X $( GIT_IMPORT) .GitCommit= $( GIT_COMMIT) $( GIT_DIRTY) -X $( GIT_IMPORT) .GitDescribe= $( GIT_DESCRIBE)
export GOLDFLAGS
# all builds binaries for all targets
all : bin
bin : tools
@mkdir -p bin/
@GOTAGS= '$(GOTAGS)' sh -c " ' $( CURDIR) /scripts/build.sh' "
# dev creates binaries for testing locally - these are put into ./bin and $GOPATH
dev : changelogfmt vendorfmt dev -build
dev-build :
@echo "--> Building consul"
mkdir -p pkg/$( GOOS) _$( GOARCH) / bin/
go install -ldflags '$(GOLDFLAGS)' -tags '$(GOTAGS)'
cp $( GOPATH) /bin/consul bin/
cp $( GOPATH) /bin/consul pkg/$( GOOS) _$( GOARCH)
vendorfmt :
@echo "--> Formatting vendor/vendor.json"
test -x $( GOPATH) /bin/vendorfmt || go get -u github.com/magiconair/vendorfmt/cmd/vendorfmt
vendorfmt
changelogfmt :
@echo "--> Making [GH-xxxx] references clickable..."
@sed -E 's|([^\[])\[GH-([0-9]+)\]|\1[[GH-\2](https://github.com/hashicorp/consul/issues/\2)]|g' CHANGELOG.md > changelog.tmp && mv changelog.tmp CHANGELOG.md
# linux builds a linux package independent of the source platform
linux :
mkdir -p pkg/linux_amd64/
GOOS = linux GOARCH = amd64 go build -ldflags '$(GOLDFLAGS)' -tags '$(GOTAGS)' -o pkg/linux_amd64/consul
# dist builds binaries for all platforms and packages them for distribution
dist :
@GOTAGS= '$(GOTAGS)' sh -c " ' $( CURDIR) /scripts/dist.sh' "
cov :
gocov test $( GOFILES) | gocov-html > /tmp/coverage.html
open /tmp/coverage.html
test : other -consul dev -build vet
@echo "--> Running go test"
@rm -f test.log exit-code
go test -tags '$(GOTAGS)' -i ./...
go test $( GOTEST_FLAGS) -tags '$(GOTAGS)' -timeout 5m -v ./... & >test.log ; echo $$ ? > exit-code
@echo " Exit code: $$ (cat exit-code) " >> test.log
@grep -A5 'DATA RACE' test.log || true
@grep -A10 'panic: test timed out' test.log || true
@grep -A1 -- '--- SKIP:' test.log || true
@grep -A1 -- '--- FAIL:' test.log || true
@grep '^FAIL' test.log || true
@if [ " $$ (cat exit-code) " = = "0" ] ; then echo "PASS" ; exit 0 ; else exit 1 ; fi
test-race :
$( MAKE) GOTEST_FLAGS = -race
other-consul :
@echo "--> Checking for other consul instances"
@if ps -ef | grep 'consul agent' | grep -v grep ; then \
echo "Found other running consul agents. This may affect your tests." ; \
exit 1 ; \
fi
cover :
go test $( GOFILES) --cover
format :
@echo "--> Running go fmt"
@go fmt $( GOFILES)
Makefile: add vet target
Add a vet target in order to catch suspicious constructs
reported by go vet.
Vet has successfully detected problems in the past,
for example, see
c9333b1b9b472feb5cad80e2c8276d41b64bde88
Some vet flags are noisy. In particular, the following flags
reports a large amount of generally unharmful constructs:
```
-assign: check for useless assignments
-composites: check that composite literals used field-keyed
elements
-shadow: check for shadowed variables
-shadowstrict: whether to be strict about shadowing
-unreachable: check for unreachable code
```
In order to skip running the flags mentioned above, vet is
invoked on a directory basis with `go tool vet .` since package-
level type-checking with `go vet` doesn't accept flags.
Hence, each file is vetted in isolation, which is weaker than
package-level type-checking. But nevertheless, it might catch
suspicious constructs that pose a real issue.
The vet target runs the following flags on the entire repo:
```
-asmdecl: check assembly against Go declarations
-atomic: check for common mistaken usages of the
sync/atomic package
-bool: check for mistakes involving boolean operators
-buildtags: check that +build tags are valid
-copylocks: check that locks are not passed by value
-methods: check that canonically named methods are canonically
defined
-nilfunc: check for comparisons between functions and nil
-printf: check printf-like invocations
-rangeloops: check that range loop variables are used correctly
-shift: check for useless shifts
-structtags: check that struct field tags have canonical format
and apply to exported fields as needed
-unsafeptr: check for misuse of unsafe.Pointer
```
Now and then, it might make sense to check the output of the
disabled flags manually.
For example, `VETARGS=-unreachable make vet` can detect several
lines of dead code that can be deleted, etc.
10 years ago
vet :
@echo "--> Running go vet"
@go vet $( GOFILES) ; if [ $$ ? -eq 1 ] ; then \
Makefile: add vet target
Add a vet target in order to catch suspicious constructs
reported by go vet.
Vet has successfully detected problems in the past,
for example, see
c9333b1b9b472feb5cad80e2c8276d41b64bde88
Some vet flags are noisy. In particular, the following flags
reports a large amount of generally unharmful constructs:
```
-assign: check for useless assignments
-composites: check that composite literals used field-keyed
elements
-shadow: check for shadowed variables
-shadowstrict: whether to be strict about shadowing
-unreachable: check for unreachable code
```
In order to skip running the flags mentioned above, vet is
invoked on a directory basis with `go tool vet .` since package-
level type-checking with `go vet` doesn't accept flags.
Hence, each file is vetted in isolation, which is weaker than
package-level type-checking. But nevertheless, it might catch
suspicious constructs that pose a real issue.
The vet target runs the following flags on the entire repo:
```
-asmdecl: check assembly against Go declarations
-atomic: check for common mistaken usages of the
sync/atomic package
-bool: check for mistakes involving boolean operators
-buildtags: check that +build tags are valid
-copylocks: check that locks are not passed by value
-methods: check that canonically named methods are canonically
defined
-nilfunc: check for comparisons between functions and nil
-printf: check printf-like invocations
-rangeloops: check that range loop variables are used correctly
-shift: check for useless shifts
-structtags: check that struct field tags have canonical format
and apply to exported fields as needed
-unsafeptr: check for misuse of unsafe.Pointer
```
Now and then, it might make sense to check the output of the
disabled flags manually.
For example, `VETARGS=-unreachable make vet` can detect several
lines of dead code that can be deleted, etc.
10 years ago
echo "" ; \
echo "Vet found suspicious constructs. Please check the reported constructs" ; \
echo "and fix them if necessary before submitting the code for review." ; \
exit 1; \
Makefile: add vet target
Add a vet target in order to catch suspicious constructs
reported by go vet.
Vet has successfully detected problems in the past,
for example, see
c9333b1b9b472feb5cad80e2c8276d41b64bde88
Some vet flags are noisy. In particular, the following flags
reports a large amount of generally unharmful constructs:
```
-assign: check for useless assignments
-composites: check that composite literals used field-keyed
elements
-shadow: check for shadowed variables
-shadowstrict: whether to be strict about shadowing
-unreachable: check for unreachable code
```
In order to skip running the flags mentioned above, vet is
invoked on a directory basis with `go tool vet .` since package-
level type-checking with `go vet` doesn't accept flags.
Hence, each file is vetted in isolation, which is weaker than
package-level type-checking. But nevertheless, it might catch
suspicious constructs that pose a real issue.
The vet target runs the following flags on the entire repo:
```
-asmdecl: check assembly against Go declarations
-atomic: check for common mistaken usages of the
sync/atomic package
-bool: check for mistakes involving boolean operators
-buildtags: check that +build tags are valid
-copylocks: check that locks are not passed by value
-methods: check that canonically named methods are canonically
defined
-nilfunc: check for comparisons between functions and nil
-printf: check printf-like invocations
-rangeloops: check that range loop variables are used correctly
-shift: check for useless shifts
-structtags: check that struct field tags have canonical format
and apply to exported fields as needed
-unsafeptr: check for misuse of unsafe.Pointer
```
Now and then, it might make sense to check the output of the
disabled flags manually.
For example, `VETARGS=-unreachable make vet` can detect several
lines of dead code that can be deleted, etc.
10 years ago
fi
# Build the static web ui and build static assets inside a Docker container, the
# same way a release build works. This implicitly does a "make static-assets" at
# the end.
ui :
@sh -c " ' $( CURDIR) /scripts/ui.sh' "
# If you've run "make ui" manually then this will get called for you. This is
# also run as part of the release build script when it verifies that there are no
# changes to the UI assets that aren't checked in.
static-assets :
@go-bindata-assetfs -pkg agent -prefix pkg ./pkg/web_ui/...
@mv bindata_assetfs.go agent/
$( MAKE) format
tools :
go get -u -v $( GOTOOLS)
.PHONY : all ci bin dev dist cov test cover format vet ui static -assets tools vendorfmt
