Makefile

# Maintainer Binu Udayakumar <binu@dronasys.com>

REPO=dronasys

APP_STORE_APP_NAME= brain-app-store
BRAIN_REPO_APP_NAME= brain-repo
CONTAINER_SERVER_APP_NAME= brain-container-server
BRAIN_RUNNER_APP_NAME= brain-runner
SCHEDULER_APP_NAME= brain-scheduler
AIMODULE_PROXY_APP_NAME= brain-aimodule-proxy
AIMODULE_GRPC_PROXY_APP_NAME= brain-aimodule-grpc-proxy
AI_FILE_SERVER= brain-fileserver
BRAIN_BACKEND= brain-backend
BRAIN_COMBINED= brain-combined

DEBUG_IMAGE= debug-golang

BUILD_VER= a1.0.0

DOCKER_HUB_TAG= a1.0.0

TAGGED_NAME = $(REPO)/$(APP_NAME)

MULTI_PLATFORM_DOCKER = --platform=linux/amd64,linux/arm64

# Optional environmental variables


BASE_DIR	:=	$(shell git rev-parse --show-toplevel)
BIN			:=	$(BASE_DIR)/bin

## Needs protoc to be installed

ifndef PROTOC
PROTOC = protoc
endif

ifndef PROTOWEB
PROTOWEB = protoc-gen-grpc-web
endif

# HELP
# This will output the help for each task
# thanks to https://marmelab.com/blog/2016/02/29/auto-documented-makefile.html
.PHONY: help vendor vendor-update
help: ## This help.
	@awk 'BEGIN {FS = ":.*?## "} /^[a-zA-Z_-]+:.*?## / {printf "\033[36m%-30s\033[0m %s\n", $$1, $$2}' $(MAKEFILE_LIST)

.DEFAULT_GOAL := help

##
## Build, Vendor, Publish
##

main: ## Build main
	go build $(BUILDFLAGS) -o main .

build: ## build backend and frontend as a single image
	docker build --no-cache  --build-arg BUILD_VER=$(BUILD_VER) $(MULTI_PLATFORM_DOCKER) -t $(REPO)/$(BRAIN_COMBINED) -f deployment/docker/brainCombined.dockerfile .

build-backend: ## build backend as a single image
	docker build --no-cache  --build-arg BUILD_VER=$(BUILD_VER) $(MULTI_PLATFORM_DOCKER) -t $(REPO)/$(BRAIN_BACKEND) -f deployment/docker/brainBackend.dockerfile .

