kibana_cluster_info.go

// Licensed to Elasticsearch B.V. under one or more contributor
// license agreements. See the NOTICE file distributed with
// this work for additional information regarding copyright
// ownership. Elasticsearch B.V. licenses this file to you under
// the Apache License, Version 2.0 (the "License"); you may
// not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.

// Code generated by go-swagger; DO NOT EDIT.

package models

// This file was generated by the swagger tool.
// Editing this file might prove futile when you re-run the swagger generate command

import (
	"context"
	"encoding/json"
	"strconv"

	"github.com/go-openapi/errors"
	"github.com/go-openapi/strfmt"
	"github.com/go-openapi/swag"
	"github.com/go-openapi/validate"
)

// KibanaClusterInfo The top-level object information for a Kibana instance.
//
// swagger:model KibanaClusterInfo
type KibanaClusterInfo struct {

	// The id of the cluster
	// Required: true
	ClusterID *string `json:"cluster_id"`

	// The name of the cluster
	// Required: true
	ClusterName *string `json:"cluster_name"`

	// The id of the deployment to which this Kibana Server belongs to.
	DeploymentID string `json:"deployment_id,omitempty"`

	// elasticsearch cluster
	// Required: true
	ElasticsearchCluster *TargetElasticsearchCluster `json:"elasticsearch_cluster"`

	// External resources related to the cluster
	// Required: true
	// Unique: true
	ExternalLinks []*ExternalHyperlink `json:"external_links"`

	// Whether the cluster is healthy or not (one or more of the info subsections will have healthy: false)
	// Required: true
	Healthy *bool `json:"healthy"`

	// A map of application-specific operations (which map to 'operationId's in the Swagger API) to metadata about that operation
	Links map[string]Hyperlink `json:"links,omitempty"`

	// metadata
	// Required: true
	Metadata *ClusterMetadataInfo `json:"metadata"`

	// plan info
	// Required: true
	PlanInfo *KibanaClusterPlansInfo `json:"plan_info"`

	// The region that this cluster belongs to. Only populated in SaaS or federated ECE.
	Region string `json:"region,omitempty"`

	// The cluster metadata settings for a kibana cluster
	Settings *KibanaClusterSettings `json:"settings,omitempty"`

	// Cluster status
	// Required: true
	// Enum: [initializing stopping stopped rebooting restarting reconfiguring started]
	Status *string `json:"status"`

	// topology
	// Required: true
	Topology *ClusterTopologyInfo `json:"topology"`
}

// Validate validates this kibana cluster info
func (m *KibanaClusterInfo) Validate(formats strfmt.Registry) error {
	var res []error

	if err := m.validateClusterID(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateClusterName(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateElasticsearchCluster(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateExternalLinks(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateHealthy(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateLinks(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateMetadata(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validatePlanInfo(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateSettings(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateStatus(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateTopology(formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (m *KibanaClusterInfo) validateClusterID(formats strfmt.Registry) error {

	if err := validate.Required("cluster_id", "body", m.ClusterID); err != nil {
		return err
	}

	return nil
}

func (m *KibanaClusterInfo) validateClusterName(formats strfmt.Registry) error {

	if err := validate.Required("cluster_name", "body", m.ClusterName); err != nil {
		return err
	}

	return nil
}

func (m *KibanaClusterInfo) validateElasticsearchCluster(formats strfmt.Registry) error {

	if err := validate.Required("elasticsearch_cluster", "body", m.ElasticsearchCluster); err != nil {
		return err
	}

	if m.ElasticsearchCluster != nil {
		if err := m.ElasticsearchCluster.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("elasticsearch_cluster")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("elasticsearch_cluster")
			}
			return err
		}
	}

	return nil
}

func (m *KibanaClusterInfo) validateExternalLinks(formats strfmt.Registry) error {

	if err := validate.Required("external_links", "body", m.ExternalLinks); err != nil {
		return err
	}

	if err := validate.UniqueItems("external_links", "body", m.ExternalLinks); err != nil {
		return err
	}

	for i := 0; i < len(m.ExternalLinks); i++ {
		if swag.IsZero(m.ExternalLinks[i]) { // not required
			continue
		}

		if m.ExternalLinks[i] != nil {
			if err := m.ExternalLinks[i].Validate(formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("external_links" + "." + strconv.Itoa(i))
				} else if ce, ok := err.(*errors.CompositeError); ok {
					return ce.ValidateName("external_links" + "." + strconv.Itoa(i))
				}
				return err
			}
		}

	}

	return nil
}

func (m *KibanaClusterInfo) validateHealthy(formats strfmt.Registry) error {

	if err := validate.Required("healthy", "body", m.Healthy); err != nil {
		return err
	}

	return nil
}

func (m *KibanaClusterInfo) validateLinks(formats strfmt.Registry) error {
	if swag.IsZero(m.Links) { // not required
		return nil
	}

	for k := range m.Links {

		if err := validate.Required("links"+"."+k, "body", m.Links[k]); err != nil {
			return err
		}
		if val, ok := m.Links[k]; ok {
			if err := val.Validate(formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("links" + "." + k)
				} else if ce, ok := err.(*errors.CompositeError); ok {
					return ce.ValidateName("links" + "." + k)
				}
				return err
			}
		}

	}

	return nil
}

func (m *KibanaClusterInfo) validateMetadata(formats strfmt.Registry) error {

	if err := validate.Required("metadata", "body", m.Metadata); err != nil {
		return err
	}

	if m.Metadata != nil {
		if err := m.Metadata.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("metadata")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("metadata")
			}
			return err
		}
	}

	return nil
}

func (m *KibanaClusterInfo) validatePlanInfo(formats strfmt.Registry) error {

	if err := validate.Required("plan_info", "body", m.PlanInfo); err != nil {
		return err
	}

	if m.PlanInfo != nil {
		if err := m.PlanInfo.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("plan_info")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("plan_info")
			}
			return err
		}
	}

	return nil
}

func (m *KibanaClusterInfo) validateSettings(formats strfmt.Registry) error {
	if swag.IsZero(m.Settings) { // not required
		return nil
	}

	if m.Settings != nil {
		if err := m.Settings.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("settings")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("settings")
			}
			return err
		}
	}

	return nil
}

var kibanaClusterInfoTypeStatusPropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["initializing","stopping","stopped","rebooting","restarting","reconfiguring","started"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		kibanaClusterInfoTypeStatusPropEnum = append(kibanaClusterInfoTypeStatusPropEnum, v)
	}
}

const (

	// KibanaClusterInfoStatusInitializing captures enum value "initializing"
	KibanaClusterInfoStatusInitializing string = "initializing"

	// KibanaClusterInfoStatusStopping captures enum value "stopping"
	KibanaClusterInfoStatusStopping string = "stopping"

	// KibanaClusterInfoStatusStopped captures enum value "stopped"
	KibanaClusterInfoStatusStopped string = "stopped"

	// KibanaClusterInfoStatusRebooting captures enum value "rebooting"
	KibanaClusterInfoStatusRebooting string = "rebooting"

	// KibanaClusterInfoStatusRestarting captures enum value "restarting"
	KibanaClusterInfoStatusRestarting string = "restarting"

	// KibanaClusterInfoStatusReconfiguring captures enum value "reconfiguring"
	KibanaClusterInfoStatusReconfiguring string = "reconfiguring"

	// KibanaClusterInfoStatusStarted captures enum value "started"
	KibanaClusterInfoStatusStarted string = "started"
)

// prop value enum
func (m *KibanaClusterInfo) validateStatusEnum(path, location string, value string) error {
	if err := validate.EnumCase(path, location, value, kibanaClusterInfoTypeStatusPropEnum, true); err != nil {
		return err
	}
	return nil
}

func (m *KibanaClusterInfo) validateStatus(formats strfmt.Registry) error {

	if err := validate.Required("status", "body", m.Status); err != nil {
		return err
	}

	// value enum
	if err := m.validateStatusEnum("status", "body", *m.Status); err != nil {
		return err
	}

	return nil
}

func (m *KibanaClusterInfo) validateTopology(formats strfmt.Registry) error {

	if err := validate.Required("topology", "body", m.Topology); err != nil {
		return err
	}

	if m.Topology != nil {
		if err := m.Topology.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("topology")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("topology")
			}
			return err
		}
	}

	return nil
}

