github.com/tilt-dev/tilt@v0.33.15-0.20240515162809-0a22ed45d8a0/internal/tiltfile/v1alpha1/types.go (about) 1 package v1alpha1 2 3 import ( 4 "fmt" 5 "time" 6 7 "go.starlark.net/starlark" 8 metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" 9 10 "github.com/tilt-dev/tilt/internal/tiltfile/starkit" 11 "github.com/tilt-dev/tilt/internal/tiltfile/value" 12 "github.com/tilt-dev/tilt/pkg/apis/core/v1alpha1" 13 ) 14 15 // AUTOGENERATED by github.com/tilt-dev/tilt-starlark-codegen 16 // DO NOT EDIT MANUALLY 17 18 func (p Plugin) registerSymbols(env *starkit.Environment) error { 19 var err error 20 21 err = env.AddBuiltin("v1alpha1.cmd", p.cmd) 22 if err != nil { 23 return err 24 } 25 err = env.AddBuiltin("v1alpha1.config_map", p.configMap) 26 if err != nil { 27 return err 28 } 29 err = env.AddBuiltin("v1alpha1.extension", p.extension) 30 if err != nil { 31 return err 32 } 33 err = env.AddBuiltin("v1alpha1.extension_repo", p.extensionRepo) 34 if err != nil { 35 return err 36 } 37 err = env.AddBuiltin("v1alpha1.file_watch", p.fileWatch) 38 if err != nil { 39 return err 40 } 41 err = env.AddBuiltin("v1alpha1.kubernetes_apply", p.kubernetesApply) 42 if err != nil { 43 return err 44 } 45 err = env.AddBuiltin("v1alpha1.kubernetes_discovery", p.kubernetesDiscovery) 46 if err != nil { 47 return err 48 } 49 err = env.AddBuiltin("v1alpha1.ui_button", p.uiButton) 50 if err != nil { 51 return err 52 } 53 err = env.AddBuiltin("v1alpha1.config_map_disable_source", p.configMapDisableSource) 54 if err != nil { 55 return err 56 } 57 err = env.AddBuiltin("v1alpha1.disable_source", p.disableSource) 58 if err != nil { 59 return err 60 } 61 err = env.AddBuiltin("v1alpha1.exec_action", p.execAction) 62 if err != nil { 63 return err 64 } 65 err = env.AddBuiltin("v1alpha1.forward", p.forward) 66 if err != nil { 67 return err 68 } 69 err = env.AddBuiltin("v1alpha1.http_get_action", p.hTTPGetAction) 70 if err != nil { 71 return err 72 } 73 err = env.AddBuiltin("v1alpha1.http_header", p.hTTPHeader) 74 if err != nil { 75 return err 76 } 77 err = env.AddBuiltin("v1alpha1.handler", p.handler) 78 if err != nil { 79 return err 80 } 81 err = env.AddBuiltin("v1alpha1.ignore_def", p.ignoreDef) 82 if err != nil { 83 return err 84 } 85 err = env.AddBuiltin("v1alpha1.kubernetes_apply_cmd", p.kubernetesApplyCmd) 86 if err != nil { 87 return err 88 } 89 err = env.AddBuiltin("v1alpha1.kubernetes_discovery_template_spec", p.kubernetesDiscoveryTemplateSpec) 90 if err != nil { 91 return err 92 } 93 err = env.AddBuiltin("v1alpha1.kubernetes_image_locator", p.kubernetesImageLocator) 94 if err != nil { 95 return err 96 } 97 err = env.AddBuiltin("v1alpha1.kubernetes_image_object_descriptor", p.kubernetesImageObjectDescriptor) 98 if err != nil { 99 return err 100 } 101 err = env.AddBuiltin("v1alpha1.kubernetes_watch_ref", p.kubernetesWatchRef) 102 if err != nil { 103 return err 104 } 105 err = env.AddBuiltin("v1alpha1.label_selector", p.labelSelector) 106 if err != nil { 107 return err 108 } 109 err = env.AddBuiltin("v1alpha1.label_selector_requirement", p.labelSelectorRequirement) 110 if err != nil { 111 return err 112 } 113 err = env.AddBuiltin("v1alpha1.object_selector", p.objectSelector) 114 if err != nil { 115 return err 116 } 117 err = env.AddBuiltin("v1alpha1.pod_log_stream_template_spec", p.podLogStreamTemplateSpec) 118 if err != nil { 119 return err 120 } 121 err = env.AddBuiltin("v1alpha1.port_forward_template_spec", p.portForwardTemplateSpec) 122 if err != nil { 123 return err 124 } 125 err = env.AddBuiltin("v1alpha1.probe", p.probe) 126 if err != nil { 127 return err 128 } 129 err = env.AddBuiltin("v1alpha1.restart_on_spec", p.restartOnSpec) 130 if err != nil { 131 return err 132 } 133 err = env.AddBuiltin("v1alpha1.start_on_spec", p.startOnSpec) 134 if err != nil { 135 return err 136 } 137 err = env.AddBuiltin("v1alpha1.tcp_socket_action", p.tCPSocketAction) 138 if err != nil { 139 return err 140 } 141 err = env.AddBuiltin("v1alpha1.ui_bool_input_spec", p.uIBoolInputSpec) 142 if err != nil { 143 return err 144 } 145 err = env.AddBuiltin("v1alpha1.ui_choice_input_spec", p.uIChoiceInputSpec) 146 if err != nil { 147 return err 148 } 149 err = env.AddBuiltin("v1alpha1.ui_component_location", p.uIComponentLocation) 150 if err != nil { 151 return err 152 } 153 err = env.AddBuiltin("v1alpha1.ui_hidden_input_spec", p.uIHiddenInputSpec) 154 if err != nil { 155 return err 156 } 157 err = env.AddBuiltin("v1alpha1.ui_input_spec", p.uIInputSpec) 158 if err != nil { 159 return err 160 } 161 err = env.AddBuiltin("v1alpha1.ui_text_input_spec", p.uITextInputSpec) 162 if err != nil { 163 return err 164 } 165 return nil 166 } 167 func (p Plugin) cmd(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) { 168 var err error 169 obj := &v1alpha1.Cmd{ 170 ObjectMeta: metav1.ObjectMeta{}, 171 Spec: v1alpha1.CmdSpec{}, 172 } 173 var specArgs value.StringList 174 var dir value.LocalPath = value.NewLocalPathUnpacker(t) 175 err = dir.Unpack(starlark.String("")) 176 if err != nil { 177 return nil, err 178 } 179 180 var env value.StringList 181 var readinessProbe Probe = Probe{t: t} 182 var restartOn RestartOnSpec = RestartOnSpec{t: t} 183 var startOn StartOnSpec = StartOnSpec{t: t} 184 var disableSource DisableSource = DisableSource{t: t} 185 var labels value.StringStringMap 186 var annotations value.StringStringMap 187 err = starkit.UnpackArgs(t, fn.Name(), args, kwargs, 188 "name", &obj.ObjectMeta.Name, 189 "labels?", &labels, 190 "annotations?", &annotations, 191 "args?", &specArgs, 192 "dir?", &dir, 193 "env?", &env, 194 "readiness_probe?", &readinessProbe, 195 "restart_on?", &restartOn, 196 "start_on?", &startOn, 197 "disable_source?", &disableSource, 198 ) 199 if err != nil { 200 return nil, err 201 } 202 203 obj.Spec.Args = specArgs 204 obj.Spec.Dir = dir.Value 205 obj.Spec.Env = env 206 if readinessProbe.isUnpacked { 207 obj.Spec.ReadinessProbe = (*v1alpha1.Probe)(&readinessProbe.Value) 208 } 209 if restartOn.isUnpacked { 210 obj.Spec.RestartOn = (*v1alpha1.RestartOnSpec)(&restartOn.Value) 211 } 212 if startOn.isUnpacked { 213 obj.Spec.StartOn = (*v1alpha1.StartOnSpec)(&startOn.Value) 214 } 215 if disableSource.isUnpacked { 216 obj.Spec.DisableSource = (*v1alpha1.DisableSource)(&disableSource.Value) 217 } 218 obj.ObjectMeta.Labels = labels 219 obj.ObjectMeta.Annotations = annotations 220 return p.register(t, obj) 221 } 222 223 func (p Plugin) configMap(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) { 224 var err error 225 obj := &v1alpha1.ConfigMap{ 226 ObjectMeta: metav1.ObjectMeta{}, 227 } 228 var data value.StringStringMap 229 var labels value.StringStringMap 230 var annotations value.StringStringMap 231 err = starkit.UnpackArgs(t, fn.Name(), args, kwargs, 232 "name", &obj.ObjectMeta.Name, 233 "labels?", &labels, 234 "annotations?", &annotations, 235 "data?", &data, 236 ) 237 if err != nil { 238 return nil, err 239 } 240 241 obj.Data = data 242 obj.ObjectMeta.Labels = labels 243 obj.ObjectMeta.Annotations = annotations 244 return p.register(t, obj) 245 } 246 247 func (p Plugin) extension(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) { 248 var err error 249 obj := &v1alpha1.Extension{ 250 ObjectMeta: metav1.ObjectMeta{}, 251 Spec: v1alpha1.ExtensionSpec{}, 252 } 253 var specArgs value.StringList 254 var labels value.StringStringMap 255 var annotations value.StringStringMap 256 err = starkit.UnpackArgs(t, fn.Name(), args, kwargs, 257 "name", &obj.ObjectMeta.Name, 258 "labels?", &labels, 259 "annotations?", &annotations, 260 "repo_name?", &obj.Spec.RepoName, 261 "repo_path?", &obj.Spec.RepoPath, 262 "args?", &specArgs, 263 ) 264 if err != nil { 265 return nil, err 266 } 267 268 obj.Spec.Args = specArgs 269 obj.ObjectMeta.Labels = labels 270 obj.ObjectMeta.Annotations = annotations 271 return p.register(t, obj) 272 } 273 274 func (p Plugin) extensionRepo(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) { 275 var err error 276 obj := &v1alpha1.ExtensionRepo{ 277 ObjectMeta: metav1.ObjectMeta{}, 278 Spec: v1alpha1.ExtensionRepoSpec{}, 279 } 280 var labels value.StringStringMap 281 var annotations value.StringStringMap 282 err = starkit.UnpackArgs(t, fn.Name(), args, kwargs, 283 "name", &obj.ObjectMeta.Name, 284 "labels?", &labels, 285 "annotations?", &annotations, 286 "url?", &obj.Spec.URL, 287 "ref?", &obj.Spec.Ref, 288 ) 289 if err != nil { 290 return nil, err 291 } 292 293 obj.ObjectMeta.Labels = labels 294 obj.ObjectMeta.Annotations = annotations 295 return p.register(t, obj) 296 } 297 298 func (p Plugin) fileWatch(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) { 299 var err error 300 obj := &v1alpha1.FileWatch{ 301 ObjectMeta: metav1.ObjectMeta{}, 302 Spec: v1alpha1.FileWatchSpec{}, 303 } 304 var watchedPaths value.LocalPathList = value.NewLocalPathListUnpacker(t) 305 var ignores IgnoreDefList = IgnoreDefList{t: t} 306 var disableSource DisableSource = DisableSource{t: t} 307 var labels value.StringStringMap 308 var annotations value.StringStringMap 309 err = starkit.UnpackArgs(t, fn.Name(), args, kwargs, 310 "name", &obj.ObjectMeta.Name, 311 "labels?", &labels, 312 "annotations?", &annotations, 313 "watched_paths?", &watchedPaths, 314 "ignores?", &ignores, 315 "disable_source?", &disableSource, 316 ) 317 if err != nil { 318 return nil, err 319 } 320 321 obj.Spec.WatchedPaths = watchedPaths.Value 322 obj.Spec.Ignores = ignores.Value 323 if disableSource.isUnpacked { 324 obj.Spec.DisableSource = (*v1alpha1.DisableSource)(&disableSource.Value) 325 } 326 obj.ObjectMeta.Labels = labels 327 obj.ObjectMeta.Annotations = annotations 328 return p.register(t, obj) 329 } 330 331 func (p Plugin) kubernetesApply(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) { 332 var err error 333 obj := &v1alpha1.KubernetesApply{ 334 ObjectMeta: metav1.ObjectMeta{}, 335 Spec: v1alpha1.KubernetesApplySpec{}, 336 } 337 var imageMaps value.StringList 338 var imageLocators KubernetesImageLocatorList = KubernetesImageLocatorList{t: t} 339 var timeout value.Duration 340 var kubernetesDiscoveryTemplateSpec KubernetesDiscoveryTemplateSpec = KubernetesDiscoveryTemplateSpec{t: t} 341 var portForwardTemplateSpec PortForwardTemplateSpec = PortForwardTemplateSpec{t: t} 342 var podLogStreamTemplateSpec PodLogStreamTemplateSpec = PodLogStreamTemplateSpec{t: t} 343 var discoveryStrategy string 344 var disableSource DisableSource = DisableSource{t: t} 345 var applyCmd KubernetesApplyCmd = KubernetesApplyCmd{t: t} 346 var restartOn RestartOnSpec = RestartOnSpec{t: t} 347 var deleteCmd KubernetesApplyCmd = KubernetesApplyCmd{t: t} 348 var labels value.StringStringMap 349 var annotations value.StringStringMap 350 err = starkit.UnpackArgs(t, fn.Name(), args, kwargs, 351 "name", &obj.ObjectMeta.Name, 352 "labels?", &labels, 353 "annotations?", &annotations, 354 "yaml?", &obj.Spec.YAML, 355 "image_maps?", &imageMaps, 356 "image_locators?", &imageLocators, 357 "timeout?", &timeout, 358 "kubernetes_discovery_template_spec?", &kubernetesDiscoveryTemplateSpec, 359 "port_forward_template_spec?", &portForwardTemplateSpec, 360 "pod_log_stream_template_spec?", &podLogStreamTemplateSpec, 361 "discovery_strategy?", &discoveryStrategy, 362 "disable_source?", &disableSource, 363 "apply_cmd?", &applyCmd, 364 "restart_on?", &restartOn, 365 "delete_cmd?", &deleteCmd, 366 "cluster?", &obj.Spec.Cluster, 367 ) 368 if err != nil { 369 return nil, err 370 } 371 372 obj.Spec.ImageMaps = imageMaps 373 obj.Spec.ImageLocators = imageLocators.Value 374 obj.Spec.Timeout = metav1.Duration{Duration: time.Duration(timeout)} 375 if kubernetesDiscoveryTemplateSpec.isUnpacked { 376 obj.Spec.KubernetesDiscoveryTemplateSpec = (*v1alpha1.KubernetesDiscoveryTemplateSpec)(&kubernetesDiscoveryTemplateSpec.Value) 377 } 378 if portForwardTemplateSpec.isUnpacked { 379 obj.Spec.PortForwardTemplateSpec = (*v1alpha1.PortForwardTemplateSpec)(&portForwardTemplateSpec.Value) 380 } 381 if podLogStreamTemplateSpec.isUnpacked { 382 obj.Spec.PodLogStreamTemplateSpec = (*v1alpha1.PodLogStreamTemplateSpec)(&podLogStreamTemplateSpec.Value) 383 } 384 obj.Spec.DiscoveryStrategy = v1alpha1.KubernetesDiscoveryStrategy(discoveryStrategy) 385 if disableSource.isUnpacked { 386 obj.Spec.DisableSource = (*v1alpha1.DisableSource)(&disableSource.Value) 387 } 388 if applyCmd.isUnpacked { 389 obj.Spec.ApplyCmd = (*v1alpha1.KubernetesApplyCmd)(&applyCmd.Value) 390 } 391 if restartOn.isUnpacked { 392 obj.Spec.RestartOn = (*v1alpha1.RestartOnSpec)(&restartOn.Value) 393 } 394 if deleteCmd.isUnpacked { 395 obj.Spec.DeleteCmd = (*v1alpha1.KubernetesApplyCmd)(&deleteCmd.Value) 396 } 397 obj.ObjectMeta.Labels = labels 398 obj.ObjectMeta.Annotations = annotations 399 return p.register(t, obj) 400 } 401 402 func (p Plugin) kubernetesDiscovery(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) { 403 var err error 404 obj := &v1alpha1.KubernetesDiscovery{ 405 ObjectMeta: metav1.ObjectMeta{}, 406 Spec: v1alpha1.KubernetesDiscoverySpec{}, 407 } 408 var watches KubernetesWatchRefList = KubernetesWatchRefList{t: t} 409 var extraSelectors LabelSelectorList = LabelSelectorList{t: t} 410 var portForwardTemplateSpec PortForwardTemplateSpec = PortForwardTemplateSpec{t: t} 411 var podLogStreamTemplateSpec PodLogStreamTemplateSpec = PodLogStreamTemplateSpec{t: t} 412 var labels value.StringStringMap 413 var annotations value.StringStringMap 414 err = starkit.UnpackArgs(t, fn.Name(), args, kwargs, 415 "name", &obj.ObjectMeta.Name, 416 "labels?", &labels, 417 "annotations?", &annotations, 418 "watches?", &watches, 419 "extra_selectors?", &extraSelectors, 420 "port_forward_template_spec?", &portForwardTemplateSpec, 421 "pod_log_stream_template_spec?", &podLogStreamTemplateSpec, 422 "cluster?", &obj.Spec.Cluster, 423 ) 424 if err != nil { 425 return nil, err 426 } 427 428 obj.Spec.Watches = watches.Value 429 obj.Spec.ExtraSelectors = extraSelectors.Value 430 if portForwardTemplateSpec.isUnpacked { 431 obj.Spec.PortForwardTemplateSpec = (*v1alpha1.PortForwardTemplateSpec)(&portForwardTemplateSpec.Value) 432 } 433 if podLogStreamTemplateSpec.isUnpacked { 434 obj.Spec.PodLogStreamTemplateSpec = (*v1alpha1.PodLogStreamTemplateSpec)(&podLogStreamTemplateSpec.Value) 435 } 436 obj.ObjectMeta.Labels = labels 437 obj.ObjectMeta.Annotations = annotations 438 return p.register(t, obj) 439 } 440 441 func (p Plugin) uiButton(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) { 442 var err error 443 obj := &v1alpha1.UIButton{ 444 ObjectMeta: metav1.ObjectMeta{}, 445 Spec: v1alpha1.UIButtonSpec{}, 446 } 447 var location UIComponentLocation = UIComponentLocation{t: t} 448 var inputs UIInputSpecList = UIInputSpecList{t: t} 449 var labels value.StringStringMap 450 var annotations value.StringStringMap 451 err = starkit.UnpackArgs(t, fn.Name(), args, kwargs, 452 "name", &obj.ObjectMeta.Name, 453 "labels?", &labels, 454 "annotations?", &annotations, 455 "location?", &location, 456 "text?", &obj.Spec.Text, 457 "icon_name?", &obj.Spec.IconName, 458 "icon_svg?", &obj.Spec.IconSVG, 459 "disabled?", &obj.Spec.Disabled, 460 "requires_confirmation?", &obj.Spec.RequiresConfirmation, 461 "inputs?", &inputs, 462 ) 463 if err != nil { 464 return nil, err 465 } 466 467 obj.Spec.Location = v1alpha1.UIComponentLocation(location.Value) 468 obj.Spec.Inputs = inputs.Value 469 obj.ObjectMeta.Labels = labels 470 obj.ObjectMeta.Annotations = annotations 471 return p.register(t, obj) 472 } 473 474 type ConfigMapDisableSource struct { 475 *starlark.Dict 476 Value v1alpha1.ConfigMapDisableSource 477 isUnpacked bool 478 t *starlark.Thread // instantiation thread for computing abspath 479 } 480 481 func (p Plugin) configMapDisableSource(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) { 482 var name starlark.Value 483 var key starlark.Value 484 err := starkit.UnpackArgs(t, fn.Name(), args, kwargs, 485 "name?", &name, 486 "key?", &key, 487 ) 488 if err != nil { 489 return nil, err 490 } 491 492 dict := starlark.NewDict(2) 493 494 if name != nil { 495 err := dict.SetKey(starlark.String("name"), name) 496 if err != nil { 497 return nil, err 498 } 499 } 500 if key != nil { 501 err := dict.SetKey(starlark.String("key"), key) 502 if err != nil { 503 return nil, err 504 } 505 } 506 var obj *ConfigMapDisableSource = &ConfigMapDisableSource{t: t} 507 err = obj.Unpack(dict) 508 if err != nil { 509 return nil, err 510 } 511 return obj, nil 512 } 513 514 func (o *ConfigMapDisableSource) Unpack(v starlark.Value) error { 515 obj := v1alpha1.ConfigMapDisableSource{} 516 517 starlarkObj, ok := v.(*ConfigMapDisableSource) 518 if ok { 519 *o = *starlarkObj 520 return nil 521 } 522 523 mapObj, ok := v.(*starlark.Dict) 524 if !ok { 525 return fmt.Errorf("expected dict, actual: %v", v.Type()) 526 } 527 528 for _, item := range mapObj.Items() { 529 keyV, val := item[0], item[1] 530 key, ok := starlark.AsString(keyV) 531 if !ok { 532 return fmt.Errorf("key must be string. Got: %s", keyV.Type()) 533 } 534 535 if key == "name" { 536 v, ok := starlark.AsString(val) 537 if !ok { 538 return fmt.Errorf("Expected string, actual: %s", val.Type()) 539 } 540 obj.Name = string(v) 541 continue 542 } 543 if key == "key" { 544 v, ok := starlark.AsString(val) 545 if !ok { 546 return fmt.Errorf("Expected string, actual: %s", val.Type()) 547 } 548 obj.Key = string(v) 549 continue 550 } 551 return fmt.Errorf("Unexpected attribute name: %s", key) 552 } 553 554 mapObj.Freeze() 555 o.Dict = mapObj 556 o.Value = obj 557 o.isUnpacked = true 558 559 return nil 560 } 561 562 type ConfigMapDisableSourceList struct { 563 *starlark.List 564 Value []v1alpha1.ConfigMapDisableSource 565 t *starlark.Thread 566 } 567 568 func (o *ConfigMapDisableSourceList) Unpack(v starlark.Value) error { 569 items := []v1alpha1.ConfigMapDisableSource{} 570 571 listObj, ok := v.(*starlark.List) 572 if !ok { 573 return fmt.Errorf("expected list, actual: %v", v.Type()) 574 } 575 576 for i := 0; i < listObj.Len(); i++ { 577 v := listObj.Index(i) 578 579 item := ConfigMapDisableSource{t: o.t} 580 err := item.Unpack(v) 581 if err != nil { 582 return fmt.Errorf("at index %d: %v", i, err) 583 } 584 items = append(items, v1alpha1.ConfigMapDisableSource(item.Value)) 585 } 586 587 listObj.Freeze() 588 o.List = listObj 589 o.Value = items 590 591 return nil 592 } 593 594 type DisableSource struct { 595 *starlark.Dict 596 Value v1alpha1.DisableSource 597 isUnpacked bool 598 t *starlark.Thread // instantiation thread for computing abspath 599 } 600 601 func (p Plugin) disableSource(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) { 602 var configMap starlark.Value 603 var everyConfigMap starlark.Value 604 err := starkit.UnpackArgs(t, fn.Name(), args, kwargs, 605 "config_map?", &configMap, 606 "every_config_map?", &everyConfigMap, 607 ) 608 if err != nil { 609 return nil, err 610 } 611 612 dict := starlark.NewDict(2) 613 614 if configMap != nil { 615 err := dict.SetKey(starlark.String("config_map"), configMap) 616 if err != nil { 617 return nil, err 618 } 619 } 620 if everyConfigMap != nil { 621 err := dict.SetKey(starlark.String("every_config_map"), everyConfigMap) 622 if err != nil { 623 return nil, err 624 } 625 } 626 var obj *DisableSource = &DisableSource{t: t} 627 err = obj.Unpack(dict) 628 if err != nil { 629 return nil, err 630 } 631 return obj, nil 632 } 633 634 func (o *DisableSource) Unpack(v starlark.Value) error { 635 obj := v1alpha1.DisableSource{} 636 637 starlarkObj, ok := v.(*DisableSource) 638 if ok { 639 *o = *starlarkObj 640 return nil 641 } 642 643 mapObj, ok := v.(*starlark.Dict) 644 if !ok { 645 return fmt.Errorf("expected dict, actual: %v", v.Type()) 646 } 647 648 for _, item := range mapObj.Items() { 649 keyV, val := item[0], item[1] 650 key, ok := starlark.AsString(keyV) 651 if !ok { 652 return fmt.Errorf("key must be string. Got: %s", keyV.Type()) 653 } 654 655 if key == "config_map" { 656 v := ConfigMapDisableSource{t: o.t} 657 err := v.Unpack(val) 658 if err != nil { 659 return fmt.Errorf("unpacking %s: %v", key, err) 660 } 661 obj.ConfigMap = (*v1alpha1.ConfigMapDisableSource)(&v.Value) 662 continue 663 } 664 if key == "every_config_map" { 665 v := ConfigMapDisableSourceList{t: o.t} 666 err := v.Unpack(val) 667 if err != nil { 668 return fmt.Errorf("unpacking %s: %v", key, err) 669 } 670 obj.EveryConfigMap = v.Value 671 continue 672 } 673 return fmt.Errorf("Unexpected attribute name: %s", key) 674 } 675 676 mapObj.Freeze() 677 o.Dict = mapObj 678 o.Value = obj 679 o.isUnpacked = true 680 681 return nil 682 } 683 684 type DisableSourceList struct { 685 *starlark.List 686 Value []v1alpha1.DisableSource 687 t *starlark.Thread 688 } 689 690 func (o *DisableSourceList) Unpack(v starlark.Value) error { 691 items := []v1alpha1.DisableSource{} 692 693 listObj, ok := v.(*starlark.List) 694 if !ok { 695 return fmt.Errorf("expected list, actual: %v", v.Type()) 696 } 697 698 for i := 0; i < listObj.Len(); i++ { 699 v := listObj.Index(i) 700 701 item := DisableSource{t: o.t} 702 err := item.Unpack(v) 703 if err != nil { 704 return fmt.Errorf("at index %d: %v", i, err) 705 } 706 items = append(items, v1alpha1.DisableSource(item.Value)) 707 } 708 709 listObj.Freeze() 710 o.List = listObj 711 o.Value = items 712 713 return nil 714 } 715 716 type ExecAction struct { 717 *starlark.Dict 718 Value v1alpha1.ExecAction 719 isUnpacked bool 720 t *starlark.Thread // instantiation thread for computing abspath 721 } 722 723 func (p Plugin) execAction(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) { 724 var command starlark.Value 725 err := starkit.UnpackArgs(t, fn.Name(), args, kwargs, 726 "command?", &command, 727 ) 728 if err != nil { 729 return nil, err 730 } 731 732 dict := starlark.NewDict(1) 733 734 if command != nil { 735 err := dict.SetKey(starlark.String("command"), command) 736 if err != nil { 737 return nil, err 738 } 739 } 740 var obj *ExecAction = &ExecAction{t: t} 741 err = obj.Unpack(dict) 742 if err != nil { 743 return nil, err 744 } 745 return obj, nil 746 } 747 748 func (o *ExecAction) Unpack(v starlark.Value) error { 749 obj := v1alpha1.ExecAction{} 750 751 starlarkObj, ok := v.(*ExecAction) 752 if ok { 753 *o = *starlarkObj 754 return nil 755 } 756 757 mapObj, ok := v.(*starlark.Dict) 758 if !ok { 759 return fmt.Errorf("expected dict, actual: %v", v.Type()) 760 } 761 762 for _, item := range mapObj.Items() { 763 keyV, val := item[0], item[1] 764 key, ok := starlark.AsString(keyV) 765 if !ok { 766 return fmt.Errorf("key must be string. Got: %s", keyV.Type()) 767 } 768 769 if key == "command" { 770 var v value.StringList 771 err := v.Unpack(val) 772 if err != nil { 773 return fmt.Errorf("unpacking %s: %v", key, err) 774 } 775 obj.Command = v 776 continue 777 } 778 return fmt.Errorf("Unexpected attribute name: %s", key) 779 } 780 781 mapObj.Freeze() 782 o.Dict = mapObj 783 o.Value = obj 784 o.isUnpacked = true 785 786 return nil 787 } 788 789 type ExecActionList struct { 790 *starlark.List 791 Value []v1alpha1.ExecAction 792 t *starlark.Thread 793 } 794 795 func (o *ExecActionList) Unpack(v starlark.Value) error { 796 items := []v1alpha1.ExecAction{} 797 798 listObj, ok := v.(*starlark.List) 799 if !ok { 800 return fmt.Errorf("expected list, actual: %v", v.Type()) 801 } 802 803 for i := 0; i < listObj.Len(); i++ { 804 v := listObj.Index(i) 805 806 item := ExecAction{t: o.t} 807 err := item.Unpack(v) 808 if err != nil { 809 return fmt.Errorf("at index %d: %v", i, err) 810 } 811 items = append(items, v1alpha1.ExecAction(item.Value)) 812 } 813 814 listObj.Freeze() 815 o.List = listObj 816 o.Value = items 817 818 return nil 819 } 820 821 type Forward struct { 822 *starlark.Dict 823 Value v1alpha1.Forward 824 isUnpacked bool 825 t *starlark.Thread // instantiation thread for computing abspath 826 } 827 828 func (p Plugin) forward(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) { 829 var localPort starlark.Value 830 var containerPort starlark.Value 831 var host starlark.Value 832 var name starlark.Value 833 var path starlark.Value 834 err := starkit.UnpackArgs(t, fn.Name(), args, kwargs, 835 "local_port?", &localPort, 836 "container_port?", &containerPort, 837 "host?", &host, 838 "name?", &name, 839 "path?", &path, 840 ) 841 if err != nil { 842 return nil, err 843 } 844 845 dict := starlark.NewDict(5) 846 847 if localPort != nil { 848 err := dict.SetKey(starlark.String("local_port"), localPort) 849 if err != nil { 850 return nil, err 851 } 852 } 853 if containerPort != nil { 854 err := dict.SetKey(starlark.String("container_port"), containerPort) 855 if err != nil { 856 return nil, err 857 } 858 } 859 if host != nil { 860 err := dict.SetKey(starlark.String("host"), host) 861 if err != nil { 862 return nil, err 863 } 864 } 865 if name != nil { 866 err := dict.SetKey(starlark.String("name"), name) 867 if err != nil { 868 return nil, err 869 } 870 } 871 if path != nil { 872 err := dict.SetKey(starlark.String("path"), path) 873 if err != nil { 874 return nil, err 875 } 876 } 877 var obj *Forward = &Forward{t: t} 878 err = obj.Unpack(dict) 879 if err != nil { 880 return nil, err 881 } 882 return obj, nil 883 } 884 885 func (o *Forward) Unpack(v starlark.Value) error { 886 obj := v1alpha1.Forward{} 887 888 starlarkObj, ok := v.(*Forward) 889 if ok { 890 *o = *starlarkObj 891 return nil 892 } 893 894 mapObj, ok := v.(*starlark.Dict) 895 if !ok { 896 return fmt.Errorf("expected dict, actual: %v", v.Type()) 897 } 898 899 for _, item := range mapObj.Items() { 900 keyV, val := item[0], item[1] 901 key, ok := starlark.AsString(keyV) 902 if !ok { 903 return fmt.Errorf("key must be string. Got: %s", keyV.Type()) 904 } 905 906 if key == "local_port" { 907 v, err := starlark.AsInt32(val) 908 if err != nil { 909 return fmt.Errorf("Expected int, got: %v", err) 910 } 911 obj.LocalPort = int32(v) 912 continue 913 } 914 if key == "container_port" { 915 v, err := starlark.AsInt32(val) 916 if err != nil { 917 return fmt.Errorf("Expected int, got: %v", err) 918 } 919 obj.ContainerPort = int32(v) 920 continue 921 } 922 if key == "host" { 923 v, ok := starlark.AsString(val) 924 if !ok { 925 return fmt.Errorf("Expected string, actual: %s", val.Type()) 926 } 927 obj.Host = string(v) 928 continue 929 } 930 if key == "name" { 931 v, ok := starlark.AsString(val) 932 if !ok { 933 return fmt.Errorf("Expected string, actual: %s", val.Type()) 934 } 935 obj.Name = string(v) 936 continue 937 } 938 if key == "path" { 939 v, ok := starlark.AsString(val) 940 if !ok { 941 return fmt.Errorf("Expected string, actual: %s", val.Type()) 942 } 943 obj.Path = string(v) 944 continue 945 } 946 return fmt.Errorf("Unexpected attribute name: %s", key) 947 } 948 949 mapObj.Freeze() 950 o.Dict = mapObj 951 o.Value = obj 952 o.isUnpacked = true 953 954 return nil 955 } 956 957 type ForwardList struct { 958 *starlark.List 959 Value []v1alpha1.Forward 960 t *starlark.Thread 961 } 962 963 func (o *ForwardList) Unpack(v starlark.Value) error { 964 items := []v1alpha1.Forward{} 965 966 listObj, ok := v.(*starlark.List) 967 if !ok { 968 return fmt.Errorf("expected list, actual: %v", v.Type()) 969 } 970 971 for i := 0; i < listObj.Len(); i++ { 972 v := listObj.Index(i) 973 974 item := Forward{t: o.t} 975 err := item.Unpack(v) 976 if err != nil { 977 return fmt.Errorf("at index %d: %v", i, err) 978 } 979 items = append(items, v1alpha1.Forward(item.Value)) 980 } 981 982 listObj.Freeze() 983 o.List = listObj 984 o.Value = items 985 986 return nil 987 } 988 989 type HTTPGetAction struct { 990 *starlark.Dict 991 Value v1alpha1.HTTPGetAction 992 isUnpacked bool 993 t *starlark.Thread // instantiation thread for computing abspath 994 } 995 996 func (p Plugin) hTTPGetAction(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) { 997 var path starlark.Value 998 var port starlark.Value 999 var host starlark.Value 1000 var scheme starlark.Value 1001 var hTTPHeaders starlark.Value 1002 err := starkit.UnpackArgs(t, fn.Name(), args, kwargs, 1003 "path?", &path, 1004 "port?", &port, 1005 "host?", &host, 1006 "scheme?", &scheme, 1007 "http_headers?", &hTTPHeaders, 1008 ) 1009 if err != nil { 1010 return nil, err 1011 } 1012 1013 dict := starlark.NewDict(5) 1014 1015 if path != nil { 1016 err := dict.SetKey(starlark.String("path"), path) 1017 if err != nil { 1018 return nil, err 1019 } 1020 } 1021 if port != nil { 1022 err := dict.SetKey(starlark.String("port"), port) 1023 if err != nil { 1024 return nil, err 1025 } 1026 } 1027 if host != nil { 1028 err := dict.SetKey(starlark.String("host"), host) 1029 if err != nil { 1030 return nil, err 1031 } 1032 } 1033 if scheme != nil { 1034 err := dict.SetKey(starlark.String("scheme"), scheme) 1035 if err != nil { 1036 return nil, err 1037 } 1038 } 1039 if hTTPHeaders != nil { 1040 err := dict.SetKey(starlark.String("http_headers"), hTTPHeaders) 1041 if err != nil { 1042 return nil, err 1043 } 1044 } 1045 var obj *HTTPGetAction = &HTTPGetAction{t: t} 1046 err = obj.Unpack(dict) 1047 if err != nil { 1048 return nil, err 1049 } 1050 return obj, nil 1051 } 1052 1053 func (o *HTTPGetAction) Unpack(v starlark.Value) error { 1054 obj := v1alpha1.HTTPGetAction{} 1055 1056 starlarkObj, ok := v.(*HTTPGetAction) 1057 if ok { 1058 *o = *starlarkObj 1059 return nil 1060 } 1061 1062 mapObj, ok := v.(*starlark.Dict) 1063 if !ok { 1064 return fmt.Errorf("expected dict, actual: %v", v.Type()) 1065 } 1066 1067 for _, item := range mapObj.Items() { 1068 keyV, val := item[0], item[1] 1069 key, ok := starlark.AsString(keyV) 1070 if !ok { 1071 return fmt.Errorf("key must be string. Got: %s", keyV.Type()) 1072 } 1073 1074 if key == "path" { 1075 v, ok := starlark.AsString(val) 1076 if !ok { 1077 return fmt.Errorf("Expected string, actual: %s", val.Type()) 1078 } 1079 obj.Path = string(v) 1080 continue 1081 } 1082 if key == "port" { 1083 v, err := starlark.AsInt32(val) 1084 if err != nil { 1085 return fmt.Errorf("Expected int, got: %v", err) 1086 } 1087 obj.Port = int32(v) 1088 continue 1089 } 1090 if key == "host" { 1091 v, ok := starlark.AsString(val) 1092 if !ok { 1093 return fmt.Errorf("Expected string, actual: %s", val.Type()) 1094 } 1095 obj.Host = string(v) 1096 continue 1097 } 1098 if key == "scheme" { 1099 v, ok := starlark.AsString(val) 1100 if !ok { 1101 return fmt.Errorf("Expected string, actual: %s", val.Type()) 1102 } 1103 obj.Scheme = v1alpha1.URIScheme(v) 1104 continue 1105 } 1106 if key == "http_headers" { 1107 v := HTTPHeaderList{t: o.t} 1108 err := v.Unpack(val) 1109 if err != nil { 1110 return fmt.Errorf("unpacking %s: %v", key, err) 1111 } 1112 obj.HTTPHeaders = v.Value 1113 continue 1114 } 1115 return fmt.Errorf("Unexpected attribute name: %s", key) 1116 } 1117 1118 mapObj.Freeze() 1119 o.Dict = mapObj 1120 o.Value = obj 1121 o.isUnpacked = true 1122 1123 return nil 1124 } 1125 1126 type HTTPGetActionList struct { 1127 *starlark.List 1128 Value []v1alpha1.HTTPGetAction 1129 t *starlark.Thread 1130 } 1131 1132 func (o *HTTPGetActionList) Unpack(v starlark.Value) error { 1133 items := []v1alpha1.HTTPGetAction{} 1134 1135 listObj, ok := v.(*starlark.List) 1136 if !ok { 1137 return fmt.Errorf("expected list, actual: %v", v.Type()) 1138 } 1139 1140 for i := 0; i < listObj.Len(); i++ { 1141 v := listObj.Index(i) 1142 1143 item := HTTPGetAction{t: o.t} 1144 err := item.Unpack(v) 1145 if err != nil { 1146 return fmt.Errorf("at index %d: %v", i, err) 1147 } 1148 items = append(items, v1alpha1.HTTPGetAction(item.Value)) 1149 } 1150 1151 listObj.Freeze() 1152 o.List = listObj 1153 o.Value = items 1154 1155 return nil 1156 } 1157 1158 type HTTPHeader struct { 1159 *starlark.Dict 1160 Value v1alpha1.HTTPHeader 1161 isUnpacked bool 1162 t *starlark.Thread // instantiation thread for computing abspath 1163 } 1164 1165 func (p Plugin) hTTPHeader(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) { 1166 var name starlark.Value 1167 var value starlark.Value 1168 err := starkit.UnpackArgs(t, fn.Name(), args, kwargs, 1169 "name?", &name, 1170 "value?", &value, 1171 ) 1172 if err != nil { 1173 return nil, err 1174 } 1175 1176 dict := starlark.NewDict(2) 1177 1178 if name != nil { 1179 err := dict.SetKey(starlark.String("name"), name) 1180 if err != nil { 1181 return nil, err 1182 } 1183 } 1184 if value != nil { 1185 err := dict.SetKey(starlark.String("value"), value) 1186 if err != nil { 1187 return nil, err 1188 } 1189 } 1190 var obj *HTTPHeader = &HTTPHeader{t: t} 1191 err = obj.Unpack(dict) 1192 if err != nil { 1193 return nil, err 1194 } 1195 return obj, nil 1196 } 1197 1198 func (o *HTTPHeader) Unpack(v starlark.Value) error { 1199 obj := v1alpha1.HTTPHeader{} 1200 1201 starlarkObj, ok := v.(*HTTPHeader) 1202 if ok { 1203 *o = *starlarkObj 1204 return nil 1205 } 1206 1207 mapObj, ok := v.(*starlark.Dict) 1208 if !ok { 1209 return fmt.Errorf("expected dict, actual: %v", v.Type()) 1210 } 1211 1212 for _, item := range mapObj.Items() { 1213 keyV, val := item[0], item[1] 1214 key, ok := starlark.AsString(keyV) 1215 if !ok { 1216 return fmt.Errorf("key must be string. Got: %s", keyV.Type()) 1217 } 1218 1219 if key == "name" { 1220 v, ok := starlark.AsString(val) 1221 if !ok { 1222 return fmt.Errorf("Expected string, actual: %s", val.Type()) 1223 } 1224 obj.Name = string(v) 1225 continue 1226 } 1227 if key == "value" { 1228 v, ok := starlark.AsString(val) 1229 if !ok { 1230 return fmt.Errorf("Expected string, actual: %s", val.Type()) 1231 } 1232 obj.Value = string(v) 1233 continue 1234 } 1235 return fmt.Errorf("Unexpected attribute name: %s", key) 1236 } 1237 1238 mapObj.Freeze() 1239 o.Dict = mapObj 1240 o.Value = obj 1241 o.isUnpacked = true 1242 1243 return nil 1244 } 1245 1246 type HTTPHeaderList struct { 1247 *starlark.List 1248 Value []v1alpha1.HTTPHeader 1249 t *starlark.Thread 1250 } 1251 1252 func (o *HTTPHeaderList) Unpack(v starlark.Value) error { 1253 items := []v1alpha1.HTTPHeader{} 1254 1255 listObj, ok := v.(*starlark.List) 1256 if !ok { 1257 return fmt.Errorf("expected list, actual: %v", v.Type()) 1258 } 1259 1260 for i := 0; i < listObj.Len(); i++ { 1261 v := listObj.Index(i) 1262 1263 item := HTTPHeader{t: o.t} 1264 err := item.Unpack(v) 1265 if err != nil { 1266 return fmt.Errorf("at index %d: %v", i, err) 1267 } 1268 items = append(items, v1alpha1.HTTPHeader(item.Value)) 1269 } 1270 1271 listObj.Freeze() 1272 o.List = listObj 1273 o.Value = items 1274 1275 return nil 1276 } 1277 1278 type Handler struct { 1279 *starlark.Dict 1280 Value v1alpha1.Handler 1281 isUnpacked bool 1282 t *starlark.Thread // instantiation thread for computing abspath 1283 } 1284 1285 func (p Plugin) handler(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) { 1286 var exec starlark.Value 1287 var hTTPGet starlark.Value 1288 var tCPSocket starlark.Value 1289 err := starkit.UnpackArgs(t, fn.Name(), args, kwargs, 1290 "exec?", &exec, 1291 "http_get?", &hTTPGet, 1292 "tcp_socket?", &tCPSocket, 1293 ) 1294 if err != nil { 1295 return nil, err 1296 } 1297 1298 dict := starlark.NewDict(3) 1299 1300 if exec != nil { 1301 err := dict.SetKey(starlark.String("exec"), exec) 1302 if err != nil { 1303 return nil, err 1304 } 1305 } 1306 if hTTPGet != nil { 1307 err := dict.SetKey(starlark.String("http_get"), hTTPGet) 1308 if err != nil { 1309 return nil, err 1310 } 1311 } 1312 if tCPSocket != nil { 1313 err := dict.SetKey(starlark.String("tcp_socket"), tCPSocket) 1314 if err != nil { 1315 return nil, err 1316 } 1317 } 1318 var obj *Handler = &Handler{t: t} 1319 err = obj.Unpack(dict) 1320 if err != nil { 1321 return nil, err 1322 } 1323 return obj, nil 1324 } 1325 1326 func (o *Handler) Unpack(v starlark.Value) error { 1327 obj := v1alpha1.Handler{} 1328 1329 starlarkObj, ok := v.(*Handler) 1330 if ok { 1331 *o = *starlarkObj 1332 return nil 1333 } 1334 1335 mapObj, ok := v.(*starlark.Dict) 1336 if !ok { 1337 return fmt.Errorf("expected dict, actual: %v", v.Type()) 1338 } 1339 1340 for _, item := range mapObj.Items() { 1341 keyV, val := item[0], item[1] 1342 key, ok := starlark.AsString(keyV) 1343 if !ok { 1344 return fmt.Errorf("key must be string. Got: %s", keyV.Type()) 1345 } 1346 1347 if key == "exec" { 1348 v := ExecAction{t: o.t} 1349 err := v.Unpack(val) 1350 if err != nil { 1351 return fmt.Errorf("unpacking %s: %v", key, err) 1352 } 1353 obj.Exec = (*v1alpha1.ExecAction)(&v.Value) 1354 continue 1355 } 1356 if key == "http_get" { 1357 v := HTTPGetAction{t: o.t} 1358 err := v.Unpack(val) 1359 if err != nil { 1360 return fmt.Errorf("unpacking %s: %v", key, err) 1361 } 1362 obj.HTTPGet = (*v1alpha1.HTTPGetAction)(&v.Value) 1363 continue 1364 } 1365 if key == "tcp_socket" { 1366 v := TCPSocketAction{t: o.t} 1367 err := v.Unpack(val) 1368 if err != nil { 1369 return fmt.Errorf("unpacking %s: %v", key, err) 1370 } 1371 obj.TCPSocket = (*v1alpha1.TCPSocketAction)(&v.Value) 1372 continue 1373 } 1374 return fmt.Errorf("Unexpected attribute name: %s", key) 1375 } 1376 1377 mapObj.Freeze() 1378 o.Dict = mapObj 1379 o.Value = obj 1380 o.isUnpacked = true 1381 1382 return nil 1383 } 1384 1385 type HandlerList struct { 1386 *starlark.List 1387 Value []v1alpha1.Handler 1388 t *starlark.Thread 1389 } 1390 1391 func (o *HandlerList) Unpack(v starlark.Value) error { 1392 items := []v1alpha1.Handler{} 1393 1394 listObj, ok := v.(*starlark.List) 1395 if !ok { 1396 return fmt.Errorf("expected list, actual: %v", v.Type()) 1397 } 1398 1399 for i := 0; i < listObj.Len(); i++ { 1400 v := listObj.Index(i) 1401 1402 item := Handler{t: o.t} 1403 err := item.Unpack(v) 1404 if err != nil { 1405 return fmt.Errorf("at index %d: %v", i, err) 1406 } 1407 items = append(items, v1alpha1.Handler(item.Value)) 1408 } 1409 1410 listObj.Freeze() 1411 o.List = listObj 1412 o.Value = items 1413 1414 return nil 1415 } 1416 1417 type IgnoreDef struct { 1418 *starlark.Dict 1419 Value v1alpha1.IgnoreDef 1420 isUnpacked bool 1421 t *starlark.Thread // instantiation thread for computing abspath 1422 } 1423 1424 func (p Plugin) ignoreDef(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) { 1425 var basePath starlark.Value 1426 var patterns starlark.Value 1427 err := starkit.UnpackArgs(t, fn.Name(), args, kwargs, 1428 "base_path?", &basePath, 1429 "patterns?", &patterns, 1430 ) 1431 if err != nil { 1432 return nil, err 1433 } 1434 1435 dict := starlark.NewDict(2) 1436 1437 if basePath != nil { 1438 err := dict.SetKey(starlark.String("base_path"), basePath) 1439 if err != nil { 1440 return nil, err 1441 } 1442 } 1443 if patterns != nil { 1444 err := dict.SetKey(starlark.String("patterns"), patterns) 1445 if err != nil { 1446 return nil, err 1447 } 1448 } 1449 var obj *IgnoreDef = &IgnoreDef{t: t} 1450 err = obj.Unpack(dict) 1451 if err != nil { 1452 return nil, err 1453 } 1454 return obj, nil 1455 } 1456 1457 func (o *IgnoreDef) Unpack(v starlark.Value) error { 1458 obj := v1alpha1.IgnoreDef{} 1459 1460 starlarkObj, ok := v.(*IgnoreDef) 1461 if ok { 1462 *o = *starlarkObj 1463 return nil 1464 } 1465 1466 mapObj, ok := v.(*starlark.Dict) 1467 if !ok { 1468 return fmt.Errorf("expected dict, actual: %v", v.Type()) 1469 } 1470 1471 for _, item := range mapObj.Items() { 1472 keyV, val := item[0], item[1] 1473 key, ok := starlark.AsString(keyV) 1474 if !ok { 1475 return fmt.Errorf("key must be string. Got: %s", keyV.Type()) 1476 } 1477 1478 if key == "base_path" { 1479 v := value.NewLocalPathUnpacker(o.t) 1480 err := v.Unpack(val) 1481 if err != nil { 1482 return fmt.Errorf("unpacking %s: %v", key, err) 1483 } 1484 obj.BasePath = v.Value 1485 continue 1486 } 1487 if key == "patterns" { 1488 var v value.StringList 1489 err := v.Unpack(val) 1490 if err != nil { 1491 return fmt.Errorf("unpacking %s: %v", key, err) 1492 } 1493 obj.Patterns = v 1494 continue 1495 } 1496 return fmt.Errorf("Unexpected attribute name: %s", key) 1497 } 1498 1499 mapObj.Freeze() 1500 o.Dict = mapObj 1501 o.Value = obj 1502 o.isUnpacked = true 1503 1504 return nil 1505 } 1506 1507 type IgnoreDefList struct { 1508 *starlark.List 1509 Value []v1alpha1.IgnoreDef 1510 t *starlark.Thread 1511 } 1512 1513 func (o *IgnoreDefList) Unpack(v starlark.Value) error { 1514 items := []v1alpha1.IgnoreDef{} 1515 1516 listObj, ok := v.(*starlark.List) 1517 if !ok { 1518 return fmt.Errorf("expected list, actual: %v", v.Type()) 1519 } 1520 1521 for i := 0; i < listObj.Len(); i++ { 1522 v := listObj.Index(i) 1523 1524 item := IgnoreDef{t: o.t} 1525 err := item.Unpack(v) 1526 if err != nil { 1527 return fmt.Errorf("at index %d: %v", i, err) 1528 } 1529 items = append(items, v1alpha1.IgnoreDef(item.Value)) 1530 } 1531 1532 listObj.Freeze() 1533 o.List = listObj 1534 o.Value = items 1535 1536 return nil 1537 } 1538 1539 type KubernetesApplyCmd struct { 1540 *starlark.Dict 1541 Value v1alpha1.KubernetesApplyCmd 1542 isUnpacked bool 1543 t *starlark.Thread // instantiation thread for computing abspath 1544 } 1545 1546 func (p Plugin) kubernetesApplyCmd(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) { 1547 var specArgs starlark.Value 1548 var dir starlark.Value 1549 var env starlark.Value 1550 err := starkit.UnpackArgs(t, fn.Name(), args, kwargs, 1551 "args?", &specArgs, 1552 "dir?", &dir, 1553 "env?", &env, 1554 ) 1555 if err != nil { 1556 return nil, err 1557 } 1558 1559 dict := starlark.NewDict(3) 1560 1561 if specArgs != nil { 1562 err := dict.SetKey(starlark.String("args"), specArgs) 1563 if err != nil { 1564 return nil, err 1565 } 1566 } 1567 if dir != nil { 1568 err := dict.SetKey(starlark.String("dir"), dir) 1569 if err != nil { 1570 return nil, err 1571 } 1572 } 1573 if env != nil { 1574 err := dict.SetKey(starlark.String("env"), env) 1575 if err != nil { 1576 return nil, err 1577 } 1578 } 1579 var obj *KubernetesApplyCmd = &KubernetesApplyCmd{t: t} 1580 err = obj.Unpack(dict) 1581 if err != nil { 1582 return nil, err 1583 } 1584 return obj, nil 1585 } 1586 1587 func (o *KubernetesApplyCmd) Unpack(v starlark.Value) error { 1588 obj := v1alpha1.KubernetesApplyCmd{} 1589 1590 starlarkObj, ok := v.(*KubernetesApplyCmd) 1591 if ok { 1592 *o = *starlarkObj 1593 return nil 1594 } 1595 1596 mapObj, ok := v.(*starlark.Dict) 1597 if !ok { 1598 return fmt.Errorf("expected dict, actual: %v", v.Type()) 1599 } 1600 1601 for _, item := range mapObj.Items() { 1602 keyV, val := item[0], item[1] 1603 key, ok := starlark.AsString(keyV) 1604 if !ok { 1605 return fmt.Errorf("key must be string. Got: %s", keyV.Type()) 1606 } 1607 1608 if key == "args" { 1609 var v value.StringList 1610 err := v.Unpack(val) 1611 if err != nil { 1612 return fmt.Errorf("unpacking %s: %v", key, err) 1613 } 1614 obj.Args = v 1615 continue 1616 } 1617 if key == "dir" { 1618 v := value.NewLocalPathUnpacker(o.t) 1619 err := v.Unpack(val) 1620 if err != nil { 1621 return fmt.Errorf("unpacking %s: %v", key, err) 1622 } 1623 obj.Dir = v.Value 1624 continue 1625 } 1626 if key == "env" { 1627 var v value.StringList 1628 err := v.Unpack(val) 1629 if err != nil { 1630 return fmt.Errorf("unpacking %s: %v", key, err) 1631 } 1632 obj.Env = v 1633 continue 1634 } 1635 return fmt.Errorf("Unexpected attribute name: %s", key) 1636 } 1637 1638 mapObj.Freeze() 1639 o.Dict = mapObj 1640 o.Value = obj 1641 o.isUnpacked = true 1642 1643 return nil 1644 } 1645 1646 type KubernetesApplyCmdList struct { 1647 *starlark.List 1648 Value []v1alpha1.KubernetesApplyCmd 1649 t *starlark.Thread 1650 } 1651 1652 func (o *KubernetesApplyCmdList) Unpack(v starlark.Value) error { 1653 items := []v1alpha1.KubernetesApplyCmd{} 1654 1655 listObj, ok := v.(*starlark.List) 1656 if !ok { 1657 return fmt.Errorf("expected list, actual: %v", v.Type()) 1658 } 1659 1660 for i := 0; i < listObj.Len(); i++ { 1661 v := listObj.Index(i) 1662 1663 item := KubernetesApplyCmd{t: o.t} 1664 err := item.Unpack(v) 1665 if err != nil { 1666 return fmt.Errorf("at index %d: %v", i, err) 1667 } 1668 items = append(items, v1alpha1.KubernetesApplyCmd(item.Value)) 1669 } 1670 1671 listObj.Freeze() 1672 o.List = listObj 1673 o.Value = items 1674 1675 return nil 1676 } 1677 1678 type KubernetesDiscoveryTemplateSpec struct { 1679 *starlark.Dict 1680 Value v1alpha1.KubernetesDiscoveryTemplateSpec 1681 isUnpacked bool 1682 t *starlark.Thread // instantiation thread for computing abspath 1683 } 1684 1685 func (p Plugin) kubernetesDiscoveryTemplateSpec(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) { 1686 var extraSelectors starlark.Value 1687 err := starkit.UnpackArgs(t, fn.Name(), args, kwargs, 1688 "extra_selectors?", &extraSelectors, 1689 ) 1690 if err != nil { 1691 return nil, err 1692 } 1693 1694 dict := starlark.NewDict(1) 1695 1696 if extraSelectors != nil { 1697 err := dict.SetKey(starlark.String("extra_selectors"), extraSelectors) 1698 if err != nil { 1699 return nil, err 1700 } 1701 } 1702 var obj *KubernetesDiscoveryTemplateSpec = &KubernetesDiscoveryTemplateSpec{t: t} 1703 err = obj.Unpack(dict) 1704 if err != nil { 1705 return nil, err 1706 } 1707 return obj, nil 1708 } 1709 1710 func (o *KubernetesDiscoveryTemplateSpec) Unpack(v starlark.Value) error { 1711 obj := v1alpha1.KubernetesDiscoveryTemplateSpec{} 1712 1713 starlarkObj, ok := v.(*KubernetesDiscoveryTemplateSpec) 1714 if ok { 1715 *o = *starlarkObj 1716 return nil 1717 } 1718 1719 mapObj, ok := v.(*starlark.Dict) 1720 if !ok { 1721 return fmt.Errorf("expected dict, actual: %v", v.Type()) 1722 } 1723 1724 for _, item := range mapObj.Items() { 1725 keyV, val := item[0], item[1] 1726 key, ok := starlark.AsString(keyV) 1727 if !ok { 1728 return fmt.Errorf("key must be string. Got: %s", keyV.Type()) 1729 } 1730 1731 if key == "extra_selectors" { 1732 v := LabelSelectorList{t: o.t} 1733 err := v.Unpack(val) 1734 if err != nil { 1735 return fmt.Errorf("unpacking %s: %v", key, err) 1736 } 1737 obj.ExtraSelectors = v.Value 1738 continue 1739 } 1740 return fmt.Errorf("Unexpected attribute name: %s", key) 1741 } 1742 1743 mapObj.Freeze() 1744 o.Dict = mapObj 1745 o.Value = obj 1746 o.isUnpacked = true 1747 1748 return nil 1749 } 1750 1751 type KubernetesDiscoveryTemplateSpecList struct { 1752 *starlark.List 1753 Value []v1alpha1.KubernetesDiscoveryTemplateSpec 1754 t *starlark.Thread 1755 } 1756 1757 func (o *KubernetesDiscoveryTemplateSpecList) Unpack(v starlark.Value) error { 1758 items := []v1alpha1.KubernetesDiscoveryTemplateSpec{} 1759 1760 listObj, ok := v.(*starlark.List) 1761 if !ok { 1762 return fmt.Errorf("expected list, actual: %v", v.Type()) 1763 } 1764 1765 for i := 0; i < listObj.Len(); i++ { 1766 v := listObj.Index(i) 1767 1768 item := KubernetesDiscoveryTemplateSpec{t: o.t} 1769 err := item.Unpack(v) 1770 if err != nil { 1771 return fmt.Errorf("at index %d: %v", i, err) 1772 } 1773 items = append(items, v1alpha1.KubernetesDiscoveryTemplateSpec(item.Value)) 1774 } 1775 1776 listObj.Freeze() 1777 o.List = listObj 1778 o.Value = items 1779 1780 return nil 1781 } 1782 1783 type KubernetesImageLocator struct { 1784 *starlark.Dict 1785 Value v1alpha1.KubernetesImageLocator 1786 isUnpacked bool 1787 t *starlark.Thread // instantiation thread for computing abspath 1788 } 1789 1790 func (p Plugin) kubernetesImageLocator(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) { 1791 var objectSelector starlark.Value 1792 var path starlark.Value 1793 var object starlark.Value 1794 err := starkit.UnpackArgs(t, fn.Name(), args, kwargs, 1795 "object_selector?", &objectSelector, 1796 "path?", &path, 1797 "object?", &object, 1798 ) 1799 if err != nil { 1800 return nil, err 1801 } 1802 1803 dict := starlark.NewDict(3) 1804 1805 if objectSelector != nil { 1806 err := dict.SetKey(starlark.String("object_selector"), objectSelector) 1807 if err != nil { 1808 return nil, err 1809 } 1810 } 1811 if path != nil { 1812 err := dict.SetKey(starlark.String("path"), path) 1813 if err != nil { 1814 return nil, err 1815 } 1816 } 1817 if object != nil { 1818 err := dict.SetKey(starlark.String("object"), object) 1819 if err != nil { 1820 return nil, err 1821 } 1822 } 1823 var obj *KubernetesImageLocator = &KubernetesImageLocator{t: t} 1824 err = obj.Unpack(dict) 1825 if err != nil { 1826 return nil, err 1827 } 1828 return obj, nil 1829 } 1830 1831 func (o *KubernetesImageLocator) Unpack(v starlark.Value) error { 1832 obj := v1alpha1.KubernetesImageLocator{} 1833 1834 starlarkObj, ok := v.(*KubernetesImageLocator) 1835 if ok { 1836 *o = *starlarkObj 1837 return nil 1838 } 1839 1840 mapObj, ok := v.(*starlark.Dict) 1841 if !ok { 1842 return fmt.Errorf("expected dict, actual: %v", v.Type()) 1843 } 1844 1845 for _, item := range mapObj.Items() { 1846 keyV, val := item[0], item[1] 1847 key, ok := starlark.AsString(keyV) 1848 if !ok { 1849 return fmt.Errorf("key must be string. Got: %s", keyV.Type()) 1850 } 1851 1852 if key == "object_selector" { 1853 v := ObjectSelector{t: o.t} 1854 err := v.Unpack(val) 1855 if err != nil { 1856 return fmt.Errorf("unpacking %s: %v", key, err) 1857 } 1858 obj.ObjectSelector = v.Value 1859 continue 1860 } 1861 if key == "path" { 1862 v, ok := starlark.AsString(val) 1863 if !ok { 1864 return fmt.Errorf("Expected string, actual: %s", val.Type()) 1865 } 1866 obj.Path = string(v) 1867 continue 1868 } 1869 if key == "object" { 1870 v := KubernetesImageObjectDescriptor{t: o.t} 1871 err := v.Unpack(val) 1872 if err != nil { 1873 return fmt.Errorf("unpacking %s: %v", key, err) 1874 } 1875 obj.Object = (*v1alpha1.KubernetesImageObjectDescriptor)(&v.Value) 1876 continue 1877 } 1878 return fmt.Errorf("Unexpected attribute name: %s", key) 1879 } 1880 1881 mapObj.Freeze() 1882 o.Dict = mapObj 1883 o.Value = obj 1884 o.isUnpacked = true 1885 1886 return nil 1887 } 1888 1889 type KubernetesImageLocatorList struct { 1890 *starlark.List 1891 Value []v1alpha1.KubernetesImageLocator 1892 t *starlark.Thread 1893 } 1894 1895 func (o *KubernetesImageLocatorList) Unpack(v starlark.Value) error { 1896 items := []v1alpha1.KubernetesImageLocator{} 1897 1898 listObj, ok := v.(*starlark.List) 1899 if !ok { 1900 return fmt.Errorf("expected list, actual: %v", v.Type()) 1901 } 1902 1903 for i := 0; i < listObj.Len(); i++ { 1904 v := listObj.Index(i) 1905 1906 item := KubernetesImageLocator{t: o.t} 1907 err := item.Unpack(v) 1908 if err != nil { 1909 return fmt.Errorf("at index %d: %v", i, err) 1910 } 1911 items = append(items, v1alpha1.KubernetesImageLocator(item.Value)) 1912 } 1913 1914 listObj.Freeze() 1915 o.List = listObj 1916 o.Value = items 1917 1918 return nil 1919 } 1920 1921 type KubernetesImageObjectDescriptor struct { 1922 *starlark.Dict 1923 Value v1alpha1.KubernetesImageObjectDescriptor 1924 isUnpacked bool 1925 t *starlark.Thread // instantiation thread for computing abspath 1926 } 1927 1928 func (p Plugin) kubernetesImageObjectDescriptor(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) { 1929 var repoField starlark.Value 1930 var tagField starlark.Value 1931 err := starkit.UnpackArgs(t, fn.Name(), args, kwargs, 1932 "repo_field?", &repoField, 1933 "tag_field?", &tagField, 1934 ) 1935 if err != nil { 1936 return nil, err 1937 } 1938 1939 dict := starlark.NewDict(2) 1940 1941 if repoField != nil { 1942 err := dict.SetKey(starlark.String("repo_field"), repoField) 1943 if err != nil { 1944 return nil, err 1945 } 1946 } 1947 if tagField != nil { 1948 err := dict.SetKey(starlark.String("tag_field"), tagField) 1949 if err != nil { 1950 return nil, err 1951 } 1952 } 1953 var obj *KubernetesImageObjectDescriptor = &KubernetesImageObjectDescriptor{t: t} 1954 err = obj.Unpack(dict) 1955 if err != nil { 1956 return nil, err 1957 } 1958 return obj, nil 1959 } 1960 1961 func (o *KubernetesImageObjectDescriptor) Unpack(v starlark.Value) error { 1962 obj := v1alpha1.KubernetesImageObjectDescriptor{} 1963 1964 starlarkObj, ok := v.(*KubernetesImageObjectDescriptor) 1965 if ok { 1966 *o = *starlarkObj 1967 return nil 1968 } 1969 1970 mapObj, ok := v.(*starlark.Dict) 1971 if !ok { 1972 return fmt.Errorf("expected dict, actual: %v", v.Type()) 1973 } 1974 1975 for _, item := range mapObj.Items() { 1976 keyV, val := item[0], item[1] 1977 key, ok := starlark.AsString(keyV) 1978 if !ok { 1979 return fmt.Errorf("key must be string. Got: %s", keyV.Type()) 1980 } 1981 1982 if key == "repo_field" { 1983 v, ok := starlark.AsString(val) 1984 if !ok { 1985 return fmt.Errorf("Expected string, actual: %s", val.Type()) 1986 } 1987 obj.RepoField = string(v) 1988 continue 1989 } 1990 if key == "tag_field" { 1991 v, ok := starlark.AsString(val) 1992 if !ok { 1993 return fmt.Errorf("Expected string, actual: %s", val.Type()) 1994 } 1995 obj.TagField = string(v) 1996 continue 1997 } 1998 return fmt.Errorf("Unexpected attribute name: %s", key) 1999 } 2000 2001 mapObj.Freeze() 2002 o.Dict = mapObj 2003 o.Value = obj 2004 o.isUnpacked = true 2005 2006 return nil 2007 } 2008 2009 type KubernetesImageObjectDescriptorList struct { 2010 *starlark.List 2011 Value []v1alpha1.KubernetesImageObjectDescriptor 2012 t *starlark.Thread 2013 } 2014 2015 func (o *KubernetesImageObjectDescriptorList) Unpack(v starlark.Value) error { 2016 items := []v1alpha1.KubernetesImageObjectDescriptor{} 2017 2018 listObj, ok := v.(*starlark.List) 2019 if !ok { 2020 return fmt.Errorf("expected list, actual: %v", v.Type()) 2021 } 2022 2023 for i := 0; i < listObj.Len(); i++ { 2024 v := listObj.Index(i) 2025 2026 item := KubernetesImageObjectDescriptor{t: o.t} 2027 err := item.Unpack(v) 2028 if err != nil { 2029 return fmt.Errorf("at index %d: %v", i, err) 2030 } 2031 items = append(items, v1alpha1.KubernetesImageObjectDescriptor(item.Value)) 2032 } 2033 2034 listObj.Freeze() 2035 o.List = listObj 2036 o.Value = items 2037 2038 return nil 2039 } 2040 2041 type KubernetesWatchRef struct { 2042 *starlark.Dict 2043 Value v1alpha1.KubernetesWatchRef 2044 isUnpacked bool 2045 t *starlark.Thread // instantiation thread for computing abspath 2046 } 2047 2048 func (p Plugin) kubernetesWatchRef(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) { 2049 var uID starlark.Value 2050 var namespace starlark.Value 2051 var name starlark.Value 2052 err := starkit.UnpackArgs(t, fn.Name(), args, kwargs, 2053 "uid?", &uID, 2054 "namespace?", &namespace, 2055 "name?", &name, 2056 ) 2057 if err != nil { 2058 return nil, err 2059 } 2060 2061 dict := starlark.NewDict(3) 2062 2063 if uID != nil { 2064 err := dict.SetKey(starlark.String("uid"), uID) 2065 if err != nil { 2066 return nil, err 2067 } 2068 } 2069 if namespace != nil { 2070 err := dict.SetKey(starlark.String("namespace"), namespace) 2071 if err != nil { 2072 return nil, err 2073 } 2074 } 2075 if name != nil { 2076 err := dict.SetKey(starlark.String("name"), name) 2077 if err != nil { 2078 return nil, err 2079 } 2080 } 2081 var obj *KubernetesWatchRef = &KubernetesWatchRef{t: t} 2082 err = obj.Unpack(dict) 2083 if err != nil { 2084 return nil, err 2085 } 2086 return obj, nil 2087 } 2088 2089 func (o *KubernetesWatchRef) Unpack(v starlark.Value) error { 2090 obj := v1alpha1.KubernetesWatchRef{} 2091 2092 starlarkObj, ok := v.(*KubernetesWatchRef) 2093 if ok { 2094 *o = *starlarkObj 2095 return nil 2096 } 2097 2098 mapObj, ok := v.(*starlark.Dict) 2099 if !ok { 2100 return fmt.Errorf("expected dict, actual: %v", v.Type()) 2101 } 2102 2103 for _, item := range mapObj.Items() { 2104 keyV, val := item[0], item[1] 2105 key, ok := starlark.AsString(keyV) 2106 if !ok { 2107 return fmt.Errorf("key must be string. Got: %s", keyV.Type()) 2108 } 2109 2110 if key == "uid" { 2111 v, ok := starlark.AsString(val) 2112 if !ok { 2113 return fmt.Errorf("Expected string, actual: %s", val.Type()) 2114 } 2115 obj.UID = string(v) 2116 continue 2117 } 2118 if key == "namespace" { 2119 v, ok := starlark.AsString(val) 2120 if !ok { 2121 return fmt.Errorf("Expected string, actual: %s", val.Type()) 2122 } 2123 obj.Namespace = string(v) 2124 continue 2125 } 2126 if key == "name" { 2127 v, ok := starlark.AsString(val) 2128 if !ok { 2129 return fmt.Errorf("Expected string, actual: %s", val.Type()) 2130 } 2131 obj.Name = string(v) 2132 continue 2133 } 2134 return fmt.Errorf("Unexpected attribute name: %s", key) 2135 } 2136 2137 mapObj.Freeze() 2138 o.Dict = mapObj 2139 o.Value = obj 2140 o.isUnpacked = true 2141 2142 return nil 2143 } 2144 2145 type KubernetesWatchRefList struct { 2146 *starlark.List 2147 Value []v1alpha1.KubernetesWatchRef 2148 t *starlark.Thread 2149 } 2150 2151 func (o *KubernetesWatchRefList) Unpack(v starlark.Value) error { 2152 items := []v1alpha1.KubernetesWatchRef{} 2153 2154 listObj, ok := v.(*starlark.List) 2155 if !ok { 2156 return fmt.Errorf("expected list, actual: %v", v.Type()) 2157 } 2158 2159 for i := 0; i < listObj.Len(); i++ { 2160 v := listObj.Index(i) 2161 2162 item := KubernetesWatchRef{t: o.t} 2163 err := item.Unpack(v) 2164 if err != nil { 2165 return fmt.Errorf("at index %d: %v", i, err) 2166 } 2167 items = append(items, v1alpha1.KubernetesWatchRef(item.Value)) 2168 } 2169 2170 listObj.Freeze() 2171 o.List = listObj 2172 o.Value = items 2173 2174 return nil 2175 } 2176 2177 type LabelSelector struct { 2178 *starlark.Dict 2179 Value metav1.LabelSelector 2180 isUnpacked bool 2181 t *starlark.Thread // instantiation thread for computing abspath 2182 } 2183 2184 func (p Plugin) labelSelector(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) { 2185 var matchLabels starlark.Value 2186 var matchExpressions starlark.Value 2187 err := starkit.UnpackArgs(t, fn.Name(), args, kwargs, 2188 "match_labels?", &matchLabels, 2189 "match_expressions?", &matchExpressions, 2190 ) 2191 if err != nil { 2192 return nil, err 2193 } 2194 2195 dict := starlark.NewDict(2) 2196 2197 if matchLabels != nil { 2198 err := dict.SetKey(starlark.String("match_labels"), matchLabels) 2199 if err != nil { 2200 return nil, err 2201 } 2202 } 2203 if matchExpressions != nil { 2204 err := dict.SetKey(starlark.String("match_expressions"), matchExpressions) 2205 if err != nil { 2206 return nil, err 2207 } 2208 } 2209 var obj *LabelSelector = &LabelSelector{t: t} 2210 err = obj.Unpack(dict) 2211 if err != nil { 2212 return nil, err 2213 } 2214 return obj, nil 2215 } 2216 2217 func (o *LabelSelector) Unpack(v starlark.Value) error { 2218 obj := metav1.LabelSelector{} 2219 2220 starlarkObj, ok := v.(*LabelSelector) 2221 if ok { 2222 *o = *starlarkObj 2223 return nil 2224 } 2225 2226 mapObj, ok := v.(*starlark.Dict) 2227 if !ok { 2228 return fmt.Errorf("expected dict, actual: %v", v.Type()) 2229 } 2230 2231 for _, item := range mapObj.Items() { 2232 keyV, val := item[0], item[1] 2233 key, ok := starlark.AsString(keyV) 2234 if !ok { 2235 return fmt.Errorf("key must be string. Got: %s", keyV.Type()) 2236 } 2237 2238 if key == "match_labels" { 2239 var v value.StringStringMap 2240 err := v.Unpack(val) 2241 if err != nil { 2242 return fmt.Errorf("unpacking %s: %v", key, err) 2243 } 2244 obj.MatchLabels = (map[string]string)(v) 2245 continue 2246 } 2247 if key == "match_expressions" { 2248 v := LabelSelectorRequirementList{t: o.t} 2249 err := v.Unpack(val) 2250 if err != nil { 2251 return fmt.Errorf("unpacking %s: %v", key, err) 2252 } 2253 obj.MatchExpressions = v.Value 2254 continue 2255 } 2256 return fmt.Errorf("Unexpected attribute name: %s", key) 2257 } 2258 2259 mapObj.Freeze() 2260 o.Dict = mapObj 2261 o.Value = obj 2262 o.isUnpacked = true 2263 2264 return nil 2265 } 2266 2267 type LabelSelectorList struct { 2268 *starlark.List 2269 Value []metav1.LabelSelector 2270 t *starlark.Thread 2271 } 2272 2273 func (o *LabelSelectorList) Unpack(v starlark.Value) error { 2274 items := []metav1.LabelSelector{} 2275 2276 listObj, ok := v.(*starlark.List) 2277 if !ok { 2278 return fmt.Errorf("expected list, actual: %v", v.Type()) 2279 } 2280 2281 for i := 0; i < listObj.Len(); i++ { 2282 v := listObj.Index(i) 2283 2284 item := LabelSelector{t: o.t} 2285 err := item.Unpack(v) 2286 if err != nil { 2287 return fmt.Errorf("at index %d: %v", i, err) 2288 } 2289 items = append(items, metav1.LabelSelector(item.Value)) 2290 } 2291 2292 listObj.Freeze() 2293 o.List = listObj 2294 o.Value = items 2295 2296 return nil 2297 } 2298 2299 type LabelSelectorRequirement struct { 2300 *starlark.Dict 2301 Value metav1.LabelSelectorRequirement 2302 isUnpacked bool 2303 t *starlark.Thread // instantiation thread for computing abspath 2304 } 2305 2306 func (p Plugin) labelSelectorRequirement(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) { 2307 var key starlark.Value 2308 var operator starlark.Value 2309 var values starlark.Value 2310 err := starkit.UnpackArgs(t, fn.Name(), args, kwargs, 2311 "key?", &key, 2312 "operator?", &operator, 2313 "values?", &values, 2314 ) 2315 if err != nil { 2316 return nil, err 2317 } 2318 2319 dict := starlark.NewDict(3) 2320 2321 if key != nil { 2322 err := dict.SetKey(starlark.String("key"), key) 2323 if err != nil { 2324 return nil, err 2325 } 2326 } 2327 if operator != nil { 2328 err := dict.SetKey(starlark.String("operator"), operator) 2329 if err != nil { 2330 return nil, err 2331 } 2332 } 2333 if values != nil { 2334 err := dict.SetKey(starlark.String("values"), values) 2335 if err != nil { 2336 return nil, err 2337 } 2338 } 2339 var obj *LabelSelectorRequirement = &LabelSelectorRequirement{t: t} 2340 err = obj.Unpack(dict) 2341 if err != nil { 2342 return nil, err 2343 } 2344 return obj, nil 2345 } 2346 2347 func (o *LabelSelectorRequirement) Unpack(v starlark.Value) error { 2348 obj := metav1.LabelSelectorRequirement{} 2349 2350 starlarkObj, ok := v.(*LabelSelectorRequirement) 2351 if ok { 2352 *o = *starlarkObj 2353 return nil 2354 } 2355 2356 mapObj, ok := v.(*starlark.Dict) 2357 if !ok { 2358 return fmt.Errorf("expected dict, actual: %v", v.Type()) 2359 } 2360 2361 for _, item := range mapObj.Items() { 2362 keyV, val := item[0], item[1] 2363 key, ok := starlark.AsString(keyV) 2364 if !ok { 2365 return fmt.Errorf("key must be string. Got: %s", keyV.Type()) 2366 } 2367 2368 if key == "key" { 2369 v, ok := starlark.AsString(val) 2370 if !ok { 2371 return fmt.Errorf("Expected string, actual: %s", val.Type()) 2372 } 2373 obj.Key = string(v) 2374 continue 2375 } 2376 if key == "operator" { 2377 v, ok := starlark.AsString(val) 2378 if !ok { 2379 return fmt.Errorf("Expected string, actual: %s", val.Type()) 2380 } 2381 obj.Operator = metav1.LabelSelectorOperator(v) 2382 continue 2383 } 2384 if key == "values" { 2385 var v value.StringList 2386 err := v.Unpack(val) 2387 if err != nil { 2388 return fmt.Errorf("unpacking %s: %v", key, err) 2389 } 2390 obj.Values = v 2391 continue 2392 } 2393 return fmt.Errorf("Unexpected attribute name: %s", key) 2394 } 2395 2396 mapObj.Freeze() 2397 o.Dict = mapObj 2398 o.Value = obj 2399 o.isUnpacked = true 2400 2401 return nil 2402 } 2403 2404 type LabelSelectorRequirementList struct { 2405 *starlark.List 2406 Value []metav1.LabelSelectorRequirement 2407 t *starlark.Thread 2408 } 2409 2410 func (o *LabelSelectorRequirementList) Unpack(v starlark.Value) error { 2411 items := []metav1.LabelSelectorRequirement{} 2412 2413 listObj, ok := v.(*starlark.List) 2414 if !ok { 2415 return fmt.Errorf("expected list, actual: %v", v.Type()) 2416 } 2417 2418 for i := 0; i < listObj.Len(); i++ { 2419 v := listObj.Index(i) 2420 2421 item := LabelSelectorRequirement{t: o.t} 2422 err := item.Unpack(v) 2423 if err != nil { 2424 return fmt.Errorf("at index %d: %v", i, err) 2425 } 2426 items = append(items, metav1.LabelSelectorRequirement(item.Value)) 2427 } 2428 2429 listObj.Freeze() 2430 o.List = listObj 2431 o.Value = items 2432 2433 return nil 2434 } 2435 2436 type ObjectSelector struct { 2437 *starlark.Dict 2438 Value v1alpha1.ObjectSelector 2439 isUnpacked bool 2440 t *starlark.Thread // instantiation thread for computing abspath 2441 } 2442 2443 func (p Plugin) objectSelector(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) { 2444 var aPIVersionRegexp starlark.Value 2445 var kindRegexp starlark.Value 2446 var nameRegexp starlark.Value 2447 var namespaceRegexp starlark.Value 2448 err := starkit.UnpackArgs(t, fn.Name(), args, kwargs, 2449 "api_version_regexp?", &aPIVersionRegexp, 2450 "kind_regexp?", &kindRegexp, 2451 "name_regexp?", &nameRegexp, 2452 "namespace_regexp?", &namespaceRegexp, 2453 ) 2454 if err != nil { 2455 return nil, err 2456 } 2457 2458 dict := starlark.NewDict(4) 2459 2460 if aPIVersionRegexp != nil { 2461 err := dict.SetKey(starlark.String("api_version_regexp"), aPIVersionRegexp) 2462 if err != nil { 2463 return nil, err 2464 } 2465 } 2466 if kindRegexp != nil { 2467 err := dict.SetKey(starlark.String("kind_regexp"), kindRegexp) 2468 if err != nil { 2469 return nil, err 2470 } 2471 } 2472 if nameRegexp != nil { 2473 err := dict.SetKey(starlark.String("name_regexp"), nameRegexp) 2474 if err != nil { 2475 return nil, err 2476 } 2477 } 2478 if namespaceRegexp != nil { 2479 err := dict.SetKey(starlark.String("namespace_regexp"), namespaceRegexp) 2480 if err != nil { 2481 return nil, err 2482 } 2483 } 2484 var obj *ObjectSelector = &ObjectSelector{t: t} 2485 err = obj.Unpack(dict) 2486 if err != nil { 2487 return nil, err 2488 } 2489 return obj, nil 2490 } 2491 2492 func (o *ObjectSelector) Unpack(v starlark.Value) error { 2493 obj := v1alpha1.ObjectSelector{} 2494 2495 starlarkObj, ok := v.(*ObjectSelector) 2496 if ok { 2497 *o = *starlarkObj 2498 return nil 2499 } 2500 2501 mapObj, ok := v.(*starlark.Dict) 2502 if !ok { 2503 return fmt.Errorf("expected dict, actual: %v", v.Type()) 2504 } 2505 2506 for _, item := range mapObj.Items() { 2507 keyV, val := item[0], item[1] 2508 key, ok := starlark.AsString(keyV) 2509 if !ok { 2510 return fmt.Errorf("key must be string. Got: %s", keyV.Type()) 2511 } 2512 2513 if key == "api_version_regexp" { 2514 v, ok := starlark.AsString(val) 2515 if !ok { 2516 return fmt.Errorf("Expected string, actual: %s", val.Type()) 2517 } 2518 obj.APIVersionRegexp = string(v) 2519 continue 2520 } 2521 if key == "kind_regexp" { 2522 v, ok := starlark.AsString(val) 2523 if !ok { 2524 return fmt.Errorf("Expected string, actual: %s", val.Type()) 2525 } 2526 obj.KindRegexp = string(v) 2527 continue 2528 } 2529 if key == "name_regexp" { 2530 v, ok := starlark.AsString(val) 2531 if !ok { 2532 return fmt.Errorf("Expected string, actual: %s", val.Type()) 2533 } 2534 obj.NameRegexp = string(v) 2535 continue 2536 } 2537 if key == "namespace_regexp" { 2538 v, ok := starlark.AsString(val) 2539 if !ok { 2540 return fmt.Errorf("Expected string, actual: %s", val.Type()) 2541 } 2542 obj.NamespaceRegexp = string(v) 2543 continue 2544 } 2545 return fmt.Errorf("Unexpected attribute name: %s", key) 2546 } 2547 2548 mapObj.Freeze() 2549 o.Dict = mapObj 2550 o.Value = obj 2551 o.isUnpacked = true 2552 2553 return nil 2554 } 2555 2556 type ObjectSelectorList struct { 2557 *starlark.List 2558 Value []v1alpha1.ObjectSelector 2559 t *starlark.Thread 2560 } 2561 2562 func (o *ObjectSelectorList) Unpack(v starlark.Value) error { 2563 items := []v1alpha1.ObjectSelector{} 2564 2565 listObj, ok := v.(*starlark.List) 2566 if !ok { 2567 return fmt.Errorf("expected list, actual: %v", v.Type()) 2568 } 2569 2570 for i := 0; i < listObj.Len(); i++ { 2571 v := listObj.Index(i) 2572 2573 item := ObjectSelector{t: o.t} 2574 err := item.Unpack(v) 2575 if err != nil { 2576 return fmt.Errorf("at index %d: %v", i, err) 2577 } 2578 items = append(items, v1alpha1.ObjectSelector(item.Value)) 2579 } 2580 2581 listObj.Freeze() 2582 o.List = listObj 2583 o.Value = items 2584 2585 return nil 2586 } 2587 2588 type PodLogStreamTemplateSpec struct { 2589 *starlark.Dict 2590 Value v1alpha1.PodLogStreamTemplateSpec 2591 isUnpacked bool 2592 t *starlark.Thread // instantiation thread for computing abspath 2593 } 2594 2595 func (p Plugin) podLogStreamTemplateSpec(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) { 2596 var sinceTime starlark.Value 2597 var onlyContainers starlark.Value 2598 var ignoreContainers starlark.Value 2599 err := starkit.UnpackArgs(t, fn.Name(), args, kwargs, 2600 "since_time?", &sinceTime, 2601 "only_containers?", &onlyContainers, 2602 "ignore_containers?", &ignoreContainers, 2603 ) 2604 if err != nil { 2605 return nil, err 2606 } 2607 2608 dict := starlark.NewDict(3) 2609 2610 if sinceTime != nil { 2611 err := dict.SetKey(starlark.String("since_time"), sinceTime) 2612 if err != nil { 2613 return nil, err 2614 } 2615 } 2616 if onlyContainers != nil { 2617 err := dict.SetKey(starlark.String("only_containers"), onlyContainers) 2618 if err != nil { 2619 return nil, err 2620 } 2621 } 2622 if ignoreContainers != nil { 2623 err := dict.SetKey(starlark.String("ignore_containers"), ignoreContainers) 2624 if err != nil { 2625 return nil, err 2626 } 2627 } 2628 var obj *PodLogStreamTemplateSpec = &PodLogStreamTemplateSpec{t: t} 2629 err = obj.Unpack(dict) 2630 if err != nil { 2631 return nil, err 2632 } 2633 return obj, nil 2634 } 2635 2636 func (o *PodLogStreamTemplateSpec) Unpack(v starlark.Value) error { 2637 obj := v1alpha1.PodLogStreamTemplateSpec{} 2638 2639 starlarkObj, ok := v.(*PodLogStreamTemplateSpec) 2640 if ok { 2641 *o = *starlarkObj 2642 return nil 2643 } 2644 2645 mapObj, ok := v.(*starlark.Dict) 2646 if !ok { 2647 return fmt.Errorf("expected dict, actual: %v", v.Type()) 2648 } 2649 2650 for _, item := range mapObj.Items() { 2651 keyV, val := item[0], item[1] 2652 key, ok := starlark.AsString(keyV) 2653 if !ok { 2654 return fmt.Errorf("key must be string. Got: %s", keyV.Type()) 2655 } 2656 2657 if key == "only_containers" { 2658 var v value.StringList 2659 err := v.Unpack(val) 2660 if err != nil { 2661 return fmt.Errorf("unpacking %s: %v", key, err) 2662 } 2663 obj.OnlyContainers = v 2664 continue 2665 } 2666 if key == "ignore_containers" { 2667 var v value.StringList 2668 err := v.Unpack(val) 2669 if err != nil { 2670 return fmt.Errorf("unpacking %s: %v", key, err) 2671 } 2672 obj.IgnoreContainers = v 2673 continue 2674 } 2675 return fmt.Errorf("Unexpected attribute name: %s", key) 2676 } 2677 2678 mapObj.Freeze() 2679 o.Dict = mapObj 2680 o.Value = obj 2681 o.isUnpacked = true 2682 2683 return nil 2684 } 2685 2686 type PodLogStreamTemplateSpecList struct { 2687 *starlark.List 2688 Value []v1alpha1.PodLogStreamTemplateSpec 2689 t *starlark.Thread 2690 } 2691 2692 func (o *PodLogStreamTemplateSpecList) Unpack(v starlark.Value) error { 2693 items := []v1alpha1.PodLogStreamTemplateSpec{} 2694 2695 listObj, ok := v.(*starlark.List) 2696 if !ok { 2697 return fmt.Errorf("expected list, actual: %v", v.Type()) 2698 } 2699 2700 for i := 0; i < listObj.Len(); i++ { 2701 v := listObj.Index(i) 2702 2703 item := PodLogStreamTemplateSpec{t: o.t} 2704 err := item.Unpack(v) 2705 if err != nil { 2706 return fmt.Errorf("at index %d: %v", i, err) 2707 } 2708 items = append(items, v1alpha1.PodLogStreamTemplateSpec(item.Value)) 2709 } 2710 2711 listObj.Freeze() 2712 o.List = listObj 2713 o.Value = items 2714 2715 return nil 2716 } 2717 2718 type PortForwardTemplateSpec struct { 2719 *starlark.Dict 2720 Value v1alpha1.PortForwardTemplateSpec 2721 isUnpacked bool 2722 t *starlark.Thread // instantiation thread for computing abspath 2723 } 2724 2725 func (p Plugin) portForwardTemplateSpec(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) { 2726 var forwards starlark.Value 2727 err := starkit.UnpackArgs(t, fn.Name(), args, kwargs, 2728 "forwards?", &forwards, 2729 ) 2730 if err != nil { 2731 return nil, err 2732 } 2733 2734 dict := starlark.NewDict(1) 2735 2736 if forwards != nil { 2737 err := dict.SetKey(starlark.String("forwards"), forwards) 2738 if err != nil { 2739 return nil, err 2740 } 2741 } 2742 var obj *PortForwardTemplateSpec = &PortForwardTemplateSpec{t: t} 2743 err = obj.Unpack(dict) 2744 if err != nil { 2745 return nil, err 2746 } 2747 return obj, nil 2748 } 2749 2750 func (o *PortForwardTemplateSpec) Unpack(v starlark.Value) error { 2751 obj := v1alpha1.PortForwardTemplateSpec{} 2752 2753 starlarkObj, ok := v.(*PortForwardTemplateSpec) 2754 if ok { 2755 *o = *starlarkObj 2756 return nil 2757 } 2758 2759 mapObj, ok := v.(*starlark.Dict) 2760 if !ok { 2761 return fmt.Errorf("expected dict, actual: %v", v.Type()) 2762 } 2763 2764 for _, item := range mapObj.Items() { 2765 keyV, val := item[0], item[1] 2766 key, ok := starlark.AsString(keyV) 2767 if !ok { 2768 return fmt.Errorf("key must be string. Got: %s", keyV.Type()) 2769 } 2770 2771 if key == "forwards" { 2772 v := ForwardList{t: o.t} 2773 err := v.Unpack(val) 2774 if err != nil { 2775 return fmt.Errorf("unpacking %s: %v", key, err) 2776 } 2777 obj.Forwards = v.Value 2778 continue 2779 } 2780 return fmt.Errorf("Unexpected attribute name: %s", key) 2781 } 2782 2783 mapObj.Freeze() 2784 o.Dict = mapObj 2785 o.Value = obj 2786 o.isUnpacked = true 2787 2788 return nil 2789 } 2790 2791 type PortForwardTemplateSpecList struct { 2792 *starlark.List 2793 Value []v1alpha1.PortForwardTemplateSpec 2794 t *starlark.Thread 2795 } 2796 2797 func (o *PortForwardTemplateSpecList) Unpack(v starlark.Value) error { 2798 items := []v1alpha1.PortForwardTemplateSpec{} 2799 2800 listObj, ok := v.(*starlark.List) 2801 if !ok { 2802 return fmt.Errorf("expected list, actual: %v", v.Type()) 2803 } 2804 2805 for i := 0; i < listObj.Len(); i++ { 2806 v := listObj.Index(i) 2807 2808 item := PortForwardTemplateSpec{t: o.t} 2809 err := item.Unpack(v) 2810 if err != nil { 2811 return fmt.Errorf("at index %d: %v", i, err) 2812 } 2813 items = append(items, v1alpha1.PortForwardTemplateSpec(item.Value)) 2814 } 2815 2816 listObj.Freeze() 2817 o.List = listObj 2818 o.Value = items 2819 2820 return nil 2821 } 2822 2823 type Probe struct { 2824 *starlark.Dict 2825 Value v1alpha1.Probe 2826 isUnpacked bool 2827 t *starlark.Thread // instantiation thread for computing abspath 2828 } 2829 2830 func (p Plugin) probe(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) { 2831 var handler starlark.Value 2832 var initialDelaySeconds starlark.Value 2833 var timeoutSeconds starlark.Value 2834 var periodSeconds starlark.Value 2835 var successThreshold starlark.Value 2836 var failureThreshold starlark.Value 2837 err := starkit.UnpackArgs(t, fn.Name(), args, kwargs, 2838 "handler?", &handler, 2839 "initial_delay_seconds?", &initialDelaySeconds, 2840 "timeout_seconds?", &timeoutSeconds, 2841 "period_seconds?", &periodSeconds, 2842 "success_threshold?", &successThreshold, 2843 "failure_threshold?", &failureThreshold, 2844 ) 2845 if err != nil { 2846 return nil, err 2847 } 2848 2849 dict := starlark.NewDict(6) 2850 2851 if handler != nil { 2852 err := dict.SetKey(starlark.String("handler"), handler) 2853 if err != nil { 2854 return nil, err 2855 } 2856 } 2857 if initialDelaySeconds != nil { 2858 err := dict.SetKey(starlark.String("initial_delay_seconds"), initialDelaySeconds) 2859 if err != nil { 2860 return nil, err 2861 } 2862 } 2863 if timeoutSeconds != nil { 2864 err := dict.SetKey(starlark.String("timeout_seconds"), timeoutSeconds) 2865 if err != nil { 2866 return nil, err 2867 } 2868 } 2869 if periodSeconds != nil { 2870 err := dict.SetKey(starlark.String("period_seconds"), periodSeconds) 2871 if err != nil { 2872 return nil, err 2873 } 2874 } 2875 if successThreshold != nil { 2876 err := dict.SetKey(starlark.String("success_threshold"), successThreshold) 2877 if err != nil { 2878 return nil, err 2879 } 2880 } 2881 if failureThreshold != nil { 2882 err := dict.SetKey(starlark.String("failure_threshold"), failureThreshold) 2883 if err != nil { 2884 return nil, err 2885 } 2886 } 2887 var obj *Probe = &Probe{t: t} 2888 err = obj.Unpack(dict) 2889 if err != nil { 2890 return nil, err 2891 } 2892 return obj, nil 2893 } 2894 2895 func (o *Probe) Unpack(v starlark.Value) error { 2896 obj := v1alpha1.Probe{} 2897 2898 starlarkObj, ok := v.(*Probe) 2899 if ok { 2900 *o = *starlarkObj 2901 return nil 2902 } 2903 2904 mapObj, ok := v.(*starlark.Dict) 2905 if !ok { 2906 return fmt.Errorf("expected dict, actual: %v", v.Type()) 2907 } 2908 2909 for _, item := range mapObj.Items() { 2910 keyV, val := item[0], item[1] 2911 key, ok := starlark.AsString(keyV) 2912 if !ok { 2913 return fmt.Errorf("key must be string. Got: %s", keyV.Type()) 2914 } 2915 2916 if key == "exec" { 2917 v := ExecAction{t: o.t} 2918 err := v.Unpack(val) 2919 if err != nil { 2920 return fmt.Errorf("unpacking %s: %v", key, err) 2921 } 2922 obj.Exec = (*v1alpha1.ExecAction)(&v.Value) 2923 continue 2924 } 2925 if key == "http_get" { 2926 v := HTTPGetAction{t: o.t} 2927 err := v.Unpack(val) 2928 if err != nil { 2929 return fmt.Errorf("unpacking %s: %v", key, err) 2930 } 2931 obj.HTTPGet = (*v1alpha1.HTTPGetAction)(&v.Value) 2932 continue 2933 } 2934 if key == "tcp_socket" { 2935 v := TCPSocketAction{t: o.t} 2936 err := v.Unpack(val) 2937 if err != nil { 2938 return fmt.Errorf("unpacking %s: %v", key, err) 2939 } 2940 obj.TCPSocket = (*v1alpha1.TCPSocketAction)(&v.Value) 2941 continue 2942 } 2943 if key == "initial_delay_seconds" { 2944 v, err := starlark.AsInt32(val) 2945 if err != nil { 2946 return fmt.Errorf("Expected int, got: %v", err) 2947 } 2948 obj.InitialDelaySeconds = int32(v) 2949 continue 2950 } 2951 if key == "timeout_seconds" { 2952 v, err := starlark.AsInt32(val) 2953 if err != nil { 2954 return fmt.Errorf("Expected int, got: %v", err) 2955 } 2956 obj.TimeoutSeconds = int32(v) 2957 continue 2958 } 2959 if key == "period_seconds" { 2960 v, err := starlark.AsInt32(val) 2961 if err != nil { 2962 return fmt.Errorf("Expected int, got: %v", err) 2963 } 2964 obj.PeriodSeconds = int32(v) 2965 continue 2966 } 2967 if key == "success_threshold" { 2968 v, err := starlark.AsInt32(val) 2969 if err != nil { 2970 return fmt.Errorf("Expected int, got: %v", err) 2971 } 2972 obj.SuccessThreshold = int32(v) 2973 continue 2974 } 2975 if key == "failure_threshold" { 2976 v, err := starlark.AsInt32(val) 2977 if err != nil { 2978 return fmt.Errorf("Expected int, got: %v", err) 2979 } 2980 obj.FailureThreshold = int32(v) 2981 continue 2982 } 2983 return fmt.Errorf("Unexpected attribute name: %s", key) 2984 } 2985 2986 mapObj.Freeze() 2987 o.Dict = mapObj 2988 o.Value = obj 2989 o.isUnpacked = true 2990 2991 return nil 2992 } 2993 2994 type ProbeList struct { 2995 *starlark.List 2996 Value []v1alpha1.Probe 2997 t *starlark.Thread 2998 } 2999 3000 func (o *ProbeList) Unpack(v starlark.Value) error { 3001 items := []v1alpha1.Probe{} 3002 3003 listObj, ok := v.(*starlark.List) 3004 if !ok { 3005 return fmt.Errorf("expected list, actual: %v", v.Type()) 3006 } 3007 3008 for i := 0; i < listObj.Len(); i++ { 3009 v := listObj.Index(i) 3010 3011 item := Probe{t: o.t} 3012 err := item.Unpack(v) 3013 if err != nil { 3014 return fmt.Errorf("at index %d: %v", i, err) 3015 } 3016 items = append(items, v1alpha1.Probe(item.Value)) 3017 } 3018 3019 listObj.Freeze() 3020 o.List = listObj 3021 o.Value = items 3022 3023 return nil 3024 } 3025 3026 type RestartOnSpec struct { 3027 *starlark.Dict 3028 Value v1alpha1.RestartOnSpec 3029 isUnpacked bool 3030 t *starlark.Thread // instantiation thread for computing abspath 3031 } 3032 3033 func (p Plugin) restartOnSpec(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) { 3034 var fileWatches starlark.Value 3035 var uiButtons starlark.Value 3036 err := starkit.UnpackArgs(t, fn.Name(), args, kwargs, 3037 "file_watches?", &fileWatches, 3038 "ui_buttons?", &uiButtons, 3039 ) 3040 if err != nil { 3041 return nil, err 3042 } 3043 3044 dict := starlark.NewDict(2) 3045 3046 if fileWatches != nil { 3047 err := dict.SetKey(starlark.String("file_watches"), fileWatches) 3048 if err != nil { 3049 return nil, err 3050 } 3051 } 3052 if uiButtons != nil { 3053 err := dict.SetKey(starlark.String("ui_buttons"), uiButtons) 3054 if err != nil { 3055 return nil, err 3056 } 3057 } 3058 var obj *RestartOnSpec = &RestartOnSpec{t: t} 3059 err = obj.Unpack(dict) 3060 if err != nil { 3061 return nil, err 3062 } 3063 return obj, nil 3064 } 3065 3066 func (o *RestartOnSpec) Unpack(v starlark.Value) error { 3067 obj := v1alpha1.RestartOnSpec{} 3068 3069 starlarkObj, ok := v.(*RestartOnSpec) 3070 if ok { 3071 *o = *starlarkObj 3072 return nil 3073 } 3074 3075 mapObj, ok := v.(*starlark.Dict) 3076 if !ok { 3077 return fmt.Errorf("expected dict, actual: %v", v.Type()) 3078 } 3079 3080 for _, item := range mapObj.Items() { 3081 keyV, val := item[0], item[1] 3082 key, ok := starlark.AsString(keyV) 3083 if !ok { 3084 return fmt.Errorf("key must be string. Got: %s", keyV.Type()) 3085 } 3086 3087 if key == "file_watches" { 3088 var v value.StringList 3089 err := v.Unpack(val) 3090 if err != nil { 3091 return fmt.Errorf("unpacking %s: %v", key, err) 3092 } 3093 obj.FileWatches = v 3094 continue 3095 } 3096 if key == "ui_buttons" { 3097 var v value.StringList 3098 err := v.Unpack(val) 3099 if err != nil { 3100 return fmt.Errorf("unpacking %s: %v", key, err) 3101 } 3102 obj.UIButtons = v 3103 continue 3104 } 3105 return fmt.Errorf("Unexpected attribute name: %s", key) 3106 } 3107 3108 mapObj.Freeze() 3109 o.Dict = mapObj 3110 o.Value = obj 3111 o.isUnpacked = true 3112 3113 return nil 3114 } 3115 3116 type RestartOnSpecList struct { 3117 *starlark.List 3118 Value []v1alpha1.RestartOnSpec 3119 t *starlark.Thread 3120 } 3121 3122 func (o *RestartOnSpecList) Unpack(v starlark.Value) error { 3123 items := []v1alpha1.RestartOnSpec{} 3124 3125 listObj, ok := v.(*starlark.List) 3126 if !ok { 3127 return fmt.Errorf("expected list, actual: %v", v.Type()) 3128 } 3129 3130 for i := 0; i < listObj.Len(); i++ { 3131 v := listObj.Index(i) 3132 3133 item := RestartOnSpec{t: o.t} 3134 err := item.Unpack(v) 3135 if err != nil { 3136 return fmt.Errorf("at index %d: %v", i, err) 3137 } 3138 items = append(items, v1alpha1.RestartOnSpec(item.Value)) 3139 } 3140 3141 listObj.Freeze() 3142 o.List = listObj 3143 o.Value = items 3144 3145 return nil 3146 } 3147 3148 type StartOnSpec struct { 3149 *starlark.Dict 3150 Value v1alpha1.StartOnSpec 3151 isUnpacked bool 3152 t *starlark.Thread // instantiation thread for computing abspath 3153 } 3154 3155 func (p Plugin) startOnSpec(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) { 3156 var startAfter starlark.Value 3157 var uiButtons starlark.Value 3158 err := starkit.UnpackArgs(t, fn.Name(), args, kwargs, 3159 "start_after?", &startAfter, 3160 "ui_buttons?", &uiButtons, 3161 ) 3162 if err != nil { 3163 return nil, err 3164 } 3165 3166 dict := starlark.NewDict(2) 3167 3168 if startAfter != nil { 3169 err := dict.SetKey(starlark.String("start_after"), startAfter) 3170 if err != nil { 3171 return nil, err 3172 } 3173 } 3174 if uiButtons != nil { 3175 err := dict.SetKey(starlark.String("ui_buttons"), uiButtons) 3176 if err != nil { 3177 return nil, err 3178 } 3179 } 3180 var obj *StartOnSpec = &StartOnSpec{t: t} 3181 err = obj.Unpack(dict) 3182 if err != nil { 3183 return nil, err 3184 } 3185 return obj, nil 3186 } 3187 3188 func (o *StartOnSpec) Unpack(v starlark.Value) error { 3189 obj := v1alpha1.StartOnSpec{} 3190 3191 starlarkObj, ok := v.(*StartOnSpec) 3192 if ok { 3193 *o = *starlarkObj 3194 return nil 3195 } 3196 3197 mapObj, ok := v.(*starlark.Dict) 3198 if !ok { 3199 return fmt.Errorf("expected dict, actual: %v", v.Type()) 3200 } 3201 3202 for _, item := range mapObj.Items() { 3203 keyV, val := item[0], item[1] 3204 key, ok := starlark.AsString(keyV) 3205 if !ok { 3206 return fmt.Errorf("key must be string. Got: %s", keyV.Type()) 3207 } 3208 3209 if key == "ui_buttons" { 3210 var v value.StringList 3211 err := v.Unpack(val) 3212 if err != nil { 3213 return fmt.Errorf("unpacking %s: %v", key, err) 3214 } 3215 obj.UIButtons = v 3216 continue 3217 } 3218 return fmt.Errorf("Unexpected attribute name: %s", key) 3219 } 3220 3221 mapObj.Freeze() 3222 o.Dict = mapObj 3223 o.Value = obj 3224 o.isUnpacked = true 3225 3226 return nil 3227 } 3228 3229 type StartOnSpecList struct { 3230 *starlark.List 3231 Value []v1alpha1.StartOnSpec 3232 t *starlark.Thread 3233 } 3234 3235 func (o *StartOnSpecList) Unpack(v starlark.Value) error { 3236 items := []v1alpha1.StartOnSpec{} 3237 3238 listObj, ok := v.(*starlark.List) 3239 if !ok { 3240 return fmt.Errorf("expected list, actual: %v", v.Type()) 3241 } 3242 3243 for i := 0; i < listObj.Len(); i++ { 3244 v := listObj.Index(i) 3245 3246 item := StartOnSpec{t: o.t} 3247 err := item.Unpack(v) 3248 if err != nil { 3249 return fmt.Errorf("at index %d: %v", i, err) 3250 } 3251 items = append(items, v1alpha1.StartOnSpec(item.Value)) 3252 } 3253 3254 listObj.Freeze() 3255 o.List = listObj 3256 o.Value = items 3257 3258 return nil 3259 } 3260 3261 type TCPSocketAction struct { 3262 *starlark.Dict 3263 Value v1alpha1.TCPSocketAction 3264 isUnpacked bool 3265 t *starlark.Thread // instantiation thread for computing abspath 3266 } 3267 3268 func (p Plugin) tCPSocketAction(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) { 3269 var port starlark.Value 3270 var host starlark.Value 3271 err := starkit.UnpackArgs(t, fn.Name(), args, kwargs, 3272 "port?", &port, 3273 "host?", &host, 3274 ) 3275 if err != nil { 3276 return nil, err 3277 } 3278 3279 dict := starlark.NewDict(2) 3280 3281 if port != nil { 3282 err := dict.SetKey(starlark.String("port"), port) 3283 if err != nil { 3284 return nil, err 3285 } 3286 } 3287 if host != nil { 3288 err := dict.SetKey(starlark.String("host"), host) 3289 if err != nil { 3290 return nil, err 3291 } 3292 } 3293 var obj *TCPSocketAction = &TCPSocketAction{t: t} 3294 err = obj.Unpack(dict) 3295 if err != nil { 3296 return nil, err 3297 } 3298 return obj, nil 3299 } 3300 3301 func (o *TCPSocketAction) Unpack(v starlark.Value) error { 3302 obj := v1alpha1.TCPSocketAction{} 3303 3304 starlarkObj, ok := v.(*TCPSocketAction) 3305 if ok { 3306 *o = *starlarkObj 3307 return nil 3308 } 3309 3310 mapObj, ok := v.(*starlark.Dict) 3311 if !ok { 3312 return fmt.Errorf("expected dict, actual: %v", v.Type()) 3313 } 3314 3315 for _, item := range mapObj.Items() { 3316 keyV, val := item[0], item[1] 3317 key, ok := starlark.AsString(keyV) 3318 if !ok { 3319 return fmt.Errorf("key must be string. Got: %s", keyV.Type()) 3320 } 3321 3322 if key == "port" { 3323 v, err := starlark.AsInt32(val) 3324 if err != nil { 3325 return fmt.Errorf("Expected int, got: %v", err) 3326 } 3327 obj.Port = int32(v) 3328 continue 3329 } 3330 if key == "host" { 3331 v, ok := starlark.AsString(val) 3332 if !ok { 3333 return fmt.Errorf("Expected string, actual: %s", val.Type()) 3334 } 3335 obj.Host = string(v) 3336 continue 3337 } 3338 return fmt.Errorf("Unexpected attribute name: %s", key) 3339 } 3340 3341 mapObj.Freeze() 3342 o.Dict = mapObj 3343 o.Value = obj 3344 o.isUnpacked = true 3345 3346 return nil 3347 } 3348 3349 type TCPSocketActionList struct { 3350 *starlark.List 3351 Value []v1alpha1.TCPSocketAction 3352 t *starlark.Thread 3353 } 3354 3355 func (o *TCPSocketActionList) Unpack(v starlark.Value) error { 3356 items := []v1alpha1.TCPSocketAction{} 3357 3358 listObj, ok := v.(*starlark.List) 3359 if !ok { 3360 return fmt.Errorf("expected list, actual: %v", v.Type()) 3361 } 3362 3363 for i := 0; i < listObj.Len(); i++ { 3364 v := listObj.Index(i) 3365 3366 item := TCPSocketAction{t: o.t} 3367 err := item.Unpack(v) 3368 if err != nil { 3369 return fmt.Errorf("at index %d: %v", i, err) 3370 } 3371 items = append(items, v1alpha1.TCPSocketAction(item.Value)) 3372 } 3373 3374 listObj.Freeze() 3375 o.List = listObj 3376 o.Value = items 3377 3378 return nil 3379 } 3380 3381 type UIBoolInputSpec struct { 3382 *starlark.Dict 3383 Value v1alpha1.UIBoolInputSpec 3384 isUnpacked bool 3385 t *starlark.Thread // instantiation thread for computing abspath 3386 } 3387 3388 func (p Plugin) uIBoolInputSpec(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) { 3389 var defaultValue starlark.Value 3390 var trueString starlark.Value 3391 var falseString starlark.Value 3392 err := starkit.UnpackArgs(t, fn.Name(), args, kwargs, 3393 "default_value?", &defaultValue, 3394 "true_string?", &trueString, 3395 "false_string?", &falseString, 3396 ) 3397 if err != nil { 3398 return nil, err 3399 } 3400 3401 dict := starlark.NewDict(3) 3402 3403 if defaultValue != nil { 3404 err := dict.SetKey(starlark.String("default_value"), defaultValue) 3405 if err != nil { 3406 return nil, err 3407 } 3408 } 3409 if trueString != nil { 3410 err := dict.SetKey(starlark.String("true_string"), trueString) 3411 if err != nil { 3412 return nil, err 3413 } 3414 } 3415 if falseString != nil { 3416 err := dict.SetKey(starlark.String("false_string"), falseString) 3417 if err != nil { 3418 return nil, err 3419 } 3420 } 3421 var obj *UIBoolInputSpec = &UIBoolInputSpec{t: t} 3422 err = obj.Unpack(dict) 3423 if err != nil { 3424 return nil, err 3425 } 3426 return obj, nil 3427 } 3428 3429 func (o *UIBoolInputSpec) Unpack(v starlark.Value) error { 3430 obj := v1alpha1.UIBoolInputSpec{} 3431 3432 starlarkObj, ok := v.(*UIBoolInputSpec) 3433 if ok { 3434 *o = *starlarkObj 3435 return nil 3436 } 3437 3438 mapObj, ok := v.(*starlark.Dict) 3439 if !ok { 3440 return fmt.Errorf("expected dict, actual: %v", v.Type()) 3441 } 3442 3443 for _, item := range mapObj.Items() { 3444 keyV, val := item[0], item[1] 3445 key, ok := starlark.AsString(keyV) 3446 if !ok { 3447 return fmt.Errorf("key must be string. Got: %s", keyV.Type()) 3448 } 3449 3450 if key == "default_value" { 3451 v, ok := val.(starlark.Bool) 3452 if !ok { 3453 return fmt.Errorf("Expected bool, got: %v", val.Type()) 3454 } 3455 obj.DefaultValue = bool(v) 3456 continue 3457 } 3458 if key == "true_string" { 3459 v, ok := starlark.AsString(val) 3460 if !ok { 3461 return fmt.Errorf("Expected string, actual: %s", val.Type()) 3462 } 3463 obj.TrueString = (*string)(&v) 3464 continue 3465 } 3466 if key == "false_string" { 3467 v, ok := starlark.AsString(val) 3468 if !ok { 3469 return fmt.Errorf("Expected string, actual: %s", val.Type()) 3470 } 3471 obj.FalseString = (*string)(&v) 3472 continue 3473 } 3474 return fmt.Errorf("Unexpected attribute name: %s", key) 3475 } 3476 3477 mapObj.Freeze() 3478 o.Dict = mapObj 3479 o.Value = obj 3480 o.isUnpacked = true 3481 3482 return nil 3483 } 3484 3485 type UIBoolInputSpecList struct { 3486 *starlark.List 3487 Value []v1alpha1.UIBoolInputSpec 3488 t *starlark.Thread 3489 } 3490 3491 func (o *UIBoolInputSpecList) Unpack(v starlark.Value) error { 3492 items := []v1alpha1.UIBoolInputSpec{} 3493 3494 listObj, ok := v.(*starlark.List) 3495 if !ok { 3496 return fmt.Errorf("expected list, actual: %v", v.Type()) 3497 } 3498 3499 for i := 0; i < listObj.Len(); i++ { 3500 v := listObj.Index(i) 3501 3502 item := UIBoolInputSpec{t: o.t} 3503 err := item.Unpack(v) 3504 if err != nil { 3505 return fmt.Errorf("at index %d: %v", i, err) 3506 } 3507 items = append(items, v1alpha1.UIBoolInputSpec(item.Value)) 3508 } 3509 3510 listObj.Freeze() 3511 o.List = listObj 3512 o.Value = items 3513 3514 return nil 3515 } 3516 3517 type UIChoiceInputSpec struct { 3518 *starlark.Dict 3519 Value v1alpha1.UIChoiceInputSpec 3520 isUnpacked bool 3521 t *starlark.Thread // instantiation thread for computing abspath 3522 } 3523 3524 func (p Plugin) uIChoiceInputSpec(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) { 3525 var choices starlark.Value 3526 err := starkit.UnpackArgs(t, fn.Name(), args, kwargs, 3527 "choices?", &choices, 3528 ) 3529 if err != nil { 3530 return nil, err 3531 } 3532 3533 dict := starlark.NewDict(1) 3534 3535 if choices != nil { 3536 err := dict.SetKey(starlark.String("choices"), choices) 3537 if err != nil { 3538 return nil, err 3539 } 3540 } 3541 var obj *UIChoiceInputSpec = &UIChoiceInputSpec{t: t} 3542 err = obj.Unpack(dict) 3543 if err != nil { 3544 return nil, err 3545 } 3546 return obj, nil 3547 } 3548 3549 func (o *UIChoiceInputSpec) Unpack(v starlark.Value) error { 3550 obj := v1alpha1.UIChoiceInputSpec{} 3551 3552 starlarkObj, ok := v.(*UIChoiceInputSpec) 3553 if ok { 3554 *o = *starlarkObj 3555 return nil 3556 } 3557 3558 mapObj, ok := v.(*starlark.Dict) 3559 if !ok { 3560 return fmt.Errorf("expected dict, actual: %v", v.Type()) 3561 } 3562 3563 for _, item := range mapObj.Items() { 3564 keyV, val := item[0], item[1] 3565 key, ok := starlark.AsString(keyV) 3566 if !ok { 3567 return fmt.Errorf("key must be string. Got: %s", keyV.Type()) 3568 } 3569 3570 if key == "choices" { 3571 var v value.StringList 3572 err := v.Unpack(val) 3573 if err != nil { 3574 return fmt.Errorf("unpacking %s: %v", key, err) 3575 } 3576 obj.Choices = v 3577 continue 3578 } 3579 return fmt.Errorf("Unexpected attribute name: %s", key) 3580 } 3581 3582 mapObj.Freeze() 3583 o.Dict = mapObj 3584 o.Value = obj 3585 o.isUnpacked = true 3586 3587 return nil 3588 } 3589 3590 type UIChoiceInputSpecList struct { 3591 *starlark.List 3592 Value []v1alpha1.UIChoiceInputSpec 3593 t *starlark.Thread 3594 } 3595 3596 func (o *UIChoiceInputSpecList) Unpack(v starlark.Value) error { 3597 items := []v1alpha1.UIChoiceInputSpec{} 3598 3599 listObj, ok := v.(*starlark.List) 3600 if !ok { 3601 return fmt.Errorf("expected list, actual: %v", v.Type()) 3602 } 3603 3604 for i := 0; i < listObj.Len(); i++ { 3605 v := listObj.Index(i) 3606 3607 item := UIChoiceInputSpec{t: o.t} 3608 err := item.Unpack(v) 3609 if err != nil { 3610 return fmt.Errorf("at index %d: %v", i, err) 3611 } 3612 items = append(items, v1alpha1.UIChoiceInputSpec(item.Value)) 3613 } 3614 3615 listObj.Freeze() 3616 o.List = listObj 3617 o.Value = items 3618 3619 return nil 3620 } 3621 3622 type UIComponentLocation struct { 3623 *starlark.Dict 3624 Value v1alpha1.UIComponentLocation 3625 isUnpacked bool 3626 t *starlark.Thread // instantiation thread for computing abspath 3627 } 3628 3629 func (p Plugin) uIComponentLocation(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) { 3630 var componentID starlark.Value 3631 var componentType starlark.Value 3632 err := starkit.UnpackArgs(t, fn.Name(), args, kwargs, 3633 "component_id?", &componentID, 3634 "component_type?", &componentType, 3635 ) 3636 if err != nil { 3637 return nil, err 3638 } 3639 3640 dict := starlark.NewDict(2) 3641 3642 if componentID != nil { 3643 err := dict.SetKey(starlark.String("component_id"), componentID) 3644 if err != nil { 3645 return nil, err 3646 } 3647 } 3648 if componentType != nil { 3649 err := dict.SetKey(starlark.String("component_type"), componentType) 3650 if err != nil { 3651 return nil, err 3652 } 3653 } 3654 var obj *UIComponentLocation = &UIComponentLocation{t: t} 3655 err = obj.Unpack(dict) 3656 if err != nil { 3657 return nil, err 3658 } 3659 return obj, nil 3660 } 3661 3662 func (o *UIComponentLocation) Unpack(v starlark.Value) error { 3663 obj := v1alpha1.UIComponentLocation{} 3664 3665 starlarkObj, ok := v.(*UIComponentLocation) 3666 if ok { 3667 *o = *starlarkObj 3668 return nil 3669 } 3670 3671 mapObj, ok := v.(*starlark.Dict) 3672 if !ok { 3673 return fmt.Errorf("expected dict, actual: %v", v.Type()) 3674 } 3675 3676 for _, item := range mapObj.Items() { 3677 keyV, val := item[0], item[1] 3678 key, ok := starlark.AsString(keyV) 3679 if !ok { 3680 return fmt.Errorf("key must be string. Got: %s", keyV.Type()) 3681 } 3682 3683 if key == "component_id" { 3684 v, ok := starlark.AsString(val) 3685 if !ok { 3686 return fmt.Errorf("Expected string, actual: %s", val.Type()) 3687 } 3688 obj.ComponentID = string(v) 3689 continue 3690 } 3691 if key == "component_type" { 3692 v, ok := starlark.AsString(val) 3693 if !ok { 3694 return fmt.Errorf("Expected string, actual: %s", val.Type()) 3695 } 3696 obj.ComponentType = v1alpha1.ComponentType(v) 3697 continue 3698 } 3699 return fmt.Errorf("Unexpected attribute name: %s", key) 3700 } 3701 3702 mapObj.Freeze() 3703 o.Dict = mapObj 3704 o.Value = obj 3705 o.isUnpacked = true 3706 3707 return nil 3708 } 3709 3710 type UIComponentLocationList struct { 3711 *starlark.List 3712 Value []v1alpha1.UIComponentLocation 3713 t *starlark.Thread 3714 } 3715 3716 func (o *UIComponentLocationList) Unpack(v starlark.Value) error { 3717 items := []v1alpha1.UIComponentLocation{} 3718 3719 listObj, ok := v.(*starlark.List) 3720 if !ok { 3721 return fmt.Errorf("expected list, actual: %v", v.Type()) 3722 } 3723 3724 for i := 0; i < listObj.Len(); i++ { 3725 v := listObj.Index(i) 3726 3727 item := UIComponentLocation{t: o.t} 3728 err := item.Unpack(v) 3729 if err != nil { 3730 return fmt.Errorf("at index %d: %v", i, err) 3731 } 3732 items = append(items, v1alpha1.UIComponentLocation(item.Value)) 3733 } 3734 3735 listObj.Freeze() 3736 o.List = listObj 3737 o.Value = items 3738 3739 return nil 3740 } 3741 3742 type UIHiddenInputSpec struct { 3743 *starlark.Dict 3744 Value v1alpha1.UIHiddenInputSpec 3745 isUnpacked bool 3746 t *starlark.Thread // instantiation thread for computing abspath 3747 } 3748 3749 func (p Plugin) uIHiddenInputSpec(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) { 3750 var value starlark.Value 3751 err := starkit.UnpackArgs(t, fn.Name(), args, kwargs, 3752 "value?", &value, 3753 ) 3754 if err != nil { 3755 return nil, err 3756 } 3757 3758 dict := starlark.NewDict(1) 3759 3760 if value != nil { 3761 err := dict.SetKey(starlark.String("value"), value) 3762 if err != nil { 3763 return nil, err 3764 } 3765 } 3766 var obj *UIHiddenInputSpec = &UIHiddenInputSpec{t: t} 3767 err = obj.Unpack(dict) 3768 if err != nil { 3769 return nil, err 3770 } 3771 return obj, nil 3772 } 3773 3774 func (o *UIHiddenInputSpec) Unpack(v starlark.Value) error { 3775 obj := v1alpha1.UIHiddenInputSpec{} 3776 3777 starlarkObj, ok := v.(*UIHiddenInputSpec) 3778 if ok { 3779 *o = *starlarkObj 3780 return nil 3781 } 3782 3783 mapObj, ok := v.(*starlark.Dict) 3784 if !ok { 3785 return fmt.Errorf("expected dict, actual: %v", v.Type()) 3786 } 3787 3788 for _, item := range mapObj.Items() { 3789 keyV, val := item[0], item[1] 3790 key, ok := starlark.AsString(keyV) 3791 if !ok { 3792 return fmt.Errorf("key must be string. Got: %s", keyV.Type()) 3793 } 3794 3795 if key == "value" { 3796 v, ok := starlark.AsString(val) 3797 if !ok { 3798 return fmt.Errorf("Expected string, actual: %s", val.Type()) 3799 } 3800 obj.Value = string(v) 3801 continue 3802 } 3803 return fmt.Errorf("Unexpected attribute name: %s", key) 3804 } 3805 3806 mapObj.Freeze() 3807 o.Dict = mapObj 3808 o.Value = obj 3809 o.isUnpacked = true 3810 3811 return nil 3812 } 3813 3814 type UIHiddenInputSpecList struct { 3815 *starlark.List 3816 Value []v1alpha1.UIHiddenInputSpec 3817 t *starlark.Thread 3818 } 3819 3820 func (o *UIHiddenInputSpecList) Unpack(v starlark.Value) error { 3821 items := []v1alpha1.UIHiddenInputSpec{} 3822 3823 listObj, ok := v.(*starlark.List) 3824 if !ok { 3825 return fmt.Errorf("expected list, actual: %v", v.Type()) 3826 } 3827 3828 for i := 0; i < listObj.Len(); i++ { 3829 v := listObj.Index(i) 3830 3831 item := UIHiddenInputSpec{t: o.t} 3832 err := item.Unpack(v) 3833 if err != nil { 3834 return fmt.Errorf("at index %d: %v", i, err) 3835 } 3836 items = append(items, v1alpha1.UIHiddenInputSpec(item.Value)) 3837 } 3838 3839 listObj.Freeze() 3840 o.List = listObj 3841 o.Value = items 3842 3843 return nil 3844 } 3845 3846 type UIInputSpec struct { 3847 *starlark.Dict 3848 Value v1alpha1.UIInputSpec 3849 isUnpacked bool 3850 t *starlark.Thread // instantiation thread for computing abspath 3851 } 3852 3853 func (p Plugin) uIInputSpec(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) { 3854 var name starlark.Value 3855 var label starlark.Value 3856 var text starlark.Value 3857 var bool starlark.Value 3858 var hidden starlark.Value 3859 var choice starlark.Value 3860 err := starkit.UnpackArgs(t, fn.Name(), args, kwargs, 3861 "name?", &name, 3862 "label?", &label, 3863 "text?", &text, 3864 "bool?", &bool, 3865 "hidden?", &hidden, 3866 "choice?", &choice, 3867 ) 3868 if err != nil { 3869 return nil, err 3870 } 3871 3872 dict := starlark.NewDict(6) 3873 3874 if name != nil { 3875 err := dict.SetKey(starlark.String("name"), name) 3876 if err != nil { 3877 return nil, err 3878 } 3879 } 3880 if label != nil { 3881 err := dict.SetKey(starlark.String("label"), label) 3882 if err != nil { 3883 return nil, err 3884 } 3885 } 3886 if text != nil { 3887 err := dict.SetKey(starlark.String("text"), text) 3888 if err != nil { 3889 return nil, err 3890 } 3891 } 3892 if bool != nil { 3893 err := dict.SetKey(starlark.String("bool"), bool) 3894 if err != nil { 3895 return nil, err 3896 } 3897 } 3898 if hidden != nil { 3899 err := dict.SetKey(starlark.String("hidden"), hidden) 3900 if err != nil { 3901 return nil, err 3902 } 3903 } 3904 if choice != nil { 3905 err := dict.SetKey(starlark.String("choice"), choice) 3906 if err != nil { 3907 return nil, err 3908 } 3909 } 3910 var obj *UIInputSpec = &UIInputSpec{t: t} 3911 err = obj.Unpack(dict) 3912 if err != nil { 3913 return nil, err 3914 } 3915 return obj, nil 3916 } 3917 3918 func (o *UIInputSpec) Unpack(v starlark.Value) error { 3919 obj := v1alpha1.UIInputSpec{} 3920 3921 starlarkObj, ok := v.(*UIInputSpec) 3922 if ok { 3923 *o = *starlarkObj 3924 return nil 3925 } 3926 3927 mapObj, ok := v.(*starlark.Dict) 3928 if !ok { 3929 return fmt.Errorf("expected dict, actual: %v", v.Type()) 3930 } 3931 3932 for _, item := range mapObj.Items() { 3933 keyV, val := item[0], item[1] 3934 key, ok := starlark.AsString(keyV) 3935 if !ok { 3936 return fmt.Errorf("key must be string. Got: %s", keyV.Type()) 3937 } 3938 3939 if key == "name" { 3940 v, ok := starlark.AsString(val) 3941 if !ok { 3942 return fmt.Errorf("Expected string, actual: %s", val.Type()) 3943 } 3944 obj.Name = string(v) 3945 continue 3946 } 3947 if key == "label" { 3948 v, ok := starlark.AsString(val) 3949 if !ok { 3950 return fmt.Errorf("Expected string, actual: %s", val.Type()) 3951 } 3952 obj.Label = string(v) 3953 continue 3954 } 3955 if key == "text" { 3956 v := UITextInputSpec{t: o.t} 3957 err := v.Unpack(val) 3958 if err != nil { 3959 return fmt.Errorf("unpacking %s: %v", key, err) 3960 } 3961 obj.Text = (*v1alpha1.UITextInputSpec)(&v.Value) 3962 continue 3963 } 3964 if key == "bool" { 3965 v := UIBoolInputSpec{t: o.t} 3966 err := v.Unpack(val) 3967 if err != nil { 3968 return fmt.Errorf("unpacking %s: %v", key, err) 3969 } 3970 obj.Bool = (*v1alpha1.UIBoolInputSpec)(&v.Value) 3971 continue 3972 } 3973 if key == "hidden" { 3974 v := UIHiddenInputSpec{t: o.t} 3975 err := v.Unpack(val) 3976 if err != nil { 3977 return fmt.Errorf("unpacking %s: %v", key, err) 3978 } 3979 obj.Hidden = (*v1alpha1.UIHiddenInputSpec)(&v.Value) 3980 continue 3981 } 3982 if key == "choice" { 3983 v := UIChoiceInputSpec{t: o.t} 3984 err := v.Unpack(val) 3985 if err != nil { 3986 return fmt.Errorf("unpacking %s: %v", key, err) 3987 } 3988 obj.Choice = (*v1alpha1.UIChoiceInputSpec)(&v.Value) 3989 continue 3990 } 3991 return fmt.Errorf("Unexpected attribute name: %s", key) 3992 } 3993 3994 mapObj.Freeze() 3995 o.Dict = mapObj 3996 o.Value = obj 3997 o.isUnpacked = true 3998 3999 return nil 4000 } 4001 4002 type UIInputSpecList struct { 4003 *starlark.List 4004 Value []v1alpha1.UIInputSpec 4005 t *starlark.Thread 4006 } 4007 4008 func (o *UIInputSpecList) Unpack(v starlark.Value) error { 4009 items := []v1alpha1.UIInputSpec{} 4010 4011 listObj, ok := v.(*starlark.List) 4012 if !ok { 4013 return fmt.Errorf("expected list, actual: %v", v.Type()) 4014 } 4015 4016 for i := 0; i < listObj.Len(); i++ { 4017 v := listObj.Index(i) 4018 4019 item := UIInputSpec{t: o.t} 4020 err := item.Unpack(v) 4021 if err != nil { 4022 return fmt.Errorf("at index %d: %v", i, err) 4023 } 4024 items = append(items, v1alpha1.UIInputSpec(item.Value)) 4025 } 4026 4027 listObj.Freeze() 4028 o.List = listObj 4029 o.Value = items 4030 4031 return nil 4032 } 4033 4034 type UITextInputSpec struct { 4035 *starlark.Dict 4036 Value v1alpha1.UITextInputSpec 4037 isUnpacked bool 4038 t *starlark.Thread // instantiation thread for computing abspath 4039 } 4040 4041 func (p Plugin) uITextInputSpec(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) { 4042 var defaultValue starlark.Value 4043 var placeholder starlark.Value 4044 err := starkit.UnpackArgs(t, fn.Name(), args, kwargs, 4045 "default_value?", &defaultValue, 4046 "placeholder?", &placeholder, 4047 ) 4048 if err != nil { 4049 return nil, err 4050 } 4051 4052 dict := starlark.NewDict(2) 4053 4054 if defaultValue != nil { 4055 err := dict.SetKey(starlark.String("default_value"), defaultValue) 4056 if err != nil { 4057 return nil, err 4058 } 4059 } 4060 if placeholder != nil { 4061 err := dict.SetKey(starlark.String("placeholder"), placeholder) 4062 if err != nil { 4063 return nil, err 4064 } 4065 } 4066 var obj *UITextInputSpec = &UITextInputSpec{t: t} 4067 err = obj.Unpack(dict) 4068 if err != nil { 4069 return nil, err 4070 } 4071 return obj, nil 4072 } 4073 4074 func (o *UITextInputSpec) Unpack(v starlark.Value) error { 4075 obj := v1alpha1.UITextInputSpec{} 4076 4077 starlarkObj, ok := v.(*UITextInputSpec) 4078 if ok { 4079 *o = *starlarkObj 4080 return nil 4081 } 4082 4083 mapObj, ok := v.(*starlark.Dict) 4084 if !ok { 4085 return fmt.Errorf("expected dict, actual: %v", v.Type()) 4086 } 4087 4088 for _, item := range mapObj.Items() { 4089 keyV, val := item[0], item[1] 4090 key, ok := starlark.AsString(keyV) 4091 if !ok { 4092 return fmt.Errorf("key must be string. Got: %s", keyV.Type()) 4093 } 4094 4095 if key == "default_value" { 4096 v, ok := starlark.AsString(val) 4097 if !ok { 4098 return fmt.Errorf("Expected string, actual: %s", val.Type()) 4099 } 4100 obj.DefaultValue = string(v) 4101 continue 4102 } 4103 if key == "placeholder" { 4104 v, ok := starlark.AsString(val) 4105 if !ok { 4106 return fmt.Errorf("Expected string, actual: %s", val.Type()) 4107 } 4108 obj.Placeholder = string(v) 4109 continue 4110 } 4111 return fmt.Errorf("Unexpected attribute name: %s", key) 4112 } 4113 4114 mapObj.Freeze() 4115 o.Dict = mapObj 4116 o.Value = obj 4117 o.isUnpacked = true 4118 4119 return nil 4120 } 4121 4122 type UITextInputSpecList struct { 4123 *starlark.List 4124 Value []v1alpha1.UITextInputSpec 4125 t *starlark.Thread 4126 } 4127 4128 func (o *UITextInputSpecList) Unpack(v starlark.Value) error { 4129 items := []v1alpha1.UITextInputSpec{} 4130 4131 listObj, ok := v.(*starlark.List) 4132 if !ok { 4133 return fmt.Errorf("expected list, actual: %v", v.Type()) 4134 } 4135 4136 for i := 0; i < listObj.Len(); i++ { 4137 v := listObj.Index(i) 4138 4139 item := UITextInputSpec{t: o.t} 4140 err := item.Unpack(v) 4141 if err != nil { 4142 return fmt.Errorf("at index %d: %v", i, err) 4143 } 4144 items = append(items, v1alpha1.UITextInputSpec(item.Value)) 4145 } 4146 4147 listObj.Freeze() 4148 o.List = listObj 4149 o.Value = items 4150 4151 return nil 4152 }