github.com/oam-dev/kubevela@v1.9.11/pkg/stdlib/pkgs/multicluster.cue (about)

     1  // deprecated
     2  #Placement: {
     3  	clusterSelector?: {
     4  		labels?: [string]: string
     5  		name?: string
     6  	}
     7  	namespaceSelector?: {
     8  		labels?: [string]: string
     9  		name?: string
    10  	}
    11  }
    12  
    13  // deprecated
    14  #PlacementDecision: {
    15  	namespace?: string
    16  	cluster?:   string
    17  }
    18  
    19  // deprecated
    20  #Component: {
    21  	name?: string
    22  	type?: string
    23  	properties?: {...}
    24  	traits?: [...{
    25  		type:     string
    26  		disable?: bool
    27  		properties: {...}
    28  	}]
    29  	externalRevision?: string
    30  	dependsOn?: [...string]
    31  }
    32  
    33  // deprecated
    34  #MakePlacementDecisions: {
    35  	#provider: "multicluster"
    36  	#do:       "make-placement-decisions"
    37  
    38  	inputs: {
    39  		policyName: string
    40  		envName:    string
    41  		placement:  #Placement
    42  	}
    43  
    44  	outputs: {
    45  		decisions: [...#PlacementDecision]
    46  	}
    47  }
    48  
    49  // deprecated
    50  #PatchApplication: {
    51  	#provider: "multicluster"
    52  	#do:       "patch-application"
    53  
    54  	inputs: {
    55  		envName: string
    56  		patch?: components: [...#Component]
    57  		selector?: components: [...string]
    58  	}
    59  
    60  	outputs: {...}
    61  	...
    62  }
    63  
    64  // deprecated
    65  #LoadEnvBindingEnv: #Steps & {
    66  	inputs: {
    67  		env:    string
    68  		policy: string
    69  	}
    70  
    71  	loadPolicies: oam.#LoadPolicies @step(1)
    72  	policy_:      string
    73  	envBindingPolicies: []
    74  	if inputs.policy == "" && loadPolicies.value != _|_ {
    75  		envBindingPolicies: [ for k, v in loadPolicies.value if v.type == "env-binding" {k}]
    76  		policy_: envBindingPolicies[0]
    77  	}
    78  	if inputs.policy != "" {
    79  		policy_: inputs.policy
    80  	}
    81  
    82  	loadPolicy: loadPolicies.value["\(policy_)"]
    83  	envMap: {
    84  		for ev in loadPolicy.properties.envs {
    85  			"\(ev.name)": ev
    86  		}
    87  		...
    88  	}
    89  	envConfig_: envMap["\(inputs.env)"]
    90  
    91  	outputs: {
    92  		policy:    policy_
    93  		envConfig: envConfig_
    94  	}
    95  }
    96  
    97  // deprecated
    98  #PrepareEnvBinding: #Steps & {
    99  	inputs: {
   100  		env:    string
   101  		policy: string
   102  	}
   103  	env_:    inputs.env
   104  	policy_: inputs.policy
   105  
   106  	loadEnv: #LoadEnvBindingEnv & {
   107  		inputs: {
   108  			env:    env_
   109  			policy: policy_
   110  		}
   111  	}          @step(1)
   112  	envConfig: loadEnv.outputs.envConfig
   113  
   114  	placementDecisions: #MakePlacementDecisions & {
   115  		inputs: {
   116  			policyName: loadEnv.outputs.policy
   117  			envName:    env_
   118  			placement:  envConfig.placement
   119  		}
   120  	} @step(2)
   121  
   122  	patchedApp: #PatchApplication & {
   123  		inputs: {
   124  			envName: env_
   125  			if envConfig.selector != _|_ {
   126  				selector: envConfig.selector
   127  			}
   128  			if envConfig.patch != _|_ {
   129  				patch: envConfig.patch
   130  			}
   131  		}
   132  	} @step(3)
   133  
   134  	outputs: {
   135  		components: patchedApp.outputs.spec.components
   136  		decisions:  placementDecisions.outputs.decisions
   137  	}
   138  }
   139  
   140  // deprecated
   141  #ApplyComponentsToEnv: #Steps & {
   142  	inputs: {
   143  		decisions: [...#PlacementDecision]
   144  		components: [...#Component]
   145  		env:         string
   146  		waitHealthy: bool
   147  	} @step(1)
   148  
   149  	outputs: #Steps & {
   150  		for decision in inputs.decisions {
   151  			for key, comp in inputs.components {
   152  				"\(decision.cluster)-\(decision.namespace)-\(key)": #ApplyComponent & {
   153  					value: comp
   154  					if decision.cluster != _|_ {
   155  						cluster: decision.cluster
   156  					}
   157  					if decision.namespace != _|_ {
   158  						namespace: decision.namespace
   159  					}
   160  					waitHealthy: inputs.waitHealthy
   161  					env:         inputs.env
   162  				} @step(1)
   163  			}
   164  		}
   165  	} @step(2)
   166  }
   167  
   168  // deprecated
   169  #ApplyEnvBindApp: {
   170  	#do: "steps"
   171  
   172  	env:       string
   173  	policy:    string
   174  	app:       string
   175  	namespace: string
   176  	parallel:  bool
   177  
   178  	env_:    env
   179  	policy_: policy
   180  	prepare: #PrepareEnvBinding & {
   181  		inputs: {
   182  			env:    env_
   183  			policy: policy_
   184  		}
   185  	} @step(1)
   186  
   187  	apply: #ApplyComponentsToEnv & {
   188  		inputs: {
   189  			decisions:   prepare.outputs.decisions
   190  			components:  prepare.outputs.components
   191  			env:         env_
   192  			waitHealthy: !parallel
   193  		}
   194  	} @step(2)
   195  
   196  	if parallel {
   197  		wait: #ApplyComponentsToEnv & {
   198  			inputs: {
   199  				decisions:   prepare.outputs.decisions
   200  				components:  prepare.outputs.components
   201  				env:         env_
   202  				waitHealthy: true
   203  			}
   204  		} @step(3)
   205  	}
   206  }
   207  
   208  #ListClusters: {
   209  	#provider: "multicluster"
   210  	#do:       "list-clusters"
   211  
   212  	outputs: {
   213  		clusters: [...string]
   214  	}
   215  }
   216  
   217  #GetPlacementsFromTopologyPolicies: {
   218  	#provider: "multicluster"
   219  	#do:       "get-placements-from-topology-policies"
   220  	policies: [...string]
   221  	placements: [...{
   222  		cluster:   string
   223  		namespace: string
   224  	}]
   225  }
   226  
   227  #Deploy: {
   228  	#provider: "multicluster"
   229  	#do:       "deploy"
   230  	policies: [...string]
   231  	parallelism:              int
   232  	ignoreTerraformComponent: bool
   233  	inlinePolicies:           *[] | [...{...}]
   234  }