harmony/adr/core-abstractions/topology2/src/main_capabilities.rs

fn main() {
    // Create various topologies
    let okd_topology = OKDHaClusterTopology::new();
    let k3d_topology = K3DTopology::new();
    let linux_topology = LinuxTopology::new();

    // Create scores
    let lamp_score = LAMPScore::new("MySQL 8.0", "PHP 8.1", "Apache 2.4");
    let binary_score = BinaryScore::new("https://example.com/binary", vec!["--arg1", "--arg2"]);
    let load_balancer_score = LoadBalancerScore::new(vec!["service1", "service2"], 80);

    // Example 1: Running LAMP stack on OKD
    println!("\n=== Deploying LAMP stack on OKD cluster ===");
    lamp_score.execute(&okd_topology);

    // Example 2: Running LAMP stack on K3D
    println!("\n=== Deploying LAMP stack on K3D cluster ===");
    lamp_score.execute(&k3d_topology);

    // Example 3: Running binary on Linux host
    println!("\n=== Running binary on Linux host ===");
    binary_score.execute(&linux_topology);

    // Example 4: Running binary on OKD (which can also run Linux commands)
    println!("\n=== Running binary on OKD host ===");
    binary_score.execute(&okd_topology);

    // Example 5: Load balancer configuration on OKD
    println!("\n=== Configuring load balancer on OKD ===");
    load_balancer_score.execute(&okd_topology);

    // The following would not compile:
    // load_balancer_score.execute(&k3d_topology); // K3D doesn't implement LoadBalancerCapability
    // lamp_score.execute(&linux_topology);        // Linux doesn't implement K8sCapability
}

// Base Topology trait
trait Topology {
    fn name(&self) -> &str;
}

// Define capabilities
trait K8sCapability {
    fn deploy_k8s_resource(&self, resource_yaml: &str);
    fn execute_kubectl(&self, command: &str) -> String;
}

trait OKDCapability: K8sCapability {
    fn execute_oc(&self, command: &str) -> String;
}

trait LinuxCapability {
    fn execute_command(&self, command: &str, args: &[&str]) -> String;
    fn download_file(&self, url: &str, destination: &str) -> Result<(), String>;
}

trait LoadBalancerCapability {
    fn configure_load_balancer(&self, services: &[&str], port: u16);
    fn get_load_balancer_status(&self) -> String;
}

trait FirewallCapability {
    fn open_port(&self, port: u16, protocol: &str);
    fn close_port(&self, port: u16, protocol: &str);
}

trait RouterCapability {
    fn configure_route(&self, service: &str, hostname: &str);
}

// Topology implementations
struct OKDHaClusterTopology {
    cluster_name: String,
}

impl OKDHaClusterTopology {
    fn new() -> Self {
        Self {
            cluster_name: "okd-ha-cluster".to_string(),
        }
    }
}

impl Topology for OKDHaClusterTopology {
    fn name(&self) -> &str {
        &self.cluster_name
    }
}

impl K8sCapability for OKDHaClusterTopology {
    fn deploy_k8s_resource(&self, resource_yaml: &str) {
        println!("Deploying K8s resource on OKD cluster: {}", resource_yaml);
    }

    fn execute_kubectl(&self, command: &str) -> String {
        println!("Executing kubectl command on OKD cluster: {}", command);
        "kubectl command output".to_string()
    }
}

impl OKDCapability for OKDHaClusterTopology {
    fn execute_oc(&self, command: &str) -> String {
        println!("Executing oc command on OKD cluster: {}", command);
        "oc command output".to_string()
    }
}

impl LinuxCapability for OKDHaClusterTopology {
    fn execute_command(&self, command: &str, args: &[&str]) -> String {
        println!(
            "Executing command '{}' with args {:?} on OKD node",
            command, args
        );
        todo!()
    }

    fn download_file(&self, url: &str, destination: &str) -> Result<(), String> {
        println!(
            "Downloading file from {} to {} on OKD node",
            url, destination
        );
        Ok(())
    }
}

impl LoadBalancerCapability for OKDHaClusterTopology {
    fn configure_load_balancer(&self, services: &[&str], port: u16) {
        println!(
            "Configuring load balancer for services {:?} on port {} in OKD",
            services, port
        );
    }

    fn get_load_balancer_status(&self) -> String {
        "OKD Load Balancer: HEALTHY".to_string()
    }
}

