• Home
• com.infobip.kafkistry
• kafkistry-web
• 0.9.0
• source code
• incrementalProposedMigrations.ftl

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

ui.clusters.incrementalProposedMigrations.ftl Maven / Gradle / Ivy

<#-- @ftlvariable name="appUrl" type="com.infobip.kafkistry.webapp.url.AppUrl" -->
<#-- @ftlvariable name="clusterIdentifier"  type="java.lang.String" -->
<#-- @ftlvariable name="proposedMigrations"  type="com.infobip.kafkistry.service.generator.balance.ProposedMigrations" -->

<#import "../common/util.ftl" as util>

<#if proposedMigrations.migrations?size == 0>
    

        Did not find topic replicas candidates to migrate
    
    

        
Cluster might already be balanced enough so that any migration would cause bigger disbalance
        
Max migration size limit might be to restrictive
        
Analyze timeout too low
    
<#else>
    

        Suggested ${proposedMigrations.migrations?size} topic replica(s) to migrate
    

    <#macro migrationRow migration>
    <#-- @ftlvariable name="migration"  type="com.infobip.kafkistry.service.generator.balance.TopicPartitionMigration" -->
        
            
                ${migration.topicPartition.topic}
            
            [${migration.topicPartition.partition?c}]
        
        
            <#if migration.fromBrokerIds?size == 0 && migration.toBrokerIds?size == 0>
                ---
            <#else>
                ${migration.fromBrokerIds?join(", ")} → ${migration.toBrokerIds?join(", ")}
            
        
        
            <#if migration.oldLeader == migration.newLeader>
                ${migration.newLeader}
            <#else>
                ${migration.oldLeader} → ${migration.newLeader}
            
        
        ${util.prettyDataSize(migration.load.size)}
        ${util.prettyNumber(migration.load.rate)} msg/sec
        ${migration.load.consumers}
    

    

        

            Topic partition migrations
            
                
                    All effective
                    
                
                
                    Per iteration
                    
                
            
        
        

            
                <#list proposedMigrations.migrations as migration>
                    
                        <@migrationRow migration=migration/>
                    

                

                

                    
Topic partition
                    
Migration
                    
Leader
                    
Disk usage
                    
Rate usage
                    
# Consumers
                
                

                
            
            
                <#list proposedMigrations.iterationMigrations as migrations>
                    <#list migrations as migration>
                        
                            <#if migration?index == 0>
                                
                            <@migrationRow migration=migration/>
                        

                

                

                    
Iteration
                    
Topic partition
                    
Migration
                    
Leader
                    
Disk usage
                    
Rate usage
                    
