33 Continuous Delivery mit Gradle

// Continuous Delivery Pipeline Configuration
plugins {
    id("com.bmuschko.docker-remote-api") version "9.3.2"
    id("com.google.cloud.tools.jib") version "3.4.0"
    id("org.springframework.boot") version "3.1.0"
}

// Pipeline Stages Definition
val pipelineStages = listOf(
    "compile",
    "unit-test",
    "integration-test",
    "security-scan",
    "quality-gate",
    "build-image",
    "deploy-staging",
    "smoke-test",
    "performance-test",
    "deploy-production"
)

// Version Management for CD
version = "${project.property("version.major")}.${project.property("version.minor")}.${project.property("version.patch")}-${getBuildNumber()}"

fun getBuildNumber(): String {
    return System.getenv("BUILD_NUMBER") ?: "LOCAL"
}

// Artifact Repository Configuration
publishing {
    publications {
        create<MavenPublication>("release") {
            from(components["java"])
            
            artifact(tasks.register<Jar>("sourcesJar") {
                from(sourceSets.main.get().allJava)
                archiveClassifier.set("sources")
            })
            
            artifact(tasks.register<Jar>("configJar") {
                from("src/main/resources/config") {
                    include("*.yml", "*.properties")
                    exclude("**/local.*")
                }
                archiveClassifier.set("config")
            })
            
            // Version metadata for traceability
            pom.properties.put("buildNumber", getBuildNumber())
            pom.properties.put("gitCommit", getGitCommit())
            pom.properties.put("buildTimestamp", Instant.now().toString())
        }
    }
    
    repositories {
        maven {
            name = "releases"
            url = uri("https://nexus.company.com/repository/releases")
            credentials(PasswordCredentials::class)
        }
    }
}

// Continuous Delivery Master Task
tasks.register("continuousDelivery") {
    description = "Execute complete CD pipeline"
    group = "delivery"
    
    val stages = pipelineStages.map { stage ->
        tasks.findByName(stage) ?: tasks.register(stage) {
            doLast {
                logger.lifecycle("Executing pipeline stage: $stage")
            }
        }
    }
    
    dependsOn(stages)
    
    doFirst {
        logger.lifecycle("Starting Continuous Delivery Pipeline")
        logger.lifecycle("Version: ${project.version}")
        logger.lifecycle("Build: ${getBuildNumber()}")
    }
    
    doLast {
        val pipelineReport = file("${buildDir}/reports/cd-pipeline.json")
        pipelineReport.parentFile.mkdirs()
        pipelineReport.writeText(generatePipelineReport())
        
        logger.lifecycle("Continuous Delivery Pipeline completed successfully")
    }
}

// Deployment Pipeline Implementation
abstract class DeploymentStage : DefaultTask() {
    @Input
    abstract val environment: Property<String>
    
    @Input
    abstract val artifact: RegularFileProperty
    
    @Input
    abstract val version: Property<String>
    
    @Internal
    abstract val deploymentConfig: Property<DeploymentConfiguration>
    
    init {
        group = "deployment"
    }
    
    @TaskAction
    fun deploy() {
        val env = environment.get()
        val config = deploymentConfig.get()
        
        logger.lifecycle("Deploying to $env environment")
        
        // Pre-deployment checks
        performHealthCheck(config.healthEndpoint)
        backupCurrentVersion(config)
        
        // Deployment execution
        val deploymentId = initiateDeployment(config)
        
        try {
            // Deploy artifact
            deployArtifact(artifact.get().asFile, config)
            
            // Wait for deployment to complete
            waitForDeployment(deploymentId, config.timeout)
            
            // Post-deployment validation
            validateDeployment(config)
            runSmokeTests(config.smokeTestEndpoint)
            
            logger.lifecycle("Deployment to $env completed successfully")
            
        } catch (e: Exception) {
            logger.error("Deployment to $env failed: ${e.message}")
            
            // Automatic rollback
            if (config.autoRollback) {
                logger.lifecycle("Initiating automatic rollback")
                rollbackDeployment(deploymentId, config)
            }
            
            throw e
        }
    }
    
    private fun performHealthCheck(endpoint: String) {
        val healthy = retry(3) {
            val response = URL(endpoint).readText()
            response.contains("\"status\":\"UP\"")
        }
        
        if (!healthy) {
            throw GradleException("Environment health check failed")
        }
    }
    
