github.com/vmware/govmomi@v0.37.1/eam/object/agency.go (about)

     1  /*
     2  Copyright (c) 2021 VMware, Inc. All Rights Reserved.
     3  
     4  Licensed under the Apache License, Version 2.0 (the "License");
     5  you may not use this file except in compliance with the License.
     6  You may obtain a copy of the License at
     7  
     8      http://www.apache.org/licenses/LICENSE-2.0
     9  
    10  Unless required by applicable law or agreed to in writing, software
    11  distributed under the License is distributed on an "AS IS" BASIS,
    12  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13  See the License for the specific language governing permissions and
    14  limitations under the License.
    15  */
    16  
    17  package object
    18  
    19  import (
    20  	"context"
    21  
    22  	"github.com/vmware/govmomi/eam"
    23  	"github.com/vmware/govmomi/eam/methods"
    24  	"github.com/vmware/govmomi/eam/types"
    25  	vim "github.com/vmware/govmomi/vim25/types"
    26  )
    27  
    28  type Agency struct {
    29  	EamObject
    30  }
    31  
    32  // NewAgency returns a wrapper for an Agency managed object.
    33  func NewAgency(c *eam.Client, ref vim.ManagedObjectReference) Agency {
    34  	return Agency{
    35  		EamObject: EamObject{
    36  			c: c,
    37  			r: ref,
    38  		},
    39  	}
    40  }
    41  
    42  func (m Agency) Agents(ctx context.Context) ([]Agent, error) {
    43  	resp, err := methods.QueryAgent(ctx, m.c, &types.QueryAgent{
    44  		This: m.r,
    45  	})
    46  	if err != nil {
    47  		return nil, err
    48  	}
    49  	objs := make([]Agent, len(resp.Returnval))
    50  	for i := range resp.Returnval {
    51  		objs[i].c = m.c
    52  		objs[i].r = resp.Returnval[i]
    53  	}
    54  	return objs, nil
    55  }
    56  
    57  func (m Agency) Config(ctx context.Context) (types.BaseAgencyConfigInfo, error) {
    58  	resp, err := methods.QueryConfig(ctx, m.c, &types.QueryConfig{
    59  		This: m.r,
    60  	})
    61  	if err != nil {
    62  		return nil, err
    63  	}
    64  	return resp.Returnval, nil
    65  }
    66  
    67  func (m Agency) Runtime(ctx context.Context) (*types.EamObjectRuntimeInfo, error) {
    68  	resp, err := methods.AgencyQueryRuntime(ctx, m.c, &types.AgencyQueryRuntime{
    69  		This: m.r,
    70  	})
    71  	if err != nil {
    72  		return nil, err
    73  	}
    74  	return resp.Returnval.GetEamObjectRuntimeInfo(), nil
    75  }
    76  
    77  func (m Agency) SolutionId(ctx context.Context) (string, error) {
    78  	resp, err := methods.QuerySolutionId(ctx, m.c, &types.QuerySolutionId{
    79  		This: m.r,
    80  	})
    81  	if err != nil {
    82  		return "", err
    83  	}
    84  	return resp.Returnval, nil
    85  }
    86  
    87  func (m Agency) Destroy(ctx context.Context) error {
    88  	_, err := methods.DestroyAgency(ctx, m.c, &types.DestroyAgency{
    89  		This: m.r,
    90  	})
    91  	if err != nil {
    92  		return err
    93  	}
    94  	return nil
    95  }
    96  
    97  func (m Agency) Disable(ctx context.Context) error {
    98  	_, err := methods.Agency_Disable(ctx, m.c, &types.Agency_Disable{
    99  		This: m.r,
   100  	})
   101  	if err != nil {
   102  		return err
   103  	}
   104  	return nil
   105  }
   106  
   107  func (m Agency) Enable(ctx context.Context) error {
   108  	_, err := methods.Agency_Enable(ctx, m.c, &types.Agency_Enable{
   109  		This: m.r,
   110  	})
   111  	if err != nil {
   112  		return err
   113  	}
   114  	return nil
   115  }
   116  
   117  func (m Agency) RegisterAgentVm(
   118  	ctx context.Context,
   119  	agentVmMoRef vim.ManagedObjectReference) (*Agent, error) {
   120  
   121  	resp, err := methods.RegisterAgentVm(ctx, m.c, &types.RegisterAgentVm{
   122  		This:    m.r,
   123  		AgentVm: agentVmMoRef,
   124  	})
   125  	if err != nil {
   126  		return nil, err
   127  	}
   128  	return NewAgent(m.c, resp.Returnval), nil
   129  }
   130  
   131  func (m Agency) Uninstall(ctx context.Context) error {
   132  	_, err := methods.Uninstall(ctx, m.c, &types.Uninstall{
   133  		This: m.r,
   134  	})
   135  	if err != nil {
   136  		return err
   137  	}
   138  	return nil
   139  }
   140  
   141  func (m Agency) UnregisterAgentVm(
   142  	ctx context.Context,
   143  	agentVmMoRef vim.ManagedObjectReference) error {
   144  
   145  	_, err := methods.UnregisterAgentVm(ctx, m.c, &types.UnregisterAgentVm{
   146  		This:    m.r,
   147  		AgentVm: agentVmMoRef,
   148  	})
   149  	if err != nil {
   150  		return err
   151  	}
   152  	return nil
   153  }
   154  
   155  func (m Agency) Update(
   156  	ctx context.Context,
   157  	config types.BaseAgencyConfigInfo) error {
   158  
   159  	_, err := methods.Update(ctx, m.c, &types.Update{
   160  		This:   m.r,
   161  		Config: config,
   162  	})
   163  	if err != nil {
   164  		return err
   165  	}
   166  	return nil
   167  }