# Consumers
                
                
${migrations?index + 1}.
                            
                    
                
            
        
    
    


    

        

            
Cluster balance comparison
        
        

            <#assign maxValueClass = "text-primary">
            <#assign minValueClass = "text-info">
            

                

                    MAX value broker
                
                

                    MIN value broker
                
            

            
                <#assign statusBefore = proposedMigrations.clusterBalanceBefore>
                <#assign statusAfter = proposedMigrations.clusterBalanceAfter>
                <#list statusBefore.brokerLoads as brokerId, loadBefore>
                    <#assign loadAfter = statusAfter.brokerLoads?api.get(brokerId)>
                    

                        <#assign maxClass = statusBefore.maxLoadBrokers.size?seq_contains(brokerId)?then(maxValueClass, "")>
                        <#assign minClass = statusBefore.minLoadBrokers.size?seq_contains(brokerId)?then(minValueClass, "")>
                        <#assign classes = (maxClass?has_content && minClass?has_content)?then("", minClass + " "+ maxClass)>
                        

                        <#assign maxClass = statusBefore.maxLoadBrokers.rate?seq_contains(brokerId)?then(maxValueClass, "")>
                        <#assign minClass = statusBefore.minLoadBrokers.rate?seq_contains(brokerId)?then(minValueClass, "")>
                        <#assign classes = (maxClass?has_content && minClass?has_content)?then("", minClass + " "+ maxClass)>
                        

                        <#assign maxClass = statusBefore.maxLoadBrokers.consumeRate?seq_contains(brokerId)?then(maxValueClass, "")>
                        <#assign minClass = statusBefore.minLoadBrokers.consumeRate?seq_contains(brokerId)?then(minValueClass, "")>
                        <#assign classes = (maxClass?has_content && minClass?has_content)?then("", minClass + " "+ maxClass)>
                        

                        <#assign maxClass = statusBefore.maxLoadBrokers.replicationRate?seq_contains(brokerId)?then(maxValueClass, "")>
                        <#assign minClass = statusBefore.minLoadBrokers.replicationRate?seq_contains(brokerId)?then(minValueClass, "")>
                        <#assign classes = (maxClass?has_content && minClass?has_content)?then("", minClass + " "+ maxClass)>
                        

                        <#assign maxClass = statusBefore.maxLoadBrokers.replicas?seq_contains(brokerId)?then(maxValueClass, "")>
                        <#assign minClass = statusBefore.minLoadBrokers.replicas?seq_contains(brokerId)?then(minValueClass, "")>
                        <#assign classes = (maxClass?has_content && minClass?has_content)?then("", minClass + " "+ maxClass)>
                        

                        <#assign maxClass = statusBefore.maxLoadBrokers.leaders?seq_contains(brokerId)?then(maxValueClass, "")>
                        <#assign minClass = statusBefore.minLoadBrokers.leaders?seq_contains(brokerId)?then(minValueClass, "")>
                        <#assign classes = (maxClass?has_content && minClass?has_content)?then("", minClass + " "+ maxClass)>
                        

                        <#assign maxClass = statusAfter.maxLoadBrokers.size?seq_contains(brokerId)?then(maxValueClass, "")>
                        <#assign minClass = statusAfter.minLoadBrokers.size?seq_contains(brokerId)?then(minValueClass, "")>
                        <#assign classes = (maxClass?has_content && minClass?has_content)?then("", minClass + " "+ maxClass)>
                        

                        <#assign maxClass = statusAfter.maxLoadBrokers.rate?seq_contains(brokerId)?then(maxValueClass, "")>
                        <#assign minClass = statusAfter.minLoadBrokers.rate?seq_contains(brokerId)?then(minValueClass, "")>
                        <#assign classes = (maxClass?has_content && minClass?has_content)?then("", minClass + " "+ maxClass)>
                        

                        <#assign maxClass = statusAfter.maxLoadBrokers.consumeRate?seq_contains(brokerId)?then(maxValueClass, "")>
                        <#assign minClass = statusAfter.minLoadBrokers.consumeRate?seq_contains(brokerId)?then(minValueClass, "")>
                        <#assign classes = (maxClass?has_content && minClass?has_content)?then("", minClass + " "+ maxClass)>
                        

                        <#assign maxClass = statusAfter.maxLoadBrokers.replicationRate?seq_contains(brokerId)?then(maxValueClass, "")>
                        <#assign minClass = statusAfter.minLoadBrokers.replicationRate?seq_contains(brokerId)?then(minValueClass, "")>
                        <#assign classes = (maxClass?has_content && minClass?has_content)?then("", minClass + " "+ maxClass)>
                        

                        <#assign maxClass = statusAfter.maxLoadBrokers.replicas?seq_contains(brokerId)?then(maxValueClass, "")>
                        <#assign minClass = statusAfter.minLoadBrokers.replicas?seq_contains(brokerId)?then(minValueClass, "")>
                        <#assign classes = (maxClass?has_content && minClass?has_content)?then("", minClass + " "+ maxClass)>
                        

                        <#assign maxClass = statusAfter.maxLoadBrokers.leaders?seq_contains(brokerId)?then(maxValueClass, "")>
                        <#assign minClass = statusAfter.minLoadBrokers.leaders?seq_contains(brokerId)?then(minValueClass, "")>
                        <#assign classes = (maxClass?has_content && minClass?has_content)?then("", minClass + " "+ maxClass)>
                        

                

                

                    
Broker/Metric
                    
When
                    
Disk
                    
Rate
                    
Consume
                    
Replication
                    
Replicas
                    
Leaders
                
                

                        
${brokerId?c}
                        
