pgmon/Makefile

PACKAGE_NAME := pgmon
VERSION := 1.0

SCRIPT := src/$(PACKAGE_NAME).py

# Where packages are built
BUILD_DIR := build

# OS images used to build packages
# These are created with: make docker
# Targets are at the bottom of this file
DEB_IMAGE := debian-package-builder
RPM_IMAGE := rpm-package-builder
EL7_IMAGE := el7-package-builder

# List of versions to test for each distro
INSTALL_TEST_DEBIAN_RELEASES := 10 11
INSTALL_TEST_REDHAT_RELEASES := 8 9
INSTALL_TEST_REDHAT_OLD_RELEASES := 7
INSTALL_TEST_UBUNTU_RELEASES := 20.04 22.04 24.04

# The default release to test for each distro (basically pick the last one in the list)
INSTALL_TEST_DEBIAN_RELEASE := $(lastword $(INSTALL_TEST_DEBIAN_RELEASES))
INSTALL_TEST_REDHAT_RELEASE := $(lastword $(INSTALL_TEST_REDHAT_RELEASES))
INSTALL_TEST_REDHAT_OLD_RELEASE := $(lastword $(INSTALL_TEST_REDHAT_OLD_RELEASES))
INSTALL_TEST_UBUNTU_RELEASE := $(lastword $(INSTALL_TEST_UBUNTU_RELEASES))


##
# These targets are the main ones to use for most things.
##

.PHONY: all clean deb rpm test install install-tests

all: deb rpm

# Create a deb package
deb:
	mkdir -p $(BUILD_DIR)/deb
	docker run --rm \
	    -v .:/src:ro \
	    -v ./$(BUILD_DIR)/deb:/output \
	    --user $(shell id -u):$(shell id -g) \
	    $(DEB_IMAGE)

# Create an rpm package
rpm:
	mkdir -p $(BUILD_DIR)/rpm
	docker run --rm \
	    -v .:/src:ro \
	    -v ./$(BUILD_DIR)/rpm:/output \
	    --user $(shell id -u):$(shell id -g) \
	    $(RPM_IMAGE)

# Create a tarball
tgz:
	rm -rf $(BUILD_DIR)/tgz/root
	mkdir -p $(BUILD_DIR)/tgz/root
	$(MAKE) install DESTDIR=$(BUILD_DIR)/tgz/root
	tar -cz -f $(BUILD_DIR)/tgz/$(PACKAGE_NAME)-$(VERSION).tgz -C $(BUILD_DIR)/tgz/root .

# Clean up the build directory
clean:
	rm -rf $(BUILD_DIR)

# Run unit tests for the script
test:
	cd src ; python3 -m unittest