impl FirewallCapability for OKDHaClusterTopology {
    fn open_port(&self, port: u16, protocol: &str) {
        println!(
            "Opening port {} with protocol {} on OKD firewall",
            port, protocol
        );
    }

    fn close_port(&self, port: u16, protocol: &str) {
        println!(
            "Closing port {} with protocol {} on OKD firewall",
            port, protocol
        );
    }
}

impl RouterCapability for OKDHaClusterTopology {
    fn configure_route(&self, service: &str, hostname: &str) {
        println!(
            "Configuring route for service {} with hostname {} on OKD",
            service, hostname
        );
    }
}

struct K3DTopology {
    cluster_name: String,
}

impl K3DTopology {
    fn new() -> Self {
        Self {
            cluster_name: "k3d-local".to_string(),
        }
    }
}

impl Topology for K3DTopology {
    fn name(&self) -> &str {
        &self.cluster_name
    }
}

impl K8sCapability for K3DTopology {
    fn deploy_k8s_resource(&self, resource_yaml: &str) {
        println!("Deploying K8s resource on K3D cluster: {}", resource_yaml);
    }

    fn execute_kubectl(&self, command: &str) -> String {
        println!("Executing kubectl command on K3D cluster: {}", command);
        "kubectl command output from K3D".to_string()
    }
}

struct LinuxTopology {
    hostname: String,
}

impl LinuxTopology {
    fn new() -> Self {
        Self {
            hostname: "linux-host".to_string(),
        }
    }
}

impl Topology for LinuxTopology {
    fn name(&self) -> &str {
        &self.hostname
    }
}

impl LinuxCapability for LinuxTopology {
    fn execute_command(&self, command: &str, args: &[&str]) -> String {
        println!(
            "Executing command '{}' with args {:?} on Linux host",
            command, args
        );
        todo!()
    }

    fn download_file(&self, url: &str, destination: &str) -> Result<(), String> {
        println!(
            "Downloading file from {} to {} on Linux host",
            url, destination
        );
        Ok(())
    }
}

// Score implementations
struct LAMPScore {
    mysql_version: String,
    php_version: String,
    apache_version: String,
}

impl LAMPScore {
    fn new(mysql_version: &str, php_version: &str, apache_version: &str) -> Self {
        Self {
            mysql_version: mysql_version.to_string(),
            php_version: php_version.to_string(),
            apache_version: apache_version.to_string(),
        }
    }

    fn execute<T: K8sCapability>(&self, topology: &T) {
        // Deploy MySQL
        topology.deploy_k8s_resource("mysql-deployment.yaml");

        // Deploy PHP
        topology.deploy_k8s_resource("php-deployment.yaml");

        // Deploy Apache
        topology.deploy_k8s_resource("apache-deployment.yaml");

        // Create service
        topology.deploy_k8s_resource("lamp-service.yaml");

        // Check deployment
        let status = topology.execute_kubectl("get pods -l app=lamp");
        println!("LAMP deployment status: {}", status);
    }
}

struct BinaryScore {
    url: String,
    args: Vec<String>,
}

impl BinaryScore {
    fn new(url: &str, args: Vec<&str>) -> Self {
        Self {
            url: url.to_string(),
            args: args.iter().map(|s| s.to_string()).collect(),
        }
    }

    fn execute<T: LinuxCapability>(&self, topology: &T) {
        let destination = "/tmp/binary";

        match topology.download_file(&self.url, destination) {
            Ok(_) => {
                println!("Binary downloaded successfully");

                // Convert args to slice of &str
                let args: Vec<&str> = self.args.iter().map(|s| s.as_str()).collect();

                // Execute the binary
                topology.execute_command(destination, &args);
                println!("Binary execution completed");
            }
            Err(e) => {
                println!("Failed to download binary: {}", e);
            }
        }
    }
}

struct LoadBalancerScore {
    services: Vec<String>,
    port: u16,
}

impl LoadBalancerScore {
    fn new(services: Vec<&str>, port: u16) -> Self {
        Self {
            services: services.iter().map(|s| s.to_string()).collect(),
            port,
        }
    }

    fn execute<T: LoadBalancerCapability>(&self, topology: &T) {
        println!("Configuring load balancer for services");

        // Convert services to slice of &str
        let services: Vec<&str> = self.services.iter().map(|s| s.as_str()).collect();

        // Configure load balancer
        topology.configure_load_balancer(&services, self.port);

        // Check status
        let status = topology.get_load_balancer_status();
        println!("Load balancer status: {}", status);
    }
}