func (storageservice *StorageService) Redundancy() ([]*redfish.Redundancy, error) {
	var result []*redfish.Redundancy
	collectionError := common.NewCollectionError()
	for _, redundancyLink := range storageservice.redundancy {
		redundancy, err := redfish.GetRedundancy(storageservice.Client, redundancyLink)
		if err != nil {
			collectionError.Failures[redundancyLink] = err
		} else {
			result = append(result, redundancy)
		}
	}
	if collectionError.Empty() {
		return result, nil
	}
	return result, collectionError
}
Redundancy gets the redundancy information for the storage subsystem.
package swordfish
import (
	"encoding/json"
	"github.com/stmcginnis/gofish/common"
	"github.com/stmcginnis/gofish/redfish"
)
type StorageService struct {
	common.Entity
	ODataContext string `json:"@odata.context"`
	ODataType string `json:"@odata.type"`
	Description string
	Identifier common.Identifier
	RedundancyCount int `json:"Redundancy@odata.count"`
	SpareResourceSetsCount int `json:"SpareResourceSets@odata.count"`
	Status common.Status
	classesOfService string
	dataProtectionLoSCapabilities string
	dataSecurityLoSCapabilities string
	dataStorageLoSCapabilities string
	defaultClassOfService string
	drives string
	endpointGroups string
	endpoints string
	fileSystems string
	hostingSystem string
	ioConnectivityLoSCapabilities string
	ioPerformanceLoSCapabilities string
	IOStatistics IOStatistics
	spareResourceSets []string
	storageGroups string
	storagePools string
	storageSubsystems string
	redundancy []string
	volumes string
	setEncryptionKeyTarget string
}
func (storageservice *StorageService) UnmarshalJSON(b []byte) error {
	type temp StorageService
	type links struct {
		HostingSystem common.Link
	}
	type actions struct {
		SetEncryptionKey struct {
			Target string
		} `json:"#StorageService.SetEncryptionKey"`
	}
	var t struct {
		temp
		ClassesOfService              common.Link
		DataProtectionLoSCapabilities common.Link
		DataSecurityLoSCapabilities   common.Link
		DataStorageLoSCapabilities    common.Link
		DefaultClassOfService         common.Link
		Drives                        common.Link
		EndpointGroups                common.Link
		Endpoints                     common.Link
		FileSystems                   common.Link
		IOConnectivityLoSCapabilities common.Link
		IOPerformanceLoSCapabilities  common.Link
		Redundancy                    common.Links
		SpareResourceSets             common.Links
		StorageGroups                 common.Link
		StoragePools                  common.Link
		StorageSubsystems             common.Link
		Volumes                       common.Link
		Links                         links
		Actions                       actions
	}
	err := json.Unmarshal(b, &t)
	if err != nil {
		return err
	}
	*storageservice = StorageService(t.temp)
	storageservice.classesOfService = string(t.ClassesOfService)
	storageservice.dataProtectionLoSCapabilities = string(t.DataProtectionLoSCapabilities)
	storageservice.dataSecurityLoSCapabilities = string(t.DataSecurityLoSCapabilities)
	storageservice.dataStorageLoSCapabilities = string(t.DataStorageLoSCapabilities)
	storageservice.defaultClassOfService = string(t.DefaultClassOfService)
	storageservice.drives = string(t.Drives)
	storageservice.endpointGroups = string(t.EndpointGroups)
	storageservice.endpoints = string(t.Endpoints)
	storageservice.fileSystems = string(t.FileSystems)
	storageservice.ioConnectivityLoSCapabilities = string(t.IOConnectivityLoSCapabilities)
	storageservice.ioPerformanceLoSCapabilities = string(t.IOPerformanceLoSCapabilities)
	storageservice.redundancy = t.Redundancy.ToStrings()
	storageservice.spareResourceSets = t.SpareResourceSets.ToStrings()
	storageservice.storageGroups = string(t.StorageGroups)
	storageservice.storagePools = string(t.StoragePools)
	storageservice.storageSubsystems = string(t.StorageSubsystems)
	storageservice.hostingSystem = string(t.Links.HostingSystem)
	storageservice.volumes = string(t.Volumes)
	storageservice.setEncryptionKeyTarget = t.Actions.SetEncryptionKey.Target
	return nil
}
func GetStorageService(c common.Client, uri string) (*StorageService, error) {
	resp, err := c.Get(uri)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()
	var storageservice StorageService
	err = json.NewDecoder(resp.Body).Decode(&storageservice)
	if err != nil {
		return nil, err
	}
	storageservice.SetClient(c)
	return &storageservice, nil
}
func ListReferencedStorageServices(c common.Client, link string) ([]*StorageService, error) {
	var result []*StorageService
	links, err := common.GetCollection(c, link)
	if err != nil {
		return result, err
	}
	collectionError := common.NewCollectionError()
	for _, storageserviceLink := range links.ItemLinks {
		storageservice, err := GetStorageService(c, storageserviceLink)
		if err != nil {
			collectionError.Failures[storageserviceLink] = err
		} else {
			result = append(result, storageservice)
		}
	}
	if collectionError.Empty() {
		return result, nil
	}
	return result, collectionError
}
func (storageservice *StorageService) ClassesOfService() ([]*ClassOfService, error) {
	return ListReferencedClassOfServices(storageservice.Client, storageservice.classesOfService)
}
func (storageservice *StorageService) DataProtectionLoSCapabilities() (*DataProtectionLoSCapabilities, error) {
	if storageservice.dataProtectionLoSCapabilities == "" {
		return nil, nil
	}
	return GetDataProtectionLoSCapabilities(storageservice.Client, storageservice.dataProtectionLoSCapabilities)
}
func (storageservice *StorageService) DataSecurityLoSCapabilities() (*DataSecurityLoSCapabilities, error) {
	if storageservice.dataSecurityLoSCapabilities == "" {
		return nil, nil
	}
	return GetDataSecurityLoSCapabilities(storageservice.Client, storageservice.dataSecurityLoSCapabilities)
}
func (storageservice *StorageService) DataStorageLoSCapabilities() (*DataStorageLoSCapabilities, error) {
	if storageservice.dataStorageLoSCapabilities == "" {
		return nil, nil
	}
	return GetDataStorageLoSCapabilities(storageservice.Client, storageservice.dataStorageLoSCapabilities)
}
func (storageservice *StorageService) DefaultClassOfService() (*ClassOfService, error) {
	if storageservice.defaultClassOfService == "" {
		return nil, nil
	}
	return GetClassOfService(storageservice.Client, storageservice.defaultClassOfService)
}
func (storageservice *StorageService) Drives() ([]*redfish.Drive, error) {
	return redfish.ListReferencedDrives(storageservice.Client, storageservice.drives)
}
func (storageservice *StorageService) EndpointGroups() ([]*EndpointGroup, error) {
	return ListReferencedEndpointGroups(storageservice.Client, storageservice.endpointGroups)
}
func (storageservice *StorageService) Endpoints() ([]*redfish.Endpoint, error) {
	return redfish.ListReferencedEndpoints(storageservice.Client, storageservice.endpoints)
}
func (storageservice *StorageService) FileSystems() ([]*FileSystem, error) {
	return ListReferencedFileSystems(storageservice.Client, storageservice.fileSystems)
}
func (storageservice *StorageService) IOConnectivityLoSCapabilities() (*IOConnectivityLoSCapabilities, error) {
	if storageservice.ioConnectivityLoSCapabilities == "" {
		return nil, nil
	}
	return GetIOConnectivityLoSCapabilities(storageservice.Client, storageservice.ioConnectivityLoSCapabilities)
}
func (storageservice *StorageService) IOPerformanceLoSCapabilities() (*IOPerformanceLoSCapabilities, error) {
	if storageservice.ioConnectivityLoSCapabilities == "" {
		return nil, nil
	}
	return GetIOPerformanceLoSCapabilities(storageservice.Client, storageservice.ioPerformanceLoSCapabilities)
}