Fix godocs.

cmd/rsocket-cli/runner.go

@@ -26,6 +26,7 @@ import (
 
 var errConflictHeadersAndMetadata = errors.New("can't specify headers and metadata")
 
+// Runner can be used to execute a command.
 type Runner struct {
 	Headers          cli.StringSlice
 	TransportHeaders cli.StringSlice
@@ -89,6 +90,7 @@ func (r *Runner) preflight() (err error) {
 	return
 }
 
+// Run run the Runner.
 func (r *Runner) Run() error {
 	if err := r.preflight(); err != nil {
 		return err

core/framing/frame_cancel.go

@@ -6,15 +6,17 @@ import (
 	"github.com/rsocket/rsocket-go/core"
 )
 
-// CancelFrame is frame of cancel.
+// CancelFrame is frame of Cancel.
 type CancelFrame struct {
 	*RawFrame
 }
 
+// WriteableCancelFrame is writeable frame of Cancel.
 type WriteableCancelFrame struct {
 	*tinyFrame
 }
 
+// WriteTo writes current frame to given writer.
 func (c WriteableCancelFrame) WriteTo(w io.Writer) (n int64, err error) {
 	var wrote int64
 	wrote, err = c.header.WriteTo(w)
@@ -25,6 +27,7 @@ func (c WriteableCancelFrame) WriteTo(w io.Writer) (n int64, err error) {
 	return
 }
 
+// Len returns length of frame.
 func (c WriteableCancelFrame) Len() int {
 	return core.FrameHeaderLen
 }
@@ -38,6 +41,7 @@ func (f *CancelFrame) Validate() (err error) {
 	return
 }
 
+// NewWriteableCancelFrame creates a new WriteableCancelFrame.
 func NewWriteableCancelFrame(id uint32) *WriteableCancelFrame {
 	h := core.NewFrameHeader(id, core.FrameTypeCancel, 0)
 	return &WriteableCancelFrame{

core/framing/frame_error.go

@@ -20,16 +20,19 @@ type ErrorFrame struct {
 	*RawFrame
 }
 
+// WriteableErrorFrame is writeable error frame.
 type WriteableErrorFrame struct {
 	*tinyFrame
 	code core.ErrorCode
 	data []byte
 }
 
+// Error returns error string.
 func (e WriteableErrorFrame) Error() string {
 	return makeErrorString(e.code, e.data)
 }
 
+// WriteTo writes frame to writer.
 func (e WriteableErrorFrame) WriteTo(w io.Writer) (n int64, err error) {
 	var wrote int64
 	wrote, err = e.header.WriteTo(w)
@@ -52,6 +55,7 @@ func (e WriteableErrorFrame) WriteTo(w io.Writer) (n int64, err error) {
 	return
 }
 
+// Len returns length of frame.
 func (e WriteableErrorFrame) Len() int {
 	return core.FrameHeaderLen + 4 + len(e.data)
 }
@@ -64,6 +68,7 @@ func (p *ErrorFrame) Validate() (err error) {
 	return
 }
 
+// Error returns error string.
 func (p *ErrorFrame) Error() string {
 	return makeErrorString(p.ErrorCode(), p.ErrorData())
 }
@@ -79,6 +84,7 @@ func (p *ErrorFrame) ErrorData() []byte {
 	return p.body.Bytes()[errDataOff:]
 }
 
+// NewWriteableErrorFrame creates WriteableErrorFrame.
 func NewWriteableErrorFrame(id uint32, code core.ErrorCode, data []byte) *WriteableErrorFrame {
 	h := core.NewFrameHeader(id, core.FrameTypeError, 0)
 	t := newTinyFrame(h)

core/framing/frame_fnf.go

@@ -7,17 +7,19 @@ import (
 	"github.com/rsocket/rsocket-go/internal/common"
 )
 
-// FireAndForgetFrame is fire and forget frame.
+// FireAndForgetFrame is FireAndForget frame.
 type FireAndForgetFrame struct {
 	*RawFrame
 }
 
+// WriteableFireAndForgetFrame is writeable FireAndForget frame.
 type WriteableFireAndForgetFrame struct {
 	*tinyFrame
 	metadata []byte
 	data     []byte
 }
 
+// WriteTo writes frame to writer.
 func (f WriteableFireAndForgetFrame) WriteTo(w io.Writer) (n int64, err error) {
 	var wrote int64
 	wrote, err = f.header.WriteTo(w)
@@ -34,6 +36,7 @@ func (f WriteableFireAndForgetFrame) WriteTo(w io.Writer) (n int64, err error) {
 	return
 }
 
+// Len returns length of frame.
 func (f WriteableFireAndForgetFrame) Len() int {
 	return CalcPayloadFrameSize(f.data, f.metadata)
 }
@@ -70,6 +73,7 @@ func (f *FireAndForgetFrame) DataUTF8() string {
 	return string(f.Data())
 }
 
+// NewWriteableFireAndForgetFrame creates a new WriteableFireAndForgetFrame.
 func NewWriteableFireAndForgetFrame(sid uint32, data, metadata []byte, flag core.FrameFlag) *WriteableFireAndForgetFrame {
 	if len(metadata) > 0 {
 		flag |= core.FlagMetadata
@@ -83,7 +87,7 @@ func NewWriteableFireAndForgetFrame(sid uint32, data, metadata []byte, flag core
 	}
 }
 
-// NewFireAndForgetFrame returns a new fire and forget frame.
+// NewFireAndForgetFrame returns a new FireAndForgetFrame.
 func NewFireAndForgetFrame(sid uint32, data, metadata []byte, flag core.FrameFlag) *FireAndForgetFrame {
 	bf := common.NewByteBuff()
 	if len(metadata) > 0 {

core/framing/frame_keepalive.go

@@ -13,17 +13,19 @@ const (
 	minKeepaliveFrameLen = lastRecvPosLen
 )
 
-// KeepaliveFrame is keepalive frame.
+// KeepaliveFrame is Keepalive frame.
 type KeepaliveFrame struct {
 	*RawFrame
 }
 
+// WriteableKeepaliveFrame is writeable Keepalive frame.
 type WriteableKeepaliveFrame struct {
 	*tinyFrame
 	pos  [8]byte
 	data []byte
 }
 
+// WriteTo writes frame to writer.
 func (k WriteableKeepaliveFrame) WriteTo(w io.Writer) (n int64, err error) {
 	var wrote int64
 	wrote, err = k.header.WriteTo(w)
@@ -48,6 +50,7 @@ func (k WriteableKeepaliveFrame) WriteTo(w io.Writer) (n int64, err error) {
 	return
 }
 
+// Len returns length of frame.
 func (k WriteableKeepaliveFrame) Len() int {
 	return core.FrameHeaderLen + 8 + len(k.data)
 }
@@ -70,6 +73,7 @@ func (k *KeepaliveFrame) Data() []byte {
 	return k.body.Bytes()[lastRecvPosLen:]
 }
 
+// NewWriteableKeepaliveFrame creates a new WriteableKeepaliveFrame.
 func NewWriteableKeepaliveFrame(position uint64, data []byte, respond bool) *WriteableKeepaliveFrame {
 	var flag core.FrameFlag
 	if respond {
@@ -89,7 +93,7 @@ func NewWriteableKeepaliveFrame(position uint64, data []byte, respond bool) *Wri
 	}
 }
 
-// NewKeepaliveFrame returns a new keepalive frame.
+// NewKeepaliveFrame creates a new KeepaliveFrame.
 func NewKeepaliveFrame(position uint64, data []byte, respond bool) *KeepaliveFrame {
 	var fg core.FrameFlag
 	if respond {

core/framing/frame_lease.go

@@ -16,11 +16,12 @@ const (
 	minLeaseFrame = ttlLen + reqLen
 )
 
-// LeaseFrame is lease frame.
+// LeaseFrame is Lease frame.
 type LeaseFrame struct {
 	*RawFrame
 }
 
+// WriteableLeaseFrame is writeable Lease frame.
 type WriteableLeaseFrame struct {
 	*tinyFrame
 	ttl      [4]byte
@@ -55,6 +56,7 @@ func (l *LeaseFrame) Metadata() []byte {
 	return l.body.Bytes()[8:]
 }
 
+// WriteTo writes frame to writer.
 func (l WriteableLeaseFrame) WriteTo(w io.Writer) (n int64, err error) {
 	var wrote int64
 	wrote, err = l.header.WriteTo(w)
@@ -87,6 +89,7 @@ func (l WriteableLeaseFrame) WriteTo(w io.Writer) (n int64, err error) {
 	return
 }
 
+// Len returns length of frame.
 func (l WriteableLeaseFrame) Len() int {
 	n := core.FrameHeaderLen + 8
 	if l.header.Flag().Check(core.FlagMetadata) {
@@ -95,6 +98,7 @@ func (l WriteableLeaseFrame) Len() int {
 	return n
 }
 
+// NewWriteableLeaseFrame creates a new WriteableLeaseFrame.
 func NewWriteableLeaseFrame(ttl time.Duration, n uint32, metadata []byte) *WriteableLeaseFrame {
 	var a, b [4]byte
 	binary.BigEndian.PutUint32(a[:], uint32(ttl.Milliseconds()))
@@ -114,6 +118,7 @@ func NewWriteableLeaseFrame(ttl time.Duration, n uint32, metadata []byte) *Write
 	}
 }
 
+// NewLeaseFrame creates a new LeaseFrame.
 func NewLeaseFrame(ttl time.Duration, n uint32, metadata []byte) *LeaseFrame {
 	bf := common.NewByteBuff()
 	if err := binary.Write(bf, binary.BigEndian, uint32(ttl.Milliseconds())); err != nil {

core/framing/frame_metadata_push.go

@@ -9,10 +9,12 @@ import (
 
 var _metadataPushHeader = core.NewFrameHeader(0, core.FrameTypeMetadataPush, core.FlagMetadata)
 
-// MetadataPushFrame is metadata push frame.
+// MetadataPushFrame is MetadataPush frame.
 type MetadataPushFrame struct {
 	*RawFrame
 }
+
+// WriteableMetadataPushFrame is writeable MetadataPush frame.
 type WriteableMetadataPushFrame struct {
 	*tinyFrame
 	metadata []byte
@@ -42,6 +44,7 @@ func (m *MetadataPushFrame) MetadataUTF8() (metadata string, ok bool) {
 	return
 }
 
+// WriteTo writes frame to writer.
 func (m WriteableMetadataPushFrame) WriteTo(w io.Writer) (n int64, err error) {
 	var wrote int64
 	wrote, err = m.header.WriteTo(w)
@@ -59,6 +62,7 @@ func (m WriteableMetadataPushFrame) WriteTo(w io.Writer) (n int64, err error) {
 	return
 }
 
+// Len returns length of frame.
 func (m WriteableMetadataPushFrame) Len() int {
 	return core.FrameHeaderLen + len(m.metadata)
 }
@@ -68,6 +72,7 @@ func (m *MetadataPushFrame) DataUTF8() (data string) {
 	return
 }
 
+// NewWriteableMetadataPushFrame creates a new WriteableMetadataPushFrame.
 func NewWriteableMetadataPushFrame(metadata []byte) *WriteableMetadataPushFrame {
 	t := newTinyFrame(_metadataPushHeader)
 	return &WriteableMetadataPushFrame{
@@ -76,7 +81,7 @@ func NewWriteableMetadataPushFrame(metadata []byte) *WriteableMetadataPushFrame
 	}
 }
 
-// NewMetadataPushFrame returns a new metadata push frame.
+// NewMetadataPushFrame returns a new MetadataPushFrame.
 func NewMetadataPushFrame(metadata []byte) *MetadataPushFrame {
 	bf := common.NewByteBuff()
 	if _, err := bf.Write(metadata); err != nil {

core/framing/frame_payload.go

@@ -12,6 +12,7 @@ type PayloadFrame struct {
 	*RawFrame
 }
 
+// WriteablePayloadFrame is writeable Payload frame.
 type WriteablePayloadFrame struct {
 	*tinyFrame
 	metadata []byte
@@ -37,6 +38,7 @@ func (p *PayloadFrame) Data() []byte {
 	return p.trySliceData(0)
 }
 
+// MetadataUTF8 returns metadata as UTF8 string.
 func (p *PayloadFrame) MetadataUTF8() (metadata string, ok bool) {
 	raw, ok := p.Metadata()
 	if ok {
@@ -45,14 +47,17 @@ func (p *PayloadFrame) MetadataUTF8() (metadata string, ok bool) {
 	return
 }
 
+// DataUTF8 returns data as UTF8 string.
 func (p *PayloadFrame) DataUTF8() string {
 	return string(p.Data())
 }
 
+// Data returns data bytes.
 func (p WriteablePayloadFrame) Data() []byte {
 	return p.data
 }
 
+// Metadata returns metadata bytes.
 func (p WriteablePayloadFrame) Metadata() (metadata []byte, ok bool) {
 	ok = p.header.Flag().Check(core.FlagMetadata)
 	if ok {
@@ -61,13 +66,15 @@ func (p WriteablePayloadFrame) Metadata() (metadata []byte, ok bool) {
 	return
 }
 
+// DataUTF8 returns data as UTF8 string.
 func (p WriteablePayloadFrame) DataUTF8() (data string) {
 	if p.data != nil {
 		data = string(p.data)
 	}
 	return
 }
 
+// MetadataUTF8 returns metadata as UTF8 string.
 func (p WriteablePayloadFrame) MetadataUTF8() (metadata string, ok bool) {
 	ok = p.header.Flag().Check(core.FlagMetadata)
 	if ok {
@@ -76,6 +83,7 @@ func (p WriteablePayloadFrame) MetadataUTF8() (metadata string, ok bool) {
 	return
 }
 
+// WriteTo writes frame to writer.
 func (p WriteablePayloadFrame) WriteTo(w io.Writer) (n int64, err error) {
 	var wrote int64
 	wrote, err = p.header.WriteTo(w)
@@ -90,11 +98,12 @@ func (p WriteablePayloadFrame) WriteTo(w io.Writer) (n int64, err error) {
 	return
 }
 
+// Len returns length of frame.
 func (p WriteablePayloadFrame) Len() int {
 	return CalcPayloadFrameSize(p.data, p.metadata)
 }
 
-// NewWriteablePayloadFrame returns a new payload frame.
+// NewWriteablePayloadFrame returns a new WriteablePayloadFrame.
 func NewWriteablePayloadFrame(id uint32, data, metadata []byte, flag core.FrameFlag) *WriteablePayloadFrame {
 	if len(metadata) > 0 {
 		flag |= core.FlagMetadata
@@ -108,7 +117,7 @@ func NewWriteablePayloadFrame(id uint32, data, metadata []byte, flag core.FrameF
 	}
 }
 
-// NewPayloadFrame returns a new payload frame.
+// NewPayloadFrame returns a new PayloadFrame.
 func NewPayloadFrame(id uint32, data, metadata []byte, flag core.FrameFlag) *PayloadFrame {
 	bf := common.NewByteBuff()
 	if len(metadata) > 0 {