APP_NAME := acra

APP_LICENSE_NAME = Apache License Version 2.0

VCS_URL := https://github.com/cossacklabs/acra

APP_SHORT_DESCRIPTION := "Acra helps you easily secure your databases in distributed, microservice-rich environments"

APP_LONG_DESCRIPTION := "Acra helps you easily secure your databases in distributed, microservice-rich environments. \

It allows you to selectively encrypt sensitive records with strong multi-layer cryptography, detect potential \

intrusions and SQL injections and cryptographically compartmentalize data stored in large sharded schemes. \

Acra's security model guarantees that if your database or your application become compromised, they will not \

leak sensitive data, or keys to decrypt them."

APP_VENDOR_URL := https://www.cossacklabs.com

APP_VENDOR_NAME := Cossack Labs Limited

APP_VENDOR_EMAIL := dev@cossacklabs.com

BUILD_DATE := $(shell date -u +'%Y-%m-%dT%H:%M:%SZ')

BUILD_DIR ?= build

BUILD_DIR_ABS := $(abspath $(BUILD_DIR))

DOCKER_BUILD_CACHE ?= false

ifeq ($(DOCKER_BUILD_CACHE),true)

DOCKER_BUILD_FLAGS += --no-cache=false

DOCKER_BUILD_FLAGS += --no-cache=true

GIT_VERSION := $(shell if [ -d ".git" ]; then git version; fi 2>/dev/null)

ifdef GIT_VERSION

APP_VERSION := $(shell git describe --tags HEAD 2>/dev/null || printf '0.0.0' | cut -b 1-)

VCS_HASH := $(shell git rev-parse --verify HEAD)

# CircleCI likes to perform builds in detached branches so usual approaches

# for determining the current branch fail. Instead, query all 'head refs'

# (i.e., branches) and see which one references the HEAD commit.

VCS_BRANCH := $(shell git show-ref --heads | awk -v head=$(VCS_HASH) '$$1 == head { sub(/^refs\/heads\//, "", $$2); branch=$$2; print(branch); exit(0); } END { if (!branch) {print "undefined"} }')

else

APP_VERSION := $(shell date +%s)

VCS_HASH := 00000000

VCS_BRANCH := master

PKG_COMPONENTS ?= addzone backup keymaker keys poisonrecordmaker rollback rotate server translator tokens

PKG_INSTALL_PREFIX ?= /usr

DOCKER_BIN := $(shell command -v docker 2> /dev/null)

DOCKER_REGISTRY_HOST ?= localhost

DOCKER_REGISTRY_PATH ?= cossacklabs

DOCKER_EXTRA_BUILD_TAGS ?=

DOCKER_EXTRA_PUSH_TAGS ?=

