# generic utility modules
# (c) 2004 jannet it services
# contact@jannet.de
# $Id$

# config
#KERNEL_VERSION       = 2.4.24
#HOST                 = zwischenhuber
#CUSTOMER             = jannet
#KERNEL_PKG           = /home/samba/dat/share/exe/linux/os/$(basename $(KERNEL_VERSION))/linux-$(KERNEL_VERSION).tar.gz
#KERNEL_BASE          = linux-$(CUSTOMER)-$(HOST)
#UPLOAD_HOST          = ftp.jannet.de
#UPLOAD_PATH          = /home/ftp/dat/pub/packages/$(CUSTOMER)/linux/$(HOST)
#UPLOAD_OWNER         = $(shell whoami)

# abbreviations
define EXTRAVERSION
$(shell sed '/^ *EXTRAVERSION *=/ !d; s/^ *EXTRAVERSION *= *-*//; s/ *$$//' linux-$(KERNEL_VERSION)/Makefile 2>/dev/null)
endef

KERNEL_MINOR        := $(shell echo $(KERNEL_VERSION) | cut -d\. -f2)
#HOST                = $(shell cd ../..; pwd | xargs basename)
WD                  := $(shell pwd)
KERNEL_SRC_DIR       = $(shell tar -tzf $(KERNEL_DIR)/$(KERNEL_PKG) | head -1)
TMP_INSTALL          = $(KERNEL_BASE)-$(KERNEL_VERSION)-$(EXTRAVERSION)
TAG                  = $(shell echo V_$(KERNEL_VERSION)_$(KERNEL_RELEASE) | sed 's/\./_/g')
ARCH                 = $(shell $(RPMBUILD) --showrc | sed '/build arch / !d; s/.*build arch *://; s/ //g')

RPMBUILD             = $(shell which rpmbuild 2>/dev/null)
ifeq ($(RPMBUILD),)
RPMBUILD             = $(shell which rpm 2>/dev/null)
endif

ifeq ($(wildcard RELEASE-$(KERNEL_VERSION)),)
KERNEL_RELEASE      := $(shell make newrelease; exit 1)
else
KERNEL_RELEASE_NUM  := $(strip $(shell grep Id: RELEASE-$(KERNEL_VERSION) | sed "s/.*RELEASE-$(KERNEL_VERSION),v[ 	]*[0-9]*\.\([0-9]*\)[^0-9]*.*/\1/"))
ifeq ($(UNAME_SUFFIX),)
KERNEL_RELEASE       = $(KERNEL_RELEASE_NUM)
else
KERNEL_RELEASE       = $(UNAME_SUFFIX)$(KERNEL_RELEASE_NUM)
endif
endif


ifeq ($(BOOT_LABEL),)
BOOT_LABEL = lx-$(KERNEL_VERSION)-$(EXTRAVERSION)
endif

BASE                 = $(KERNEL_BASE)-$(KERNEL_VERSION)-$(EXTRAVERSION)
BASE_RUN             = $(KERNEL_BASE)-run-$(KERNEL_VERSION)-$(EXTRAVERSION)
BASE_DEVEL           = $(KERNEL_BASE)-devel-$(KERNEL_VERSION)-$(EXTRAVERSION)

KERNEL_TGZ           = $(notdir $(KERNEL_PKG))
F_SPEC               = $(BASE).spec
F_TGZ                = $(BASE).tar.gz
F_SPM                = $(BASE).src.rpm
F_RPM_RUN            = $(BASE_RUN).$(ARCH).rpm
F_RPM_DEVEL          = $(BASE_DEVEL).$(ARCH).rpm
F_RPMS               = $(F_RPM_RUN) $(F_RPM_DEVEL)
blah:
	echo $(EXTRAVERSION)

F_BOOTFILES          = $(addsuffix -$(KERNEL_VERSION)-$(EXTRAVERSION),$(addprefix $(TMP_INSTALL)/boot/,vmlinuz config System.map))
blub:
	echo $(F_BOOTFILES)
F_CURRENT            = $(addprefix CURRENT_, SRC RPM_SRC RPM_RUN_I386 RPM_DEVEL_I386)
F_ULDONE             = $(addsuffix .uldone,$(F_RPMS) $(F_TGZ) $(F_SPM) current)
# note that order matters for F_ULDONE and F_RPMS (remote directory attributes)
KERNEL_INSTALL_PREFIX= $(shell pwd)/$(TMP_INSTALL)

BUILD = build_linux.sh \
		-c config-$(KERNEL_VERSION) \
		-t $(HOST) \
		-b $(WD) \
		-a i386 \
		-s $(KERNEL_SRC_DIR) \
		-i $(TMP_INSTALL)