    private fun validateDeployment(config: DeploymentConfiguration) {
        // Version verification
        val deployedVersion = getDeployedVersion(config.versionEndpoint)
        if (deployedVersion != version.get()) {
            throw GradleException("Version mismatch: expected ${version.get()}, got $deployedVersion")
        }
        
        // Component health checks
        config.componentEndpoints.forEach { (component, endpoint) ->
            val componentHealthy = checkComponentHealth(endpoint)
            if (!componentHealthy) {
                throw GradleException("Component $component is not healthy")
            }
        }
    }
}

// Environment-specific deployment tasks
val environments = mapOf(
    "development" to DeploymentConfiguration(
        url = "https://dev.deploy.company.com",
        healthEndpoint = "https://dev.api.company.com/health",
        smokeTestEndpoint = "https://dev.api.company.com/smoke",
        timeout = Duration.ofMinutes(5),
        autoRollback = false,
        approvalRequired = false
    ),
    "staging" to DeploymentConfiguration(
        url = "https://staging.deploy.company.com",
        healthEndpoint = "https://staging.api.company.com/health",
        smokeTestEndpoint = "https://staging.api.company.com/smoke",
        timeout = Duration.ofMinutes(10),
        autoRollback = true,
        approvalRequired = false
    ),
    "production" to DeploymentConfiguration(
        url = "https://prod.deploy.company.com",
        healthEndpoint = "https://api.company.com/health",
        smokeTestEndpoint = "https://api.company.com/smoke",
        timeout = Duration.ofMinutes(15),
        autoRollback = true,
        approvalRequired = true
    )
)

environments.forEach { (env, config) ->
    tasks.register<DeploymentStage>("deployTo${env.capitalize()}") {
        description = "Deploy to $env environment"
        
        environment.set(env)
        artifact.set(tasks.named<Jar>("bootJar").flatMap { it.archiveFile })
        version.set(project.version.toString())
        deploymentConfig.set(config)
        
        // Environment-specific dependencies
        when (env) {
            "development" -> dependsOn("test")
            "staging" -> dependsOn("integrationTest", "securityScan")
            "production" -> dependsOn("qualityGate", "approvalGate")
        }
        
        // Conditional execution
        onlyIf {
            when (env) {
                "production" -> {
                    val branch = getCurrentBranch()
                    branch == "main" || branch.startsWith("release/")
                }
                else -> true
            }
        }
    }
}

// Automated promotion between environments
tasks.register("promoteToProduction") {
    description = "Promote staging deployment to production"
    group = "delivery"
    
    dependsOn("verifyStagingDeployment")
    
    doLast {
        val stagingVersion = getStagingVersion()
        val artifact = downloadArtifact(stagingVersion)
        
        // Create promotion record
        val promotion = PromotionRecord(
            sourceEnvironment = "staging",
            targetEnvironment = "production",
            version = stagingVersion,
            promotedBy = System.getProperty("user.name"),
            timestamp = Instant.now(),
            testResults = collectTestResults(),
            approvals = collectApprovals()
        )
        
        recordPromotion(promotion)
        
        // Execute production deployment
        project.tasks.named("deployToProduction").get().apply {
            (this as DeploymentStage).artifact.set(artifact)
            (this as DeploymentStage).version.set(stagingVersion)
        }.execute()
    }
}

// Blue-Green Deployment Implementation
tasks.register("blueGreenDeployment") {
    description = "Execute blue-green deployment"
    group = "deployment"
    
    doLast {
        val currentEnvironment = determineActiveEnvironment() // "blue" or "green"
        val targetEnvironment = if (currentEnvironment == "blue") "green" else "blue"
        
        logger.lifecycle("Current active: $currentEnvironment, deploying to: $targetEnvironment")
        
        // Deploy to inactive environment
        deployToEnvironment(targetEnvironment)
        
        // Warm up new environment
        warmUpEnvironment(targetEnvironment)
        
        // Run health checks
        val healthy = performHealthChecks(targetEnvironment)
        if (!healthy) {
            throw GradleException("Health checks failed for $targetEnvironment")
        }
        
        // Run smoke tests
        runSmokeTests(targetEnvironment)
        
        // Switch traffic
        logger.lifecycle("Switching traffic from $currentEnvironment to $targetEnvironment")
        updateLoadBalancer(targetEnvironment)
        
        // Monitor new environment
        monitorDeployment(targetEnvironment, Duration.ofMinutes(5))
        
        // Cleanup old environment (after delay)
        scheduleCleanup(currentEnvironment, Duration.ofMinutes(30))
    }
}