build-ui: ## build the ui and copy the distribution folder
	cd ../brain-ui && make build
	rm -rf ./deployment/uiDistribution/*
	mv ../brain-ui/app/dist/brain-ui/browser/*  ./deployment/uiDistribution/

build-go-binary: ## build the go binary
	go build -o brainBackend cmd/brainCombined/main.go

build-app-repo: ## Build the app repo and continer manager image	
	docker build --no-cache  --build-arg BUILD_VER=$(BUILD_VER) -t $(REPO)/$(APP_STORE_APP_NAME)  --target $(APP_STORE_APP_NAME)  -f deployment/docker/appStore.dockerfile .
	docker build --no-cache  --build-arg BUILD_VER=$(BUILD_VER) -t $(REPO)/$(CONTAINER_SERVER_APP_NAME)  --target $(CONTAINER_SERVER_APP_NAME)  -f deployment/docker/appStore.dockerfile .

build-aimodule-proxy: ## Build the proxy	servers
	docker build --no-cache  --build-arg BUILD_VER=$(BUILD_VER) -t $(REPO)/$(AIMODULE_PROXY_APP_NAME)  --target $(AIMODULE_PROXY_APP_NAME)  -f deployment/docker/proxy.dockerfile .
	docker build --no-cache  --build-arg BUILD_VER=$(BUILD_VER) -t $(REPO)/$(AIMODULE_GRPC_PROXY_APP_NAME)  --target $(AIMODULE_GRPC_PROXY_APP_NAME)  -f deployment/docker/proxy.dockerfile .
	docker build --no-cache  --build-arg BUILD_VER=$(BUILD_VER) -t $(REPO)/$(AI_FILE_SERVER)  --target $(AI_FILE_SERVER)  -f deployment/docker/proxy.dockerfile .
	

build-scheduler: ## Build the scheduler image
	docker build --no-cache  --build-arg BUILD_VER=$(BUILD_VER) -t $(REPO)/$(BRAIN_REPO_APP_NAME)  --target $(BRAIN_REPO_APP_NAME)   -f deployment/docker/brainNode.dockerfile .
	docker build --no-cache  --build-arg BUILD_VER=$(BUILD_VER) -t $(REPO)/$(BRAIN_RUNNER_APP_NAME)  --target $(BRAIN_RUNNER_APP_NAME)  -f deployment/docker/brainNode.dockerfile .
	docker build --no-cache  --build-arg BUILD_VER=$(BUILD_VER) -t $(REPO)/$(SCHEDULER_APP_NAME)  --target $(SCHEDULER_APP_NAME)  -f deployment/docker/brainNode.dockerfile .

build-debug-image: ## Build docker debug image
	docker build --no-cache  --build-arg BUILD_VER=$(BUILD_VER) -t $(REPO)/$(DEBUG_IMAGE) -f deployment/docker/ brainNode.debug.dockerfile .

publish-docker: ## Publish docker backend and combined images to docker !! PUBLIC IMAGE !!
	@echo "====================> Pushing image to dockerhub !! PUBLIC IMAGE !!"
## @docker login --username=$(DOCKER_HUB_USER) --password="$(DOCKER_HUB_PASSWD)"
	docker tag $(REPO)/${BRAIN_COMBINED} $(REPO)/${BRAIN_COMBINED}:$(DOCKER_HUB_TAG)
	docker push $(REPO)/${BRAIN_COMBINED}:$(DOCKER_HUB_TAG)

publish-private-microservices: ## Deploy all images to docker hub 
	@echo "====================> Pushing image to dockerhub$(AWS_ECR) ."
	## @docker login --username=$(DOCKER_HUB_USER) --password="$(DOCKER_HUB_PASSWD)"
	aws ecr get-login-password --region ap-southeast-1 | docker login --username AWS --password-stdin $(AWS_ECR)

	docker tag $(REPO)/${APP_NAME} $(AWS_ECR)/${APP_NAME}:$(DOCKER_HUB_TAG)
	docker push $(AWS_ECR)/$(APP_NAME):$(DOCKER_HUB_TAG)


run-grpc: ## Run Spine GRPC Server - no token required
	./run.sh

tidy: ## run tidy
	go mod tidy

vendor: ## run vendor
	go mod tidy
	go mod vendor

staticcheck:
	GOFLAGS="" go install honnef.co/go/tools/cmd/staticcheck@v0.2.2
	staticcheck $(PKGS)

errcheck:
	go get -u github.com/kisielk/errcheck
	errcheck -ignoregenerated -verbose -blank $(PKGS)

clean-docker: ## Clean existing containers
	docker rm -f trance_agent

### the ordering of sub targets is very important
### do not change
protos: protos-container protos-node protos-brain ## run all protos


## protos
protos-node: ## Build Go and Web Proto
# ****** Brain AiModule 
	$(PROTOC) -I=./proto/.  \
	--go_out=./gen/go/ \
	--go_opt paths=source_relative \
	--go-grpc_out=./gen/go/ \
	--go-grpc_opt paths=source_relative \
	--grpc-gateway_out=./gen/go/ \
	--grpc-gateway_opt paths=source_relative \
	--grpc-gateway_opt generate_unbound_methods=true \
	--grpc-gateway-ts_out=./gen/go/ \
	--grpc-gateway-ts_opt paths=source_relative \
	--grpc-gateway-ts_opt generate_unbound_methods=true \
	--oas_out ./gen/go/v1/node/ \
	proto/v1/node/nodeMeta.proto proto/v1/node/nodeRepo.proto  proto/v1/node/node.proto proto/v1/node/containerService.proto
	yq eval ./gen/go/v1/node/openapi.yaml -o=json -P > ./gen/go/v1/node/openapi.json
## 

protos-container: ## generate protos for container
	$(PROTOC) -I=./proto/.  \
	--go_out=./gen/go/ \
	--go_opt paths=source_relative \
	--go-grpc_out=./gen/go/ \
	--go-grpc_opt paths=source_relative \
	--grpc-gateway_out=./gen/go/ \
	--grpc-gateway_opt paths=source_relative \
	--grpc-gateway_opt generate_unbound_methods=true \
	--grpc-gateway-ts_out=./gen/go/ \
	--grpc-gateway-ts_opt paths=source_relative \
	--grpc-gateway-ts_opt generate_unbound_methods=true \
	--oas_out ./gen/go/v1/container/ \
	proto/v1/container/container.proto 
	yq eval ./gen/go/v1/container/openapi.yaml -o=json -P > ./gen/go/v1/container/openapi.json

protos-brain: ## generate protos for brain entity
	$(PROTOC) -I=./proto/.  \
	--go_out=./gen/go/ \
	--go_opt paths=source_relative \
	--go-grpc_out=./gen/go/ \
	--go-grpc_opt paths=source_relative \
	--grpc-gateway_out=./gen/go/ \
	--grpc-gateway_opt paths=source_relative \
	--grpc-gateway_opt generate_unbound_methods=true \
	--grpc-gateway-ts_out=./gen/go/ \
	--grpc-gateway-ts_opt paths=source_relative \
	--grpc-gateway-ts_opt generate_unbound_methods=true \
	--oas_out ./gen/go/v1/brain/ \
	proto/v1/brain/cortex.proto	\
	proto/v1/brain/brainRepoService.proto \
	proto/v1/brain/brainRunnerService.proto \
	proto/v1/brain/scheduler.proto 
	yq eval ./gen/go/v1/brain/openapi.yaml -o=json -P > ./gen/go/v1/brain/openapi.json

protos-aimodule: ## generate protos for ai module
	$(PROTOC) -I=./proto/.  \
	--go_out=./gen/go/ \
	--go_opt paths=source_relative \
	--go-grpc_out=./gen/go/ \
	--go-grpc_opt paths=source_relative \
	--grpc-gateway_out=./gen/go/ \
	--grpc-gateway_opt paths=source_relative \
	--grpc-gateway_opt generate_unbound_methods=true \
	--grpc-gateway-ts_out=./gen/go/ \
	--grpc-gateway-ts_opt paths=source_relative \
	--grpc-gateway-ts_opt generate_unbound_methods=true \
	--oas_out ./gen/go/v1/aiModule/ \
	proto/v1/aiModule/aiModuleService.proto 
	yq eval ./gen/go/v1/aiModule/openapi.yaml -o=json -P > ./gen/go/v1/aiModule/openapi.json

protos-ts: ## Build typescript files from proto
# ****** Brain AiModule 
	$(PROTOC) -I=./proto/.  \
	--grpc-gateway-ts_out=./gen/go/ \
	--grpc-gateway-ts_opt paths=source_relative \
	--grpc-gateway-ts_opt generate_unbound_methods=true \
	proto/v1/container/container.proto \
	proto/v1/node/nodeMeta.proto  proto/v1/node/nodeRepo.proto proto/v1/node/node.proto

##
## Test Code
##

testScheduler: ## Test Scheduler
	scripts/testScheduler.sh

testBrain: ## Run tests
	go test -v ./pkg/servers/brainRunner/...

testCRUDL: ## Run tests against File CRUDL server
	FILE_STORE_PATH="$(shell pwd)/dataVolumes/store" bash -c 'go test -v ./pkg/dataLayer/...'	

testCoverage: ## Run test coverage
	go test ./pkg/... -coverprofile=coverage.out

##
## Deployments
##


infra-local-down: ## docker compose down
	cd deployments/local && docker-compose down  

##
## Run on local machine
##

compose-local-up-debug: ## docker compose up all the microservices for brain-node, runs in foreground
	cd deployment/local/compose && docker compose up

compose-local-up: ## docker compose up all the microservices for brain-node, except UI, in background
	cd deployment/local/compose && docker compose up -d

compose-local-down: ## docker compose destroy all the microservices for brain-node, except UI
	cd deployment/local/compose && docker compose down	

run-app-store: ## run node repo server
	./scripts/runNodeAppStore.sh

run-container-server: ## run container server
	./scripts/runContainerServer.sh 

run-brain-repo-server: ## run brain repo server
	./scripts/runBrainRepo.sh 	

run-brain-runner: ## run brain runner
	./scripts/runBrainRunner.sh 	

run-scheduler: ## run scheduler
	./scripts/runScheduler.sh 	

run-scratch: ## run test or scratch code
	./scripts/runScratch.sh 	


run: ## combine all services for single user case
	./scripts/runCombined.sh

run-docker-combined: ## run the docker image
	cd ./scripts && ./runDockerCombined.sh

run-debug-go-shell: ## get a go shell to debug 
	docker stop debug-golang; docker rm debug-golang; docker run  -it -v /var/run/docker.sock:/var/run/docker.sock  -v .:/home  -p 9091:9091 -p 9081:9081 --name debug-golang $(REPO)/$(DEBUG_IMAGE) /bin/bash  


run-docker: ## run docker # docker stop $(APP_NAME) && docker rm $(APP_NAME); 
	docker run  -it -v /var/run/docker.sock:/var/run/docker.sock $(REPO)/$(APP_NAME)