MKSPEC := $(shell which mkspec-linux.sh)

PATCHES                 += $(wildcard $(LINUX_KERNEL_PATCH_DIR)/*-$(KERNEL_VERSION).patch) \
                           $(wildcard $(LINUX_KERNEL_PATCH_DIR)/*-$(KERNEL_VERSION).diff)
LOCAL_PATCHES            = $(notdir $(PATCHES))

LOCAL_PRE_BUILD += patches.done

# exports
export KERNEL_VERSION
export KERNEL_INSTALL_PREFIX

# first target
all: rpm

# file rules
$(KERNEL_PKG):
	mkdir -p $(dir $(KERNEL_PKG))
	ftp -a ftp.kernel.org:/pub/linux/kernel/v$(basename $(KERNEL_VERSION))/$(KERNEL_TGZ)
	install -m 664 $(KERNEL_TGZ) $@

config-$(KERNEL_VERSION):
	cp $(shell ls config-$(basename $(KERNEL_VERSION)).* | sed 's/\([0-9]*\)\.\([0-9]*\)\.\([0-9]\)$$/\1.\2.0\3/' | sort -g | sed 's/\.0/./; $$ !d') $@
	cvs add $@
	cvs commit

#		if ($$0 ~ "^ *EXTRAVERSION *= [0-9]*.[0-9]*.[0-9]") {                \

toplevel-makefile: patches.done
	awk -v release=$(KERNEL_RELEASE) '{   \
		if ($$0 ~ /EXTRAVERSION *= *-/) {                             \
			oldextra=$$3;                                         \
			gsub(/-/,_,oldextra);                                 \
			printf "EXTRAVERSION = -%s_%s\n", release, oldextra  \
		} else if ($$0 ~ /EXTRAVERSION *= *$$/) {                     \
			printf "EXTRAVERSION = -%s\n",release                 \
		} else {                                                      \
			print $$0                                             \
		}                                                             \
	}' linux-$(KERNEL_VERSION)/Makefile >$@

#	sed "s/\(^ *EXTRAVERSION *= *[^ 	]*\) *$$/\\1$(shell echo _$(KERNEL_RELEASE) | sed 's/^_/-/')/" \

linux-$(KERNEL_VERSION)/Makefile: toplevel-makefile
	cp $< $@

unpack.done: $(KERNEL_PKG)
	rm -rf linux-$(KERNEL_VERSION)
ifeq ($(suffix $(KERNEL_PKG)),.gz)
	tar -xzf $(KERNEL_PKG)
endif
ifeq ($(suffix $(KERNEL_PKG)),.bz2)
	tar -xjf $(KERNEL_PKG)
endif
	touch $@

%.lxdone: unpack.done config-$(KERNEL_VERSION) $(LOCAL_PRE_BUILD) linux-$(KERNEL_VERSION)/Makefile
	$(BUILD) $(basename $@)
	touch $@

$(TMP_INSTALL)/$(F_SPEC): linux-$(KERNEL_VERSION)/Makefile $(MKSPEC) Makefile
	$(MKSPEC) -d $(TMP_INSTALL) -b $(KERNEL_BASE) -v $(KERNEL_VERSION) -r $(EXTRAVERSION) \
		-a $(ARCH) -l $(BOOT_LABEL) > $@

#		-r $(shell sed '/^ *EXTRAVERSION *=/ !d; s/^ *EXTRAVERSION *= *-*//; s/ *$$//' $<) \

$(TMP_INSTALL)/boot/%-$(KERNEL_VERSION)-$(KERNEL_RELEASE): build.lxdone $(LOCAL_AFTER_KERNEL_BUILD)
	@echo -n

.PRECIOUS: $(TMP_INSTALL)/boot/%-$(KERNEL_VERSION)

#$(TMP_INSTALL)/boot/%-$(KERNEL_VERSION)-$(KERNEL_RELEASE): $(TMP_INSTALL)/boot/%-$(KERNEL_VERSION)
#	cp $< $@

$(F_TGZ): Makefile build.lxdone $(F_BOOTFILES) $(TMP_INSTALL)/$(F_SPEC) 
	tar -czf $@ \
		$(F_BOOTFILES)  \
		$(addprefix $(TMP_INSTALL)/, \
			lib		\
			$(F_SPEC)	\
	)

%.src.rpm: %.tar.gz
	$(RPMBUILD) -ts $<
	cp /usr/src/packages/SRPMS/$@ .

rpm.done: $(F_SPM)
	$(RPMBUILD) --rebuild $(F_SPM)
	touch $@

%.$(ARCH).rpm: rpm.done
	cp /usr/src/packages/RPMS/$(ARCH)/$@ .

CURRENT_RPM_RUN_I386: $(F_RPM_RUN)
	echo $(UPLOAD_PATH)/rpm/run/$(F_RPM_RUN) > $@

CURRENT_RPM_DEVEL_I386: $(F_RPM_RUN)
	echo $(UPLOAD_PATH)/rpm/devel/$(F_RPM_DEVEL) > $@

CURRENT_RPM_SRC: $(F_RPM_RUN)
	echo $(UPLOAD_PATH)/rpm/src/$(F_RPM_SRC) > $@

CURRENT_SRC: $(F_RPM_RUN)
	echo $(UPLOAD_PATH)/src/$(F_TGZ) > $@

update.done:
	cvs update -dP
	make rpm
	touch $@

upload.done: $(F_RPMS)
	touch $@

%.tar.gz.uldone: %.tar.gz
	upload.sh $< rsync_ssh://$(UPLOAD_HOST):$(UPLOAD_PATH)/src/$<:640:750:$(UPLOAD_OWNER).$(CUSTOMER)
	touch $@

%.src.rpm.uldone: %.src.rpm
	upload.sh $< rsync_ssh://$(UPLOAD_HOST):$(UPLOAD_PATH)/rpm/src/$<:640:750:$(UPLOAD_OWNER).$(CUSTOMER)
	touch $@

%.rpm.uldone: %.rpm
	upload.sh $< rsync_ssh://$(UPLOAD_HOST):$(UPLOAD_PATH)/rpm/$(shell echo $@ | sed 's/.*\(run\|devel\).*/\1/')/$<:640:750:$(UPLOAD_OWNER).$(CUSTOMER)
	touch $@

current.uldone: $(F_CURRENT)
	upload.sh $^ rsync_ssh://$(UPLOAD_HOST):$(UPLOAD_PATH)/:640:750:$(UPLOAD_OWNER).$(CUSTOMER)
	touch $@

tag.done:
	cvs tag $(TAG)
	touch $@

version:
	date >> RELEASE-$(KERNEL_VERSION)
	cvs commit -m "$(KERNEL_VERSION)" RELEASE-$(KERNEL_VERSION)
	exit 1

copy-run.done: $(F_RPM_RUN)
	scp $< root@$(HOST):/root/rpm/
	touch $@
copy-devel.done: $(F_RPM_DEVEL)
	scp $< root@$(HOST):/root/rpm/
	touch $@

ping:
	ping $(HOST)
ssh:
	ssh -l root $(HOST)
	
patches.done: unpack.done $(addsuffix .done,$(notdir $(PATCHES)))
	touch $@

%.patch.done: %.patch
	patch -d linux-$(KERNEL_VERSION) -p1 < $<
	touch $@

%.patch:
	cp $(filter %/$@,$(PATCHES)) $@

# user targets
unpack: unpack.done
build: build.lxdone 
driver: driver.done
tgz: $(F_TGZ)
spm: $(F_SPM)
rpm: $(F_RPMS)
upload: update.done rpm $(F_ULDONE)
tag: tag.done
install: build.lxdone driver.done install.lxdone
copy-run: copy-run.done
copy-devel: copy-devel.done
copy: copy-run copy-devel
patch: patches.done
shutdown:
	ssh -l root $(HOST) "shutdown -h now"
reboot:
	ssh -l root $(HOST) "reboot"
update-rpm: copy
	ssh -l root $(HOST) rpm -U $(addprefix rpm/,$(F_RPMS))
erase-rpm:
	ssh -l root $(HOST) rpm -e $(KERNEL_BASE)-run $(KERNEL_BASE)-devel
dist: clean
	cd ..;\
	tar -czf kernel.tar.gz `find kernel -type f -maxdepth 1 | grep -ve "setup\|trash\|CVS"`
	mv ../kernel.tar.gz .
clean:
	rm -rf $(TMP_INSTALL)
	rm -rf install/* reiser.patch *~ *.done *.lxdone *.uldone *.patch *.rpm *.tar.gz *.tar $(SCOPE_DRIVER_BASE)
	rm -rf linux linux-$(KERNEL_VERSION) CURRENT_*
	rm -f toplevel-makefile

newrelease:
	echo '# $$Id$$' > RELEASE-$(KERNEL_VERSION); \
	cvs add RELEASE-$(KERNEL_VERSION); \
	cvs commit -m "initial checkin" RELEASE-$(KERNEL_VERSION)