// Rolling Deployment Implementation
tasks.register("rollingDeployment") {
    description = "Execute rolling deployment"
    group = "deployment"
    
    doLast {
        val instances = getInstanceList()
        val batchSize = maxOf(1, instances.size / 3) // Deploy in thirds
        val batchDelay = Duration.ofSeconds(30)
        
        instances.chunked(batchSize).forEachIndexed { index, batch ->
            logger.lifecycle("Deploying batch ${index + 1}/${(instances.size + batchSize - 1) / batchSize}")
            
            batch.parallelStream().forEach { instance ->
                // Remove from load balancer
                removeFromLoadBalancer(instance)
                
                // Deploy new version
                deployToInstance(instance)
                
                // Health check
                waitForHealthy(instance)
                
                // Add back to load balancer
                addToLoadBalancer(instance)
                
                logger.lifecycle("Instance ${instance.id} updated successfully")
            }
            
            // Monitor batch before proceeding
            monitorBatch(batch, Duration.ofMinutes(2))
            
            // Delay between batches
            if (index < instances.chunked(batchSize).size - 1) {
                Thread.sleep(batchDelay.toMillis())
            }
        }
    }
}

// Canary Deployment Implementation
tasks.register("canaryDeployment") {
    description = "Execute canary deployment with gradual rollout"
    group = "deployment"
    
    val canaryStages = listOf(
        CanaryStage(1, Duration.ofMinutes(5)),    // 1% for 5 minutes
        CanaryStage(5, Duration.ofMinutes(10)),   // 5% for 10 minutes
        CanaryStage(10, Duration.ofMinutes(15)),  // 10% for 15 minutes
        CanaryStage(25, Duration.ofMinutes(20)),  // 25% for 20 minutes
        CanaryStage(50, Duration.ofMinutes(30)),  // 50% for 30 minutes
        CanaryStage(100, null)                    // 100% - complete
    )
    
    doLast {
        val baselineMetrics = collectBaselineMetrics()
        var canaryInstance: Instance? = null
        
        try {
            canaryStages.forEach { stage ->
                logger.lifecycle("Canary stage: ${stage.percentage}% of traffic")
                
                // Deploy or scale canary
                if (canaryInstance == null) {
                    canaryInstance = deployCanaryInstance()
                } else {
                    scaleCanary(canaryInstance, stage.percentage)
                }
                
                // Update traffic routing
                updateTrafficSplit(
                    canary = stage.percentage,
                    stable = 100 - stage.percentage
                )
                
                // Monitor and validate
                if (stage.duration != null) {
                    val endTime = Instant.now().plus(stage.duration)
                    
                    while (Instant.now().isBefore(endTime)) {
                        val currentMetrics = collectMetrics()
                        
                        // Compare with baseline
                        val degradation = compareMetrics(baselineMetrics, currentMetrics)
                        
                        if (degradation.errorRate > 0.01 || degradation.latency > 1.2) {
                            logger.error("Canary metrics degradation detected")
                            throw CanaryFailureException("Metrics degradation: $degradation")
                        }
                        
                        Thread.sleep(30000) // Check every 30 seconds
                    }
                    
                    logger.lifecycle("Canary stage ${stage.percentage}% completed successfully")
                }
            }
            
            logger.lifecycle("Canary deployment completed successfully")
            
        } catch (e: Exception) {
            logger.error("Canary deployment failed: ${e.message}")
            
            // Rollback
            logger.lifecycle("Rolling back canary deployment")
            updateTrafficSplit(canary = 0, stable = 100)
            
            canaryInstance?.let { terminateInstance(it) }
            
            throw e
        }
    }
}

// Feature Flag Deployment
tasks.register("featureFlagDeployment") {
    description = "Deploy with feature flags for gradual rollout"
    group = "deployment"
    
    doLast {
        val featureFlags = mapOf(
            "newPaymentFlow" to FeatureFlag(
                enabled = false,
                rolloutPercentage = 0,
                enabledForUsers = emptyList()
            ),
            "improvedSearch" to FeatureFlag(
                enabled = true,
                rolloutPercentage = 10,
                enabledForUsers = listOf("beta-testers")
            )
        )
        
        // Deploy application with flags
        deployWithFeatureFlags(featureFlags)
        
        // Gradual feature enablement
        val rolloutPlan = listOf(
            RolloutStep("newPaymentFlow", 5, Duration.ofHours(1)),
            RolloutStep("newPaymentFlow", 25, Duration.ofHours(4)),
            RolloutStep("newPaymentFlow", 50, Duration.ofDays(1)),
            RolloutStep("newPaymentFlow", 100, null)
        )
        
        rolloutPlan.forEach { step ->
            updateFeatureFlag(step.feature, step.percentage)
            
            if (step.duration != null) {
                monitorFeatureMetrics(step.feature, step.duration)
            }
        }
    }
}

