Documentation
¶
Overview ¶
Package bytestream provides a client for any service that exposes a ByteStream API.
Note: This package is a work-in-progress. Backwards-incompatible changes should be expected.
Index ¶
Examples ¶
Constants ¶
const (
// MaxBufSize is the maximum buffer size (in bytes) received in a read chunk or sent in a write chunk.
MaxBufSize = 2 * 1024 * 1024
)
Variables ¶
This section is empty.
Functions ¶
This section is empty.
Types ¶
type Client ¶
type Client struct {
// contains filtered or unexported fields
}
Client is the go wrapper around a ByteStreamClient and provides an interface to it.
func NewClient ¶
func NewClient(cc *grpc.ClientConn, options ...grpc.CallOption) *Client
NewClient creates a new bytestream.Client.
Example ¶
serverPort := 8080
resourceName := "foo"
ctx := context.Background()
conn, err := grpc.Dial(fmt.Sprintf("localhost:%d", serverPort), grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil {
log.Printf("grpc.Dial: %v", err)
return
}
client := NewClient(conn)
reader, err := client.NewReader(ctx, resourceName)
if err != nil {
log.Printf("NewReader(%q): %v", resourceName, err)
}
var buf bytes.Buffer
n, err := buf.ReadFrom(reader)
if err != nil && err != io.EOF {
log.Printf("Read %d bytes, got err=%v", n, err)
}
log.Printf("read %q", buf.String())
func (*Client) Close ¶ added in v0.37.0
func (c *Client) Close()
Close closes the connection to the API service. The user should invoke this when the client is no longer required.
func (*Client) NewReader ¶
NewReader creates a new Reader to read a resource.
Example ¶
serverPort := 8080
resourceName := "foo"
ctx := context.Background()
conn, err := grpc.Dial(fmt.Sprintf("localhost:%d", serverPort), grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil {
log.Printf("grpc.Dial: %v", err)
return
}
client := NewClient(conn)
reader, err := client.NewReader(ctx, resourceName)
if err != nil {
log.Printf("NewReader(%q): %v", resourceName, err)
}
var buf bytes.Buffer
n, err := buf.ReadFrom(reader)
if err != nil && err != io.EOF {
log.Printf("Read %d bytes, got err=%v", n, err)
}
log.Printf("read %q", buf.String())
func (*Client) NewReaderAt ¶
func (c *Client) NewReaderAt(ctx context.Context, resourceName string, offset int64) (*Reader, error)
NewReaderAt creates a new Reader to read a resource from the given offset.
func (*Client) NewWriter ¶
NewWriter creates a new Writer to write a resource.
resourceName specifies the name of the resource. The resource will be available after Close has been called.
It is the caller's responsibility to call Close when writing is done.
TODO: There is currently no way to resume a write. Maybe NewWriter should begin with a call to QueryWriteStatus.
Example ¶
serverPort := 8080
resourceName := "foo"
ctx := context.Background()
conn, err := grpc.Dial(fmt.Sprintf("localhost:%d", serverPort), grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil {
log.Printf("grpc.Dial: %v", err)
return
}
client := NewClient(conn)
w, err := client.NewWriter(ctx, resourceName)
if err != nil {
log.Printf("NewWriter: %v", err)
return
}
defer func() {
err := w.Close()
if err != nil {
log.Printf("Close: %v", err)
}
}()
buf := []byte("hello world")
n, err := w.Write(buf)
if err != nil {
log.Printf("Write: %v", err)
}
log.Printf("Wrote %d bytes", n)
type Reader ¶
type Reader struct {
// contains filtered or unexported fields
}
Reader reads from a byte stream.
func (*Reader) ResourceName ¶
ResourceName gets the resource name this Reader is reading.
type Writer ¶
type Writer struct {
// contains filtered or unexported fields
}
Writer writes to a byte stream.
func (*Writer) Close ¶
Close implements io.Closer. It is the caller's responsibility to call Close() when writing is done.
func (*Writer) ResourceName ¶
ResourceName gets the resource name this Writer is writing.
Source Files
Directories