make: rework makefiles for non-recursive make and add sharness coverage

This commit introduces non-recursive Makefile infrastructure that replaces current Makefile infrastructure.
It also generally cleanups the Makefiles, separates them into nicer sub-modules and centralizes common operations into single definitions.

It allows to depend on any target that is defined in the makefile, this means that for example `gx install` is called once when `make build test_expensive_sharness` is called instead of 4 or 5 times.

It also makes the dependencies much cleaner and allows for reuse of modules. For example sharness coverage collection (WIP) uses sharness target with amended PATH, previously it might have been possible but not without wiring in the coverage collection into sharness make runner code.

Yes, it is more complex but not much more. There are few rules that have to be followed and few complexities added but IMHO it is worth it.

How to NR-make:
1. If make is to generate some file via a target, it MUST be defined in Rules.mk file in the directory of the target.
2. `Rules.mk` file MUST have `include mk/header.mk` statement as the first line and `include mk/footer.mk` statement as the last line (apart from project root `Rules.mk`).
3. It then MUST be included by the closest `Rules.mk` file up the directory tree.
4. Inside a `Rules.mk` special variable accessed as `$(d)` is defined. Its value is current directory, use it so if the `Rules.mk` file is moved in the tree it still works without a problem. Caution: this variable is not available in the recipe part and MUST NOT be used. Use name of the target or prerequisite to extract it if you need it.
5. Make has only one global scope, this means that name conflicts are a thing. Names SHOULD  follow `VAR_NAME_$(d)` convention. There are exceptions from this rule in form of well defined global variables. Examples: General lists `TGT_BIN`, `CLEAN`; General targets: `TEST`, `COVERAGE`; General variables: `GOFLAGS`, `DEPS_GO`.
3. Any rules, definitions or variables that fit some family SHOULD be defined in `mk/$family.mk` file and included from project root `Rules.mk`

License: MIT
Signed-off-by: Jakub Sztandera <kubuxu@protonmail.ch>
This commit is contained in:
Jakub Sztandera 2016-12-16 19:04:22 +01:00
parent 2cb68b2210
commit f630222580
No known key found for this signature in database
GPG Key ID: 9A9AF56F8B3879BA
42 changed files with 640 additions and 457 deletions

197
Makefile
View File