// Release Orchestration
tasks.register("orchestratedRelease") {
    description = "Orchestrate multi-component release"
    group = "release"
    
    doLast {
        val releaseVersion = project.version.toString()
        val components = listOf(
            "database",
            "backend-api",
            "frontend-app",
            "mobile-api",
            "notification-service"
        )
        
        val releaseOrchestrator = ReleaseOrchestrator(releaseVersion)
        
        try {
            // Pre-release validation
            releaseOrchestrator.validateDependencies(components)
            releaseOrchestrator.checkVersionCompatibility()
            
            // Create release checkpoint
            val checkpoint = releaseOrchestrator.createCheckpoint()
            
            // Database migrations first
            logger.lifecycle("Executing database migrations")
            executeDatabaseMigrations(releaseVersion)
            
            // Deploy services in dependency order
            val deploymentOrder = releaseOrchestrator.calculateDeploymentOrder(components)
            
            deploymentOrder.forEach { component ->
                logger.lifecycle("Deploying $component")
                
                val deployTask = tasks.findByName("deploy${component.capitalize()}")
                    ?: throw GradleException("No deploy task for $component")
                
                deployTask.execute()
                
                // Wait for component to be ready
                waitForComponentReady(component)
                
                // Run integration tests
                runComponentIntegrationTests(component)
            }
            
            // Post-release validation
            releaseOrchestrator.validateRelease()
            
            // Update release manifest
            updateReleaseManifest(releaseVersion, components)
            
            logger.lifecycle("Release $releaseVersion completed successfully")
            
        } catch (e: Exception) {
            logger.error("Release failed: ${e.message}")
            
            // Orchestrated rollback
            performOrchestrated rollback(checkpoint, components)
            
            throw e
        }
    }
}

// Rollback Task
tasks.register("rollback") {
    description = "Rollback to previous release"
    group = "release"
    
    val targetVersion = project.findProperty("rollbackVersion") as String?
        ?: getPreviousReleaseVersion()
    
    doLast {
        logger.lifecycle("Rolling back to version: $targetVersion")
        
        val rollbackPlan = RollbackPlan(
            targetVersion = targetVersion,
            currentVersion = getCurrentDeployedVersion(),
            strategy = determineRollbackStrategy(),
            components = identifyAffectedComponents()
        )
        
        // Validate rollback feasibility
        validateRollbackPlan(rollbackPlan)
        
        // Execute rollback
        when (rollbackPlan.strategy) {
            RollbackStrategy.BLUE_GREEN -> {
                // Simple traffic switch
                switchToInactiveEnvironment()
            }
            
            RollbackStrategy.REDEPLOY -> {
                // Redeploy previous version
                rollbackPlan.components.reversed().forEach { component ->
                    redeployComponent(component, targetVersion)
                }
            }
            
            RollbackStrategy.DATABASE_RESTORE -> {
                // Complex rollback with data restore
                createDatabaseBackup("pre-rollback")
                restoreDatabaseToVersion(targetVersion)
                redeployAllComponents(targetVersion)
            }
        }
        
        // Verify rollback
        verifyRollback(targetVersion)
        
        // Send notifications
        notifyRollback(rollbackPlan)
        
        logger.lifecycle("Rollback to $targetVersion completed")
    }
}

// Database Migration Management
tasks.register("databaseMigration") {
    description = "Execute database migrations for CD"
    group = "database"
    
    doLast {
        val migrationConfig = DatabaseMigrationConfig(
            url = System.getenv("DB_URL"),
            username = System.getenv("DB_USERNAME"),
            password = System.getenv("DB_PASSWORD"),
            schemas = listOf("public", "audit")
        )
        
        // Backup before migration
        createDatabaseBackup("pre-migration-${project.version}")
        
        try {
            // Execute forward migrations
            flyway {
                url = migrationConfig.url
                user = migrationConfig.username
                password = migrationConfig.password
                schemas = migrationConfig.schemas
                
                // CD-specific configuration
                baselineOnMigrate = true
                validateOnMigrate = true
                placeholders = mapOf(
                    "version" to project.version.toString(),
                    "environment" to System.getenv("ENVIRONMENT")
                )
            }
            
            tasks.named("flywayMigrate").get().execute()
            
            // Validate migration
            tasks.named("flywayValidate").get().execute()
            
            // Record migration metadata
            recordMigrationMetadata(project.version.toString())
            
        } catch (e: Exception) {
            logger.error("Migration failed: ${e.message}")
            
            // Attempt rollback
            if (project.hasProperty("autoRollbackDb")) {
                tasks.named("flywayUndo").get().execute()
            }
            
            throw e
        }
    }
}

