depRicKubernetesOperator/internal/controller/getServices.go

   1 package controller\r
   2 \r
   3 import (\r
   4         corev1 "k8s.io/api/core/v1"\r
   5         metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"\r
   6         "k8s.io/apimachinery/pkg/util/intstr"\r
   7 )\r
   8 \r
   9 func GetService() []*corev1.Service {\r
  10 \r
  11         service1 := &corev1.Service{\r
  12                 ObjectMeta: metav1.ObjectMeta{\r
  13                         Labels: map[string]string{\r
  14                                 "app":      "ricplt-a1mediator",\r
  15                                 "chart":    "a1mediator-3.0.0",\r
  16                                 "heritage": "Helm",\r
  17                                 "release":  "release-name",\r
  18                         },\r
  19                         Name:      "service-ricplt-a1mediator-http",\r
  20                         Namespace: "ricplt",\r
  21                 },\r
  22                 Spec: corev1.ServiceSpec{\r
  23                         Type: corev1.ServiceType("ClusterIP"),\r
  24                         Ports: []corev1.ServicePort{\r
  25 \r
  26                                 corev1.ServicePort{\r
  27                                         Protocol: corev1.Protocol("TCP"),\r
  28                                         TargetPort: intstr.IntOrString{\r
  29                                                 StrVal: "http",\r
  30                                                 Type:   intstr.Type(1),\r
  31                                         },\r
  32                                         Name: "http",\r
  33                                         Port: 10000,\r
  34                                 },\r
  35                         },\r
  36                         PublishNotReadyAddresses: false,\r
  37                         Selector: map[string]string{\r
  38                                 "app":     "ricplt-a1mediator",\r
  39                                 "release": "release-name",\r
  40                         },\r
  41                 },\r
  42                 TypeMeta: metav1.TypeMeta{\r
  43                         APIVersion: "v1",\r
  44                         Kind:       "Service",\r
  45                 },\r
  46         }\r
  47 \r
  48         service2 := &corev1.Service{\r
  49                 ObjectMeta: metav1.ObjectMeta{\r
  50                         Labels: map[string]string{\r
  51                                 "release":  "release-name",\r
  52                                 "app":      "ricplt-a1mediator",\r
  53                                 "chart":    "a1mediator-3.0.0",\r
  54                                 "heritage": "Helm",\r
  55                         },\r
  56                         Name:      "service-ricplt-a1mediator-rmr",\r
  57                         Namespace: "ricplt",\r
  58                 },\r
  59                 Spec: corev1.ServiceSpec{\r
  60                         PublishNotReadyAddresses: false,\r
  61                         Selector: map[string]string{\r
  62                                 "app":     "ricplt-a1mediator",\r
  63                                 "release": "release-name",\r
  64                         },\r
  65                         Type: corev1.ServiceType("ClusterIP"),\r
  66                         Ports: []corev1.ServicePort{\r
  67 \r
  68                                 corev1.ServicePort{\r
  69                                         Name:     "rmrroute",\r
  70                                         Port:     4561,\r
  71                                         Protocol: corev1.Protocol("TCP"),\r
  72                                         TargetPort: intstr.IntOrString{\r
  73                                                 Type:   intstr.Type(1),\r
  74                                                 StrVal: "rmrroute",\r
  75                                         },\r
  76                                 },\r
  77                                 corev1.ServicePort{\r
  78                                         Name:     "rmrdata",\r
  79                                         Port:     4562,\r
  80                                         Protocol: corev1.Protocol("TCP"),\r
  81                                         TargetPort: intstr.IntOrString{\r
  82                                                 StrVal: "rmrdata",\r
  83                                                 Type:   intstr.Type(1),\r
  84                                         },\r
  85                                 },\r
  86                         },\r
  87                 },\r
  88                 TypeMeta: metav1.TypeMeta{\r
  89                         APIVersion: "v1",\r
  90                         Kind:       "Service",\r
  91                 },\r
  92         }\r
  93 \r
  94         service3 := &corev1.Service{\r
  95                 ObjectMeta: metav1.ObjectMeta{\r
  96                         Labels: map[string]string{\r
  97                                 "heritage": "Helm",\r
  98                                 "release":  "release-name",\r
  99                                 "app":      "ricplt-alarmmanager",\r
 100                                 "chart":    "alarmmanager-5.0.0",\r
 101                         },\r
 102                         Name:      "service-ricplt-alarmmanager-http",\r
 103                         Namespace: "ricplt",\r
 104                 },\r
 105                 Spec: corev1.ServiceSpec{\r
 106                         Ports: []corev1.ServicePort{\r
 107 \r
 108                                 corev1.ServicePort{\r
 109                                         Name:     "http",\r
 110                                         Port:     8080,\r
 111                                         Protocol: corev1.Protocol("TCP"),\r
 112                                         TargetPort: intstr.IntOrString{\r
 113                                                 IntVal: 8080,\r
 114                                         },\r
 115                                 },\r
 116                         },\r
 117                         PublishNotReadyAddresses: false,\r
 118                         Selector: map[string]string{\r
 119                                 "app":     "ricplt-alarmmanager",\r
 120                                 "release": "release-name",\r
 121                         },\r
 122                         Type: corev1.ServiceType("ClusterIP"),\r
 123                 },\r
 124                 TypeMeta: metav1.TypeMeta{\r
 125                         Kind:       "Service",\r
 126                         APIVersion: "v1",\r
 127                 },\r
 128         }\r
 129 \r
 130         service4 := &corev1.Service{\r
 131                 ObjectMeta: metav1.ObjectMeta{\r
 132                         Labels: map[string]string{\r
 133                                 "app":      "ricplt-alarmmanager",\r
 134                                 "chart":    "alarmmanager-5.0.0",\r
 135                                 "heritage": "Helm",\r
 136                                 "release":  "release-name",\r
 137                         },\r
 138                         Name:      "service-ricplt-alarmmanager-rmr",\r
 139                         Namespace: "ricplt",\r
 140                 },\r
 141                 Spec: corev1.ServiceSpec{\r
 142                         Ports: []corev1.ServicePort{\r
 143 \r
 144                                 corev1.ServicePort{\r
 145                                         TargetPort: intstr.IntOrString{\r
 146                                                 StrVal: "rmrdata",\r
 147                                                 Type:   intstr.Type(1),\r
 148                                         },\r
 149                                         Name:     "rmrdata",\r
 150                                         Port:     4560,\r
 151                                         Protocol: corev1.Protocol("TCP"),\r
 152                                 },\r
 153                                 corev1.ServicePort{\r
 154                                         Name:     "rmrroute",\r
 155                                         Port:     4561,\r
 156                                         Protocol: corev1.Protocol("TCP"),\r
 157                                         TargetPort: intstr.IntOrString{\r
 158                                                 StrVal: "rmrroute",\r
 159                                                 Type:   intstr.Type(1),\r
 160                                         },\r
 161                                 },\r
 162                         },\r
 163                         PublishNotReadyAddresses: false,\r
 164                         Selector: map[string]string{\r
 165                                 "app":     "ricplt-alarmmanager",\r
 166                                 "release": "release-name",\r
 167                         },\r
 168                         Type: corev1.ServiceType("ClusterIP"),\r
 169                 },\r
 170                 TypeMeta: metav1.TypeMeta{\r
 171                         APIVersion: "v1",\r
 172                         Kind:       "Service",\r
 173                 },\r
 174         }\r
 175 \r
 176         service5 := &corev1.Service{\r
 177                 ObjectMeta: metav1.ObjectMeta{\r
 178                         Labels: map[string]string{\r
 179                                 "app":      "ricplt-appmgr",\r
 180                                 "chart":    "appmgr-3.0.0",\r
 181                                 "heritage": "Helm",\r
 182                                 "release":  "release-name",\r
 183                         },\r
 184                         Name:      "service-ricplt-appmgr-http",\r
 185                         Namespace: "ricplt",\r
 186                 },\r
 187                 Spec: corev1.ServiceSpec{\r
 188                         Ports: []corev1.ServicePort{\r
 189 \r
 190                                 corev1.ServicePort{\r
 191                                         Name:     "http",\r
 192                                         Port:     8080,\r
 193                                         Protocol: corev1.Protocol("TCP"),\r
 194                                         TargetPort: intstr.IntOrString{\r
 195                                                 Type:   intstr.Type(1),\r
 196                                                 StrVal: "http",\r
 197                                         },\r
 198                                 },\r
 199                         },\r
 200                         PublishNotReadyAddresses: false,\r
 201                         Selector: map[string]string{\r
 202                                 "release": "release-name",\r
 203                                 "app":     "ricplt-appmgr",\r
 204                         },\r
 205                         Type: corev1.ServiceType("ClusterIP"),\r
 206                 },\r
 207                 TypeMeta: metav1.TypeMeta{\r
 208                         APIVersion: "v1",\r
 209                         Kind:       "Service",\r
 210                 },\r
 211         }\r
 212 \r
 213         service6 := &corev1.Service{\r
 214                 ObjectMeta: metav1.ObjectMeta{\r
 215                         Name:      "service-ricplt-appmgr-rmr",\r
 216                         Namespace: "ricplt",\r
 217                         Labels: map[string]string{\r
 218                                 "chart":    "appmgr-3.0.0",\r
 219                                 "heritage": "Helm",\r
 220                                 "release":  "release-name",\r
 221                                 "app":      "ricplt-appmgr",\r
 222                         },\r
 223                 },\r
 224                 Spec: corev1.ServiceSpec{\r
 225                         Ports: []corev1.ServicePort{\r
 226 \r
 227                                 corev1.ServicePort{\r
 228                                         Name:     "rmrroute",\r
 229                                         Port:     4561,\r
 230                                         Protocol: corev1.Protocol("TCP"),\r
 231                                         TargetPort: intstr.IntOrString{\r
 232                                                 Type:   intstr.Type(1),\r
 233                                                 StrVal: "rmrroute",\r
 234                                         },\r
 235                                 },\r
 236                                 corev1.ServicePort{\r
 237                                         Name:     "rmrdata",\r
 238                                         Port:     4560,\r
 239                                         Protocol: corev1.Protocol("TCP"),\r
 240                                         TargetPort: intstr.IntOrString{\r
 241                                                 StrVal: "rmrdata",\r
 242                                                 Type:   intstr.Type(1),\r
 243                                         },\r
 244                                 },\r
 245                         },\r
 246                         PublishNotReadyAddresses: false,\r
 247                         Selector: map[string]string{\r
 248                                 "app":     "ricplt-appmgr",\r
 249                                 "release": "release-name",\r
 250                         },\r
 251                         Type: corev1.ServiceType("ClusterIP"),\r
 252                 },\r
 253                 TypeMeta: metav1.TypeMeta{\r
 254                         APIVersion: "v1",\r
 255                         Kind:       "Service",\r
 256                 },\r
 257         }\r
 258 \r
 259         service7 := &corev1.Service{\r
 260                 ObjectMeta: metav1.ObjectMeta{\r
 261                         Labels: map[string]string{\r
 262                                 "app":      "ricplt-dbaas",\r
 263                                 "chart":    "dbaas-2.0.0",\r
 264                                 "heritage": "Helm",\r
 265                                 "release":  "release-name",\r
 266                         },\r
 267                         Name: "service-ricplt-dbaas-tcp",\r
 268                 },\r
 269                 Spec: corev1.ServiceSpec{\r
 270                         ClusterIP: "None",\r
 271                         Ports: []corev1.ServicePort{\r
 272 \r
 273                                 corev1.ServicePort{\r
 274                                         Name:     "server",\r
 275                                         Port:     6379,\r
 276                                         Protocol: corev1.Protocol("TCP"),\r
 277                                         TargetPort: intstr.IntOrString{\r
 278                                                 StrVal: "redis",\r
 279                                                 Type:   intstr.Type(1),\r
 280                                         },\r
 281                                 },\r
 282                         },\r
 283                         PublishNotReadyAddresses: false,\r
 284                         Selector: map[string]string{\r
 285                                 "app":     "ricplt-dbaas",\r
 286                                 "release": "release-name",\r
 287                         },\r
 288                         Type: corev1.ServiceType("ClusterIP"),\r
 289                 },\r
 290                 TypeMeta: metav1.TypeMeta{\r
 291                         APIVersion: "v1",\r
 292                         Kind:       "Service",\r
 293                 },\r
 294         }\r
 295 \r
 296         service8 := &corev1.Service{\r
 297                 ObjectMeta: metav1.ObjectMeta{\r
 298                         Labels: map[string]string{\r
 299                                 "app":      "ricplt-e2mgr",\r
 300                                 "chart":    "e2mgr-3.0.0",\r
 301                                 "heritage": "Helm",\r
 302                                 "release":  "release-name",\r
 303                         },\r
 304                         Name:      "service-ricplt-e2mgr-http",\r
 305                         Namespace: "ricplt",\r
 306                 },\r
 307                 Spec: corev1.ServiceSpec{\r
 308                         Ports: []corev1.ServicePort{\r
 309 \r
 310                                 corev1.ServicePort{\r
 311                                         TargetPort: intstr.IntOrString{\r
 312                                                 StrVal: "http",\r
 313                                                 Type:   intstr.Type(1),\r
 314                                         },\r
 315                                         Name:     "http",\r
 316                                         Port:     3800,\r
 317                                         Protocol: corev1.Protocol("TCP"),\r
 318                                 },\r
 319                         },\r
 320                         PublishNotReadyAddresses: false,\r
 321                         Selector: map[string]string{\r
 322                                 "app":     "ricplt-e2mgr",\r
 323                                 "release": "release-name",\r
 324                         },\r
 325                         Type: corev1.ServiceType("ClusterIP"),\r
 326                 },\r
 327                 TypeMeta: metav1.TypeMeta{\r
 328                         Kind:       "Service",\r
 329                         APIVersion: "v1",\r
 330                 },\r
 331         }\r
 332 \r
 333         service9 := &corev1.Service{\r
 334                 TypeMeta: metav1.TypeMeta{\r
 335                         APIVersion: "v1",\r
 336                         Kind:       "Service",\r
 337                 },\r
 338                 ObjectMeta: metav1.ObjectMeta{\r
 339                         Labels: map[string]string{\r
 340                                 "app":      "ricplt-e2mgr",\r
 341                                 "chart":    "e2mgr-3.0.0",\r
 342                                 "heritage": "Helm",\r
 343                                 "release":  "release-name",\r
 344                         },\r
 345                         Name:      "service-ricplt-e2mgr-rmr",\r
 346                         Namespace: "ricplt",\r
 347                 },\r
 348                 Spec: corev1.ServiceSpec{\r
 349                         Selector: map[string]string{\r
 350                                 "app":     "ricplt-e2mgr",\r
 351                                 "release": "release-name",\r
 352                         },\r
 353                         Type: corev1.ServiceType("ClusterIP"),\r
 354                         Ports: []corev1.ServicePort{\r
 355 \r
 356                                 corev1.ServicePort{\r
 357                                         Protocol: corev1.Protocol("TCP"),\r
 358                                         TargetPort: intstr.IntOrString{\r
 359                                                 StrVal: "rmrroute",\r
 360                                                 Type:   intstr.Type(1),\r
 361                                         },\r
 362                                         Name: "rmrroute",\r
 363                                         Port: 4561,\r
 364                                 },\r
 365                                 corev1.ServicePort{\r
 366                                         Name:     "rmrdata",\r
 367                                         Port:     3801,\r
 368                                         Protocol: corev1.Protocol("TCP"),\r
 369                                         TargetPort: intstr.IntOrString{\r
 370                                                 StrVal: "rmrdata",\r
 371                                                 Type:   intstr.Type(1),\r
 372                                         },\r
 373                                 },\r
 374                         },\r
 375                         PublishNotReadyAddresses: false,\r
 376                 },\r
 377         }\r
 378 \r
 379         service10 := &corev1.Service{\r
 380                 ObjectMeta: metav1.ObjectMeta{\r
 381                         Annotations: map[string]string{\r
 382                                 "prometheus.io/path":   "/metrics",\r
 383                                 "prometheus.io/port":   "8088",\r
 384                                 "prometheus.io/scrape": "true",\r
 385                         },\r
 386                         Labels: map[string]string{\r
 387                                 "heritage": "Helm",\r
 388                                 "release":  "release-name",\r
 389                                 "app":      "ricplt-e2term-alpha",\r
 390                                 "chart":    "e2term-3.0.0",\r
 391                         },\r
 392                         Name:      "service-ricplt-e2term-prometheus-alpha",\r
 393                         Namespace: "ricplt",\r
 394                 },\r
 395                 Spec: corev1.ServiceSpec{\r
 396                         Ports: []corev1.ServicePort{\r
 397 \r
 398                                 corev1.ServicePort{\r
 399                                         Name:     "prmts-alpha",\r
 400                                         Port:     8088,\r
 401                                         Protocol: corev1.Protocol("TCP"),\r
 402                                         TargetPort: intstr.IntOrString{\r
 403                                                 StrVal: "prmts-alpha",\r
 404                                                 Type:   intstr.Type(1),\r
 405                                         },\r
 406                                 },\r
 407                         },\r
 408                         PublishNotReadyAddresses: false,\r
 409                         Selector: map[string]string{\r
 410                                 "release": "release-name",\r
 411                                 "app":     "ricplt-e2term-alpha",\r
 412                         },\r
 413                         Type: corev1.ServiceType("ClusterIP"),\r
 414                 },\r
 415                 TypeMeta: metav1.TypeMeta{\r
 416                         APIVersion: "v1",\r
 417                         Kind:       "Service",\r
 418                 },\r
 419         }\r
 420 \r
 421         service11 := &corev1.Service{\r
 422                 ObjectMeta: metav1.ObjectMeta{\r
 423                         Labels: map[string]string{\r
 424                                 "chart":    "e2term-3.0.0",\r
 425                                 "heritage": "Helm",\r
 426                                 "release":  "release-name",\r
 427                                 "app":      "ricplt-e2term-alpha",\r
 428                         },\r
 429                         Name:      "service-ricplt-e2term-rmr-alpha",\r
 430                         Namespace: "ricplt",\r
 431                 },\r
 432                 Spec: corev1.ServiceSpec{\r
 433                         Ports: []corev1.ServicePort{\r
 434 \r
 435                                 corev1.ServicePort{\r
 436                                         Name:     "rmrroute-alpha",\r
 437                                         Port:     4561,\r
 438                                         Protocol: corev1.Protocol("TCP"),\r
 439                                         TargetPort: intstr.IntOrString{\r
 440                                                 StrVal: "rmrroute-alpha",\r
 441                                                 Type:   intstr.Type(1),\r
 442                                         },\r
 443                                 },\r
 444                                 corev1.ServicePort{\r
 445                                         TargetPort: intstr.IntOrString{\r
 446                                                 StrVal: "rmrdata-alpha",\r
 447                                                 Type:   intstr.Type(1),\r
 448                                         },\r
 449                                         Name:     "rmrdata-alpha",\r
 450                                         Port:     38000,\r
 451                                         Protocol: corev1.Protocol("TCP"),\r
 452                                 },\r
 453                         },\r
 454                         PublishNotReadyAddresses: false,\r
 455                         Selector: map[string]string{\r
 456                                 "app":     "ricplt-e2term-alpha",\r
 457                                 "release": "release-name",\r
 458                         },\r
 459                         Type: corev1.ServiceType("ClusterIP"),\r
 460                 },\r
 461                 TypeMeta: metav1.TypeMeta{\r
 462                         APIVersion: "v1",\r
 463                         Kind:       "Service",\r
 464                 },\r
 465         }\r
 466 \r
 467         service12 := &corev1.Service{\r
 468                 ObjectMeta: metav1.ObjectMeta{\r
 469                         Namespace: "ricplt",\r
 470                         Labels: map[string]string{\r
 471                                 "app":      "ricplt-e2term-alpha",\r
 472                                 "chart":    "e2term-3.0.0",\r
 473                                 "heritage": "Helm",\r
 474                                 "release":  "release-name",\r
 475                         },\r
 476                         Name: "service-ricplt-e2term-sctp-alpha",\r
 477                 },\r
 478                 Spec: corev1.ServiceSpec{\r
 479                         Ports: []corev1.ServicePort{\r
 480 \r
 481                                 corev1.ServicePort{\r
 482                                         Name:     "sctp-alpha",\r
 483                                         NodePort: 32222,\r
 484                                         Port:     36422,\r
 485                                         Protocol: corev1.Protocol("SCTP"),\r
 486                                         TargetPort: intstr.IntOrString{\r
 487                                                 IntVal: 36422,\r
 488                                         },\r
 489                                 },\r
 490                         },\r
 491                         PublishNotReadyAddresses: false,\r
 492                         Selector: map[string]string{\r
 493                                 "app":     "ricplt-e2term-alpha",\r
 494                                 "release": "release-name",\r
 495                         },\r
 496                         Type: corev1.ServiceType("NodePort"),\r
 497                 },\r
 498                 TypeMeta: metav1.TypeMeta{\r
 499                         APIVersion: "v1",\r
 500                         Kind:       "Service",\r
 501                 },\r
 502         }\r
 503 \r
 504         service13 := &corev1.Service{\r
 505                 TypeMeta: metav1.TypeMeta{\r
 506                         APIVersion: "v1",\r
 507                         Kind:       "Service",\r
 508                 },\r
 509                 ObjectMeta: metav1.ObjectMeta{\r
 510                         Name:      "aux-entry",\r
 511                         Namespace: "ricplt",\r
 512                 },\r
 513                 Spec: corev1.ServiceSpec{\r
 514                         Ports: []corev1.ServicePort{\r
 515 \r
 516                                 corev1.ServicePort{\r
 517                                         Name:     "aux-entry-http-ingress-port",\r
 518                                         Port:     80,\r
 519                                         Protocol: corev1.Protocol("TCP"),\r
 520                                 },\r
 521                                 corev1.ServicePort{\r
 522                                         Name:     "aux-entry-https-ingress-port",\r
 523                                         Port:     443,\r
 524                                         Protocol: corev1.Protocol("TCP"),\r
 525                                 },\r
 526                         },\r
 527                         PublishNotReadyAddresses: false,\r
 528                 },\r
 529         }\r
 530 \r
 531         service14 := &corev1.Service{\r
 532                 ObjectMeta: metav1.ObjectMeta{\r
 533                         Name:      "aux-entry",\r
 534                         Namespace: "ricxapp",\r
 535                 },\r
 536                 Spec: corev1.ServiceSpec{\r
 537                         Ports: []corev1.ServicePort{\r
 538 \r
 539                                 corev1.ServicePort{\r
 540                                         Name:     "aux-entry-http-ingress-port",\r
 541                                         Port:     80,\r
 542                                         Protocol: corev1.Protocol("TCP"),\r
 543                                 },\r
 544                                 corev1.ServicePort{\r
 545                                         Protocol: corev1.Protocol("TCP"),\r
 546                                         Name:     "aux-entry-https-ingress-port",\r
 547                                         Port:     443,\r
 548                                 },\r
 549                         },\r
 550                         PublishNotReadyAddresses: false,\r
 551                 },\r
 552                 TypeMeta: metav1.TypeMeta{\r
 553                         Kind:       "Service",\r
 554                         APIVersion: "v1",\r
 555                 },\r
 556         }\r
 557 \r
 558         service15 := &corev1.Service{\r
 559                 ObjectMeta: metav1.ObjectMeta{\r
 560                         Name:      "aux-entry",\r
 561                         Namespace: "ricplt",\r
 562                 },\r
 563                 Spec: corev1.ServiceSpec{\r
 564                         Ports: []corev1.ServicePort{\r
 565 \r
 566                                 corev1.ServicePort{\r
 567                                         Name:     "aux-entry-http-ingress-port",\r
 568                                         Port:     80,\r
 569                                         Protocol: corev1.Protocol("TCP"),\r
 570                                 },\r
 571                                 corev1.ServicePort{\r
 572                                         Name:     "aux-entry-https-ingress-port",\r
 573                                         Port:     443,\r
 574                                         Protocol: corev1.Protocol("TCP"),\r
 575                                 },\r
 576                         },\r
 577                         PublishNotReadyAddresses: false,\r
 578                 },\r
 579                 TypeMeta: metav1.TypeMeta{\r
 580                         Kind:       "Service",\r
 581                         APIVersion: "v1",\r
 582                 },\r
 583         }\r
 584 \r
 585         service16 := &corev1.Service{\r
 586                 ObjectMeta: metav1.ObjectMeta{\r
 587                         Name:      "aux-entry",\r
 588                         Namespace: "ricxapp",\r
 589                 },\r
 590                 Spec: corev1.ServiceSpec{\r
 591                         Ports: []corev1.ServicePort{\r
 592 \r
 593                                 corev1.ServicePort{\r
 594                                         Port:     80,\r
 595                                         Protocol: corev1.Protocol("TCP"),\r
 596                                         Name:     "aux-entry-http-ingress-port",\r
 597                                 },\r
 598                                 corev1.ServicePort{\r
 599                                         Name:     "aux-entry-https-ingress-port",\r
 600                                         Port:     443,\r
 601                                         Protocol: corev1.Protocol("TCP"),\r
 602                                 },\r
 603                         },\r
 604                         PublishNotReadyAddresses: false,\r
 605                 },\r
 606                 TypeMeta: metav1.TypeMeta{\r
 607                         Kind:       "Service",\r
 608                         APIVersion: "v1",\r
 609                 },\r
 610         }\r
 611 \r
 612         service17 := &corev1.Service{\r
 613                 Spec: corev1.ServiceSpec{\r
 614                         Selector: map[string]string{\r
 615                                 "app.kubernetes.io/instance":  "release-name",\r
 616                                 "app.kubernetes.io/name":      "kong",\r
 617                                 "app.kubernetes.io/component": "app",\r
 618                         },\r
 619                         Type: corev1.ServiceType("NodePort"),\r
 620                         Ports: []corev1.ServicePort{\r
 621 \r
 622                                 corev1.ServicePort{\r
 623                                         Name:     "kong-proxy",\r
 624                                         NodePort: 32080,\r
 625                                         Port:     32080,\r
 626                                         Protocol: corev1.Protocol("TCP"),\r
 627                                         TargetPort: intstr.IntOrString{\r
 628                                                 IntVal: 32080,\r
 629                                         },\r
 630                                 },\r
 631                                 corev1.ServicePort{\r
 632                                         Port:     32443,\r
 633                                         Protocol: corev1.Protocol("TCP"),\r
 634                                         TargetPort: intstr.IntOrString{\r
 635                                                 IntVal: 32443,\r
 636                                         },\r
 637                                         Name:     "kong-proxy-tls",\r
 638                                         NodePort: 32443,\r
 639                                 },\r
 640                         },\r
 641                         PublishNotReadyAddresses: false,\r
 642                 },\r
 643                 TypeMeta: metav1.TypeMeta{\r
 644                         APIVersion: "v1",\r
 645                         Kind:       "Service",\r
 646                 },\r
 647                 ObjectMeta: metav1.ObjectMeta{\r
 648                         Name: "release-name-kong-proxy",\r
 649                         Labels: map[string]string{\r
 650                                 "app.kubernetes.io/instance":   "release-name",\r
 651                                 "app.kubernetes.io/managed-by": "Helm",\r
 652                                 "app.kubernetes.io/name":       "kong",\r
 653                                 "app.kubernetes.io/version":    "1.4",\r
 654                                 "helm.sh/chart":                "kong-0.36.6",\r
 655                         },\r
 656                 },\r
 657         }\r
 658 \r
 659         service18 := &corev1.Service{\r
 660                 ObjectMeta: metav1.ObjectMeta{\r
 661                         Labels: map[string]string{\r
 662                                 "app":  "helm",\r
 663                                 "name": "tiller",\r
 664                         },\r
 665                         Name:      "service-tiller-ricxapp",\r
 666                         Namespace: "ricinfra",\r
 667                 },\r
 668                 Spec: corev1.ServiceSpec{\r
 669                         PublishNotReadyAddresses: false,\r
 670                         Selector: map[string]string{\r
 671                                 "app":  "helm",\r
 672                                 "name": "tiller",\r
 673                         },\r
 674                         Type: corev1.ServiceType("ClusterIP"),\r
 675                         Ports: []corev1.ServicePort{\r
 676 \r
 677                                 corev1.ServicePort{\r
 678                                         Name: "tiller",\r
 679                                         Port: 44134,\r
 680                                         TargetPort: intstr.IntOrString{\r
 681                                                 StrVal: "tiller",\r
 682                                                 Type:   intstr.Type(1),\r
 683                                         },\r
 684                                 },\r
 685                         },\r
 686                 },\r
 687                 TypeMeta: metav1.TypeMeta{\r
 688                         APIVersion: "v1",\r
 689                         Kind:       "Service",\r
 690                 },\r
 691         }\r
 692 \r
 693         service19 := &corev1.Service{\r
 694                 Spec: corev1.ServiceSpec{\r
 695                         Ports: []corev1.ServicePort{\r
 696 \r
 697                                 corev1.ServicePort{\r
 698                                         Port:     5775,\r
 699                                         Protocol: corev1.Protocol("UDP"),\r
 700                                         TargetPort: intstr.IntOrString{\r
 701                                                 IntVal: 5775,\r
 702                                         },\r
 703                                         Name: "zipkincompact",\r
 704                                 },\r
 705                                 corev1.ServicePort{\r
 706                                         Name:     "jaegercompact",\r
 707                                         Port:     6831,\r
 708                                         Protocol: corev1.Protocol("UDP"),\r
 709                                         TargetPort: intstr.IntOrString{\r
 710                                                 IntVal: 6831,\r
 711                                         },\r
 712                                 },\r
 713                                 corev1.ServicePort{\r
 714                                         Name:     "jaegerbinary",\r
 715                                         Port:     6832,\r
 716                                         Protocol: corev1.Protocol("UDP"),\r
 717                                         TargetPort: intstr.IntOrString{\r
 718                                                 IntVal: 6832,\r
 719                                         },\r
 720                                 },\r
 721                         },\r
 722                         PublishNotReadyAddresses: false,\r
 723                         Selector: map[string]string{\r
 724                                 "release": "release-name",\r
 725                                 "app":     "ricplt-jaegeradapter",\r
 726                         },\r
 727                         Type: corev1.ServiceType("ClusterIP"),\r
 728                 },\r
 729                 TypeMeta: metav1.TypeMeta{\r
 730                         Kind:       "Service",\r
 731                         APIVersion: "v1",\r
 732                 },\r
 733                 ObjectMeta: metav1.ObjectMeta{\r
 734                         Labels: map[string]string{\r
 735                                 "app":      "ricplt-jaegeradapter",\r
 736                                 "chart":    "jaegeradapter-3.0.0",\r
 737                                 "heritage": "Helm",\r
 738                                 "release":  "release-name",\r
 739                         },\r
 740                         Name:      "service-ricplt-jaegeradapter-agent",\r
 741                         Namespace: "ricplt",\r
 742                 },\r
 743         }\r
 744 \r
 745         service20 := &corev1.Service{\r
 746                 ObjectMeta: metav1.ObjectMeta{\r
 747                         Labels: map[string]string{\r
 748                                 "app":      "ricplt-jaegeradapter",\r
 749                                 "chart":    "jaegeradapter-3.0.0",\r
 750                                 "heritage": "Helm",\r
 751                                 "release":  "release-name",\r
 752                         },\r
 753                         Name:      "service-ricplt-jaegeradapter-collector",\r
 754                         Namespace: "ricplt",\r
 755                 },\r
 756                 Spec: corev1.ServiceSpec{\r
 757                         Ports: []corev1.ServicePort{\r
 758 \r
 759                                 corev1.ServicePort{\r
 760                                         Name:     "jaegerhttpt",\r
 761                                         Port:     14267,\r
 762                                         Protocol: corev1.Protocol("TCP"),\r
 763                                         TargetPort: intstr.IntOrString{\r
 764                                                 IntVal: 14267,\r
 765                                         },\r
 766                                 },\r
 767                                 corev1.ServicePort{\r
 768                                         Port:     14268,\r
 769                                         Protocol: corev1.Protocol("TCP"),\r
 770                                         TargetPort: intstr.IntOrString{\r
 771                                                 IntVal: 14268,\r
 772                                         },\r
 773                                         Name: "jaegerhttp",\r
 774                                 },\r
 775                                 corev1.ServicePort{\r
 776                                         Protocol: corev1.Protocol("TCP"),\r
 777                                         TargetPort: intstr.IntOrString{\r
 778                                                 IntVal: 9411,\r
 779                                         },\r
 780                                         Name: "zipkinhttp",\r
 781                                         Port: 9411,\r
 782                                 },\r
 783                         },\r
 784                         PublishNotReadyAddresses: false,\r
 785                         Selector: map[string]string{\r
 786                                 "app":     "ricplt-jaegeradapter",\r
 787                                 "release": "release-name",\r
 788                         },\r
 789                         Type: corev1.ServiceType("ClusterIP"),\r
 790                 },\r
 791                 TypeMeta: metav1.TypeMeta{\r
 792                         APIVersion: "v1",\r
 793                         Kind:       "Service",\r
 794                 },\r
 795         }\r
 796 \r
 797         service21 := &corev1.Service{\r
 798                 ObjectMeta: metav1.ObjectMeta{\r
 799                         Labels: map[string]string{\r
 800                                 "app":      "ricplt-jaegeradapter",\r
 801                                 "chart":    "jaegeradapter-3.0.0",\r
 802                                 "heritage": "Helm",\r
 803                                 "release":  "release-name",\r
 804                         },\r
 805                         Name:      "service-ricplt-jaegeradapter-query",\r
 806                         Namespace: "ricplt",\r
 807                 },\r
 808                 Spec: corev1.ServiceSpec{\r
 809                         Selector: map[string]string{\r
 810                                 "app":     "ricplt-jaegeradapter",\r
 811                                 "release": "release-name",\r
 812                         },\r
 813                         Type: corev1.ServiceType("ClusterIP"),\r
 814                         Ports: []corev1.ServicePort{\r
 815 \r
 816                                 corev1.ServicePort{\r
 817                                         Name:     "httpquery",\r
 818                                         Port:     16686,\r
 819                                         Protocol: corev1.Protocol("TCP"),\r
 820                                         TargetPort: intstr.IntOrString{\r
 821                                                 IntVal: 16686,\r
 822                                         },\r
 823                                 },\r
 824                         },\r
 825                         PublishNotReadyAddresses: false,\r
 826                 },\r
 827                 TypeMeta: metav1.TypeMeta{\r
 828                         Kind:       "Service",\r
 829                         APIVersion: "v1",\r
 830                 },\r
 831         }\r
 832 \r
 833         service22 := &corev1.Service{\r
 834                 ObjectMeta: metav1.ObjectMeta{\r
 835                         Labels: map[string]string{\r
 836                                 "app.kubernetes.io/managed-by": "Helm",\r
 837                                 "app.kubernetes.io/name":       "kong",\r
 838                                 "app.kubernetes.io/version":    "1.4",\r
 839                                 "helm.sh/chart":                "kong-0.36.6",\r
 840                                 "app.kubernetes.io/instance":   "release-name",\r
 841                         },\r
 842                         Name: "release-name-kong-proxy",\r
 843                 },\r
 844                 Spec: corev1.ServiceSpec{\r
 845                         Type: corev1.ServiceType("NodePort"),\r
 846                         Ports: []corev1.ServicePort{\r
 847 \r
 848                                 corev1.ServicePort{\r
 849                                         NodePort: 32080,\r
 850                                         Port:     32080,\r
 851                                         Protocol: corev1.Protocol("TCP"),\r
 852                                         TargetPort: intstr.IntOrString{\r
 853                                                 IntVal: 32080,\r
 854                                         },\r
 855                                         Name: "kong-proxy",\r
 856                                 },\r
 857                                 corev1.ServicePort{\r
 858                                         Port:     32443,\r
 859                                         Protocol: corev1.Protocol("TCP"),\r
 860                                         TargetPort: intstr.IntOrString{\r
 861                                                 IntVal: 32443,\r
 862                                         },\r
 863                                         Name:     "kong-proxy-tls",\r
 864                                         NodePort: 32443,\r
 865                                 },\r
 866                         },\r
 867                         PublishNotReadyAddresses: false,\r
 868                         Selector: map[string]string{\r
 869                                 "app.kubernetes.io/component": "app",\r
 870                                 "app.kubernetes.io/instance":  "release-name",\r
 871                                 "app.kubernetes.io/name":      "kong",\r
 872                         },\r
 873                 },\r
 874                 TypeMeta: metav1.TypeMeta{\r
 875                         APIVersion: "v1",\r
 876                         Kind:       "Service",\r
 877                 },\r
 878         }\r
 879 \r
 880         service23 := &corev1.Service{\r
 881                 Spec: corev1.ServiceSpec{\r
 882                         Ports: []corev1.ServicePort{\r
 883 \r
 884                                 corev1.ServicePort{\r
 885                                         TargetPort: intstr.IntOrString{\r
 886                                                 IntVal: 9001,\r
 887                                         },\r
 888                                         Name:     "http-supervise",\r
 889                                         Port:     9001,\r
 890                                         Protocol: corev1.Protocol("TCP"),\r
 891                                 },\r
 892                                 corev1.ServicePort{\r
 893                                         Port:     8080,\r
 894                                         Protocol: corev1.Protocol("TCP"),\r
 895                                         TargetPort: intstr.IntOrString{\r
 896                                                 IntVal: 8080,\r
 897                                         },\r
 898                                         Name: "http-mediation",\r
 899                                 },\r
 900                                 corev1.ServicePort{\r
 901                                         Port:     3000,\r
 902                                         Protocol: corev1.Protocol("TCP"),\r
 903                                         TargetPort: intstr.IntOrString{\r
 904                                                 IntVal: 3000,\r
 905                                         },\r
 906                                         Name: "http-event",\r
 907                                 },\r
 908                         },\r
 909                         PublishNotReadyAddresses: false,\r
 910                         Selector: map[string]string{\r
 911                                 "app":     "ricplt-o1mediator",\r
 912                                 "release": "release-name",\r
 913                         },\r
 914                         Type: corev1.ServiceType("ClusterIP"),\r
 915                 },\r
 916                 TypeMeta: metav1.TypeMeta{\r
 917                         APIVersion: "v1",\r
 918                         Kind:       "Service",\r
 919                 },\r
 920                 ObjectMeta: metav1.ObjectMeta{\r
 921                         Namespace: "ricplt",\r
 922                         Labels: map[string]string{\r
 923                                 "app":      "ricplt-o1mediator",\r
 924                                 "chart":    "o1mediator-3.0.0",\r
 925                                 "heritage": "Helm",\r
 926                                 "release":  "release-name",\r
 927                         },\r
 928                         Name: "service-ricplt-o1mediator-http",\r
 929                 },\r
 930         }\r
 931 \r
 932         service24 := &corev1.Service{\r
 933                 ObjectMeta: metav1.ObjectMeta{\r
 934                         Namespace: "ricplt",\r
 935                         Labels: map[string]string{\r
 936                                 "heritage": "Helm",\r
 937                                 "release":  "release-name",\r
 938                                 "app":      "ricplt-o1mediator",\r
 939                                 "chart":    "o1mediator-3.0.0",\r
 940                         },\r
 941                         Name: "service-ricplt-o1mediator-tcp-netconf",\r
 942                 },\r
 943                 Spec: corev1.ServiceSpec{\r
 944                         Ports: []corev1.ServicePort{\r
 945 \r
 946                                 corev1.ServicePort{\r
 947                                         Name:     "tcp-netconf",\r
 948                                         NodePort: 30830,\r
 949                                         Port:     830,\r
 950                                         Protocol: corev1.Protocol("TCP"),\r
 951                                 },\r
 952                         },\r
 953                         PublishNotReadyAddresses: false,\r
 954                         Selector: map[string]string{\r
 955                                 "app":     "ricplt-o1mediator",\r
 956                                 "release": "release-name",\r
 957                         },\r
 958                         Type: corev1.ServiceType("NodePort"),\r
 959                 },\r
 960                 TypeMeta: metav1.TypeMeta{\r
 961                         APIVersion: "v1",\r
 962                         Kind:       "Service",\r
 963                 },\r
 964         }\r
 965 \r
 966         service25 := &corev1.Service{\r
 967                 ObjectMeta: metav1.ObjectMeta{\r
 968                         Labels: map[string]string{\r
 969                                 "app":       "prometheus",\r
 970                                 "chart":     "prometheus-11.3.0",\r
 971                                 "component": "alertmanager",\r
 972                                 "heritage":  "Helm",\r
 973                                 "release":   "release-name",\r
 974                         },\r
 975                         Name:      "release-name-prometheus-alertmanager",\r
 976                         Namespace: "ricplt",\r
 977                 },\r
 978                 Spec: corev1.ServiceSpec{\r
 979                         Type: corev1.ServiceType("ClusterIP"),\r
 980                         Ports: []corev1.ServicePort{\r
 981 \r
 982                                 corev1.ServicePort{\r
 983                                         Name:     "http",\r
 984                                         Port:     80,\r
 985                                         Protocol: corev1.Protocol("TCP"),\r
 986                                         TargetPort: intstr.IntOrString{\r
 987                                                 IntVal: 9093,\r
 988                                         },\r
 989                                 },\r
 990                         },\r
 991                         PublishNotReadyAddresses: false,\r
 992                         Selector: map[string]string{\r
 993                                 "app":       "prometheus",\r
 994                                 "component": "alertmanager",\r
 995                                 "release":   "release-name",\r
 996                         },\r
 997                         SessionAffinity: corev1.ServiceAffinity("None"),\r
 998                 },\r
 999                 TypeMeta: metav1.TypeMeta{\r
1000                         APIVersion: "v1",\r
1001                         Kind:       "Service",\r
1002                 },\r
1003         }\r
1004 \r
1005         service26 := &corev1.Service{\r
1006                 ObjectMeta: metav1.ObjectMeta{\r
1007                         Labels: map[string]string{\r
1008                                 "app":       "prometheus",\r
1009                                 "chart":     "prometheus-11.3.0",\r
1010                                 "component": "server",\r
1011                                 "heritage":  "Helm",\r
1012                                 "release":   "release-name",\r
1013                         },\r
1014                         Name:      "release-name-prometheus-server",\r
1015                         Namespace: "ricplt",\r
1016                 },\r
1017                 Spec: corev1.ServiceSpec{\r
1018                         Ports: []corev1.ServicePort{\r
1019 \r
1020                                 corev1.ServicePort{\r
1021                                         Name:     "http",\r
1022                                         Port:     80,\r
1023                                         Protocol: corev1.Protocol("TCP"),\r
1024                                         TargetPort: intstr.IntOrString{\r
1025                                                 IntVal: 9090,\r
1026                                         },\r
1027                                 },\r
1028                         },\r
1029                         PublishNotReadyAddresses: false,\r
1030                         Selector: map[string]string{\r
1031                                 "release":   "release-name",\r
1032                                 "app":       "prometheus",\r
1033                                 "component": "server",\r
1034                         },\r
1035                         SessionAffinity: corev1.ServiceAffinity("None"),\r
1036                         Type:            corev1.ServiceType("ClusterIP"),\r
1037                 },\r
1038                 TypeMeta: metav1.TypeMeta{\r
1039                         APIVersion: "v1",\r
1040                         Kind:       "Service",\r
1041                 },\r
1042         }\r
1043 \r
1044         service27 := &corev1.Service{\r
1045                 ObjectMeta: metav1.ObjectMeta{\r
1046                         Name: "redis-cluster-svc",\r
1047                 },\r
1048                 Spec: corev1.ServiceSpec{\r
1049                         Selector: map[string]string{\r
1050                                 "app.kubernetes.io/instance": "release-name",\r
1051                                 "app.kubernetes.io/name":     "redis-cluster",\r
1052                         },\r
1053                         Type: corev1.ServiceType("ClusterIP"),\r
1054                         Ports: []corev1.ServicePort{\r
1055 \r
1056                                 corev1.ServicePort{\r
1057                                         Name: "client",\r
1058                                         Port: 6379,\r
1059                                         TargetPort: intstr.IntOrString{\r
1060                                                 IntVal: 6379,\r
1061                                         },\r
1062                                 },\r
1063                                 corev1.ServicePort{\r
1064                                         Name: "gossip",\r
1065                                         Port: 16379,\r
1066                                         TargetPort: intstr.IntOrString{\r
1067                                                 IntVal: 16379,\r
1068                                         },\r
1069                                 },\r
1070                         },\r
1071                         PublishNotReadyAddresses: false,\r
1072                 },\r
1073                 TypeMeta: metav1.TypeMeta{\r
1074                         APIVersion: "v1",\r
1075                         Kind:       "Service",\r
1076                 },\r
1077         }\r
1078 \r
1079         service28 := &corev1.Service{\r
1080                 ObjectMeta: metav1.ObjectMeta{\r
1081                         Labels: map[string]string{\r
1082                                 "app":      "ricplt-rsm",\r
1083                                 "chart":    "rsm-3.0.0",\r
1084                                 "heritage": "Helm",\r
1085                                 "release":  "release-name",\r
1086                         },\r
1087                         Name:      "service-ricplt-rsm-http",\r
1088                         Namespace: "ricplt",\r
1089                 },\r
1090                 Spec: corev1.ServiceSpec{\r
1091                         PublishNotReadyAddresses: false,\r
1092                         Selector: map[string]string{\r
1093                                 "app":     "ricplt-rsm",\r
1094                                 "release": "release-name",\r
1095                         },\r
1096                         Type: corev1.ServiceType("ClusterIP"),\r
1097                         Ports: []corev1.ServicePort{\r
1098 \r
1099                                 corev1.ServicePort{\r
1100                                         Port:     4800,\r
1101                                         Protocol: corev1.Protocol("TCP"),\r
1102                                         TargetPort: intstr.IntOrString{\r
1103                                                 StrVal: "http",\r
1104                                                 Type:   intstr.Type(1),\r
1105                                         },\r
1106                                         Name: "http",\r
1107                                 },\r
1108                         },\r
1109                 },\r
1110                 TypeMeta: metav1.TypeMeta{\r
1111                         APIVersion: "v1",\r
1112                         Kind:       "Service",\r
1113                 },\r
1114         }\r
1115 \r
1116         service29 := &corev1.Service{\r
1117                 ObjectMeta: metav1.ObjectMeta{\r
1118                         Namespace: "ricplt",\r
1119                         Labels: map[string]string{\r
1120                                 "app":      "ricplt-rsm",\r
1121                                 "chart":    "rsm-3.0.0",\r
1122                                 "heritage": "Helm",\r
1123                                 "release":  "release-name",\r
1124                         },\r
1125                         Name: "service-ricplt-rsm-rmr",\r
1126                 },\r
1127                 Spec: corev1.ServiceSpec{\r
1128                         Ports: []corev1.ServicePort{\r
1129 \r
1130                                 corev1.ServicePort{\r
1131                                         Name:     "rmrroute",\r
1132                                         Port:     4561,\r
1133                                         Protocol: corev1.Protocol("TCP"),\r
1134                                         TargetPort: intstr.IntOrString{\r
1135                                                 StrVal: "rmrroute",\r
1136                                                 Type:   intstr.Type(1),\r
1137                                         },\r
1138                                 },\r
1139                                 corev1.ServicePort{\r
1140                                         Name:     "rmrdata",\r
1141                                         Port:     4801,\r
1142                                         Protocol: corev1.Protocol("TCP"),\r
1143                                         TargetPort: intstr.IntOrString{\r
1144                                                 StrVal: "rmrdata",\r
1145                                                 Type:   intstr.Type(1),\r
1146                                         },\r
1147                                 },\r
1148                         },\r
1149                         PublishNotReadyAddresses: false,\r
1150                         Selector: map[string]string{\r
1151                                 "release": "release-name",\r
1152                                 "app":     "ricplt-rsm",\r
1153                         },\r
1154                         Type: corev1.ServiceType("ClusterIP"),\r
1155                 },\r
1156                 TypeMeta: metav1.TypeMeta{\r
1157                         APIVersion: "v1",\r
1158                         Kind:       "Service",\r
1159                 },\r
1160         }\r
1161 \r
1162         service30 := &corev1.Service{\r
1163                 TypeMeta: metav1.TypeMeta{\r
1164                         APIVersion: "v1",\r
1165                         Kind:       "Service",\r
1166                 },\r
1167                 ObjectMeta: metav1.ObjectMeta{\r
1168                         Labels: map[string]string{\r
1169                                 "app":      "ricplt-rtmgr",\r
1170                                 "chart":    "rtmgr-3.0.0",\r
1171                                 "heritage": "Helm",\r
1172                                 "release":  "release-name",\r
1173                         },\r
1174                         Name:      "service-ricplt-rtmgr-http",\r
1175                         Namespace: "ricplt",\r
1176                 },\r
1177                 Spec: corev1.ServiceSpec{\r
1178                         PublishNotReadyAddresses: false,\r
1179                         Selector: map[string]string{\r
1180                                 "app":     "ricplt-rtmgr",\r
1181                                 "release": "release-name",\r
1182                         },\r
1183                         Type: corev1.ServiceType("ClusterIP"),\r
1184                         Ports: []corev1.ServicePort{\r
1185 \r
1186                                 corev1.ServicePort{\r
1187                                         Name:     "http",\r
1188                                         Port:     3800,\r
1189                                         Protocol: corev1.Protocol("TCP"),\r
1190                                         TargetPort: intstr.IntOrString{\r
1191                                                 StrVal: "http",\r
1192                                                 Type:   intstr.Type(1),\r
1193                                         },\r
1194                                 },\r
1195                         },\r
1196                 },\r
1197         }\r
1198 \r
1199         service31 := &corev1.Service{\r
1200                 ObjectMeta: metav1.ObjectMeta{\r
1201                         Namespace: "ricplt",\r
1202                         Labels: map[string]string{\r
1203                                 "app":      "ricplt-rtmgr",\r
1204                                 "chart":    "rtmgr-3.0.0",\r
1205                                 "heritage": "Helm",\r
1206                                 "release":  "release-name",\r
1207                         },\r
1208                         Name: "service-ricplt-rtmgr-rmr",\r
1209                 },\r
1210                 Spec: corev1.ServiceSpec{\r
1211                         Selector: map[string]string{\r
1212                                 "app":     "ricplt-rtmgr",\r
1213                                 "release": "release-name",\r
1214                         },\r
1215                         Type: corev1.ServiceType("ClusterIP"),\r
1216                         Ports: []corev1.ServicePort{\r
1217 \r
1218                                 corev1.ServicePort{\r
1219                                         Protocol: corev1.Protocol("TCP"),\r
1220                                         TargetPort: intstr.IntOrString{\r
1221                                                 Type:   intstr.Type(1),\r
1222                                                 StrVal: "rmrroute",\r
1223                                         },\r
1224                                         Name: "rmrroute",\r
1225                                         Port: 4561,\r
1226                                 },\r
1227                                 corev1.ServicePort{\r
1228                                         Port:     4560,\r
1229                                         Protocol: corev1.Protocol("TCP"),\r
1230                                         TargetPort: intstr.IntOrString{\r
1231                                                 StrVal: "rmrdata",\r
1232                                                 Type:   intstr.Type(1),\r
1233                                         },\r
1234                                         Name: "rmrdata",\r
1235                                 },\r
1236                         },\r
1237                         PublishNotReadyAddresses: false,\r
1238                 },\r
1239                 TypeMeta: metav1.TypeMeta{\r
1240                         APIVersion: "v1",\r
1241                         Kind:       "Service",\r
1242                 },\r
1243         }\r
1244 \r
1245         service32 := &corev1.Service{\r
1246                 ObjectMeta: metav1.ObjectMeta{\r
1247                         Labels: map[string]string{\r
1248                                 "app":      "ricplt-submgr",\r
1249                                 "chart":    "submgr-3.0.0",\r
1250                                 "heritage": "Helm",\r
1251                                 "release":  "release-name",\r
1252                         },\r
1253                         Name:      "service-ricplt-submgr-http",\r
1254                         Namespace: "ricplt",\r
1255                 },\r
1256                 Spec: corev1.ServiceSpec{\r
1257                         ClusterIP: "None",\r
1258                         Ports: []corev1.ServicePort{\r
1259 \r
1260                                 corev1.ServicePort{\r
1261                                         Name:     "http",\r
1262                                         Port:     3800,\r
1263                                         Protocol: corev1.Protocol("TCP"),\r
1264                                         TargetPort: intstr.IntOrString{\r
1265                                                 StrVal: "http",\r
1266                                                 Type:   intstr.Type(1),\r
1267                                         },\r
1268                                 },\r
1269                         },\r
1270                         PublishNotReadyAddresses: false,\r
1271                         Selector: map[string]string{\r
1272                                 "app":     "ricplt-submgr",\r
1273                                 "release": "release-name",\r
1274                         },\r
1275                 },\r
1276                 TypeMeta: metav1.TypeMeta{\r
1277                         APIVersion: "v1",\r
1278                         Kind:       "Service",\r
1279                 },\r
1280         }\r
1281 \r
1282         service33 := &corev1.Service{\r
1283                 ObjectMeta: metav1.ObjectMeta{\r
1284                         Labels: map[string]string{\r
1285                                 "app":      "ricplt-submgr",\r
1286                                 "chart":    "submgr-3.0.0",\r
1287                                 "heritage": "Helm",\r
1288                                 "release":  "release-name",\r
1289                         },\r
1290                         Name:      "service-ricplt-submgr-rmr",\r
1291                         Namespace: "ricplt",\r
1292                 },\r
1293                 Spec: corev1.ServiceSpec{\r
1294                         ClusterIP: "None",\r
1295                         Ports: []corev1.ServicePort{\r
1296 \r
1297                                 corev1.ServicePort{\r
1298                                         Port:     4560,\r
1299                                         Protocol: corev1.Protocol("TCP"),\r
1300                                         TargetPort: intstr.IntOrString{\r
1301                                                 Type:   intstr.Type(1),\r
1302                                                 StrVal: "rmrdata",\r
1303                                         },\r
1304                                         Name: "rmrdata",\r
1305                                 },\r
1306                                 corev1.ServicePort{\r
1307                                         Name:     "rmrroute",\r
1308                                         Port:     4561,\r
1309                                         Protocol: corev1.Protocol("TCP"),\r
1310                                         TargetPort: intstr.IntOrString{\r
1311                                                 StrVal: "rmrroute",\r
1312                                                 Type:   intstr.Type(1),\r
1313                                         },\r
1314                                 },\r
1315                         },\r
1316                         PublishNotReadyAddresses: false,\r
1317                         Selector: map[string]string{\r
1318                                 "app":     "ricplt-submgr",\r
1319                                 "release": "release-name",\r
1320                         },\r
1321                 },\r
1322                 TypeMeta: metav1.TypeMeta{\r
1323                         Kind:       "Service",\r
1324                         APIVersion: "v1",\r
1325                 },\r
1326         }\r
1327 \r
1328         service34 := &corev1.Service{\r
1329                 ObjectMeta: metav1.ObjectMeta{\r
1330                         Labels: map[string]string{\r
1331                                 "app":      "ricplt-vespamgr",\r
1332                                 "chart":    "vespamgr-3.0.0",\r
1333                                 "heritage": "Helm",\r
1334                                 "release":  "release-name",\r
1335                         },\r
1336                         Name:      "service-ricplt-vespamgr-http",\r
1337                         Namespace: "ricplt",\r
1338                 },\r
1339                 Spec: corev1.ServiceSpec{\r
1340                         Selector: map[string]string{\r
1341                                 "app":     "ricplt-vespamgr",\r
1342                                 "release": "release-name",\r
1343                         },\r
1344                         Type: corev1.ServiceType("ClusterIP"),\r
1345                         Ports: []corev1.ServicePort{\r
1346 \r
1347                                 corev1.ServicePort{\r
1348                                         Name:     "http",\r
1349                                         Port:     8080,\r
1350                                         Protocol: corev1.Protocol("TCP"),\r
1351                                         TargetPort: intstr.IntOrString{\r
1352                                                 StrVal: "http",\r
1353                                                 Type:   intstr.Type(1),\r
1354                                         },\r
1355                                 },\r
1356                                 corev1.ServicePort{\r
1357                                         Name:     "alert",\r
1358                                         Port:     9095,\r
1359                                         Protocol: corev1.Protocol("TCP"),\r
1360                                         TargetPort: intstr.IntOrString{\r
1361                                                 StrVal: "alert",\r
1362                                                 Type:   intstr.Type(1),\r
1363                                         },\r
1364                                 },\r
1365                         },\r
1366                         PublishNotReadyAddresses: false,\r
1367                 },\r
1368                 TypeMeta: metav1.TypeMeta{\r
1369                         Kind:       "Service",\r
1370                         APIVersion: "v1",\r
1371                 },\r
1372         }\r
1373 \r
1374         service35 := &corev1.Service{\r
1375                 ObjectMeta: metav1.ObjectMeta{\r
1376                         Labels: map[string]string{\r
1377                                 "app":      "ricplt-xapp-onboarder",\r
1378                                 "chart":    "xapp-onboarder-3.0.0",\r
1379                                 "heritage": "Helm",\r
1380                                 "release":  "release-name",\r
1381                         },\r
1382                         Name:      "service-ricplt-xapp-onboarder-http",\r
1383                         Namespace: "ricplt",\r
1384                 },\r
1385                 Spec: corev1.ServiceSpec{\r
1386                         Ports: []corev1.ServicePort{\r
1387 \r
1388                                 corev1.ServicePort{\r
1389                                         Port:     8888,\r
1390                                         Protocol: corev1.Protocol("TCP"),\r
1391                                         TargetPort: intstr.IntOrString{\r
1392                                                 StrVal: "server",\r
1393                                                 Type:   intstr.Type(1),\r
1394                                         },\r
1395                                         Name: "server",\r
1396                                 },\r
1397                                 corev1.ServicePort{\r
1398                                         Port:     8080,\r
1399                                         Protocol: corev1.Protocol("TCP"),\r
1400                                         TargetPort: intstr.IntOrString{\r
1401                                                 StrVal: "chartmuseum",\r
1402                                                 Type:   intstr.Type(1),\r
1403                                         },\r
1404                                         Name: "chartmuseum",\r
1405                                 },\r
1406                         },\r
1407                         PublishNotReadyAddresses: false,\r
1408                         Selector: map[string]string{\r
1409                                 "app":     "ricplt-xapp-onboarder",\r
1410                                 "release": "release-name",\r
1411                         },\r
1412                         Type: corev1.ServiceType("ClusterIP"),\r
1413                 },\r
1414                 TypeMeta: metav1.TypeMeta{\r
1415                         APIVersion: "v1",\r
1416                         Kind:       "Service",\r
1417                 },\r
1418         }\r
1419 \r
1420         return []*corev1.Service{service1, service2, service3, service4, service5, service6, service7, service8, service9, service10, service11, service12, service13, service14, service15, service16, service17, service18, service19, service20, service21, service22, service23, service24, service25, service26, service27, service28, service29, service30, service31, service32, service33, service34, service35}\r
1421 }\r