ioextras

type CloseHook ¶

type CloseHook struct {
	IOCombo
	Callback func(s io.Closer)
}

CloseHook wraps a io.Closer so that it will call the specified callback function on closing the channel. The callback will only be called on an explicit close operation by the user.

f, err := os.OpenFile("/dev/null", os.O_RDWR, os.FileMode(0666))
hf := ioextras.NewCloseHook(f, func(io.Closer) {
	log.Printf("File has been closed")
})
defer hf.Close()
if err != nil {
	log.Fatalf("Failed to open file: %v", err)
}
_, err = f.Write([]byte("test"))
if err != nil {
	log.Fatalf("Failed to write data", err)
}

Output:

func NewCloseHook(c io.Closer, callback func(s io.Closer)) *CloseHook

func (c *CloseHook) Close() error

type CloserErrorPair ¶

type CloserErrorPair struct {
	Closer io.Closer
	Error  error
}

CloserErrorPair identifies the place where the I/O error has occurred during closing the file.

type ContextualReader ¶

type ContextualReader interface {
	ReadWithCtx([]byte, interface{}) (int, error)
}

Defines a reader interface accompanied by the opaque context information

type ContextualWriter ¶

type ContextualWriter interface {
	WriteWithCtx([]byte, interface{}) (int, error)
}

Defines a writer interface accompanied by the opaque context information

type DynamicRotatingWriter ¶

type DynamicRotatingWriter struct {
	IDBuilder            IDBuilder
	WriterFactory        WriterFactory
	HeadPathGenerator    HeadPathGenerator
	RotationCallback     RotationCallback
	CloseErrorReportChan chan<- CloserErrorPair
	// contains filtered or unexported fields
}

DynamicRotatingWriter is an io.Writer that writes the data to the file determined by HeadPathGenerator until the next rotation cycle. The rotation cycle is determined by the return value of IDBuilder. The file is created by WriterFactory. RotationCallback will be called on rotation.

currentId := 0
maxSize := int64(4)
w := ioextras.NewDynamicRotatingWriter(
	// IDBuilder
	func(f io.Writer, _ interface{}) string {
		_f, ok := f.(*os.File)
		if !ok {
			panic("WTF?")
		}
		fi, err := _f.Stat()
		if err != nil {
			return strconv.Itoa(currentId)
		}
		if fi.Size() > maxSize {
			currentId++
		}
		return strconv.Itoa(currentId)
	},
	// WriterFactory
	ioextras.StandardWriterFactory,
	// HeadPathGenerator
	func(id string, _ interface{}) string {
		return "/tmp/demo.log"
	},
	// RotationCallback
	ioextras.SerialRotationCallbackFactory(3),
	// CloseErrorReportChan
	nil,
)
var err error

_, err = w.Write([]byte("test"))
if err != nil {
	log.Fatalf("error writing data: %v", err)
}
_, err = w.Write([]byte("test"))
if err != nil {
	log.Fatalf("error writing data: %v", err)
}
_, err = w.Write([]byte("test"))
if err != nil {
	log.Fatalf("error writing data: %v", err)
}
_, err = w.Write([]byte("test"))
if err != nil {
	log.Fatalf("error writing data: %v", err)
}

Output:

func NewDynamicRotatingWriter(idBuilder IDBuilder, writerFactory WriterFactory, headPathGenerator HeadPathGenerator, rotationCallback RotationCallback, closeErrorReportChan chan<- CloserErrorPair) *DynamicRotatingWriter

func (w *DynamicRotatingWriter) Close() error

func (w *DynamicRotatingWriter) Write(b []byte) (int, error)

func (w *DynamicRotatingWriter) WriteWithCtx(b []byte, ctx interface{}) (int, error)

type Flusher ¶

type Flusher interface {
	Flush() error
}

Flusher is an I/O channel (or stream) that provides `Flush` operation.

type HeadPathGenerator ¶

type HeadPathGenerator func(ID string, ctx interface{}) string

