github.com/vmware/govmomi@v0.43.0/lookup/types/types.go (about)

     1  /*
     2  Copyright (c) 2014-2018 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 types
    18  
    19  import (
    20  	"reflect"
    21  
    22  	"github.com/vmware/govmomi/vim25/types"
    23  	vim "github.com/vmware/govmomi/vim25/types"
    24  )
    25  
    26  type Create CreateRequestType
    27  
    28  func init() {
    29  	types.Add("lookup:Create", reflect.TypeOf((*Create)(nil)).Elem())
    30  }
    31  
    32  type CreateRequestType struct {
    33  	This       vim.ManagedObjectReference          `xml:"_this"`
    34  	ServiceId  string                              `xml:"serviceId"`
    35  	CreateSpec LookupServiceRegistrationCreateSpec `xml:"createSpec"`
    36  }
    37  
    38  func init() {
    39  	types.Add("lookup:CreateRequestType", reflect.TypeOf((*CreateRequestType)(nil)).Elem())
    40  }
    41  
    42  type CreateResponse struct {
    43  }
    44  
    45  type Delete DeleteRequestType
    46  
    47  func init() {
    48  	types.Add("lookup:Delete", reflect.TypeOf((*Delete)(nil)).Elem())
    49  }
    50  
    51  type DeleteRequestType struct {
    52  	This      vim.ManagedObjectReference `xml:"_this"`
    53  	ServiceId string                     `xml:"serviceId"`
    54  }
    55  
    56  func init() {
    57  	types.Add("lookup:DeleteRequestType", reflect.TypeOf((*DeleteRequestType)(nil)).Elem())
    58  }
    59  
    60  type DeleteResponse struct {
    61  }
    62  
    63  type Get GetRequestType
    64  
    65  func init() {
    66  	types.Add("lookup:Get", reflect.TypeOf((*Get)(nil)).Elem())
    67  }
    68  
    69  type GetLocale GetLocaleRequestType
    70  
    71  func init() {
    72  	types.Add("lookup:GetLocale", reflect.TypeOf((*GetLocale)(nil)).Elem())
    73  }
    74  
    75  type GetLocaleRequestType struct {
    76  	This vim.ManagedObjectReference `xml:"_this"`
    77  }
    78  
    79  func init() {
    80  	types.Add("lookup:GetLocaleRequestType", reflect.TypeOf((*GetLocaleRequestType)(nil)).Elem())
    81  }
    82  
    83  type GetLocaleResponse struct {
    84  	Returnval string `xml:"returnval"`
    85  }
    86  
    87  type GetRequestType struct {
    88  	This      vim.ManagedObjectReference `xml:"_this"`
    89  	ServiceId string                     `xml:"serviceId"`
    90  }
    91  
    92  func init() {
    93  	types.Add("lookup:GetRequestType", reflect.TypeOf((*GetRequestType)(nil)).Elem())
    94  }
    95  
    96  type GetResponse struct {
    97  	Returnval LookupServiceRegistrationInfo `xml:"returnval"`
    98  }
    99  
   100  type GetSiteId GetSiteIdRequestType
   101  
   102  func init() {
   103  	types.Add("lookup:GetSiteId", reflect.TypeOf((*GetSiteId)(nil)).Elem())
   104  }
   105  
   106  type GetSiteIdRequestType struct {
   107  	This vim.ManagedObjectReference `xml:"_this"`
   108  }
   109  
   110  func init() {
   111  	types.Add("lookup:GetSiteIdRequestType", reflect.TypeOf((*GetSiteIdRequestType)(nil)).Elem())
   112  }
   113  
   114  type GetSiteIdResponse struct {
   115  	Returnval string `xml:"returnval"`
   116  }
   117  
   118  type List ListRequestType
   119  
   120  func init() {
   121  	types.Add("lookup:List", reflect.TypeOf((*List)(nil)).Elem())
   122  }
   123  
   124  type ListRequestType struct {
   125  	This           vim.ManagedObjectReference       `xml:"_this"`
   126  	FilterCriteria *LookupServiceRegistrationFilter `xml:"filterCriteria,omitempty"`
   127  }
   128  
   129  func init() {
   130  	types.Add("lookup:ListRequestType", reflect.TypeOf((*ListRequestType)(nil)).Elem())
   131  }
   132  
   133  type ListResponse struct {
   134  	Returnval []LookupServiceRegistrationInfo `xml:"returnval,omitempty"`
   135  }
   136  
   137  type LookupFaultEntryExistsFault struct {
   138  	LookupFaultServiceFault
   139  
   140  	Name string `xml:"name"`
   141  }
   142  
   143  func init() {
   144  	types.Add("lookup:LookupFaultEntryExistsFault", reflect.TypeOf((*LookupFaultEntryExistsFault)(nil)).Elem())
   145  }
   146  
   147  type LookupFaultEntryExistsFaultFault LookupFaultEntryExistsFault
   148  
   149  func init() {
   150  	types.Add("lookup:LookupFaultEntryExistsFaultFault", reflect.TypeOf((*LookupFaultEntryExistsFaultFault)(nil)).Elem())
   151  }
   152  
   153  type LookupFaultEntryNotFoundFault struct {
   154  	LookupFaultServiceFault
   155  
   156  	Name string `xml:"name"`
   157  }
   158  
   159  func init() {
   160  	types.Add("lookup:LookupFaultEntryNotFoundFault", reflect.TypeOf((*LookupFaultEntryNotFoundFault)(nil)).Elem())
   161  }
   162  
   163  type LookupFaultEntryNotFoundFaultFault LookupFaultEntryNotFoundFault
   164  
   165  func init() {
   166  	types.Add("lookup:LookupFaultEntryNotFoundFaultFault", reflect.TypeOf((*LookupFaultEntryNotFoundFaultFault)(nil)).Elem())
   167  }
   168  
   169  type LookupFaultServiceFault struct {
   170  	vim.MethodFault
   171  
   172  	ErrorMessage string `xml:"errorMessage,omitempty"`
   173  }
   174  
   175  func init() {
   176  	types.Add("lookup:LookupFaultServiceFault", reflect.TypeOf((*LookupFaultServiceFault)(nil)).Elem())
   177  }
   178  
   179  type LookupFaultUnsupportedSiteFault struct {
   180  	LookupFaultServiceFault
   181  
   182  	OperatingSite string `xml:"operatingSite"`
   183  	RequestedSite string `xml:"requestedSite"`
   184  }
   185  
   186  func init() {
   187  	types.Add("lookup:LookupFaultUnsupportedSiteFault", reflect.TypeOf((*LookupFaultUnsupportedSiteFault)(nil)).Elem())
   188  }
   189  
   190  type LookupFaultUnsupportedSiteFaultFault LookupFaultUnsupportedSiteFault
   191  
   192  func init() {
   193  	types.Add("lookup:LookupFaultUnsupportedSiteFaultFault", reflect.TypeOf((*LookupFaultUnsupportedSiteFaultFault)(nil)).Elem())
   194  }
   195  
   196  type LookupHaBackupNodeConfiguration struct {
   197  	vim.DynamicData
   198  
   199  	DbType    string `xml:"dbType"`
   200  	DbJdbcUrl string `xml:"dbJdbcUrl"`
   201  	DbUser    string `xml:"dbUser"`
   202  	DbPass    string `xml:"dbPass"`
   203  }
   204  
   205  func init() {
   206  	types.Add("lookup:LookupHaBackupNodeConfiguration", reflect.TypeOf((*LookupHaBackupNodeConfiguration)(nil)).Elem())
   207  }
   208  
   209  type LookupServiceContent struct {
   210  	vim.DynamicData
   211  
   212  	LookupService                vim.ManagedObjectReference  `xml:"lookupService"`
   213  	ServiceRegistration          *vim.ManagedObjectReference `xml:"serviceRegistration,omitempty"`
   214  	DeploymentInformationService vim.ManagedObjectReference  `xml:"deploymentInformationService"`
   215  	L10n                         vim.ManagedObjectReference  `xml:"l10n"`
   216  }
   217  
   218  func init() {
   219  	types.Add("lookup:LookupServiceContent", reflect.TypeOf((*LookupServiceContent)(nil)).Elem())
   220  }
   221  
   222  type LookupServiceRegistrationAttribute struct {
   223  	vim.DynamicData
   224  
   225  	Key   string `xml:"key"`
   226  	Value string `xml:"value"`
   227  }
   228  
   229  func init() {
   230  	types.Add("lookup:LookupServiceRegistrationAttribute", reflect.TypeOf((*LookupServiceRegistrationAttribute)(nil)).Elem())
   231  }
   232  
   233  type LookupServiceRegistrationCommonServiceInfo struct {
   234  	LookupServiceRegistrationMutableServiceInfo
   235  
   236  	OwnerId     string                               `xml:"ownerId"`
   237  	ServiceType LookupServiceRegistrationServiceType `xml:"serviceType"`
   238  	NodeId      string                               `xml:"nodeId,omitempty"`
   239  }
   240  
   241  func init() {
   242  	types.Add("lookup:LookupServiceRegistrationCommonServiceInfo", reflect.TypeOf((*LookupServiceRegistrationCommonServiceInfo)(nil)).Elem())
   243  }
   244  
   245  type LookupServiceRegistrationCreateSpec struct {
   246  	LookupServiceRegistrationCommonServiceInfo
   247  }
   248  
   249  func init() {
   250  	types.Add("lookup:LookupServiceRegistrationCreateSpec", reflect.TypeOf((*LookupServiceRegistrationCreateSpec)(nil)).Elem())
   251  }
   252  
   253  type LookupServiceRegistrationEndpoint struct {
   254  	vim.DynamicData
   255  
   256  	Url                string                                `xml:"url"`
   257  	EndpointType       LookupServiceRegistrationEndpointType `xml:"endpointType"`
   258  	SslTrust           []string                              `xml:"sslTrust,omitempty"`
   259  	EndpointAttributes []LookupServiceRegistrationAttribute  `xml:"endpointAttributes,omitempty"`
   260  }
   261  
   262  func init() {
   263  	types.Add("lookup:LookupServiceRegistrationEndpoint", reflect.TypeOf((*LookupServiceRegistrationEndpoint)(nil)).Elem())
   264  }
   265  
   266  type LookupServiceRegistrationEndpointType struct {
   267  	vim.DynamicData
   268  
   269  	Protocol string `xml:"protocol,omitempty"`
   270  	Type     string `xml:"type,omitempty"`
   271  }
   272  
   273  func init() {
   274  	types.Add("lookup:LookupServiceRegistrationEndpointType", reflect.TypeOf((*LookupServiceRegistrationEndpointType)(nil)).Elem())
   275  }
   276  
   277  type LookupServiceRegistrationFilter struct {
   278  	vim.DynamicData
   279  
   280  	SiteId       string                                 `xml:"siteId,omitempty"`
   281  	NodeId       string                                 `xml:"nodeId,omitempty"`
   282  	ServiceType  *LookupServiceRegistrationServiceType  `xml:"serviceType,omitempty"`
   283  	EndpointType *LookupServiceRegistrationEndpointType `xml:"endpointType,omitempty"`
   284  }
   285  
   286  func init() {
   287  	types.Add("lookup:LookupServiceRegistrationFilter", reflect.TypeOf((*LookupServiceRegistrationFilter)(nil)).Elem())
   288  }
   289  
   290  type LookupServiceRegistrationInfo struct {
   291  	LookupServiceRegistrationCommonServiceInfo
   292  
   293  	ServiceId string `xml:"serviceId"`
   294  	SiteId    string `xml:"siteId"`
   295  }
   296  
   297  func init() {
   298  	types.Add("lookup:LookupServiceRegistrationInfo", reflect.TypeOf((*LookupServiceRegistrationInfo)(nil)).Elem())
   299  }
   300  
   301  type LookupServiceRegistrationMutableServiceInfo struct {
   302  	vim.DynamicData
   303  
   304  	ServiceVersion                string                               `xml:"serviceVersion"`
   305  	VendorNameResourceKey         string                               `xml:"vendorNameResourceKey,omitempty"`
   306  	VendorNameDefault             string                               `xml:"vendorNameDefault,omitempty"`
   307  	VendorProductInfoResourceKey  string                               `xml:"vendorProductInfoResourceKey,omitempty"`
   308  	VendorProductInfoDefault      string                               `xml:"vendorProductInfoDefault,omitempty"`
   309  	ServiceEndpoints              []LookupServiceRegistrationEndpoint  `xml:"serviceEndpoints,omitempty"`
   310  	ServiceAttributes             []LookupServiceRegistrationAttribute `xml:"serviceAttributes,omitempty"`
   311  	ServiceNameResourceKey        string                               `xml:"serviceNameResourceKey,omitempty"`
   312  	ServiceNameDefault            string                               `xml:"serviceNameDefault,omitempty"`
   313  	ServiceDescriptionResourceKey string                               `xml:"serviceDescriptionResourceKey,omitempty"`
   314  	ServiceDescriptionDefault     string                               `xml:"serviceDescriptionDefault,omitempty"`
   315  }
   316  
   317  func init() {
   318  	types.Add("lookup:LookupServiceRegistrationMutableServiceInfo", reflect.TypeOf((*LookupServiceRegistrationMutableServiceInfo)(nil)).Elem())
   319  }
   320  
   321  type LookupServiceRegistrationServiceType struct {
   322  	vim.DynamicData
   323  
   324  	Product string `xml:"product"`
   325  	Type    string `xml:"type"`
   326  }
   327  
   328  func init() {
   329  	types.Add("lookup:LookupServiceRegistrationServiceType", reflect.TypeOf((*LookupServiceRegistrationServiceType)(nil)).Elem())
   330  }
   331  
   332  type LookupServiceRegistrationSetSpec struct {
   333  	LookupServiceRegistrationMutableServiceInfo
   334  }
   335  
   336  func init() {
   337  	types.Add("lookup:LookupServiceRegistrationSetSpec", reflect.TypeOf((*LookupServiceRegistrationSetSpec)(nil)).Elem())
   338  }
   339  
   340  type RetrieveHaBackupConfiguration RetrieveHaBackupConfigurationRequestType
   341  
   342  func init() {
   343  	types.Add("lookup:RetrieveHaBackupConfiguration", reflect.TypeOf((*RetrieveHaBackupConfiguration)(nil)).Elem())
   344  }
   345  
   346  type RetrieveHaBackupConfigurationRequestType struct {
   347  	This vim.ManagedObjectReference `xml:"_this"`
   348  }
   349  
   350  func init() {
   351  	types.Add("lookup:RetrieveHaBackupConfigurationRequestType", reflect.TypeOf((*RetrieveHaBackupConfigurationRequestType)(nil)).Elem())
   352  }
   353  
   354  type RetrieveHaBackupConfigurationResponse struct {
   355  	Returnval LookupHaBackupNodeConfiguration `xml:"returnval"`
   356  }
   357  
   358  type RetrieveServiceContent RetrieveServiceContentRequestType
   359  
   360  func init() {
   361  	types.Add("lookup:RetrieveServiceContent", reflect.TypeOf((*RetrieveServiceContent)(nil)).Elem())
   362  }
   363  
   364  type RetrieveServiceContentRequestType struct {
   365  	This vim.ManagedObjectReference `xml:"_this"`
   366  }
   367  
   368  func init() {
   369  	types.Add("lookup:RetrieveServiceContentRequestType", reflect.TypeOf((*RetrieveServiceContentRequestType)(nil)).Elem())
   370  }
   371  
   372  type RetrieveServiceContentResponse struct {
   373  	Returnval LookupServiceContent `xml:"returnval"`
   374  }
   375  
   376  type Set SetRequestType
   377  
   378  func init() {
   379  	types.Add("lookup:Set", reflect.TypeOf((*Set)(nil)).Elem())
   380  }
   381  
   382  type SetLocale SetLocaleRequestType
   383  
   384  func init() {
   385  	types.Add("lookup:SetLocale", reflect.TypeOf((*SetLocale)(nil)).Elem())
   386  }
   387  
   388  type SetLocaleRequestType struct {
   389  	This   vim.ManagedObjectReference `xml:"_this"`
   390  	Locale string                     `xml:"locale"`
   391  }
   392  
   393  func init() {
   394  	types.Add("lookup:SetLocaleRequestType", reflect.TypeOf((*SetLocaleRequestType)(nil)).Elem())
   395  }
   396  
   397  type SetLocaleResponse struct {
   398  	Returnval string `xml:"returnval"`
   399  }
   400  
   401  type SetRequestType struct {
   402  	This        vim.ManagedObjectReference       `xml:"_this"`
   403  	ServiceId   string                           `xml:"serviceId"`
   404  	ServiceSpec LookupServiceRegistrationSetSpec `xml:"serviceSpec"`
   405  }
   406  
   407  func init() {
   408  	types.Add("lookup:SetRequestType", reflect.TypeOf((*SetRequestType)(nil)).Elem())
   409  }
   410  
   411  type SetResponse struct {
   412  }