Jenkinsfile.build

import groovy.transform.Field

@Field def SERVICE_PARAM_MAP = [
	cart            : 'TAG_CART',
	tax             : 'TAG_TAX',
	order           : 'TAG_ORDER',
	product         : 'TAG_PRODUCT',
	media           : 'TAG_MEDIA',
	rating          : 'TAG_RATING',
	customer        : 'TAG_CUSTOMER',
	location        : 'TAG_LOCATION',
	inventory       : 'TAG_INVENTORY',
	search          : 'TAG_SEARCH',
	payment         : 'TAG_PAYMENT',
	promotion       : 'TAG_PROMOTION',
	recommendation  : 'TAG_RECOMMENDATION',
	sampledata      : 'TAG_SAMPLEDATA',
	webhook         : 'TAG_WEBHOOK',
	'backoffice-bff': 'TAG_BACKOFFICE_BFF',
	'storefront-bff': 'TAG_STOREFRONT_BFF',
	'backoffice-ui' : 'TAG_BACKOFFICE_UI',
	'storefront-ui' : 'TAG_STOREFRONT_UI'
]

@Field def SERVICE_IMAGE_KEY_MAP = [
	'backoffice-ui': 'ui',
	'storefront-ui': 'ui'
]

@Field def RESOLVED_BRANCH_BY_SERVICE = [:]
@Field def RESOLVED_TAG_BY_SERVICE = [:]
@Field def NON_MAIN_SERVICES = []
@Field def FRONTEND_ENTRY_SERVICES = ['storefront-ui', 'backoffice-ui']

def normalizeName(String input) {
	return input.toLowerCase().replaceAll('[^a-z0-9-]', '-').replaceAll('-+', '-').replaceAll('^-|-$', '')
}

def normalizeBranchInput(String rawValue) {
	def value = (rawValue ?: 'main').trim()
	if (!value) {
		return 'main'
	}

	value = value.replaceFirst('^refs/heads/', '')
	value = value.replaceFirst('^origin/', '')
	return value
}

def validateBranchName(String branchName) {
	if (branchName == 'main') {
		return
	}

	if (!(branchName ==~ /^[A-Za-z0-9._\\/-]+$/)) {
		error("Invalid branch name '${branchName}'. Allowed characters: letters, numbers, '.', '_', '-', '/'.")
	}
}

def resolveBranchToShortCommit(String repositoryUrl, String branchName) {
	validateBranchName(branchName)

	if (branchName == 'main') {
		return 'main'
	}

	def output = sh(
		script: "git ls-remote --heads '${repositoryUrl}' 'refs/heads/${branchName}'",
		returnStdout: true
	).trim()

	if (!output) {
		error("Branch '${branchName}' does not exist in source repository: ${repositoryUrl}")
	}

	def commitSha = output.tokenize()[0]
	if (!commitSha || commitSha.length() < 8) {
		error("Could not resolve a valid commit SHA for branch '${branchName}'.")
	}

	return commitSha.take(8)
}

def printDomainInstructions(String deployDomain) {
    def publicIp = sh(
        script: "curl -s ifconfig.me || curl -s icanhazip.com",
        returnStdout: true
    ).trim() ?: '127.0.0.1'

    def minikubeIp = sh(
        script: "kubectl get nodes -o jsonpath='{.items[0].status.addresses[?(@.type==\"InternalIP\")].address}' || true",
        returnStdout: true
    ).trim()

    echo "=========================================================================="
    echo "How to Access the Test Environment"
    echo "=========================================================================="
    echo "Your services are deployed with the domain: ${deployDomain}"
    echo "- Internal IP of Minikube: ${minikubeIp}"
    echo "- Public IP of the VM: ${publicIp}"
    echo ""
    echo "PLEASE CONFIGURE THE HOSTS FILE ON YOUR LOCAL MACHINE:"
    echo "- Windows: C:\\Windows\\System32\\drivers\\etc\\hosts"
    echo "- MacOS/Linux: /etc/hosts"
    echo ""
    echo "Please add the following entries to your hosts file to access the services:"
    echo "------------------------------------------------"
    echo "${publicIp}    api.${deployDomain}"
    echo "${publicIp}    storefront.${deployDomain}"
    echo "${publicIp}    backoffice.${deployDomain}"
    echo "------------------------------------------------"
    echo ""
    echo "After saving the hosts file, access the test environment using the following links:"
    echo "API Gateway:    http://api.${deployDomain}/swagger-ui"
    echo "Storefront UI:  http://storefront.${deployDomain}"
    echo "Backoffice UI:  http://backoffice.${deployDomain}"
    echo "=========================================================================="
}

