databricks-cli/cmd/workspace/vector-search-endpoints/vector-search-endpoints.go

314 lines
8.4 KiB
Go
Raw Normal View History

// Code generated from OpenAPI specs by Databricks SDK Generator. DO NOT EDIT.
package vector_search_endpoints
import (
"fmt"
"time"
"github.com/databricks/cli/cmd/root"
"github.com/databricks/cli/libs/cmdio"
"github.com/databricks/cli/libs/flags"
"github.com/databricks/databricks-sdk-go/service/vectorsearch"
"github.com/spf13/cobra"
)
// Slice with functions to override default command behavior.
// Functions can be added from the `init()` function in manually curated files in this directory.
var cmdOverrides []func(*cobra.Command)
func New() *cobra.Command {
cmd := &cobra.Command{
Use: "vector-search-endpoints",
Short: `**Endpoint**: Represents the compute resources to host vector search indexes.`,
Long: `**Endpoint**: Represents the compute resources to host vector search indexes.`,
GroupID: "vectorsearch",
Annotations: map[string]string{
"package": "vectorsearch",
},
}
// Add methods
cmd.AddCommand(newCreateEndpoint())
cmd.AddCommand(newDeleteEndpoint())
cmd.AddCommand(newGetEndpoint())
cmd.AddCommand(newListEndpoints())
// Apply optional overrides to this command.
for _, fn := range cmdOverrides {
fn(cmd)
}
return cmd
}
// start create-endpoint command
// Slice with functions to override default command behavior.
// Functions can be added from the `init()` function in manually curated files in this directory.
var createEndpointOverrides []func(
*cobra.Command,
*vectorsearch.CreateEndpoint,
)
func newCreateEndpoint() *cobra.Command {
cmd := &cobra.Command{}
var createEndpointReq vectorsearch.CreateEndpoint
var createEndpointJson flags.JsonFlag
var createEndpointSkipWait bool
var createEndpointTimeout time.Duration
cmd.Flags().BoolVar(&createEndpointSkipWait, "no-wait", createEndpointSkipWait, `do not wait to reach ONLINE state`)
cmd.Flags().DurationVar(&createEndpointTimeout, "timeout", 20*time.Minute, `maximum amount of time to reach ONLINE state`)
// TODO: short flags
cmd.Flags().Var(&createEndpointJson, "json", `either inline JSON string or @path/to/file.json with request body`)
cmd.Use = "create-endpoint NAME ENDPOINT_TYPE"
cmd.Short = `Create an endpoint.`
cmd.Long = `Create an endpoint.
Create a new endpoint.
Arguments:
NAME: Name of endpoint
ENDPOINT_TYPE: Type of endpoint.`
cmd.Annotations = make(map[string]string)
cmd.Args = func(cmd *cobra.Command, args []string) error {
if cmd.Flags().Changed("json") {
err := cobra.ExactArgs(0)(cmd, args)
if err != nil {
return fmt.Errorf("when --json flag is specified, no positional arguments are required. Provide 'name', 'endpoint_type' in your JSON input")
}
return nil
}
check := cobra.ExactArgs(2)
return check(cmd, args)
}
cmd.PreRunE = root.MustWorkspaceClient
cmd.RunE = func(cmd *cobra.Command, args []string) (err error) {
ctx := cmd.Context()
w := root.WorkspaceClient(ctx)
if cmd.Flags().Changed("json") {
err = createEndpointJson.Unmarshal(&createEndpointReq)
if err != nil {
return err
}
}
if !cmd.Flags().Changed("json") {
createEndpointReq.Name = args[0]
}
if !cmd.Flags().Changed("json") {
_, err = fmt.Sscan(args[1], &createEndpointReq.EndpointType)
if err != nil {
return fmt.Errorf("invalid ENDPOINT_TYPE: %s", args[1])
}
}
wait, err := w.VectorSearchEndpoints.CreateEndpoint(ctx, createEndpointReq)
if err != nil {
return err
}
if createEndpointSkipWait {
return cmdio.Render(ctx, wait.Response)
}
spinner := cmdio.Spinner(ctx)
info, err := wait.OnProgress(func(i *vectorsearch.EndpointInfo) {
if i.EndpointStatus == nil {
return
}
status := i.EndpointStatus.State
statusMessage := fmt.Sprintf("current status: %s", status)
if i.EndpointStatus != nil {
statusMessage = i.EndpointStatus.Message
}
spinner <- statusMessage
}).GetWithTimeout(createEndpointTimeout)
close(spinner)
if err != nil {
return err
}
return cmdio.Render(ctx, info)
}
// Disable completions since they are not applicable.
// Can be overridden by manual implementation in `override.go`.
cmd.ValidArgsFunction = cobra.NoFileCompletions
// Apply optional overrides to this command.
for _, fn := range createEndpointOverrides {
fn(cmd, &createEndpointReq)
}
return cmd
}
// start delete-endpoint command
// Slice with functions to override default command behavior.
// Functions can be added from the `init()` function in manually curated files in this directory.
var deleteEndpointOverrides []func(
*cobra.Command,
*vectorsearch.DeleteEndpointRequest,
)
func newDeleteEndpoint() *cobra.Command {
cmd := &cobra.Command{}
var deleteEndpointReq vectorsearch.DeleteEndpointRequest
// TODO: short flags
cmd.Use = "delete-endpoint ENDPOINT_NAME"
cmd.Short = `Delete an endpoint.`
cmd.Long = `Delete an endpoint.
Arguments:
ENDPOINT_NAME: Name of the endpoint`
cmd.Annotations = make(map[string]string)
cmd.Args = func(cmd *cobra.Command, args []string) error {
check := cobra.ExactArgs(1)
return check(cmd, args)
}
cmd.PreRunE = root.MustWorkspaceClient
cmd.RunE = func(cmd *cobra.Command, args []string) (err error) {
ctx := cmd.Context()
w := root.WorkspaceClient(ctx)
deleteEndpointReq.EndpointName = args[0]
err = w.VectorSearchEndpoints.DeleteEndpoint(ctx, deleteEndpointReq)
if err != nil {
return err
}
return nil
}
// Disable completions since they are not applicable.
// Can be overridden by manual implementation in `override.go`.
cmd.ValidArgsFunction = cobra.NoFileCompletions
// Apply optional overrides to this command.
for _, fn := range deleteEndpointOverrides {
fn(cmd, &deleteEndpointReq)
}
return cmd
}
// start get-endpoint command
// Slice with functions to override default command behavior.
// Functions can be added from the `init()` function in manually curated files in this directory.
var getEndpointOverrides []func(
*cobra.Command,
*vectorsearch.GetEndpointRequest,
)
func newGetEndpoint() *cobra.Command {
cmd := &cobra.Command{}
var getEndpointReq vectorsearch.GetEndpointRequest
// TODO: short flags
cmd.Use = "get-endpoint ENDPOINT_NAME"
cmd.Short = `Get an endpoint.`
cmd.Long = `Get an endpoint.
Arguments:
ENDPOINT_NAME: Name of the endpoint`
cmd.Annotations = make(map[string]string)
cmd.Args = func(cmd *cobra.Command, args []string) error {
check := cobra.ExactArgs(1)
return check(cmd, args)
}
cmd.PreRunE = root.MustWorkspaceClient
cmd.RunE = func(cmd *cobra.Command, args []string) (err error) {
ctx := cmd.Context()
w := root.WorkspaceClient(ctx)
getEndpointReq.EndpointName = args[0]
response, err := w.VectorSearchEndpoints.GetEndpoint(ctx, getEndpointReq)
if err != nil {
return err
}
return cmdio.Render(ctx, response)
}
// Disable completions since they are not applicable.
// Can be overridden by manual implementation in `override.go`.
cmd.ValidArgsFunction = cobra.NoFileCompletions
// Apply optional overrides to this command.
for _, fn := range getEndpointOverrides {
fn(cmd, &getEndpointReq)
}
return cmd
}
// start list-endpoints command
// Slice with functions to override default command behavior.
// Functions can be added from the `init()` function in manually curated files in this directory.
var listEndpointsOverrides []func(
*cobra.Command,
*vectorsearch.ListEndpointsRequest,
)
func newListEndpoints() *cobra.Command {
cmd := &cobra.Command{}
var listEndpointsReq vectorsearch.ListEndpointsRequest
// TODO: short flags
cmd.Flags().StringVar(&listEndpointsReq.PageToken, "page-token", listEndpointsReq.PageToken, `Token for pagination.`)
cmd.Use = "list-endpoints"
cmd.Short = `List all endpoints.`
cmd.Long = `List all endpoints.`
cmd.Annotations = make(map[string]string)
cmd.Args = func(cmd *cobra.Command, args []string) error {
check := cobra.ExactArgs(0)
return check(cmd, args)
}
cmd.PreRunE = root.MustWorkspaceClient
cmd.RunE = func(cmd *cobra.Command, args []string) (err error) {
ctx := cmd.Context()
w := root.WorkspaceClient(ctx)
Use Go SDK Iterators when listing resources with the CLI (#1202) ## Changes Currently, when the CLI run a list API call (like list jobs), it uses the `List*All` methods from the SDK, which list all resources in the collection. This is very slow for large collections: if you need to list all jobs from a workspace that has 10,000+ jobs, you'll be waiting for at least 100 RPCs to complete before seeing any output. Instead of using List*All() methods, the SDK recently added an iterator data structure that allows traversing the collection without needing to completely list it first. New pages are fetched lazily if the next requested item belongs to the next page. Using the List() methods that return these iterators, the CLI can proactively print out some of the response before the complete collection has been fetched. This involves a pretty major rewrite of the rendering logic in `cmdio`. The idea there is to define custom rendering logic based on the type of the provided resource. There are three renderer interfaces: 1. textRenderer: supports printing something in a textual format (i.e. not JSON, and not templated). 2. jsonRenderer: supports printing something in a pretty-printed JSON format. 3. templateRenderer: supports printing something using a text template. There are also three renderer implementations: 1. readerRenderer: supports printing a reader. This only implements the textRenderer interface. 2. iteratorRenderer: supports printing a `listing.Iterator` from the Go SDK. This implements jsonRenderer and templateRenderer, buffering 20 resources at a time before writing them to the output. 3. defaultRenderer: supports printing arbitrary resources (the previous implementation). Callers will either use `cmdio.Render()` for rendering individual resources or `io.Reader` or `cmdio.RenderIterator()` for rendering an iterator. This separate method is needed to safely be able to match on the type of the iterator, since Go does not allow runtime type matches on generic types with an existential type parameter. One other change that needs to happen is to split the templates used for text representation of list resources into a header template and a row template. The template is now executed multiple times for List API calls, but the header should only be printed once. To support this, I have added `headerTemplate` to `cmdIO`, and I have also changed `RenderWithTemplate` to include a `headerTemplate` parameter everywhere. ## Tests - [x] Unit tests for text rendering logic - [x] Unit test for reflection-based iterator construction. --------- Co-authored-by: Andrew Nester <andrew.nester@databricks.com>
2024-02-21 14:16:36 +00:00
response := w.VectorSearchEndpoints.ListEndpoints(ctx, listEndpointsReq)
return cmdio.RenderIterator(ctx, response)
}
// Disable completions since they are not applicable.
// Can be overridden by manual implementation in `override.go`.
cmd.ValidArgsFunction = cobra.NoFileCompletions
// Apply optional overrides to this command.
for _, fn := range listEndpointsOverrides {
fn(cmd, &listEndpointsReq)
}
return cmd
}
// end service VectorSearchEndpoints