// CD Monitoring Integration
tasks.register("configureCDMonitoring") {
    description = "Configure monitoring for CD pipeline"
    group = "monitoring"
    
    doLast {
        // Deployment Events
        val deploymentEvent = DeploymentEvent(
            version = project.version.toString(),
            environment = System.getenv("TARGET_ENV"),
            timestamp = Instant.now(),
            deployer = System.getProperty("user.name"),
            source = "gradle-cd"
        )
        
        // Send to monitoring systems
        sendToDatadog(deploymentEvent)
        sendToNewRelic(deploymentEvent)
        sendToPrometheus(deploymentEvent)
        
        // Configure alerts
        val alertRules = listOf(
            AlertRule(
                name = "Deployment Failure",
                condition = "deployment.status == 'failed'",
                severity = "critical",
                action = "page"
            ),
            AlertRule(
                name = "Slow Deployment",
                condition = "deployment.duration > 1800",
                severity = "warning",
                action = "notify"
            ),
            AlertRule(
                name = "High Error Rate Post-Deploy",
                condition = "error_rate > baseline * 1.5 AND time_since_deploy < 300",
                severity = "critical",
                action = "rollback"
            )
        )
        
        deployAlertRules(alertRules)
    }
}

// Deployment Feedback Collection
tasks.register("collectDeploymentFeedback") {
    description = "Collect and analyze deployment feedback"
    group = "feedback"
    
    doLast {
        val feedback = DeploymentFeedback(
            // Automated test results
            testResults = collectTestResults(),
            
            // Performance metrics
            performanceMetrics = PerformanceMetrics(
                responseTime = measureResponseTime(),
                throughput = measureThroughput(),
                errorRate = measureErrorRate(),
                resourceUsage = measureResourceUsage()
            ),
            
            // User metrics
            userMetrics = UserMetrics(
                activeUsers = countActiveUsers(),
                featureAdoption = measureFeatureAdoption(),
                userSatisfaction = getUserSatisfactionScore()
            ),
            
            // Business metrics
            businessMetrics = BusinessMetrics(
                conversionRate = calculateConversionRate(),
                revenue = calculateRevenue(),
                customerRetention = measureRetention()
            )
        )
        
        // Generate feedback report
        val report = generateFeedbackReport(feedback)
        
        // Store for analysis
        storeFeedbackData(feedback)
        
        // Trigger actions based on feedback
        if (feedback.performanceMetrics.errorRate > 0.05) {
            triggerIncident("High error rate detected post-deployment")
        }
        
        if (feedback.userMetrics.userSatisfaction < 3.5) {
            notifyProductTeam("User satisfaction degraded after release")
        }
        
        logger.lifecycle("Deployment feedback collected and analyzed")
    }
}

// Continuous Improvement Task
tasks.register("analyzeDeliveryMetrics") {
    description = "Analyze CD metrics for improvement opportunities"
    group = "analytics"
    
    doLast {
        val metrics = collectDeliveryMetrics(days = 30)
        
        val analysis = DeliveryAnalysis(
            // DORA metrics
            deploymentFrequency = calculateDeploymentFrequency(metrics),
            leadTime = calculateLeadTime(metrics),
            mttr = calculateMTTR(metrics),
            changeFailureRate = calculateChangeFailureRate(metrics),
            
            // Pipeline efficiency
            pipelineEfficiency = PipelineEfficiency(
                buildTime = metrics.averageBuildTime,
                testTime = metrics.averageTestTime,
                deploymentTime = metrics.averageDeploymentTime,
                endToEndTime = metrics.averageEndToEndTime
            ),
            
            // Quality metrics
            qualityMetrics = QualityMetrics(
                defectEscapeRate = calculateDefectEscapeRate(metrics),
                testCoverage = metrics.averageTestCoverage,
                codeQuality = metrics.averageCodeQuality
            ),
            
            // Recommendations
            recommendations = generateRecommendations(metrics)
        )
        
        // Generate improvement report
        val reportFile = file("${buildDir}/reports/cd-improvement.html")
        reportFile.writeText(generateImprovementReport(analysis))
        
        logger.lifecycle("CD Analysis Report: ${reportFile.toURI()}")
        
        // Log key findings
        analysis.recommendations.forEach { recommendation ->
            logger.lifecycle("Improvement Opportunity: $recommendation")
        }
    }
}