@ -1,195 +1,10 @@
# Minimum version numbers for software required to build IPFS
IPFS_MIN_GO_VERSION = 1.7
IPFS_MIN_GX_VERSION = 0.6
IPFS_MIN_GX_GO_VERSION = 1.1
# General tools
GOTAGS =
GOTAGS += "" # we have to have always at least one tag, empty tag works well
SHELL=PATH=$(PATH) /bin/sh
GOFLAGS =
GOTFLAGS =
PROTOC = protoc --gogo_out=. --proto_path=.:/usr/local/opt/protobuf/include:$(dir $@) $<
export IPFS_REUSEPORT=false
export GOFLAGS
export GOTFLAGS
# enable second expansion
.SECONDEXPANSION:
GOFLAGS += -tags $(call join-with,$(comma),$(GOTAGS))
ifeq ($(TEST_NO_FUSE),1)
GOTAGS += nofuse
endif
ifeq ($(OS),Windows_NT)
GOPATH_DELIMITER = ;
else
GOPATH_DELIMITER = :
endif
dist_root=/ipfs/QmNZL8wNsvAGdVYr8uGeUE9aGfHjFpHegAWywQFEdSaJbp
gx_bin=bin/gx-v0.9.0
gx-go_bin=bin/gx-go-v1.3.0
# util functions
space =
space +=
comma =,
join-with = $(subst $(space),$1,$(strip $2))
# use things in our bin before any other system binaries
export PATH := bin:$(PATH)
export IPFS_API ?= v04x.ipfs.io
all: help
godep:
go get github.com/tools/godep
go_check:
@bin/check_go_version $(IPFS_MIN_GO_VERSION)
bin/gx-v%:
@echo "installing gx $(@:bin/gx-%=%)"
@bin/dist_get ${dist_root} gx $@ $(@:bin/gx-%=%)
rm -f bin/gx
ln -s $(@:bin/%=%) bin/gx
bin/gx-go-v%:
@echo "installing gx-go $(@:bin/gx-go-%=%)"
@bin/dist_get ${dist_root} gx-go $@ $(@:bin/gx-go-%=%)
rm -f bin/gx-go
ln -s $(@:bin/%=%) bin/gx-go
gx_check: ${gx_bin} ${gx-go_bin}
path_check:
@bin/check_go_path $(realpath $(shell pwd)) $(realpath $(addsuffix /src/github.com/ipfs/go-ipfs,$(subst $(GOPATH_DELIMITER), ,$(GOPATH))))
deps: go_check gx_check path_check $(covertools_rule)
${gx_bin} --verbose install --global
deps_covertools:
go get -u github.com/wadey/gocovmerge
go get -u golang.org/x/tools/cmd/cover
# saves/vendors third-party dependencies to Godeps/_workspace
# -r flag rewrites import paths to use the vendored path
# ./... performs operation on all packages in tree
vendor: godep
godep save -r ./...
nofuse: GOTAGS += nofuse
nofuse: deps
$(MAKE) -C cmd/ipfs install
install build: deps
$(MAKE) -C cmd/ipfs $@
clean:
$(MAKE) -C cmd/ipfs clean
$(MAKE) -C test clean
uninstall:
$(MAKE) -C cmd/ipfs uninstall
PHONY += all help godep gx_check covertools
PHONY += go_check deps vendor install build nofuse clean uninstall
##############################################################
# tests targets
test: test_expensive
test_short: test_go_fmt build test_go_short test_sharness_short
test_expensive: test_go_fmt build test_go_expensive test_sharness_expensive windows_build_check
test_3node:
$(MAKE) -C test/3nodetest
test_go_fmt:
bin/test-go-fmt
test_go_short: GOTFLAGS += -test.short
test_go_race: GOTFLAGS += -race
test_go_expensive test_go_short test_go_race:
go test $(GOFLAGS) $(GOTFLAGS) ./...
coverage: deps_covertools
@echo Running coverage
$(eval PKGS := $(shell go list -f '{{if (len .GoFiles)}}{{.ImportPath}}{{end}}' ./... | grep -v /vendor/ | grep -v /Godeps/))
#$(eval PKGS_DELIM := $(call join-with,$(comma),$(PKGS)))
@go list -f '{{if or (len .TestGoFiles) (len .XTestGoFiles)}}go test $(GOFLAGS) $(GOTFLAGS) -covermode=atomic -coverprofile={{.Name}}_{{len .Imports}}_{{len .Deps}}.coverprofile {{.ImportPath}}{{end}}' $(GOFLAGS) $(PKGS) | xargs -I {} bash -c {} 2>&1 | grep -v 'warning: no packages being tested depend on'
gocovmerge `ls *.coverprofile` > coverage.txt
rm *.coverprofile
bash -c 'bash <(curl -s https://codecov.io/bash)'
test_sharness_short:
$(MAKE) -j1 -C test/sharness/
test_sharness_expensive:
TEST_EXPENSIVE=1 $(MAKE) -j1 -C test/sharness/
test_all_commits:
@echo "testing all commits between origin/master..HEAD"
@echo "WARNING: this will 'git rebase --exec'."
@test/bin/continueyn
GIT_EDITOR=true git rebase -i --exec "$(MAKE) test" origin/master
test_all_commits_travis:
# these are needed because travis.
# we don't use this yet because it takes way too long.
git config --global user.email "nemo@ipfs.io"
git config --global user.name "IPFS BOT"
git fetch origin master:master
GIT_EDITOR=true git rebase -i --exec "$(MAKE) test" master
# since we have CI for osx and linux but not windows, this should help
windows_build_check:
GOOS=windows GOARCH=amd64 go build -o .test.ipfs.exe ./cmd/ipfs
rm -f .test.ipfs.exe
PHONY += test test_short test_expensive
##############################################################
# A semi-helpful help message
help:
@echo 'DEPENDENCY TARGETS:'
@echo ''
@echo ' gx_check - Installs or upgrades gx and gx-go'
@echo ' deps - Download dependencies using gx'
@echo ' vendor - Create a Godep workspace of 3rd party dependencies'
@echo ''
@echo 'BUILD TARGETS:'
@echo ''
@echo ' all - print this help message'
@echo ' build - Build binary at ./cmd/ipfs/ipfs'
@echo ' nofuse - Build binary with no fuse support'
@echo ' install - Build binary and install into $$GOPATH/bin'
# @echo ' dist_install - TODO: c.f. ./cmd/ipfs/dist/README.md'
@echo ''
@echo 'CLEANING TARGETS:'
@echo ''
@echo ' clean - Remove binary from build directory'
@echo ' uninstall - Remove binary from $$GOPATH/bin'
@echo ''
@echo 'TESTING TARGETS:'
@echo ''
@echo ' test - Run expensive tests and Window$$ check'
@echo ' test_short - Run short tests and sharness tests'
@echo ' test_expensive - Run a few extras'
@echo ' test_3node'
@echo ' test_go_short'
@echo ' test_go_expensive'
@echo ' test_go_race'
@echo ' test_sharness_short'
@echo ' test_sharness_expensive'
@echo ' test_all_commits'
@echo " test_all_commits_travis - DON'T USE: takes way too long"
@echo ' windows_build_check'
@echo ''
PHONY += help
.PHONY: $(PHONY)
include Rules.mk

137
Rules.mk Normal file
View File

@ -0,0 +1,137 @@
TGT_BIN :=
CLEAN :=
COVERAGE :=
DISTCLEAN :=
TEST :=
TEST_SHORT :=
all: help # all has to be first defined target
.PHONY: all
include mk/util.mk
include mk/golang.mk
include mk/gx.mk
# -------------------- #
# sub-files #
# -------------------- #
dir := bin
include $(dir)/Rules.mk
dir := test
include $(dir)/Rules.mk
dir := cmd/ipfs
include $(dir)/Rules.mk
# has to be after cmd/ipfs due to PATH
dir := coverage
include $(dir)/Rules.mk
dir := namesys/pb
include $(dir)/Rules.mk
dir := unixfs/pb
include $(dir)/Rules.mk
dir := merkledag/pb
include $(dir)/Rules.mk
dir := exchange/bitswap/message/pb
include $(dir)/Rules.mk
dir := diagnostics/pb
include $(dir)/Rules.mk
dir := pin/internal/pb
include $(dir)/Rules.mk
# -------------------- #
# universal rules #
# -------------------- #
%.pb.go: %.proto
$(PROTOC)
# -------------------- #
# extra properties #
# -------------------- #
ifeq ($(TEST_NO_FUSE),1)
GOTAGS += nofuse
endif
export IPFS_REUSEPORT=false
# -------------------- #
# core targets #
# -------------------- #
build: $(TGT_BIN)
.PHONY: build
clean:
rm -f $(CLEAN)
.PHONY: clean
coverage: $(COVERAGE)
.PHONY: coverage
distclean: clean
rm -f $(DISTCLEAN)
.PHONY: distclean
test: $(TEST)
.PHONY: test
test_short: $(TEST_SHORT)
.PHONY: test_short
deps: gx-deps
.PHONY: deps
nofuse: GOTAGS += nofuse
nofuse: build
.PHONY: nofuse
install: $$(DEPS_GO)
go install $(go-flags-with-tags) ./cmd/ipfs
.PHONY: install
uninstall:
go clean -i ./cmd/ipfs
.PHONY: uninstall
help:
@echo 'DEPENDENCY TARGETS:'
@echo ''
@echo ' deps - Download dependencies using bundled gx'
@echo ' test_sharness_deps - Download and build dependencies for sharness'
@echo ''
@echo 'BUILD TARGETS:'
@echo ''
@echo ' all - print this help message'
@echo ' build - Build binary at ./cmd/ipfs/ipfs'
@echo ' nofuse - Build binary with no fuse support'
@echo ' install - Build binary and install into $$GOPATH/bin'
# @echo ' dist_install - TODO: c.f. ./cmd/ipfs/dist/README.md'
@echo ''
@echo 'CLEANING TARGETS:'
@echo ''
@echo ' clean - Remove files generated by build'
@echo ' distclean - Remove files that are no part of a repository'
@echo ' uninstall - Remove binary from $$GOPATH/bin'
@echo ''
@echo 'TESTING TARGETS:'
@echo ''
@echo ' test - Run expensive tests'
@echo ' test_short - Run short tests and short sharness tests'
@echo ' test_go_short'
@echo ' test_go_expensive'
@echo ' test_go_race'
@echo ' test_sharness_short'
@echo ' test_sharness_expensive'
@echo ' test_sharness_race'
@echo ' coverage - Collects coverage info from unit tests and sharness'
@echo
.PHONY: help