# Install the script at the specified base directory
install:
	# Set up directories
	mkdir -p $(DESTDIR)/etc/$(PACKAGE_NAME)
	mkdir -p ${DESTDIR}/etc/logrotate.d
	mkdir -p $(DESTDIR)/lib/systemd/system
	mkdir -p $(DESTDIR)/usr/local/bin
	mkdir -p $(DESTDIR)/usr/share/man/man1
	
	# Install script
	cp $(SCRIPT) $(DESTDIR)/usr/local/bin/$(PACKAGE_NAME)
	chmod 755 $(DESTDIR)/usr/local/bin/$(PACKAGE_NAME)
	
	# Install manpage
	cp manpages/* $(DESTDIR)/usr/share/man/man1/
	gzip -f -9 $(DESTDIR)/usr/share/man/man1/$(PACKAGE_NAME).1
	
	# Install sample config
	cp sample-config/* $(DESTDIR)/etc/$(PACKAGE_NAME)/
	
	# Install systemd unit files
	cp systemd/* $(DESTDIR)/lib/systemd/system/
	
	# Install logrotate config
	cp logrotate/${PACKAGE_NAME}.logrotate ${DESTDIR}/etc/logrotate.d/${PACKAGE_NAME}


# Run all of the install tests
install-tests: all-debian-install-tests all-redhat-install-tests all-ubuntu-install-tests

.PHONY: all-debian-install-tests all-redhat-install-tests all-ubuntu-install-tests

# Run all of the Debian install tests
all-debian-install-tests:
	$(foreach version, $(INSTALL_TEST_DEBIAN_RELEASES), $(MAKE) debian-install-test INSTALL_TEST_DEBIAN_RELEASE=$(version) ;)

# Run all of the RedHat install tests
all-redhat-install-tests:
	$(foreach version, $(INSTALL_TEST_REDHAT_RELEASES), $(MAKE) redhat-install-test INSTALL_TEST_REDHAT_RELEASE=$(version) ;)

# Run all of the *old* RedHat install tests
all-redhat-old-install-tests:
	$(foreach version, $(INSTALL_TEST_REDHAT_OLD_RELEASES), $(MAKE) redhat-old-install-test INSTALL_TEST_REDHAT_OLD_RELEASE=$(version) ;)

# Run all of the Ubuntu install tests
all-ubuntu-install-tests:
	$(foreach version, $(INSTALL_TEST_REDHAT_RELEASES), $(MAKE) ubuntu-install-test INSTALL_TEST_REDHAT_RELEASE=$(version) ;)


.PHONY: debian-install-test redhat-install-test rhel-old-install-test ubuntu-install-test

# Run the specified (or latest) Debian install test
debian-install-test:
	docker run --rm \
	     -v ./$(BUILD_DIR)/deb:/output \
	     debian:$(INSTALL_TEST_DEBIAN_RELEASE) \
	     bash -c 'apt-get update && apt-get install -y /output/$(PACKAGE_NAME)_$(VERSION).deb'

# Run the specified (or latest) RedHat install test
redhat-install-test:
	docker run --rm \
	     -v ./$(BUILD_DIR)/rpm:/output \
	     rockylinux:$(INSTALL_TEST_REDHAT_RELEASE) \
	     bash -c 'dnf makecache && dnf install -y /output/$(PACKAGE_NAME)-$(VERSION).rpm'

# Run the specified (or latest) *old* RedHat install test
rhel-old-install-test:
	docker run --rm \
	     -v ./$(BUILD_DIR)/rpm:/output \
	     rockylinux:$(INSTALL_TEST_REDHAT_OLD_RELEASE) \
	     bash -c 'yum makecache && yum install -y /output/$(PACKAGE_NAME)-$(VERSION).el$(INSTALL_TEST_REDHAT_OLD_RELEASE).rpm'

# Run the specified (or latest) Ubuntu install test
ubuntu-install-test:
	docker run --rm \
	     -v ./$(BUILD_DIR)/deb:/output \
	     ubuntu:$(INSTALL_TEST_UBUNTU_RELEASE) \
	     bash -c 'apt-get update && apt-get install -y /output/$(PACKAGE_NAME)_$(VERSION).deb'


##
# Inside-container targets
#
# These targets are used inside containers.  They expect the repo to be mounted
# at /src and the package manager specific build directory to be mounted at
# /output.
##

.PHONY: package-deb package-rpm

# Debian package creation logic
package-deb:
	$(MAKE) install DESTDIR=/output
	cp -r --preserve=mode DEBIAN /output/
	dpkg-deb -Zgzip --build /output /output/$(PACKAGE_NAME)_$(VERSION).deb

# RPM package creation logic
package-rpm:
	mkdir -p /output/{BUILD,RPMS,SOURCES,SPECS,SRPMS}
	cp RPM/$(PACKAGE_NAME).spec /output/SPECS/
	rpmbuild --define '_topdir /output' \
	         --define 'version $(VERSION)' \
	         -bb /output/SPECS/$(PACKAGE_NAME).spec
	cp /output/RPMS/noarch/*.rpm /output/

# RPM package creation logic for old versions of RedHat (ie: 7)
package-rpm-old:
	mkdir -p /output/{BUILD,RPMS,SOURCES,SPECS,SRPMS}
	cp RPM-OLD/$(PACKAGE_NAME).spec /output/SPECS/
	rpmbuild --define '_topdir /output' \
	         --define 'version $(VERSION)' \
	         -bb /output/SPECS/$(PACKAGE_NAME).spec
	cp /output/RPMS/noarch/*.rpm /output/


##
# Container targets
#
# These targets build the docker images used to create packages
##

.PHONY: docker deb-package-image rpm-package-image

docker: deb-package-image rpm-package-image

deb-package-image: docker/Dockerfile-deb
	docker build -t $(DEB_IMAGE) -f docker/Dockerfile-deb .

rpm-package-image: docker/Dockerfile-rpm
	docker build -t $(RPM_IMAGE) -f docker/Dockerfile-rpm .

el7-package-image: docker/Dockerfile-el7
	docker build -t $(EL7_IMAGE) -f docker/Dockerfile-el7 .