def deployService(
	def scriptCtx,
	String service,
	String testNamespace,
	String deployDomain,
	String sharedValuesFile,
	Map resolvedTagByService,
	Map resolvedBranchByService,
	Map serviceImageKeyMap,
	List frontendEntryServices
) {
	def resolvedTag = resolvedTagByService[service]
	def branchName = resolvedBranchByService[service]
	def imageKey = serviceImageKeyMap.get(service, 'backend')
	def isUiService = serviceImageKeyMap.containsKey(service)

	def ingressHost = 'api.' + deployDomain
	if (service == 'backoffice-bff') {
		ingressHost = 'backoffice.' + deployDomain
	} else if (service == 'storefront-bff') {
		ingressHost = 'storefront.' + deployDomain
	}

	if (!resolvedTag) {
		scriptCtx.error("Missing resolved tag for service '${service}'.")
	}

	if (isUiService) {
		scriptCtx.sh """
			helm dependency build charts/${service}
			helm upgrade --install ${service} charts/${service} \\
			  -n ${testNamespace} \\
			  -f ${sharedValuesFile} \\
			  --set ${imageKey}.image.tag=${resolvedTag} \\
			  --wait --timeout 10m
		"""
	} else {
		scriptCtx.sh """
			helm dependency build charts/${service}
			helm upgrade --install ${service} charts/${service} \\
			  -n ${testNamespace} \\
			  -f ${sharedValuesFile} \\
			  --set ${imageKey}.image.tag=${resolvedTag} \\
			  --set backend.ingress.host=${ingressHost} \\
			  --wait --timeout 10m	
		"""
	}

	scriptCtx.echo("Deployed ${service} from branch '${branchName}' with image tag '${resolvedTag}'.")
}

def seedMediaAssets(def scriptCtx, String namespace, String workspaceDir) {
	def sampleImagesPath = "${workspaceDir}/sampledata/images/sample"

	scriptCtx.sh """
		set -e
		if [ ! -d '${sampleImagesPath}' ]; then
			echo "Skipping media asset seeding: '${sampleImagesPath}' not found."
			exit 0
		fi

		kubectl rollout status deployment/media -n '${namespace}' --timeout=180s
		MEDIA_POD=\$(kubectl get pod -n '${namespace}' -l app.kubernetes.io/name=media -o jsonpath='{.items[0].metadata.name}')
		if [ -z "\$MEDIA_POD" ]; then
			echo "Skipping media asset seeding: media pod not found in namespace '${namespace}'."
			exit 0
		fi

		kubectl exec -n '${namespace}' "\$MEDIA_POD" -- mkdir -p /images
		kubectl cp '${sampleImagesPath}' '${namespace}/'"\$MEDIA_POD":/images/
		echo "Media assets seeded to pod '\$MEDIA_POD' in namespace '${namespace}'."
	"""
}

def applyNamespaceApiGateway(def scriptCtx, String chartsDir, String namespace, String deployDomain) {
	def gatewayManifest = "${chartsDir}/infrastructure/scripts/nginx-api-gateway.yaml"

	scriptCtx.sh """
		set -e
		if [ ! -f '${gatewayManifest}' ]; then
			echo "Skipping API gateway apply: '${gatewayManifest}' not found."
			exit 0
		fi

		TMP_MANIFEST=\$(mktemp)
		cp '${gatewayManifest}' "\$TMP_MANIFEST"

		# Replace hardcoded namespace and host with the current developer namespace and domain.
		sed -i "s|namespace: test-minhhuy-baseline|namespace: ${namespace}|g" "\$TMP_MANIFEST"
		sed -i "s|\\.test-minhhuy-baseline\\.svc\\.cluster\\.local|.${namespace}.svc.cluster.local|g" "\$TMP_MANIFEST"
		sed -i "s|host: api.yas.test.com|host: api.${deployDomain}|g" "\$TMP_MANIFEST"

		kubectl apply -f "\$TMP_MANIFEST"
		kubectl rollout status deployment/nginx -n '${namespace}' --timeout=180s
		rm -f "\$TMP_MANIFEST"

		echo "Applied namespace-scoped API gateway to namespace '${namespace}' with host 'api.${deployDomain}'."
	"""
}