HeadPathGenerator is supposed to return the path to the file data is written to. Generally the path is a static location. ctx argument is the value passed to WriteWithCtx() method as the second argument.

type IDBuilder ¶

type IDBuilder func(w io.Writer, ctx interface{}) string

IDBuilder is supposed to return a string that determines the rotation cycle. Rotation occurs when it returns an identifier different from the one obtained during the previous call to WriteWithCtx() method. ctx argument is the value passed to WriteWithCtx() method as the second argument.

type IOCombo ¶

type IOCombo struct {
	Reader           io.Reader
	ReaderAt         io.ReaderAt
	ContextualReader ContextualReader
	Writer           io.Writer
	WriterAt         io.WriterAt
	ContextualWriter ContextualWriter
	Seeker           io.Seeker
	Closer           io.Closer
	Flusher          Flusher
	Sized            Sized
	Named            Named
}

IOCombo combines objects implementing I/O primitives interfaces in the way it would virtually provide all of the I/O privimites supported by the given objects.

Typical usage is to provide extra primitives interfaces such as io.Closer for a single I/O privimitives interface like io.Reader. In that case, ioutil.NopCloser() can be used instead unless any operation is needed in a call to Close() method.

Call on an unsupported operation returns the Unsupported error (that is a singleton).

package main

import (
	"github.com/moriyoshi/go-ioextras"
	"io"
	"log"
	"strings"
)

type myCloser int

func (myCloser) Close() error {
	log.Printf("File is being closed")
	return nil
}

func main() {
	combo := &ioextras.IOCombo{
		Reader: strings.NewReader("test"),
		Closer: myCloser(0),
	}
	// an IOCombo should have provide io.ReadCloser interface.
	rc := io.ReadCloser(combo)

	b := make([]byte, 4)
	_, err := rc.Read(b)
	if err != nil {
		log.Fatalf("Error during reading: %v", err)
	}
	rc.Close()
}

Output:

func (w *IOCombo) Close() error

func (w *IOCombo) Flush() error

func (w *IOCombo) Name() string

func (w *IOCombo) Read(b []byte) (int, error)

func (w *IOCombo) ReadAt(b []byte, o int64) (int, error)

func (w *IOCombo) ReadWithCtx(b []byte, ctx interface{}) (int, error)

func (w *IOCombo) Seek(o int64, whence int) (int64, error)

func (w *IOCombo) Size() (int64, error)

func (w *IOCombo) Write(b []byte) (int, error)

func (w *IOCombo) WriteAt(b []byte, o int64) (int, error)

func (w *IOCombo) WriteWithCtx(b []byte, ctx interface{}) (int, error)

type MemoryRandomAccessStore ¶

type MemoryRandomAccessStore struct {
	// contains filtered or unexported fields
}

MemoryRandomAccessStore implements a RandomAccessStore backed by a byte slice.

func NewMemoryRandomAccessStore() *MemoryRandomAccessStore

func (s *MemoryRandomAccessStore) Close() error

func (s *MemoryRandomAccessStore) ReadAt(p []byte, offset int64) (int, error)

func (s *MemoryRandomAccessStore) Size() (int64, error)

func (s *MemoryRandomAccessStore) WriteAt(p []byte, offset int64) (int, error)

type MemoryRandomAccessStoreFactory ¶

type MemoryRandomAccessStoreFactory struct{}

func (ras *MemoryRandomAccessStoreFactory) RandomAccessStore() (RandomAccessStore, error)

type Named ¶

type Named interface {
	Name() string
}

Named is an I/O concept for a named blob. An I/O channel (or stream) backed by such a blob may also have this.

type NamedRandomAccessStore ¶

type NamedRandomAccessStore interface {
	RandomAccessStore
	Name() string
}

NamedRandomAccessStore models an I/O channel for a named blob (probably a file)

type PathBuilder ¶

type PathBuilder func(ctx interface{}) (string, error)