26
bin/Rules.mk Normal file
View File

@ -0,0 +1,26 @@
include mk/header.mk
dist_root_$(d)=/ipfs/QmNZL8wNsvAGdVYr8uGeUE9aGfHjFpHegAWywQFEdSaJbp
$(d)/gx: $(d)/gx-v0.9.0
$(d)/gx-go: $(d)/gx-go-v1.3.0
TGTS_$(d) := $(d)/gx $(d)/gx-go
DISTCLEAN += $(wildcard $(d)/gx-v*) $(wildcard $(d)/gx-go-v*)
PATH := $(realpath $(d)):$(PATH)
$(TGTS_$(d)):
rm -f $@
ln -s $(notdir $^) $@
bin/gx-v%:
@echo "installing gx $(@:bin/gx-%=%)"
bin/dist_get $(dist_root_bin) gx $@ $(@:bin/gx-%=%)
bin/gx-go-v%:
@echo "installing gx-go $(@:bin/gx-go-%=%)"
@bin/dist_get $(dist_root_bin) gx-go $@ $(@:bin/gx-go-%=%)
CLEAN += $(TGTS_$(d))
include mk/footer.mk

9
bin/gen-make-dep-chain Executable file
View File

@ -0,0 +1,9 @@
#!/bin/sh
(for p ; do
printf "%s\n" "$p"
done) | tac |
( read -r PREV ;
while read -r CURR ; do
printf '%s: | %s\n' "$PREV" "$CURR"
PREV="$CURR"
done) | tac

View File