// ContextValidate validate this kibana cluster info based on the context it is used
func (m *KibanaClusterInfo) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	var res []error

	if err := m.contextValidateElasticsearchCluster(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateExternalLinks(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateLinks(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateMetadata(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidatePlanInfo(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateSettings(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateTopology(ctx, formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (m *KibanaClusterInfo) contextValidateElasticsearchCluster(ctx context.Context, formats strfmt.Registry) error {

	if m.ElasticsearchCluster != nil {
		if err := m.ElasticsearchCluster.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("elasticsearch_cluster")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("elasticsearch_cluster")
			}
			return err
		}
	}

	return nil
}

func (m *KibanaClusterInfo) contextValidateExternalLinks(ctx context.Context, formats strfmt.Registry) error {

	for i := 0; i < len(m.ExternalLinks); i++ {

		if m.ExternalLinks[i] != nil {
			if err := m.ExternalLinks[i].ContextValidate(ctx, formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("external_links" + "." + strconv.Itoa(i))
				} else if ce, ok := err.(*errors.CompositeError); ok {
					return ce.ValidateName("external_links" + "." + strconv.Itoa(i))
				}
				return err
			}
		}

	}

	return nil
}

func (m *KibanaClusterInfo) contextValidateLinks(ctx context.Context, formats strfmt.Registry) error {

	for k := range m.Links {

		if val, ok := m.Links[k]; ok {
			if err := val.ContextValidate(ctx, formats); err != nil {
				return err
			}
		}

	}

	return nil
}

func (m *KibanaClusterInfo) contextValidateMetadata(ctx context.Context, formats strfmt.Registry) error {

	if m.Metadata != nil {
		if err := m.Metadata.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("metadata")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("metadata")
			}
			return err
		}
	}

	return nil
}

func (m *KibanaClusterInfo) contextValidatePlanInfo(ctx context.Context, formats strfmt.Registry) error {

	if m.PlanInfo != nil {
		if err := m.PlanInfo.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("plan_info")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("plan_info")
			}
			return err
		}
	}

	return nil
}

func (m *KibanaClusterInfo) contextValidateSettings(ctx context.Context, formats strfmt.Registry) error {

	if m.Settings != nil {
		if err := m.Settings.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("settings")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("settings")
			}
			return err
		}
	}

	return nil
}

func (m *KibanaClusterInfo) contextValidateTopology(ctx context.Context, formats strfmt.Registry) error {

	if m.Topology != nil {
		if err := m.Topology.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("topology")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("topology")
			}
			return err
		}
	}

	return nil
}

// MarshalBinary interface implementation
func (m *KibanaClusterInfo) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *KibanaClusterInfo) UnmarshalBinary(b []byte) error {
	var res KibanaClusterInfo
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}