pipeline {
	agent any
	options {
		timestamps()
		disableConcurrentBuilds()
	}

	parameters {
		string(name: 'TAG_CART', defaultValue: 'main', description: 'Input branch name for cart (e.g., main, dev_cart_service)')
		string(name: 'TAG_TAX', defaultValue: 'main', description: 'Input branch name for tax (e.g., main, dev_tax_service)')
		string(name: 'TAG_ORDER', defaultValue: 'main', description: 'Input branch name for order (e.g., main, dev_order_service)')
		string(name: 'TAG_PRODUCT', defaultValue: 'main', description: 'Input branch name for product (e.g., main, dev_product_service)')
		string(name: 'TAG_MEDIA', defaultValue: 'main', description: 'Input branch name for media (e.g., main, dev_media_service)')
		string(name: 'TAG_RATING', defaultValue: 'main', description: 'Input branch name for rating (e.g., main, dev_rating_service)')
		string(name: 'TAG_CUSTOMER', defaultValue: 'main', description: 'Input branch name for customer (e.g., main, dev_customer_service)')
		string(name: 'TAG_LOCATION', defaultValue: 'main', description: 'Input branch name for location (e.g., main, dev_location_service)')
		string(name: 'TAG_INVENTORY', defaultValue: 'main', description: 'Input branch name for inventory (e.g., main, dev_inventory_service)')
		string(name: 'TAG_SEARCH', defaultValue: 'main', description: 'Input branch name for search (e.g., main, dev_search_service)')
		string(name: 'TAG_PAYMENT', defaultValue: 'main', description: 'Input branch name for payment (e.g., main, dev_payment_service)')
		string(name: 'TAG_PROMOTION', defaultValue: 'main', description: 'Input branch name for promotion (e.g., main, dev_promotion_service)')
		string(name: 'TAG_RECOMMENDATION', defaultValue: 'main', description: 'Input branch name for recommendation (e.g., main, dev_recommendation_service)')
		string(name: 'TAG_SAMPLEDATA', defaultValue: 'main', description: 'Input branch name for sampledata (e.g., main, dev_sampledata_service)')
		string(name: 'TAG_WEBHOOK', defaultValue: 'main', description: 'Input branch name for webhook (e.g., main, dev_webhook_service)')
		string(name: 'TAG_BACKOFFICE_BFF', defaultValue: 'main', description: 'Input branch name for backoffice-bff (e.g., main, dev_backoffice-bff_service)')
		string(name: 'TAG_STOREFRONT_BFF', defaultValue: 'main', description: 'Input branch name for storefront-bff (e.g., main, dev_storefront-bff_service)')
		string(name: 'TAG_BACKOFFICE_UI', defaultValue: 'main', description: 'Input branch name for backoffice-ui (e.g., main, dev_backoffice-ui_service)')
		string(name: 'TAG_STOREFRONT_UI', defaultValue: 'main', description: 'Input branch name for storefront-ui (e.g., main, dev_storefront-ui_service)')
	}

	environment {
		SOURCE_REPO_URL = 'https://github.com/AkiraTomori/DevOps-YAS.git'
		GITOPS_REPO_URL = 'https://github.com/AkiraTomori/ArgoCD-Advanced.git'
		GITOPS_TOKEN_CREDENTIALS_ID = 'gitops-token'
		GITOPS_DIR = 'gitops-yas'
		GITOPS_COMMIT_USER = 'jenkins-bot'
		GITOPS_COMMIT_EMAIL = 'jenkins@local'

		CHARTS_DIR = 'gitops-yas'
		INFRASTRUCTURE_DIR = 'infrastructure'
		HELM_SHARED_VALUES_FILE = 'environments/test/values-shared.yaml'
		LEGACY_CLUSTER_CONFIG_FILE = 'infrastructure/scripts/cluster-config.yaml'

		CLEAN_JOB_NAME = 'developer_clean'
		CLEAN_JOB_TOKEN = 'yas-destroy-token'
	}

	stages {
		stage('Checkout DevOps Repository') {
			steps {
				checkout scm
			}
		}

		stage('Resolve Branch Inputs To Image Tags') {
			steps {
				script {
					def branchToServices = [:]

					SERVICE_PARAM_MAP.each { service, paramName ->
						def normalizedBranch = normalizeBranchInput(params[paramName])
						RESOLVED_BRANCH_BY_SERVICE[service] = normalizedBranch

						if (normalizedBranch != 'main') {
							NON_MAIN_SERVICES << service
						}

						if (!branchToServices.containsKey(normalizedBranch)) {
							branchToServices[normalizedBranch] = []
						}
						branchToServices[normalizedBranch] << service
					}

					def branchToTag = ['main': 'latest']
					branchToServices.each { branchName, services ->
						if (branchName == 'main') {
							return
						}

						try {
							def shortCommit = resolveBranchToShortCommit(env.SOURCE_REPO_URL, branchName)
							branchToTag[branchName] = shortCommit
							echo "Resolved branch '${branchName}' -> image tag '${shortCommit}' for services: ${services.join(', ')}"
						} catch (Exception e) {
							error("Failed to resolve branch '${branchName}' for services [${services.join(', ')}]. ${e.getMessage()}")
						}
					}

					SERVICE_PARAM_MAP.keySet().each { service ->
						def branchName = RESOLVED_BRANCH_BY_SERVICE[service]
						RESOLVED_TAG_BY_SERVICE[service] = branchToTag[branchName]
					}

					echo "Final service -> branch map: ${RESOLVED_BRANCH_BY_SERVICE}"
					echo "Final service -> image tag map: ${RESOLVED_TAG_BY_SERVICE}"
				}
			}
		}

		stage('Resolve Namespace') {
			steps {
				script {
					def causes = currentBuild.getBuildCauses()
					def rawUserId = causes.find { it.userId }?.userId ?: 'anonymous'
					def userId = normalizeName(rawUserId)

					def suffix = NON_MAIN_SERVICES ? NON_MAIN_SERVICES.join('-') : 'baseline'
					suffix = normalizeName(suffix)

					def namespace = normalizeName("test-${userId}-${suffix}")
					if (namespace.length() > 63) {
						namespace = namespace.take(63).replaceAll('-+$', '')
					}

					env.TEST_NAMESPACE = namespace
					env.CLEAN_JOB_URL = "${env.JENKINS_URL}job/${env.CLEAN_JOB_NAME}/buildWithParameters?token=${env.CLEAN_JOB_TOKEN}&TARGET_NAMESPACE=${env.TEST_NAMESPACE}&FORCE_DELETE=true"

					echo "Resolved Jenkins user id: ${userId}"
					echo "Changed services: ${NON_MAIN_SERVICES ? NON_MAIN_SERVICES.join(', ') : 'none'}"
					echo "Generated namespace: ${env.TEST_NAMESPACE}"
				}
			}
		}

		stage('Clone ArgoCD Charts Repository') {
            steps {
                script {
                    def repoNoProtocol = env.GITOPS_REPO_URL.replaceFirst('https://', '')
                    
                    withCredentials([string(credentialsId: env.GITOPS_TOKEN_CREDENTIALS_ID, variable: 'GITOPS_TOKEN')]) {
                        sh """
                            rm -rf ${env.GITOPS_DIR}
                            git clone --depth 1 https://x-access-token:${GITOPS_TOKEN}@${repoNoProtocol} ${env.GITOPS_DIR}
                        """
                    }
                }
            }
        }

		stage('Create Namespace') {
			steps {
				sh """
					kubectl create namespace ${env.TEST_NAMESPACE} --dry-run=client -o yaml | kubectl apply -f -
					kubectl label namespace ${env.TEST_NAMESPACE} managed-by=developer-build --overwrite
					kubectl label namespace ${env.TEST_NAMESPACE} owner=${normalizeName((currentBuild.getBuildCauses().find { it.userId }?.userId ?: 'anonymous'))} --overwrite
				"""
			}
		}

		stage('Deploy Shared Configuration') {
			steps {
				dir("${env.CHARTS_DIR}") {
					sh """
						helm repo add stakater https://stakater.github.io/stakater-charts
						helm repo update
						helm dependency build charts/yas-configuration
						helm upgrade --install yas-configuration charts/yas-configuration \\
						  -n ${env.TEST_NAMESPACE} \\
						  -f ${env.HELM_SHARED_VALUES_FILE} \\
						  --wait --timeout 10m
					"""
				}
			}
		}

		stage('Load Deploy Domain') {
			steps {
				script {
					env.DEPLOY_DOMAIN = sh(
						script: "yq -r '.global.domain' ${env.CHARTS_DIR}/${env.HELM_SHARED_VALUES_FILE}",
						returnStdout: true
					).trim()

					if (!env.DEPLOY_DOMAIN) {
						error("Domain is missing in ${env.CHARTS_DIR}/${env.HELM_SHARED_VALUES_FILE} (.global.domain)")
					}

					echo "Loaded deploy domain from values-shared.yaml: ${env.DEPLOY_DOMAIN}"
				}
			}
		}

		stage('Validate Domain Consistency') {
			steps {
				script {
					def legacyDomain = sh(
						script: "yq -r '.domain // \"\"' ${env.CHARTS_DIR}/${env.LEGACY_CLUSTER_CONFIG_FILE} 2>/dev/null || true",
						returnStdout: true
					).trim()

					if (legacyDomain && legacyDomain != env.DEPLOY_DOMAIN) {
						error("Domain mismatch detected: values-shared(.global.domain)='${env.DEPLOY_DOMAIN}' vs legacy cluster-config(.domain)='${legacyDomain}'.")
					}

					if (legacyDomain) {
						echo "Domain consistency check passed against legacy cluster-config.yaml: ${legacyDomain}"
					} else {
						echo "Legacy cluster-config domain not found. Skipping consistency check."
					}
				}
			}
		}

		stage('Deploy Services') {
			steps {
				script {
					dir("${env.CHARTS_DIR}") {
						def prioritizedServices = ['storefront-ui', 'storefront-bff', 'backoffice-ui', 'backoffice-bff']
						echo "Deploying Prioritized Services & Swagger in PARALLEL..."
						
						def prioritizedTasks = [:]
						
						prioritizedServices.each { service ->
							if (SERVICE_PARAM_MAP.containsKey(service)) {
								def svc = service 
								prioritizedTasks["Deploy ${svc}"] = {
									deployService(
										this,
										svc,
										env.TEST_NAMESPACE,
										env.DEPLOY_DOMAIN,
										env.HELM_SHARED_VALUES_FILE,
										RESOLVED_TAG_BY_SERVICE,
										RESOLVED_BRANCH_BY_SERVICE,
										SERVICE_IMAGE_KEY_MAP,
										FRONTEND_ENTRY_SERVICES
									)
								}
							}
						}

						prioritizedTasks["Deploy swagger-ui"] = {
							sh """
								helm dependency build charts/swagger-ui
								helm upgrade --install swagger-ui charts/swagger-ui \\
								  -n ${env.TEST_NAMESPACE} \\
								  -f ${env.HELM_SHARED_VALUES_FILE} \\
								  --set ingress.host=api.${env.DEPLOY_DOMAIN} \\
								  --wait --timeout 10m
							"""
						}
						
						parallel prioritizedTasks


						def remainingServices = SERVICE_PARAM_MAP.keySet().findAll { !prioritizedServices.contains(it) }
						echo "Deploying remaining Backend services in PARALLEL: ${remainingServices.join(', ')}"
						
						def remainingTasks = [:]
						remainingServices.each { service ->
							def svc = service 
							remainingTasks["Deploy ${svc}"] = {
								deployService(
									this,
									svc,
									env.TEST_NAMESPACE,
									env.DEPLOY_DOMAIN,
									env.HELM_SHARED_VALUES_FILE,
									RESOLVED_TAG_BY_SERVICE,
									RESOLVED_BRANCH_BY_SERVICE,
									SERVICE_IMAGE_KEY_MAP,
									FRONTEND_ENTRY_SERVICES
								)
							}
						}
						
						parallel remainingTasks
					}
				}
			}
		}

		stage('Apply Namespace API Gateway (Swagger)') {
			steps {
				script {
					applyNamespaceApiGateway(this, env.CHARTS_DIR, env.TEST_NAMESPACE, env.DEPLOY_DOMAIN)
				}
			}
		}

		stage('Seed Media Assets') {
			steps {
				script {
					seedMediaAssets(this, env.TEST_NAMESPACE, env.WORKSPACE)
				}
			}
		}
	}

	post {
		always {
			cleanWs()
		}
		success {
			script {
				echo "=========================================================================="
				echo "DEPLOYMENT SUCCESSFUL!"
				echo "Your test environment '${env.TEST_NAMESPACE}' is ready."
                
				printDomainInstructions(env.DEPLOY_DOMAIN)
                
				echo "To clean up this environment, click: ${env.CLEAN_JOB_URL}"
				echo "=========================================================================="

				currentBuild.displayName = "#${currentBuild.number} - ${env.TEST_NAMESPACE}"
				currentBuild.description = "Deployment successful. Cleanup URL: ${env.CLEAN_JOB_URL}"
			}
		}
		failure {
			script {
				echo "=========================================================================="
				echo "DEPLOYMENT FAILED!"
				echo "Please check the logs above for details."
				echo "Cleanup URL: ${env.CLEAN_JOB_URL}"
				echo "=========================================================================="

				currentBuild.displayName = "#${currentBuild.number} - ${env.TEST_NAMESPACE}"
				currentBuild.description = "Deployment failed. Cleanup URL: ${env.CLEAN_JOB_URL}"
			}
		}
	}
}