DOCKER_BRANCH_TAGS := $(shell printf "$(VCS_BRANCH)" | \

ifeq ($(VCS_BRANCH),stable)

DOCKER_BRANCH_TAGS := $(DOCKER_BRANCH_TAGS) latest

else ifeq ($(VCS_BRANCH),master)

DOCKER_BRANCH_TAGS := $(DOCKER_BRANCH_TAGS) current

DOCKER_BUILD_TAGS := $(VCS_HASH) $(APP_VERSION) $(DOCKER_BRANCH_TAGS) $(DOCKER_EXTRA_BUILD_TAGS)

DOCKER_PUSH_TAGS := $(VCS_HASH) $(APP_VERSION) $(DOCKER_BRANCH_TAGS) $(DOCKER_EXTRA_PUSH_TAGS)

COLOR_DEFAULT := \033[0m

COLOR_MENU := \033[1m

COLOR_TARGET := \033[93m

COLOR_ENVVAR := \033[32m

COLOR_COMMENT := \033[90m

UNAME := $(shell uname)

ifeq ($(UNAME),Linux)

OS_NAME := $(shell lsb_release -is 2>/dev/null || printf 'unknown')

OS_SHORTNAME := $(shell printf "$(OS_NAME)" | tr '[:upper:]' '[:lower:]')

OS_CODENAME := $(shell lsb_release -cs 2>/dev/null || printf 'unknown')

OS_VERSION_MAJOR := $(shell (lsb_release -rs 2>/dev/null || printf 'unknown') | cut -d'.' -f1)

ifeq ($(OS_NAME),$(filter $(OS_NAME),Debian Ubuntu))

OS_ARCH_DEBIAN := $(shell dpkg --print-architecture 2>/dev/null || printf 'unknown')

else ifeq ($(OS_NAME),$(filter $(OS_NAME),RedHatEnterpriseServer CentOS))

ifeq ($(OS_NAME),RedHatEnterpriseServer)

OS_SHORTNAME := rhel

endif

OS_ARCH_RHEL := $(shell arch || printf 'unknown')

endif

define docker_build

@$(DOCKER_BIN) image build \

$(DOCKER_BUILD_FLAGS) \

--build-arg APP_NAME=$(APP_NAME) \

--build-arg VERSION='$(APP_VERSION)' \

--build-arg VCS_URL='$(VCS_URL)' \

--build-arg VCS_REF='$(VCS_HASH)' \

--build-arg VCS_BRANCH='$(VCS_BRANCH)' \

--build-arg BUILD_DATE='$(BUILD_DATE)' \

--build-arg DOCKER_REGISTRY_PATH='$(DOCKER_REGISTRY_PATH)' \

$(foreach tag_name,$(DOCKER_BUILD_TAGS), \

--tag '$(DOCKER_REGISTRY_PATH)/$(1):$(tag_name)') \

-f ./docker/$(1).dockerfile \

.

define docker_push

@$(foreach tag_name,$(DOCKER_PUSH_TAGS), \

.DEFAULT_GOAL := build

.PHONY: help \

build install test_go test_python test test_all clean \

docker-build docker-push docker-clean docker \

pkg deb rpm

help:

@echo "$(COLOR_MENU)Targets:$(COLOR_DEFAULT)"

@awk 'BEGIN { FS = ":.*?" }\

/^## *--/ { print "" }\

/^## / { split($$0,a,/## /); comment = a[2] }\

/^[a-zA-Z-][a-zA-Z_-]*:.*?/ {\

if (length(comment) == 0) { next };\

printf " $(COLOR_TARGET)%-15s$(COLOR_DEFAULT) %s\n", $$1, comment;\

comment = "" }'\

$(MAKEFILE_LIST)

@echo "\n$(COLOR_MENU)Properties allowed for overriding:$(COLOR_DEFAULT)"

@awk 'BEGIN { FS = " *\\?= *" }\

/^## / { split($$0,a,/## /); comment = a[2] }\

/^[a-zA-Z][-_a-zA-Z]+ +\?=.*/ {\

if (length(comment) == 0) { next };\

printf " $(COLOR_ENVVAR)%-23s$(COLOR_DEFAULT) - %s\n", $$1, comment;\

printf "%28s$(COLOR_COMMENT)'\''%s'\'' by default$(COLOR_DEFAULT)\n", "", $$2;\

comment = "" }'\

$(MAKEFILE_LIST)

@echo "$(COLOR_MENU)Usage example:$(COLOR_DEFAULT)\n\

make DOCKER_EXTRA_BUILD_TAGS='staging' DOCKER_REGISTRY_HOST=registry.example.com docker-build"

build_protobuf:

@go install google.golang.org/protobuf/cmd/protoc-gen-go@v1.26

@go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@v1.1

@protoc --go_out=`pwd` --go-grpc_out=`pwd` \

--go_opt=module=github.com/cossacklabs/acra \

--go-grpc_opt=module=github.com/cossacklabs/acra \

-Icmd/acra-translator/grpc_api \

cmd/acra-translator/grpc_api/*.proto

@python3 -m grpc_tools.protoc -Icmd/acra-translator/grpc_api --proto_path=. --python_out=tests/ --grpc_python_out=tests/ cmd/acra-translator/grpc_api/*.proto

build:

@GOPATH=$(BUILD_DIR_ABS) go install ./cmd/...

install:

go install ./cmd/...

test_go:

@GOPATH=$(BUILD_DIR_ABS) go test ./cmd/...

test: test_go

test_all: test

test_python:

@virtualenv --python=python3 $(BUILD_DIR_ABS)/test_env && \

$(BUILD_DIR_ABS)/test_env/bin/pip install -r tests/requirements.txt && \

GOPATH=$(BUILD_DIR_ABS) $(BUILD_DIR_ABS)/test_env/bin/python \

$(BUILD_DIR_ABS)/src/github.com/cossacklabs/acra/tests/test.py

clean:

@test -d $(BUILD_DIR_ABS) && chmod -R u+w $(BUILD_DIR_ABS) || true

@rm -rf $(BUILD_DIR_ABS)

keys: install

@chmod +x scripts/generate-keys.sh

@scripts/generate-keys.sh

docker-build:

$(call docker_build,acra-build)

$(call docker_build,acra-server)

$(call docker_build,acra-translator)

$(call docker_build,acra-keymaker)

$(call docker_build,acra-tools)

$(DOCKER_BIN) image prune --force -a \

--filter label=com.cossacklabs.product.name="$(APP_NAME)" \

--filter label=com.cossacklabs.docker.container.type="build"

docker-build-ci:

$(call docker_build,ci-py-go-themis)

docker-push:

$(call docker_push,acra-server)

$(call docker_push,acra-translator)

$(call docker_push,acra-keymaker)

$(call docker_push,acra-tools)

docker-push-ci:

$(call docker_push,ci-py-go-themis)

docker-clean:

$(DOCKER_BIN) container prune --force \

--filter label=com.cossacklabs.product.name="$(APP_NAME)"

$(DOCKER_BIN) image prune --force -a \

--filter label=com.cossacklabs.product.name="$(APP_NAME)"

docker: docker-build

pkg: build

ifeq ($(OS_NAME),unknown)

$(error OS is not detected)

ifeq ($(OS_CODENAME),unknown)

$(error OS codename is not detected)

ifeq ($(OS_VERSION_MAJOR),unknown)

$(error OS version is not detected)

ifeq ($(OS_NAME),$(filter $(OS_NAME),Debian Ubuntu))

$(eval PKG_TYPE := deb)

$(eval PKG_VERSION := $(APP_VERSION)+$(OS_CODENAME))

$(eval PKG_NAME := $(APP_NAME)_$(PKG_VERSION)_$(OS_ARCH_DEBIAN).deb)

$(eval PKG_TYPE_SPECIFIC_ARGS := --deb-priority optional \

--architecture $(OS_ARCH_DEBIAN))

else ifeq ($(OS_NAME),$(filter $(OS_NAME),RedHatEnterpriseServer CentOS))

$(eval PKG_TYPE := rpm)

$(eval PKG_VERSION := $(shell printf "$(APP_VERSION)"|sed s/-/_/g))

$(eval PKG_NAME := $(APP_NAME)-$(PKG_VERSION).$(OS_SHORTNAME)$(OS_VERSION_MAJOR).$(OS_ARCH_RHEL).rpm)

$(eval PKG_TYPE_SPECIFIC_ARGS := --rpm-summary $(APP_LONG_DESCRIPTION) \

--architecture $(OS_ARCH_RHEL))

$(error packaging for OS $(OS_NAME) is not supported yet)

@mkdir -p '$(BUILD_DIR_ABS)/$(PKG_TYPE)'

@mkdir -p '$(BUILD_DIR_ABS)/$(PKG_TYPE).struct/bin'

@for p in $(PKG_COMPONENTS); do \

cp "$(BUILD_DIR_ABS)/bin/acra-$$p" '$(BUILD_DIR_ABS)/$(PKG_TYPE).struct/bin/'; \

done

@fpm \

--input-type dir \

--output-type $(PKG_TYPE) \

--name $(APP_NAME) \

--license '$(APP_LICENSE_NAME)' \

--url '$(APP_VENDOR_URL)' \

--description $(APP_SHORT_DESCRIPTION) \

--vendor '$(APP_VENDOR_NAME)' \

--maintainer '$(shell printf "$(APP_VENDOR_NAME) <$(APP_VENDOR_EMAIL)>")' \

--package '$(BUILD_DIR_ABS)/$(PKG_TYPE)/$(PKG_NAME)' \

--version '$(PKG_VERSION)' \

--category security \

--depends libthemis \

--conflicts acra-ee \

$(PKG_TYPE_SPECIFIC_ARGS) \

'$(BUILD_DIR_ABS)/$(PKG_TYPE).struct/bin=$(PKG_INSTALL_PREFIX)'

@find '$(BUILD_DIR_ABS)' -name \*.$(PKG_TYPE)

rpm: pkg

deb: pkg