Before
${util.prettyDataSize(loadBefore.size)}
${util.prettyNumber(loadBefore.rate)} msg/sec
${util.prettyNumber(loadBefore.consumeRate)} msg/sec
${util.prettyNumber(loadBefore.replicationRate)} msg/sec
${loadBefore.replicas}
${loadBefore.leaders}
                    
                    

                        
After
${util.prettyDataSize(loadAfter.size)}
${util.prettyNumber(loadAfter.rate)} msg/sec
${util.prettyNumber(loadAfter.consumeRate)} msg/sec
${util.prettyNumber(loadAfter.replicationRate)} msg/sec
${loadAfter.replicas}
${loadAfter.leaders}
                    
                    

                        
Diff
                        

                            <#if loadAfter.size gt loadBefore.size>+${util.prettyDataSize(loadAfter.size - loadBefore.size)}
                        
                        

                            <#if loadAfter.rate gt loadBefore.rate>+${util.prettyNumber(loadAfter.rate - loadBefore.rate)} msg/sec
                        
                        

                            <#if loadAfter.consumeRate gt loadBefore.consumeRate>+${util.prettyNumber(loadAfter.consumeRate - loadBefore.consumeRate)} msg/sec
                        
                        

                            <#if loadAfter.replicationRate gt loadBefore.replicationRate>+${util.prettyNumber(loadAfter.replicationRate - loadBefore.replicationRate)} msg/sec
                        
                        

                            <#if loadAfter.replicas gt loadBefore.replicas>+${loadAfter.replicas - loadBefore.replicas}
                        
                        

                            <#if loadAfter.leaders gt loadBefore.leaders>+${loadAfter.leaders - loadBefore.leaders}
                        
                    
                
                

                    

                
                

                    
Average
                    

                    
${util.prettyDataSize(statusBefore.brokersAverageLoad.size)}
                    
${util.prettyNumber(statusBefore.brokersAverageLoad.rate)} msg/sec
                    
${util.prettyNumber(statusBefore.brokersAverageLoad.consumeRate)} msg/sec
                    
${util.prettyNumber(statusBefore.brokersAverageLoad.replicationRate)} msg/sec
                    
${statusBefore.brokersAverageLoad.replicas}
                    
${statusBefore.brokersAverageLoad.leaders}
                
                

                    
Disbalance
|max - min|
                    
Before
                    
${util.prettyDataSize(statusBefore.brokersLoadDiff.size)}
                    
${util.prettyNumber(statusBefore.brokersLoadDiff.rate)} msg/sec
                    
${util.prettyNumber(statusBefore.brokersLoadDiff.consumeRate)} msg/sec
                    
${util.prettyNumber(statusBefore.brokersLoadDiff.replicationRate)} msg/sec
                    
${statusBefore.brokersLoadDiff.replicas}
                    
${statusBefore.brokersLoadDiff.leaders}
                
                

                    
After
                    
${util.prettyDataSize(statusAfter.brokersLoadDiff.size)}
                    
${util.prettyNumber(statusAfter.brokersLoadDiff.rate)} msg/sec
                    
${util.prettyNumber(statusAfter.brokersLoadDiff.consumeRate)} msg/sec
                    
${util.prettyNumber(statusAfter.brokersLoadDiff.replicationRate)} msg/sec
                    
${statusAfter.brokersLoadDiff.replicas}
                    
${statusAfter.brokersLoadDiff.leaders}
                
                

                    
Diff
                    

                        <#assign change = statusAfter.brokersLoadDiff.size - statusBefore.brokersLoadDiff.size>
                        <#if change lte 0>
                            -${util.prettyDataSize(-change)}
                        <#else>
                            +${util.prettyDataSize(change)}
                        
                    
                    

                        <#assign change = statusAfter.brokersLoadDiff.rate - statusBefore.brokersLoadDiff.rate>
                        <#if change lte 0>
                            -${util.prettyNumber(-change)} msg/sec
                        <#else>
                            +${util.prettyNumber(change)} mgs/sec
                        
                    
                    

                        <#assign change = statusAfter.brokersLoadDiff.consumeRate - statusBefore.brokersLoadDiff.consumeRate>
                        <#if change lte 0>
                            -${util.prettyNumber(-change)} msg/sec
                        <#else>
                            +${util.prettyNumber(change)} mgs/sec
                        
                    
                    

                        <#assign change = statusAfter.brokersLoadDiff.replicationRate - statusBefore.brokersLoadDiff.replicationRate>
                        <#if change lte 0>
                            -${util.prettyNumber(-change)} msg/sec
                        <#else>
                            +${util.prettyNumber(change)} mgs/sec
                        
                    
                    

                        <#assign change = statusAfter.brokersLoadDiff.replicas - statusBefore.brokersLoadDiff.replicas>
                        <#if change lte 0>
                            ${change}
                        <#else>
                            +${change}
                        
                    
                    

                        <#assign change = statusAfter.brokersLoadDiff.leaders - statusBefore.brokersLoadDiff.leaders>
                        <#if change lte 0>
                            ${change}
                        <#else>
                            +${change}
                        
                    
                
                

                    
