func()

in sdk/resourcemanager/machinelearning/armmachinelearning/fake/server_factory.go [137:374]


func (s *ServerFactoryTransport) Do(req *http.Request) (*http.Response, error) {
	rawMethod := req.Context().Value(runtime.CtxAPINameKey{})
	method, ok := rawMethod.(string)
	if !ok {
		return nil, nonRetriableError{errors.New("unable to dispatch request, missing value for CtxAPINameKey")}
	}

	client := method[:strings.Index(method, ".")]
	var resp *http.Response
	var err error

	switch client {
	case "BatchDeploymentsClient":
		initServer(s, &s.trBatchDeploymentsServer, func() *BatchDeploymentsServerTransport {
			return NewBatchDeploymentsServerTransport(&s.srv.BatchDeploymentsServer)
		})
		resp, err = s.trBatchDeploymentsServer.Do(req)
	case "BatchEndpointsClient":
		initServer(s, &s.trBatchEndpointsServer, func() *BatchEndpointsServerTransport {
			return NewBatchEndpointsServerTransport(&s.srv.BatchEndpointsServer)
		})
		resp, err = s.trBatchEndpointsServer.Do(req)
	case "CodeContainersClient":
		initServer(s, &s.trCodeContainersServer, func() *CodeContainersServerTransport {
			return NewCodeContainersServerTransport(&s.srv.CodeContainersServer)
		})
		resp, err = s.trCodeContainersServer.Do(req)
	case "CodeVersionsClient":
		initServer(s, &s.trCodeVersionsServer, func() *CodeVersionsServerTransport { return NewCodeVersionsServerTransport(&s.srv.CodeVersionsServer) })
		resp, err = s.trCodeVersionsServer.Do(req)
	case "ComponentContainersClient":
		initServer(s, &s.trComponentContainersServer, func() *ComponentContainersServerTransport {
			return NewComponentContainersServerTransport(&s.srv.ComponentContainersServer)
		})
		resp, err = s.trComponentContainersServer.Do(req)
	case "ComponentVersionsClient":
		initServer(s, &s.trComponentVersionsServer, func() *ComponentVersionsServerTransport {
			return NewComponentVersionsServerTransport(&s.srv.ComponentVersionsServer)
		})
		resp, err = s.trComponentVersionsServer.Do(req)
	case "ComputeClient":
		initServer(s, &s.trComputeServer, func() *ComputeServerTransport { return NewComputeServerTransport(&s.srv.ComputeServer) })
		resp, err = s.trComputeServer.Do(req)
	case "DataContainersClient":
		initServer(s, &s.trDataContainersServer, func() *DataContainersServerTransport {
			return NewDataContainersServerTransport(&s.srv.DataContainersServer)
		})
		resp, err = s.trDataContainersServer.Do(req)
	case "DataVersionsClient":
		initServer(s, &s.trDataVersionsServer, func() *DataVersionsServerTransport { return NewDataVersionsServerTransport(&s.srv.DataVersionsServer) })
		resp, err = s.trDataVersionsServer.Do(req)
	case "DatastoresClient":
		initServer(s, &s.trDatastoresServer, func() *DatastoresServerTransport { return NewDatastoresServerTransport(&s.srv.DatastoresServer) })
		resp, err = s.trDatastoresServer.Do(req)
	case "EnvironmentContainersClient":
		initServer(s, &s.trEnvironmentContainersServer, func() *EnvironmentContainersServerTransport {
			return NewEnvironmentContainersServerTransport(&s.srv.EnvironmentContainersServer)
		})
		resp, err = s.trEnvironmentContainersServer.Do(req)
	case "EnvironmentVersionsClient":
		initServer(s, &s.trEnvironmentVersionsServer, func() *EnvironmentVersionsServerTransport {
			return NewEnvironmentVersionsServerTransport(&s.srv.EnvironmentVersionsServer)
		})
		resp, err = s.trEnvironmentVersionsServer.Do(req)
	case "FeaturesClient":
		initServer(s, &s.trFeaturesServer, func() *FeaturesServerTransport { return NewFeaturesServerTransport(&s.srv.FeaturesServer) })
		resp, err = s.trFeaturesServer.Do(req)
	case "FeaturesetContainersClient":
		initServer(s, &s.trFeaturesetContainersServer, func() *FeaturesetContainersServerTransport {
			return NewFeaturesetContainersServerTransport(&s.srv.FeaturesetContainersServer)
		})
		resp, err = s.trFeaturesetContainersServer.Do(req)
	case "FeaturesetVersionsClient":
		initServer(s, &s.trFeaturesetVersionsServer, func() *FeaturesetVersionsServerTransport {
			return NewFeaturesetVersionsServerTransport(&s.srv.FeaturesetVersionsServer)
		})
		resp, err = s.trFeaturesetVersionsServer.Do(req)
	case "FeaturestoreEntityContainersClient":
		initServer(s, &s.trFeaturestoreEntityContainersServer, func() *FeaturestoreEntityContainersServerTransport {
			return NewFeaturestoreEntityContainersServerTransport(&s.srv.FeaturestoreEntityContainersServer)
		})
		resp, err = s.trFeaturestoreEntityContainersServer.Do(req)
	case "FeaturestoreEntityVersionsClient":
		initServer(s, &s.trFeaturestoreEntityVersionsServer, func() *FeaturestoreEntityVersionsServerTransport {
			return NewFeaturestoreEntityVersionsServerTransport(&s.srv.FeaturestoreEntityVersionsServer)
		})
		resp, err = s.trFeaturestoreEntityVersionsServer.Do(req)
	case "JobsClient":
		initServer(s, &s.trJobsServer, func() *JobsServerTransport { return NewJobsServerTransport(&s.srv.JobsServer) })
		resp, err = s.trJobsServer.Do(req)
	case "ManagedNetworkProvisionsClient":
		initServer(s, &s.trManagedNetworkProvisionsServer, func() *ManagedNetworkProvisionsServerTransport {
			return NewManagedNetworkProvisionsServerTransport(&s.srv.ManagedNetworkProvisionsServer)
		})
		resp, err = s.trManagedNetworkProvisionsServer.Do(req)
	case "ManagedNetworkSettingsRuleClient":
		initServer(s, &s.trManagedNetworkSettingsRuleServer, func() *ManagedNetworkSettingsRuleServerTransport {
			return NewManagedNetworkSettingsRuleServerTransport(&s.srv.ManagedNetworkSettingsRuleServer)
		})
		resp, err = s.trManagedNetworkSettingsRuleServer.Do(req)
	case "MarketplaceSubscriptionsClient":
		initServer(s, &s.trMarketplaceSubscriptionsServer, func() *MarketplaceSubscriptionsServerTransport {
			return NewMarketplaceSubscriptionsServerTransport(&s.srv.MarketplaceSubscriptionsServer)
		})
		resp, err = s.trMarketplaceSubscriptionsServer.Do(req)
	case "ModelContainersClient":
		initServer(s, &s.trModelContainersServer, func() *ModelContainersServerTransport {
			return NewModelContainersServerTransport(&s.srv.ModelContainersServer)
		})
		resp, err = s.trModelContainersServer.Do(req)
	case "ModelVersionsClient":
		initServer(s, &s.trModelVersionsServer, func() *ModelVersionsServerTransport {
			return NewModelVersionsServerTransport(&s.srv.ModelVersionsServer)
		})
		resp, err = s.trModelVersionsServer.Do(req)
	case "OnlineDeploymentsClient":
		initServer(s, &s.trOnlineDeploymentsServer, func() *OnlineDeploymentsServerTransport {
			return NewOnlineDeploymentsServerTransport(&s.srv.OnlineDeploymentsServer)
		})
		resp, err = s.trOnlineDeploymentsServer.Do(req)
	case "OnlineEndpointsClient":
		initServer(s, &s.trOnlineEndpointsServer, func() *OnlineEndpointsServerTransport {
			return NewOnlineEndpointsServerTransport(&s.srv.OnlineEndpointsServer)
		})
		resp, err = s.trOnlineEndpointsServer.Do(req)
	case "OperationsClient":
		initServer(s, &s.trOperationsServer, func() *OperationsServerTransport { return NewOperationsServerTransport(&s.srv.OperationsServer) })
		resp, err = s.trOperationsServer.Do(req)
	case "PrivateEndpointConnectionsClient":
		initServer(s, &s.trPrivateEndpointConnectionsServer, func() *PrivateEndpointConnectionsServerTransport {
			return NewPrivateEndpointConnectionsServerTransport(&s.srv.PrivateEndpointConnectionsServer)
		})
		resp, err = s.trPrivateEndpointConnectionsServer.Do(req)
	case "PrivateLinkResourcesClient":
		initServer(s, &s.trPrivateLinkResourcesServer, func() *PrivateLinkResourcesServerTransport {
			return NewPrivateLinkResourcesServerTransport(&s.srv.PrivateLinkResourcesServer)
		})
		resp, err = s.trPrivateLinkResourcesServer.Do(req)
	case "QuotasClient":
		initServer(s, &s.trQuotasServer, func() *QuotasServerTransport { return NewQuotasServerTransport(&s.srv.QuotasServer) })
		resp, err = s.trQuotasServer.Do(req)
	case "RegistriesClient":
		initServer(s, &s.trRegistriesServer, func() *RegistriesServerTransport { return NewRegistriesServerTransport(&s.srv.RegistriesServer) })
		resp, err = s.trRegistriesServer.Do(req)
	case "RegistryCodeContainersClient":
		initServer(s, &s.trRegistryCodeContainersServer, func() *RegistryCodeContainersServerTransport {
			return NewRegistryCodeContainersServerTransport(&s.srv.RegistryCodeContainersServer)
		})
		resp, err = s.trRegistryCodeContainersServer.Do(req)
	case "RegistryCodeVersionsClient":
		initServer(s, &s.trRegistryCodeVersionsServer, func() *RegistryCodeVersionsServerTransport {
			return NewRegistryCodeVersionsServerTransport(&s.srv.RegistryCodeVersionsServer)
		})
		resp, err = s.trRegistryCodeVersionsServer.Do(req)
	case "RegistryComponentContainersClient":
		initServer(s, &s.trRegistryComponentContainersServer, func() *RegistryComponentContainersServerTransport {
			return NewRegistryComponentContainersServerTransport(&s.srv.RegistryComponentContainersServer)
		})
		resp, err = s.trRegistryComponentContainersServer.Do(req)
	case "RegistryComponentVersionsClient":
		initServer(s, &s.trRegistryComponentVersionsServer, func() *RegistryComponentVersionsServerTransport {
			return NewRegistryComponentVersionsServerTransport(&s.srv.RegistryComponentVersionsServer)
		})
		resp, err = s.trRegistryComponentVersionsServer.Do(req)
	case "RegistryDataContainersClient":
		initServer(s, &s.trRegistryDataContainersServer, func() *RegistryDataContainersServerTransport {
			return NewRegistryDataContainersServerTransport(&s.srv.RegistryDataContainersServer)
		})
		resp, err = s.trRegistryDataContainersServer.Do(req)
	case "RegistryDataReferencesClient":
		initServer(s, &s.trRegistryDataReferencesServer, func() *RegistryDataReferencesServerTransport {
			return NewRegistryDataReferencesServerTransport(&s.srv.RegistryDataReferencesServer)
		})
		resp, err = s.trRegistryDataReferencesServer.Do(req)
	case "RegistryDataVersionsClient":
		initServer(s, &s.trRegistryDataVersionsServer, func() *RegistryDataVersionsServerTransport {
			return NewRegistryDataVersionsServerTransport(&s.srv.RegistryDataVersionsServer)
		})
		resp, err = s.trRegistryDataVersionsServer.Do(req)
	case "RegistryEnvironmentContainersClient":
		initServer(s, &s.trRegistryEnvironmentContainersServer, func() *RegistryEnvironmentContainersServerTransport {
			return NewRegistryEnvironmentContainersServerTransport(&s.srv.RegistryEnvironmentContainersServer)
		})
		resp, err = s.trRegistryEnvironmentContainersServer.Do(req)
	case "RegistryEnvironmentVersionsClient":
		initServer(s, &s.trRegistryEnvironmentVersionsServer, func() *RegistryEnvironmentVersionsServerTransport {
			return NewRegistryEnvironmentVersionsServerTransport(&s.srv.RegistryEnvironmentVersionsServer)
		})
		resp, err = s.trRegistryEnvironmentVersionsServer.Do(req)
	case "RegistryModelContainersClient":
		initServer(s, &s.trRegistryModelContainersServer, func() *RegistryModelContainersServerTransport {
			return NewRegistryModelContainersServerTransport(&s.srv.RegistryModelContainersServer)
		})
		resp, err = s.trRegistryModelContainersServer.Do(req)
	case "RegistryModelVersionsClient":
		initServer(s, &s.trRegistryModelVersionsServer, func() *RegistryModelVersionsServerTransport {
			return NewRegistryModelVersionsServerTransport(&s.srv.RegistryModelVersionsServer)
		})
		resp, err = s.trRegistryModelVersionsServer.Do(req)
	case "SchedulesClient":
		initServer(s, &s.trSchedulesServer, func() *SchedulesServerTransport { return NewSchedulesServerTransport(&s.srv.SchedulesServer) })
		resp, err = s.trSchedulesServer.Do(req)
	case "ServerlessEndpointsClient":
		initServer(s, &s.trServerlessEndpointsServer, func() *ServerlessEndpointsServerTransport {
			return NewServerlessEndpointsServerTransport(&s.srv.ServerlessEndpointsServer)
		})
		resp, err = s.trServerlessEndpointsServer.Do(req)
	case "UsagesClient":
		initServer(s, &s.trUsagesServer, func() *UsagesServerTransport { return NewUsagesServerTransport(&s.srv.UsagesServer) })
		resp, err = s.trUsagesServer.Do(req)
	case "VirtualMachineSizesClient":
		initServer(s, &s.trVirtualMachineSizesServer, func() *VirtualMachineSizesServerTransport {
			return NewVirtualMachineSizesServerTransport(&s.srv.VirtualMachineSizesServer)
		})
		resp, err = s.trVirtualMachineSizesServer.Do(req)
	case "WorkspaceConnectionsClient":
		initServer(s, &s.trWorkspaceConnectionsServer, func() *WorkspaceConnectionsServerTransport {
			return NewWorkspaceConnectionsServerTransport(&s.srv.WorkspaceConnectionsServer)
		})
		resp, err = s.trWorkspaceConnectionsServer.Do(req)
	case "WorkspaceFeaturesClient":
		initServer(s, &s.trWorkspaceFeaturesServer, func() *WorkspaceFeaturesServerTransport {
			return NewWorkspaceFeaturesServerTransport(&s.srv.WorkspaceFeaturesServer)
		})
		resp, err = s.trWorkspaceFeaturesServer.Do(req)
	case "WorkspacesClient":
		initServer(s, &s.trWorkspacesServer, func() *WorkspacesServerTransport { return NewWorkspacesServerTransport(&s.srv.WorkspacesServer) })
		resp, err = s.trWorkspacesServer.Do(req)
	default:
		err = fmt.Errorf("unhandled client %s", client)
	}

	if err != nil {
		return nil, err
	}

	return resp, nil
}