@ -35,6 +35,6 @@ dependencies:
test:
override:
- case $CIRCLE_NODE_INDEX in 0) make coverage ;; 1) make test_sharness_expensive ;; esac:
- case $CIRCLE_NODE_INDEX in 0) make -j 1 coverage/unit_tests.coverprofile && bash <(curl -s https://codecov.io/bash) -cF unittests -X search -f coverage/unit_tests.coverprofile;; 1) make -j 1 coverage/sharness_tests.coverprofile && bash <(curl -s https://codecov.io/bash) -cF sharness -X search -f coverage/sharness_tests.coverprofile;; esac:
pwd: "../.go_workspace/src/$IMPORT_PATH"
parallel: true

1
cmd/ipfs/.gitignore vendored
View File

@ -1,2 +1,3 @@
ipfs
ipfs-test-cover
ipfs.exe

View File

@ -1,16 +0,0 @@
COMMIT := $(shell git rev-parse --short HEAD)
GOFLAGS += -ldflags="-X "github.com/ipfs/go-ipfs/repo/config".CurrentCommit=$(COMMIT)"
all: install
install:
go install $(GOFLAGS)
build:
go build -i $(GOFLAGS)
clean:
go clean $(GOFLAGS)
uninstall:
go clean -i $(GOFLAGS)

29
cmd/ipfs/Rules.mk Normal file
View File

@ -0,0 +1,29 @@
include mk/header.mk
IPFS_BIN_$(d) := $(call go-curr-pkg-tgt)
TGT_BIN += $(IPFS_BIN_$(d))
CLEAN += $(IPFS_BIN_$(d))
PATH := $(realpath $(d)):$(PATH)
# disabled for now
# depend on *.pb.go files in the repo as Order Only (as they shouldn't be rebuilt if exist)
# DPES_OO_$(d) := diagnostics/pb/diagnostics.pb.go exchange/bitswap/message/pb/message.pb.go
# DEPS_OO_$(d) += merkledag/pb/merkledag.pb.go namesys/pb/namesys.pb.go
# DEPS_OO_$(d) += pin/internal/pb/header.pb.go unixfs/pb/unixfs.pb.go
# uses second expansion to collect all $(DEPS_GO)
$(IPFS_BIN_$(d)): $(d) $$(DEPS_GO) ALWAYS #| $(DEPS_OO_$(d))
$(go-build)
COVER_BIN_$(d) := $(d)/ipfs-test-cover
CLEAN += $(COVER_BIN_$(d))
$(COVER_BIN_$(d)): GOTAGS += testrunmain
$(COVER_BIN_$(d)): $(d) $$(DEPS_GO) ALWAYS
$(eval TMP_PKGS := $(shell go list -f '{{range .Deps}}{{.}} {{end}}' $(go-flags-with-tags) ./cmd/ipfs | sed 's/ /\n/g' | grep ipfs/go-ipfs))
$(eval TMP_LIST := $(call join-with,$(comma),$(TMP_PKGS)))
@echo go test $@ -c -covermode atomic -coverpkg ... $(go-flags-with-tags) ./$(@D) # for info
@go test -o $@ -c -covermode atomic -coverpkg $(TMP_LIST) $(go-flags-with-tags) ./$(@D) 2>&1 | (grep -v 'warning: no packages being tested' || true)
include mk/footer.mk

View File

@ -64,6 +64,10 @@ type cmdInvocation struct {
// - output the response
// - if anything fails, print error, maybe with help
func main() {
os.Exit(mainRet())
}
func mainRet() int {
rand.Seed(time.Now().UnixNano())
ctx := logging.ContextWithLoggable(context.Background(), loggables.Uuid("session"))
var err error
@ -79,7 +83,7 @@ func main() {
stopFunc, err := profileIfEnabled()
if err != nil {
printErr(err)
os.Exit(1)
return 1
}
defer stopFunc() // to be executed as late as possible
@ -104,7 +108,7 @@ func main() {
if len(os.Args) == 2 {
if os.Args[1] == "help" {
printHelp(false, os.Stdout)
os.Exit(0)
return 0
} else if os.Args[1] == "--version" {
os.Args[1] = "version"
}
@ -119,11 +123,11 @@ func main() {
longH, shortH, err := invoc.requestedHelp()
if err != nil {
printErr(err)
os.Exit(1)
return 1
}
if longH || shortH {
printHelp(longH, os.Stdout)
os.Exit(0)
return 0
}
}
@ -138,7 +142,7 @@ func main() {
fmt.Fprintf(os.Stderr, "\n")
printHelp(false, os.Stderr)
}
os.Exit(1)
return 1
}
// here we handle the cases where
@ -146,7 +150,7 @@ func main() {
// - the main command is invoked.
if invoc.cmd == nil || invoc.cmd.Run == nil {
printHelp(false, os.Stdout)
os.Exit(0)
return 0
}
// ok, finally, run the command invocation.
@ -161,16 +165,16 @@ func main() {
if isClientError(err) {
printMetaHelp(os.Stderr)
}
os.Exit(1)
return 1
}
// everything went better than expected :)
_, err = io.Copy(os.Stdout, output)
if err != nil {
printErr(err)
os.Exit(1)
return 1
}
return 0
}
func (i *cmdInvocation) Run(ctx context.Context) (output io.Reader, err error) {

30
cmd/ipfs/runmain_test.go Normal file
View File

@ -0,0 +1,30 @@
// +build testrunmain
package main
import (
"flag"
"fmt"
"io/ioutil"
"os"
"testing"
)
// this abuses go so much that I felt dirty writing this code
// but it is the only way to do it without writing custom compiler that would
// be a clone of go-build with go-test
func TestRunMain(t *testing.T) {
args := flag.Args()
os.Args = append([]string{os.Args[0]}, args...)
ret := mainRet()
p := os.Getenv("IPFS_COVER_RET_FILE")
if len(p) != 0 {
ioutil.WriteFile(p, []byte(fmt.Sprintf("%d\n", ret)), 0777)
}
// close outputs so go testing doesn't print anything
null, _ := os.Open(os.DevNull)
os.Stderr = null
os.Stdout = null
}

View File

@ -311,7 +311,7 @@ func editConfig(filename string) error {
func replaceConfig(r repo.Repo, file io.Reader) error {
var cfg config.Config
if err := json.NewDecoder(file).Decode(&cfg); err != nil {
return errors.New("failed to decode file as config")
return errors.New("failed to decode file as config: " + err.Error())
}
if len(cfg.Identity.PrivKey) != 0 {
return errors.New("setting private key with API is not supported")

4
coverage/.gitignore vendored Normal file
View File

@ -0,0 +1,4 @@
unitcover
sharnesscover
ipfs

51
coverage/Rules.mk Normal file
View File

@ -0,0 +1,51 @@
include mk/header.mk
$(d)/coverage_deps:
rm -rf $(@D)/unitcover && mkdir $(@D)/unitcover
rm -rf $(@D)/sharnesscover && mkdir $(@D)/sharnesscover
go get -u github.com/Kubuxu/gocovmerge
go get -u golang.org/x/tools/cmd/cover
.PHONY: $(d)/coverage_deps
# unit tests coverage
UTESTS_$(d) := $(shell go list -f '{{if (len .TestGoFiles)}}{{.ImportPath}}{{end}}' $(go-flags-with-tags) ./... | grep -v go-ipfs/vendor | grep -v go-ipfs/Godeps)
UCOVER_$(d) := $(addsuffix .coverprofile,$(addprefix $(d)/unitcover/, $(subst /,_,$(UTESTS_$(d)))))
$(UCOVER_$(d)): $(d)/coverage_deps ALWAYS
$(eval TMP_PKG := $(subst _,/,$(basename $(@F))))
@go test $(go-flags-with-tags) $(GOTFLAGS) -covermode=atomic -coverprofile=$@ $(TMP_PKG)
$(d)/unit_tests.coverprofile: $(UCOVER_$(d))
gocovmerge $^ > $@
TGTS_$(d) := $(d)/unit_tests.coverprofile
# sharness tests coverage
$(d)/ipfs: GOTAGS += testrunmain
$(d)/ipfs: $(d)/main
$(go-build)
CLEAN += $(d)/ipfs
ifneq ($(filter coverage,$(MAKECMDGOALS)),)
# this is quite hacky but it is best way I could fiture out
DEPS_test/sharness += cmd/ipfs/ipfs-test-cover $(d)/coverage_deps $(d)/ipfs
endif
export IPFS_COVER_DIR:= $(realpath $(d))/sharnesscover/
$(d)/sharness_tests.coverprofile: $(d)/ipfs cmd/ipfs/ipfs-test-cover $(d)/coverage_deps test_sharness_short
(cd $(@D)/sharnesscover && find . -type f | gocovmerge -list -) > $@
PATH := $(realpath $(d)):$(PATH)
TGTS_$(d) += $(d)/sharness_tests.coverprofile
CLEAN += $(TGTS_$(d))
COVERAGE += $(TGTS_$(d))
include mk/footer.mk

72
coverage/main/main.go Normal file
View File

@ -0,0 +1,72 @@
// +build testrunmain
package main
import (
"fmt"
"io/ioutil"
"os"
"os/exec"
"os/signal"
"strconv"
"syscall"
)
func main() {
coverDir := os.Getenv("IPFS_COVER_DIR")
if len(coverDir) == 0 {
fmt.Println("IPFS_COVER_DIR not defined")
os.Exit(1)
}
coverFile, err := ioutil.TempFile(coverDir, "coverage-")
if err != nil {
fmt.Println(err.Error())
os.Exit(1)
}
retFile, err := ioutil.TempFile("", "cover-ret-file")
if err != nil {
fmt.Println(err.Error())
os.Exit(1)
}
args := []string{"-test.run", "^TestRunMain$", "-test.coverprofile=" + coverFile.Name(), "--"}
args = append(args, os.Args[1:]...)
p := exec.Command("ipfs-test-cover", args...)
p.Stdin = os.Stdin
p.Stdout = os.Stdout
p.Stderr = os.Stderr
p.Env = append(os.Environ(), "IPFS_COVER_RET_FILE="+retFile.Name())
p.SysProcAttr = &syscall.SysProcAttr{
Pdeathsig: syscall.SIGTERM,
}
sig := make(chan os.Signal, 1)
go func() {
for {
p.Process.Signal(<-sig)
}
}()
signal.Notify(sig, syscall.SIGHUP, syscall.SIGINT, syscall.SIGTERM)
err = p.Run()
if err != nil {
fmt.Println(err.Error())
os.Exit(1)
}
b, err := ioutil.ReadAll(retFile)
if err != nil {
fmt.Println(err.Error())
os.Exit(1)
}
b = b[:len(b)-1]
d, err := strconv.Atoi(string(b))
if err != nil {
fmt.Println(err.Error())
os.Exit(1)
}
os.Exit(d)
}

View File

@ -1,10 +0,0 @@
PB = $(wildcard *.proto)
GO = $(PB:.proto=.pb.go)
all: $(GO)
%.pb.go: %.proto
protoc --gogo_out=. --proto_path=../../../../../../:/usr/local/opt/protobuf/include:. $<
clean:
rm *.pb.go

8
diagnostics/pb/Rules.mk Normal file
View File

@ -0,0 +1,8 @@
include mk/header.mk
PB_$(d) = $(wildcard $(d)/*.proto)
TGTS_$(d) = $(PB_$(d):.proto=.pb.go)
#DEPS_GO += $(TGTS_$(d))
include mk/footer.mk

View File

@ -1,8 +0,0 @@
# TODO(brian): add proto tasks
all: message.pb.go
message.pb.go: message.proto
protoc --gogo_out=. --proto_path=../../../../../:/usr/local/opt/protobuf/include:. $<
clean:
rm message.pb.go

View File

@ -0,0 +1,8 @@
include mk/header.mk
PB_$(d) = $(wildcard $(d)/*.proto)
TGTS_$(d) = $(PB_$(d):.proto=.pb.go)
#DEPS_GO += $(TGTS_$(d))
include mk/footer.mk

View File

@ -1,11 +0,0 @@
PB = $(wildcard *.proto)
GO = $(PB:.proto=.pb.go)
all: $(GO)
%.pb.go: %.proto
protoc --gogo_out=. --proto_path=../../../../../../:/usr/local/opt/protobuf/include:. $<
clean:
rm -f *.pb.go
rm -f *.go

8
merkledag/pb/Rules.mk Normal file
View File

@ -0,0 +1,8 @@
include mk/header.mk
PB_$(d) = $(wildcard $(d)/*.proto)
TGTS_$(d) = $(PB_$(d):.proto=.pb.go)
#DEPS_GO += $(TGTS_$(d))
include mk/footer.mk

2
mk/footer.mk Normal file
View File

@ -0,0 +1,2 @@
d := $(dirstack_$(sp))
sp := $(basename $(sp))

50
mk/golang.mk Normal file
View File

@ -0,0 +1,50 @@
# golang utilities
GO_MIN_VERSION = 1.7
# pre-definitions
GOTAGS ?=
GOFLAGS ?=
GOTFLAGS ?=
DEPS_GO :=
TEST_GO :=
CHECK_GO :=
go-pkg-name=$(shell go list $(go-tags) ./$(1))
go-main-name=$(notdir $(call go-pkg-name,$(1)))$(?exe)
go-curr-pkg-tgt=$(d)/$(call go-main-name,$(d))
go-tags=$(if $(GOTAGS), -tags $(call join-with,$(comma),$(GOTAGS)))
go-flags-with-tags=$(GOFLAGS)$(go-tags)
define go-build
go build -i $(go-flags-with-tags) -o "$@" "$(call go-pkg-name,$<)"
endef
test_go_short: GOTFLAGS += -test.short
test_go_short: test_go_expensive
.PHONY: test_go_short
test_go_race: GOTFLAGS += -race
test_go_race: test_go_expensive
.PHONY: test_go_race
test_go_expensive: $$(DEPS_GO)
go test $(go-flags-with-tags) $(GOTFLAGS) ./...
.PHONY: test_go_expensive
TEST_GO += test_go_expensive
test_go_fmt:
bin/test-go-fmt
.PHONY: test_go_fmt
TEST_GO += test_go_fmt
test_go: $(TEST_GO)
check_go_version:
bin/check_go_version $(GO_MIN_VERSION)
.PHONY: check_go_version
CHECK_GO += check_go_version
TEST += $(TEST_GO)
TEST_SHORT += test_go_fmt test_go_short

6
mk/gx.mk Normal file
View File

@ -0,0 +1,6 @@
gx-path = gx/ipfs/$(shell gx deps find $(1))/$(1)
gx-deps: bin/gx bin/gx-go $(CHECK_GO)
gx install --global >/dev/null 2>&1
DEPS_GO += gx-deps

4
mk/header.mk Normal file
View File

@ -0,0 +1,4 @@
# keep track of dirs
p := $(sp).x
dirstack_$(sp) := $(d)
d := $(dir)

20
mk/util.mk Normal file
View File

@ -0,0 +1,20 @@
# util functions
ifeq ($(OS),Windows_NT)
WINDOWS :=1
?exe :=.exe # windows compat
else
?exe :=
endif
space:=
space+=
comma:=,
join-with=$(subst $(space),$1,$(strip $2))
# debug target, prints varaible. Example: `make print-GOFLAGS`
print-%:
@echo $*=$($*)
# phony target that will mean that recipe is always exectued
ALWAYS:
.PHONY: ALWAYS

View File

@ -1,10 +0,0 @@
PB = $(wildcard *.proto)
GO = $(PB:.proto=.pb.go)
all: $(GO)
%.pb.go: %.proto
protoc --gogo_out=. --proto_path=../../../../../../:/usr/local/opt/protobuf/include:. $<
clean:
rm *.pb.go

8
namesys/pb/Rules.mk Normal file
View File

@ -0,0 +1,8 @@
include mk/header.mk
PB_$(d) = $(wildcard $(d)/*.proto)
TGTS_$(d) = $(PB_$(d):.proto=.pb.go)
#DEPS_GO += $(TGTS_$(d))
include mk/footer.mk

8
pin/internal/pb/Rules.mk Normal file
View File

@ -0,0 +1,8 @@
include mk/header.mk
PB_$(d) = $(wildcard $(d)/*.proto)
TGTS_$(d) = $(PB_$(d):.proto=.pb.go)
#DEPS_GO += $(TGTS_$(d))
include mk/footer.mk

View File

@ -5,7 +5,6 @@ package pin
import (
"context"
"fmt"
"os"
"sync"
"time"
@ -26,8 +25,9 @@ var emptyKey *cid.Cid
func init() {
e, err := cid.Decode("QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n")
if err != nil {
log.Error("failed to decode empty key constant")
os.Exit(1)
msg := "failed to decode empty key constant"
log.Error(msg)
panic(msg)
}
emptyKey = e
}

View File

@ -1,115 +0,0 @@
BINS = bin/random bin/multihash bin/ipfs bin/pollEndpoint bin/iptb bin/go-sleep
BINS += bin/go-timeout
IPFS_ROOT = ../
IPFS_CMD = ../cmd/ipfs
RANDOM_SRC = ../Godeps/_workspace/src/github.com/jbenet/go-random
RANDOM_FILES_SRC = ../Godeps/_workspace/src/github.com/jbenet/go-random-files
POLLENDPOINT_SRC= ../thirdparty/pollEndpoint
GOSLEEP_SRC = ./dependencies/go-sleep
GOTIMEOUT_SRC = ./dependencies/go-timeout
export PATH := ../bin:${PATH}
# User might want to override those on the command line
GOFLAGS =
all: deps
global-deps:
$(MAKE) -C .. deps
deps: global-deps bins
clean:
$(MAKE) -C sharness clean
rm -rf $(BINS)
bins: $(BINS)
find_go_files = $(shell find $(1) -name "*.go")
# Non gx dependencies
bin/random: $(call find_go_files, $(RANDOM_SRC)) IPFS-BUILD-OPTIONS
@echo "*** installing $@ ***"
go build $(GOFLAGS) -o bin/random $(RANDOM_SRC)/random
bin/random-files:
@echo "*** installing $@ ***"
go build $(GOFLAGS) -o bin/random-files $(RANDOM_FILES_SRC)/random-files
bin/ipfs: $(call find_go_files, $(IPFS_ROOT)) IPFS-BUILD-OPTIONS
@echo "*** installing $@ ***"
go build $(GOFLAGS) -o bin/ipfs $(IPFS_CMD)
bin/pollEndpoint: $(call find_go_files, $(POLLENDPOINT_SRC)) IPFS-BUILD-OPTIONS
@echo "*** installing $@ ***"
go build $(GOFLAGS) -o bin/pollEndpoint $(POLLENDPOINT_SRC)
bin/go-sleep: $(call find_go_files, $(GOSLEEP_SRC)) IPFS-BUILD-OPTIONS
@echo "*** installing $@ ***"
go build $(GOFLAGS) -o bin/go-sleep $(GOSLEEP_SRC)
bin/go-timeout: $(call find_go_files, $(GOTIMEOUT_SRC)) IPFS-BUILD-OPTIONS
@echo "*** installing $@ ***"
go build $(GOFLAGS) -o bin/go-timeout $(GOTIMEOUT_SRC)
# gx dependencies
multihash_src:
$(eval MULTIHASH_HASH := $(shell cd .. && bin/gx deps find go-multihash))
$(eval MULTIHASH_SRC := gx/ipfs/$(MULTIHASH_HASH)/go-multihash)
hang-fds_src:
$(eval HANG_FDS_HASH := $(shell cd .. && bin/gx deps find hang-fds))
$(eval HANG_FDS_SRC := gx/ipfs/$(HANG_FDS_HASH)/hang-fds)
bin/multihash: multihash_src $(call find_go_files, $(MULTIHASH_SRC)) IPFS-BUILD-OPTIONS
@echo "*** installing $@ ***"
go build $(GOFLAGS) -o bin/multihash $(MULTIHASH_SRC)/multihash
bin/hang-fds: hang-fds_src $(call find_go_files, $(HANG_FDS_SRC)) IPFS-BUILD-OPTIONS
@echo "*** installing $@ ***"
go build $(GOFLAGS) -o bin/hang-fds $(HANG_FDS_SRC)
iptb_src:
$(eval IPTB_HASH := $(shell cd .. && bin/gx deps find iptb))
$(eval IPTB_SRC := gx/ipfs/$(IPTB_HASH)/iptb)
bin/iptb: iptb_src $(call find_go_files, $(IPTB_SRC)) IPFS-BUILD-OPTIONS
@echo "*** installing $@ ***"
go build $(GOFLAGS) -o bin/iptb $(IPTB_SRC)
# Tests
test: test_expensive
test_expensive: verify_gofmt
$(MAKE) -C sharness TEST_EXPENSIVE=1
$(MAKE) -C 3nodetest
$(MAKE) -C dependencies
test_cheap: verify_gofmt
$(MAKE) -C sharness
$(MAKE) -C 3nodetest
test_race: verify_gofmt
$(MAKE) -C sharness GOFLAGS=-race TEST_EXPENSIVE=1
$(MAKE) -C 3nodetest GOFLAGS=-race
$(MAKE) -C dependencies GOFLAGS=-race
# Misc
coverage: coverage_sharness
coverage_sharness:
./sharness_test_coverage_helper.sh
IPFS-BUILD-OPTIONS: FORCE
@bin/checkflags '$@' '$(GOFLAGS)' '*** new Go flags ***'
verify_gofmt:
bin/verify-go-fmt.sh
.PHONY: all clean FORCE

9
test/Rules.mk Normal file
View File

@ -0,0 +1,9 @@
include mk/header.mk
dir := $(d)/bin
include $(dir)/Rules.mk
dir := $(d)/sharness
include $(dir)/Rules.mk
include mk/footer.mk

1
test/bin/.gitignore vendored
View File

@ -8,3 +8,4 @@
!checkflags
!continueyn
!verify-go-fmt.sh
!Rules.mk

44
test/bin/Rules.mk Normal file
View File

@ -0,0 +1,44 @@
include mk/header.mk
TGTS_$(d) :=
$(d)/random: Godeps/_workspace/src/github.com/jbenet/go-random/random
$(go-build)
TGTS_$(d) += $(d)/random
$(d)/random-files: Godeps/_workspace/src/github.com/jbenet/go-random-files/random-files
$(go-build)
TGTS_$(d) += $(d)/random-files
$(d)/pollEndpoint: thirdparty/pollEndpoint
$(go-build)
TGTS_$(d) += $(d)/pollEndpoint
$(d)/go-sleep: test/dependencies/go-sleep
$(go-build)
TGTS_$(d) += $(d)/go-sleep
$(d)/go-timeout: test/dependencies/go-timeout
$(go-build)
TGTS_$(d) += $(d)/go-timeout
TGTS_GX_$(d) := hang-fds iptb
TGTS_GX_$(d) := $(addprefix $(d)/,$(TGTS_GX_$(d)))
$(TGTS_GX_$(d)):
go build -i $(go-flags-with-tags) -o "$@" "$(call gx-path,$(notdir $@))"
TGTS_$(d) += $(TGTS_GX_$(d))
# multihash is special
$(d)/multihash:
go build -i $(go-flags-with-tags) -o "$@" "gx/ipfs/$(shell gx deps find go-multihash)/go-multihash/multihash"
TGTS_$(d) += $(d)/multihash
$(TGTS_$(d)): $$(DEPS_GO)
CLEAN += $(TGTS_$(d))
PATH := $(realpath $(d)):$(PATH)
include mk/footer.mk

View File

@ -1,57 +0,0 @@
# Run tests
#
# Copyright (c) 2014 Christian Couder
# MIT Licensed; see the LICENSE file in this repository.
#
# NOTE: Run with TEST_VERBOSE=1 for verbose sharness tests.
T = $(sort $(wildcard t[0-9][0-9][0-9][0-9]-*.sh))
BINS = bin/random bin/multihash bin/ipfs bin/pollEndpoint \
bin/iptb bin/go-sleep bin/random-files bin/go-timeout bin/hang-fds
SHARNESS = lib/sharness/sharness.sh
IPFS_ROOT = ../..
# User might want to override those on the command line
GOFLAGS =
all: aggregate
clean: clean-test-results
@echo "*** $@ ***"
rm -rf $(BINS)
clean-test-results:
@echo "*** $@ ***"
rm -rf test-results
$(T): clean-test-results deps
@echo "*** $@ ***"
./$@
aggregate: clean-test-results $(T)
@echo "*** $@ ***"
lib/test-aggregate-results.sh
global-deps:
$(MAKE) -C ../.. deps
deps: global-deps $(SHARNESS) $(BINS) curl
$(SHARNESS): FORCE
@echo "*** checking $@ ***"
lib/install-sharness.sh
bin/%: FORCE
$(MAKE) -C .. GOFLAGS=$(GOFLAGS) $@
race:
$(MAKE) GOFLAGS=-race all
.PHONY: all clean $(T) aggregate FORCE
# will fail if curl is not installed.
# TODO: get rid of this and install curl with git or ipfs.
install_curl_pls = "curl is required to run tests. please install it"
curl:
@which curl >/dev/null || (echo "$(install_curl_pls)" && false)

View File

@ -37,7 +37,8 @@ $ ./t0010-basic-commands.sh -v -i
## Sharness
When running "make" in this directory for the first time, sharness
When running sharness tests from main Makefile or when `test_sharness_deps`
target is run dependencies for sharness
will be downloaded from its github repo and installed in a "lib/sharness"
directory.

54
test/sharness/Rules.mk Normal file
View File

@ -0,0 +1,54 @@
include mk/header.mk
SHARNESS_$(d) = $(d)/lib/sharness/sharness.sh
T_$(d) = $(sort $(wildcard $(d)/t[0-9][0-9][0-9][0-9]-*.sh))
DEPS_$(d) := test/bin/random test/bin/multihash test/bin/pollEndpoint \
test/bin/iptb test/bin/go-sleep test/bin/random-files \
test/bin/go-timeout test/bin/hang-fds
DEPS_$(d) += cmd/ipfs/ipfs
DEPS_$(d) += $(d)/clean-test-results
DEPS_$(d) += $(SHARNESS_$(d))
export MAKE_SKIP_PATH=1
$(T_$(d)): $$(DEPS_$(d)) # use second expansion so coverage can inject dependency
@echo "*** $@ ***"
@(cd $(@D) && ./$(@F)) 2>&1
.PHONY: $(T_$(d))
$(d)/aggregate: $(T_$(d))
@echo "*** $@ ***"
@(cd $(@D) && ./lib/test-aggregate-results.sh)
.PHONY: $(d)/aggregate
$(d)/clean-test-results:
rm -rf $(@D)/test-results
.PHONY: $(d)/clean-test-results
CLEAN += $(wildcard $(d)/test-results/*)
$(SHARNESS_$(d)): $(d) ALWAYS
@clonedir=$(dir $(@D)) $</lib/install-sharness.sh
test_sharness_deps: $(SHARNESS_$(d)) $$(DEPS_$(d)) # use second expansion so coverage can inject dependency
.PHONY: test_sharness_deps
test_sharness_short: $(d)/aggregate
.PHONY: test_sharness_short
test_sharness_expensive: export TEST_EXPENSIVE=1
test_sharness_expensive: test_sharness_short
.PHONY: test_sharness_expensive
test_sharness_race: GOFLAGS += -race
.PHONY: test_sharness_race
TEST += test_sharness_expensive
TEST_SHORT += test_sharness_short
include mk/footer.mk

View File

@ -1 +0,0 @@
../bin

View File

@ -8,7 +8,9 @@
# settings
version=5eee9b51b5621cec95a64018f0cc779963b230d2
urlprefix=https://github.com/mlafeldt/sharness.git
if test ! -n "$clonedir" ; then
clonedir=lib
fi
sharnessdir=sharness
if test -f "$clonedir/$sharnessdir/SHARNESS_VERSION_$version"

View File

@ -9,22 +9,23 @@
# use the ipfs tool to test against
# add current directory to path, for ipfs tool.
if test "$MAKE_SKIP_PATH" -ne "1"; then
BIN=$(cd .. && echo `pwd`/bin)
PATH=${BIN}:${PATH}
BIN2=$(cd ../.. && echo `pwd`/cmd/ipfs)
PATH=${BIN2}:${BIN}:${PATH}
# assert the `ipfs` we're using is the right one.
if test `which ipfs` != ${BIN2}/ipfs; then
echo >&2 "Cannot find the tests' local ipfs tool."
echo >&2 "Please check test and ipfs tool installation."
exit 1
fi
fi
# set sharness verbosity. we set the env var directly as
# it's too late to pass in --verbose, and --verbose is harder
# to pass through in some cases.
test "$TEST_VERBOSE" = 1 && verbose=t
# assert the `ipfs` we're using is the right one.
if test `which ipfs` != ${BIN}/ipfs; then
echo >&2 "Cannot find the tests' local ipfs tool."
echo >&2 "Please check test and ipfs tool installation."
exit 1
fi
# source the common hashes first.
. lib/test-lib-hashes.sh

View File

@ -37,7 +37,8 @@ test_kill_ipfs_daemon
test_expect_success "ipfs daemon --offline --mount fails - #2995" '
test_expect_code 1 ipfs daemon --offline --mount 2>daemon_err &&
grep "mount is not currently supported in offline mode" daemon_err
grep "mount is not currently supported in offline mode" daemon_err ||
test_fsh cat daemon_err
'
test_done

View File

@ -1,10 +0,0 @@
PB = $(wildcard *.proto)
GO = $(PB:.proto=.pb.go)
all: $(GO)
%.pb.go: %.proto
protoc --gogo_out=. --proto_path=../../../../../../:/usr/local/opt/protobuf/include:. $<
clean:
rm *.pb.go

8
unixfs/pb/Rules.mk Normal file
View File

@ -0,0 +1,8 @@
include mk/header.mk
PB_$(d) = $(wildcard $(d)/*.proto)
TGTS_$(d) = $(PB_$(d):.proto=.pb.go)
#DEPS_GO += $(TGTS_$(d))
include mk/footer.mk