Disbalance
portion
(100 * diff / avg)
                    
Before
                    
${util.prettyNumber(statusBefore.loadDiffPortion.size)}%
                    
${util.prettyNumber(statusBefore.loadDiffPortion.rate)}%
                    
${util.prettyNumber(statusBefore.loadDiffPortion.consumeRate)}%
                    
${util.prettyNumber(statusBefore.loadDiffPortion.replicationRate)}%
                    
${util.prettyNumber(statusBefore.loadDiffPortion.replicas)}%
                    
${util.prettyNumber(statusBefore.loadDiffPortion.leaders)}%
                
                

                    
After
                    
${util.prettyNumber(statusAfter.loadDiffPortion.size)}%
                    
${util.prettyNumber(statusAfter.loadDiffPortion.rate)}%
                    
${util.prettyNumber(statusAfter.loadDiffPortion.consumeRate)}%
                    
${util.prettyNumber(statusAfter.loadDiffPortion.replicationRate)}%
                    
${util.prettyNumber(statusAfter.loadDiffPortion.replicas)}%
                    
${util.prettyNumber(statusAfter.loadDiffPortion.leaders)}%
                
                

                    
Diff
                    

                        <#assign change = statusAfter.loadDiffPortion.size - statusBefore.loadDiffPortion.size>
                        <#if change lte 0>
                            -${util.prettyNumber(-change)}%
                        <#else>
                            +${util.prettyNumber(change)}%
                        
                    
                    

                        <#assign change = statusAfter.loadDiffPortion.rate - statusBefore.loadDiffPortion.rate>
                        <#if change lte 0>
                            -${util.prettyNumber(-change)}%
                        <#else>
                            +${util.prettyNumber(change)}%
                        
                    
                    

                        <#assign change = statusAfter.loadDiffPortion.consumeRate - statusBefore.loadDiffPortion.consumeRate>
                        <#if change lte 0>
                            -${util.prettyNumber(-change)}%
                        <#else>
                            +${util.prettyNumber(change)}%
                        
                    
                    

                        <#assign change = statusAfter.loadDiffPortion.replicationRate - statusBefore.loadDiffPortion.replicationRate>
                        <#if change lte 0>
                            -${util.prettyNumber(-change)}%
                        <#else>
                            +${util.prettyNumber(change)}%
                        
                    
                    

                        <#assign change = statusAfter.loadDiffPortion.replicas - statusBefore.loadDiffPortion.replicas>
                        <#if change lte 0>
                            -${util.prettyNumber(-change)}%
                        <#else>
                            +${util.prettyNumber(change)}%
                        
                    
                    

                        <#assign change = statusAfter.loadDiffPortion.leaders - statusBefore.loadDiffPortion.leaders>
                        <#if change lte 0>
                            -${util.prettyNumber(-change)}%
                        <#else>
                            +${util.prettyNumber(change)}%
                        
                    
                
            
        
    
    


    

        

            
Data migration summary
        
        

            
                <#assign dataMigration = proposedMigrations.dataMigration>
                <#include "../management/assignmentDataMigration.ftl">
            
        
    
    


    <#assign maxBrokerIOBytes = proposedMigrations.dataMigration.maxBrokerIOBytes>
    <#include "../management/replicationThrottle.ftl">
    


    

        <#list proposedMigrations.topicsAssignmentChanges as topicName, assignmentsChange>
            <#assign assignments = assignmentsChange.newAssignments>
            <#include "../management/assignmentData.ftl">