v1_storage_cluster_info.go

// 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"
	"strconv"

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

// V1StorageClusterInfo v1 storage cluster info
//
// swagger:model v1.StorageClusterInfo
type V1StorageClusterInfo struct {

	// Api endpoints
	// Required: true
	APIEndpoints []string `json:"ApiEndpoints"`

	// current max replicas
	// Required: true
	CurrentMaxReplicas *int64 `json:"CurrentMaxReplicas"`

	// discovery endpoints
	// Required: true
	DiscoveryEndpoints []string `json:"DiscoveryEndpoints"`

	// health
	// Required: true
	Health *V1ClusterHealth `json:"Health"`

	// max allowed version
	// Required: true
	MaxAllowedVersion *string `json:"MaxAllowedVersion"`

	// min allowed version
	// Required: true
	MinAllowedVersion *string `json:"MinAllowedVersion"`

	// min version in cluster
	// Required: true
	MinVersionInCluster *string `json:"MinVersionInCluster"`

	// partition
	// Required: true
	Partition *string `json:"Partition"`

	// servers
	// Required: true
	Servers []*V1StorageServerInfo `json:"Servers"`

	// statistics
	// Required: true
	Statistics *V1ClusterStatisticsAPI `json:"Statistics"`

	// subsystem n q n
	// Required: true
	SubsystemNQN *string `json:"SubsystemNQN"`

	// supported max replicas
	// Required: true
	SupportedMaxReplicas *int64 `json:"SupportedMaxReplicas"`

	// UUID
	// Required: true
	UUID *string `json:"UUID"`
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (m *V1StorageClusterInfo) validateAPIEndpoints(formats strfmt.Registry) error {

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

	return nil
}

func (m *V1StorageClusterInfo) validateCurrentMaxReplicas(formats strfmt.Registry) error {

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

	return nil
}

func (m *V1StorageClusterInfo) validateDiscoveryEndpoints(formats strfmt.Registry) error {

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

	return nil
}

func (m *V1StorageClusterInfo) validateHealth(formats strfmt.Registry) error {

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

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

	return nil
}

func (m *V1StorageClusterInfo) validateMaxAllowedVersion(formats strfmt.Registry) error {

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

	return nil
}

func (m *V1StorageClusterInfo) validateMinAllowedVersion(formats strfmt.Registry) error {

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

	return nil
}

func (m *V1StorageClusterInfo) validateMinVersionInCluster(formats strfmt.Registry) error {

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

	return nil
}

func (m *V1StorageClusterInfo) validatePartition(formats strfmt.Registry) error {

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

	return nil
}

func (m *V1StorageClusterInfo) validateServers(formats strfmt.Registry) error {

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

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

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

	}

	return nil
}

func (m *V1StorageClusterInfo) validateStatistics(formats strfmt.Registry) error {

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

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

	return nil
}

func (m *V1StorageClusterInfo) validateSubsystemNQN(formats strfmt.Registry) error {

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

	return nil
}

func (m *V1StorageClusterInfo) validateSupportedMaxReplicas(formats strfmt.Registry) error {

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

	return nil
}

func (m *V1StorageClusterInfo) validateUUID(formats strfmt.Registry) error {

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

	return nil
}

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

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

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

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

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

func (m *V1StorageClusterInfo) contextValidateHealth(ctx context.Context, formats strfmt.Registry) error {

	if m.Health != nil {

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

	return nil
}

func (m *V1StorageClusterInfo) contextValidateServers(ctx context.Context, formats strfmt.Registry) error {

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

		if m.Servers[i] != nil {

			if swag.IsZero(m.Servers[i]) { // not required
				return nil
			}

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

	}

	return nil
}

func (m *V1StorageClusterInfo) contextValidateStatistics(ctx context.Context, formats strfmt.Registry) error {

	if m.Statistics != nil {

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

	return nil
}

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

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