PathBuilder is supposed to return the path to the file to write the data to. The argument is the value passed as the second argument of WriteWithCtx().

type RandomAccessStore ¶

type RandomAccessStore interface {
	io.ReaderAt
	io.WriterAt
	io.Closer
}

RandomAccessStore models an I/O channel for a blob.

type RandomAccessStoreFactory ¶

type RandomAccessStoreFactory interface {
	RandomAccessStore() (RandomAccessStore, error)
}

RandomAccessStoreFactory creates a RandomAccessStore instance.

type RotationCallback ¶

type RotationCallback func(ID, path string, ctx interface{}) error

RotationCallback is called when rotation occurs. Typically the callback would rename the file specified by path to something like xxx.1 so that the generated files are rotating.

func SerialRotationCallbackFactory(maxFiles int) RotationCallback

type SeekerWrapper ¶

type SeekerWrapper struct {
	// contains filtered or unexported fields
}

SeekerWrapper wraps a RandomAccessStore for it to behave as io.Seeker.

func NewSeekerWrapper(s RandomAccessStore) *SeekerWrapper

func (s *SeekerWrapper) Close() error

func (s *SeekerWrapper) Name() string

func (s *SeekerWrapper) ReadAt(p []byte, offset int64) (int, error)

func (s *SeekerWrapper) Size() (int64, error)

func (s *SeekerWrapper) WriteAt(p []byte, offset int64) (int, error)

type Sized ¶

type Sized interface {
	Size() (int64, error)
}

Sized is an I/O concept for a blob of a specific size. An I/O channel (or stream) backed by such a blob may also have this.

type SizedRandomAccessStore ¶

type SizedRandomAccessStore interface {
	RandomAccessStore
	Size() (int64, error)
}

SizedRandomAccessStore models an I/O channel for a blob is supposed to have a specific size.

type StaticRotatingWriter ¶

type StaticRotatingWriter struct {
	PathBuilder          PathBuilder
	WriterFactory        WriterFactory
	CloseErrorReportChan chan<- CloserErrorPair
	// contains filtered or unexported fields
}

StaticRotatingWriter is an io.Writer that writes the data to the file whose path is determined by the given PathBuilder. It can be used in combination with the standard log package to support logging to rotating files.

func NewStaticRotatingWriter(pathBuilder PathBuilder, writerFactory WriterFactory, closeErrorReportChan chan<- CloserErrorPair) *StaticRotatingWriter

func (w *StaticRotatingWriter) Close() error

func (w *StaticRotatingWriter) Write(b []byte) (int, error)

func (w *StaticRotatingWriter) WriteWithCtx(b []byte, ctx interface{}) (int, error)

type StoreReadWriter ¶

type StoreReadWriter struct {
	Store    RandomAccessStore
	Position int64
	Size     int64
}

StoreReadWriter wraps a RandomAccessStore for it to behave like io.Reader or io.Writer.

func (rw *StoreReadWriter) Close() error

func (rw *StoreReadWriter) Read(p []byte) (int, error)

func (rw *StoreReadWriter) Seek(pos int64, whence int) (int64, error)

func (rw *StoreReadWriter) Write(p []byte) (int, error)

type TempFileRandomAccessStoreFactory ¶

type TempFileRandomAccessStoreFactory struct {
	Dir    string
	Prefix string
	GCChan chan *os.File
}

TempFileRandomAccessStoreFactory implements a RandomAccessStore backed by a temporary file that is created by ioutil.TempFIle. If the RandomAccessStore is closed, the underlying temporary file is deleted accordingly.

func (ras *TempFileRandomAccessStoreFactory) RandomAccessStore() (RandomAccessStore, error)

type WriterFactory ¶

type WriterFactory func(path string, ctx interface{}) (io.Writer, error)

WriterFactory is supposed to return an io.Writer object according to the arguments. The first argument is the path to the file for which io.Writer is prepared, and the second argument is the value passed as the second argument of WriteWithCtx().