workspace extends ../common/model/styles.dsl {
    name "Server configurations"
    description "Server configurations C4 model"

    !identifiers hierarchical
    model {

        developer = person "Developer" "Tango dev" "Person"
        autoTest = person "Autotest" "Tango autotests" "Autotest"
        emergency = person "Emergency changer" "Emergency changer" "Person"
        approver = person "Approver" "Tango approver" "Person"

        tangoSystem = softwareSystem "Tango production" "Tango production services" {
            application = container "Application"
        }

        audit = softwareSystem "Audit system" "Audit log system"

        currentSolution = softwareSystem "Unleash" {
            perspectives {
                "current" "Current solution"  
            }
            

            unleashBackend = container "Unleash" "Unleash backend" {
                autoTest -> this "Autotest override" "HTTP"
                tangoSystem.application -> this "Request updates" "HTTP"
                -> tangoSystem.application "Push updates" "HTTP" 
                -> audit "Track updates" "Webhook"
            }

            unleashUi = container "UnleashUI" "Unleash UI"{
                emergency -> this "Emergency change" "HTTP"
                developer -> this "Usual change" "HTTP"
                -> unleashBackend "Update configs" "HTTP"
            }
        }

        mainKafkaCluster = softwareSystem "Main Kafka cluster" {
            tags "Kafka" "Common"

            overridesTopic = container "Server config overrides topic" {
                tags "Kafka" "Topic"
                technology "Kafka topic"
                description "Compacted topic with service config overrides"
            }

            clientPresenceTopic = container "Client presence topic" {
                tags "Kafka" "Topic"
                technology "Kafka topic"
                description "Compacted topic with all connected clients"
            }
        }


        serverConfigSystem = softwareSystem "Server config system" {
            perspectives {
                "future" "Future soultion"  
            }
            
            !docs docs

            bucket = container "GCP bucket" {
                tags "Google Cloud Platform - Cloud Storage"
            }

            git = container "Server configs GIT" {
                repository = component "Repository" "Config repository" "Git" {
                    developer -> this "Change configs" "Git"
                    approver -> this "Approve configs" "Git"
                }
                parser = component "Parser" "Config parser" "Java" {
                    repository -> this "Push configs" "Git"
                }
                validator = component "Validator" "Config validator" "Java" {
                    parser -> this "Validate" "Java"
                }
                uploader = component "Uploader" "Config uploader" "Java" {
                    validator -> this "Init upload" "Java"
                    -> bucket "Upload prepared configs" "S3"
                }
            }


            configManager = container "Config manager" "Server config manager" "Java" {
                bucketSource = component "Bucket source" "Bucket based config source" "Spring" {
                    -> bucket "Poll config updates" "S3"
                }
                
                storageSource = component "Storage source" "Global KTable over topic with overrides" "KTable" {
                    tags "Kafka" "Database"
                    mainKafkaCluster.overridesTopic -> this "Push overrides" "Kafka client"
                }
                
                configResolver = component "Config resolver" "Server config resolver" "Spring" {
                    -> storageSource "Resolve from storage" 
                    -> bucketSource "Resolve from bucket" 
                    tangoSystem.application -> this "Request configs" "Grpc"
                }

                storageSource -> mainKafkaCluster.overridesTopic "Store overrides" "Kafka client"
                storageSource -> mainKafkaCluster.overridesTopic "Delete overrides" "Kafka client"

                api = component "API" "Config manager API" "Java" {
                    tags "API"
                    autoTest -> this "Override for autotests" "HTTP"
                }

                ui = component "UI" "Server configs UI" "Vaadin" {
                    emergency -> this "Emergency change" "HTTP"
                    developer -> this "View/compare configs" "HTTP"
                }
                

                overrider = component "Overrider" "Config overrider component" "Spring" {
                    api -> this "Override for autotests"
                    ui -> this "Emergency change" "HTTP"
                    -> storageSource "Store overrides" 
                    -> audit "Track updates" "Webhook"
                }
                
                notifier = component "Change notifier" "Change notification component" "Grpc" {
                    overrider -> notifier "Trigger notifications"
                    -> audit "Track updates" "Webhook"
                }
            }

            configEdge = container "Config edge" "Server config edge" "Java" {
                bucketSource = component "Bucket source" "Bucket based config source" "Spring" {
                    -> bucket "Poll config updates" "S3"
                }
                
                storageSource = component "Storage source" "Global KTable over topic with overrides" "KTable" {
                    tags "Kafka" "Database"
                    mainKafkaCluster.overridesTopic -> this "Push overrides" "Kafka client"
                }
                
                configResolver = component "Config resolver" "Server config resolver" "Spring" {
                    -> storageSource "Resolve from storage" 
                    -> bucketSource "Resolve from bucket" 
                    tangoSystem.application -> this "Request configs" "Grpc"
                }

                clientNotifier = component "Client config change notifier" "Change notification component" "Grpc" {
                    -> tangoSystem.application "Push updates" "Grpc"
                    -> configResolver "Resolve configs"
                    bucketSource -> this "Trigget client notification"
                    storageSource -> this "Trigget client notification"
                }
            }
        
        }

    }

    views {

        systemLandscape "SystemLandscape" "Server configs" {
            include *
            autoLayout
        }

        systemcontext currentSolution "currentSolutionContext" {
            include *
            autoLayout
        }

        systemcontext serverConfigSystem "serverConfigSystemContext" {
            include *
            autoLayout
        }

        container serverConfigSystem "serverConfigSystemContainers" {
            include *
            autoLayout
        } 

        container currentSolution "currentSolutionContainers" {
            include *
            autoLayout
        }

        component serverConfigSystem.git "gitComponents" {
            include *
            autoLayout
        }

        component serverConfigSystem.configManager "configManagerComponents" {
            include *
            autoLayout
        }

        component serverConfigSystem.configEdge "configEdgeComponents" {
            include *
            autoLayout
        }

        dynamic serverConfigSystem "git-update-config-flow" {
            developer -> serverConfigSystem.git
            approver -> serverConfigSystem.git
            serverConfigSystem.git -> serverConfigSystem.bucket
            serverConfigSystem.configEdge -> serverConfigSystem.bucket
            serverConfigSystem.configEdge -> tangoSystem.application

            autoLayout
            description "Git-based update configs flow"
        }

        dynamic serverConfigSystem "autotest-update-config-flow" {
            autoTest -> serverConfigSystem.configManager
            serverConfigSystem.configEdge -> tangoSystem.application

            autoLayout
            description "Autotest update configs flow"
        }

        dynamic serverConfigSystem "emergency-update-config-flow" {
            emergency -> serverConfigSystem.configManager
            serverConfigSystem.configEdge -> tangoSystem.application

            autoLayout
            description "Emergency update configs flow"
        }

        dynamic serverConfigSystem.configEdge "bucket-update-config-flow" {
            serverConfigSystem.git -> serverConfigSystem.bucket
            serverConfigSystem.configEdge.bucketSource -> serverConfigSystem.bucket
            serverConfigSystem.configEdge.bucketSource -> serverConfigSystem.configEdge.clientNotifier
            serverConfigSystem.configEdge.clientNotifier -> serverConfigSystem.configEdge.configResolver
            serverConfigSystem.configEdge.configResolver -> serverConfigSystem.configEdge.storageSource
            serverConfigSystem.configEdge.configResolver -> serverConfigSystem.configEdge.bucketSource
            serverConfigSystem.configEdge.clientNotifier -> tangoSystem.application

            autoLayout
            description "Bucket update configs handling flow"
        }

        dynamic serverConfigSystem.configEdge "storage-update-config-flow" {
            {
                {
                    autoTest -> serverConfigSystem.configManager.api
                    serverConfigSystem.configManager.api -> serverConfigSystem.configManager.overrider
                }
                {
                    emergency -> serverConfigSystem.configManager.ui
                    serverConfigSystem.configManager.ui -> serverConfigSystem.configManager.overrider
                }
            }
            
            serverConfigSystem.configManager.overrider -> serverConfigSystem.configManager.storageSource
            
            {
                {
                    serverConfigSystem.configManager.storageSource -> mainKafkaCluster.overridesTopic
                }
                {
                    serverConfigSystem.configManager.notifier -> audit
                }
            }
            mainKafkaCluster.overridesTopic -> serverConfigSystem.configEdge.storageSource
            serverConfigSystem.configEdge.storageSource -> serverConfigSystem.configEdge.clientNotifier
            serverConfigSystem.configEdge.clientNotifier -> serverConfigSystem.configEdge.configResolver
            serverConfigSystem.configEdge.configResolver -> serverConfigSystem.configEdge.storageSource
            serverConfigSystem.configEdge.configResolver -> serverConfigSystem.configEdge.bucketSource
            serverConfigSystem.configEdge.clientNotifier -> tangoSystem.application
            serverConfigSystem.configManager.overrider -> serverConfigSystem.configManager.notifier
            

            autoLayout
            description "Storage update configs handling flow"
        }

        dynamic serverConfigSystem.configEdge "resolve-config-flow" {
            tangoSystem.application -> serverConfigSystem.configEdge.configResolver 
            serverConfigSystem.configEdge.configResolver -> serverConfigSystem.configEdge.storageSource
            serverConfigSystem.configEdge.configResolver -> serverConfigSystem.configEdge.bucketSource 

            autoLayout
            description "Resolve config flow"
        }
    }

}