reader

type Constructor ¶ added in v0.8.1

type Constructor interface {
	SetLogger(logger tools.FieldLogger)
	SetName(name string)
	SetTypeName(typeName string)
	SetEndpoint(endpoint string)
	SetMapper(mapper datatype.Mapper)
	SetInterval(interval time.Duration)
	SetTimeout(timeout time.Duration)
	SetBackoff(backoff int)
}

Constructor is a Reader object that will accept configurations.

type DataReader ¶ added in v0.1.2

type DataReader interface {
	Name() string
	Read(*token.Context) (*Result, error)
	Ping() error
	Mapper() datatype.Mapper
	TypeName() string
	Timeout() time.Duration
	Interval() time.Duration
	Endpoint() string
	Backoff() int
}

DataReader receives job requests to read from the target. It returns an error if the data cannot be read or the connection is refused.

Notes ¶

Readers should not intercept the engine's decision on the TypeName, unless they have a valid reason. Ping should ping the endpoint and return nil if was successful. The Engine will not launch the reader if the ping result is an error. When the context is timed-out or cancelled, Read should return. The Engine uses returned object from Mapper to present the data to recorders. TypeName is usually the application name and is set by the user in the configuration file.

package main

import (
	"context"
	"fmt"
	"io"
	"net/http"
	"net/http/httptest"

	reader "github.com/arsham/expipe/reader/testing"
	"github.com/arsham/expipe/tools/token"
)

func main() {

	ts := httptest.NewServer(http.HandlerFunc(
		func(w http.ResponseWriter, r *http.Request) {
			io.WriteString(w, `{"the key": "is the value!"}`)
		}),
	)
	defer ts.Close()

	// This reader is a mocked version,
	// but the example's principals stays the same.
	red := reader.GetReader(ts.URL)
	err := red.Ping()
	fmt.Println("Ping errors:", err)

	job := token.New(context.Background())
	res, err := red.Read(job) // Issuing a job

	if err == nil { // Lets check the errors
		fmt.Println("No errors reported")
	}

	fmt.Println("Result is:", string(res.Content))

}

Output:

Ping errors: <nil>
No errors reported
Result is: {"the key": "is the value!"}

type EndpointNotAvailableError ¶ added in v0.9.2

type EndpointNotAvailableError struct {
	Endpoint string
	Err      error
}

EndpointNotAvailableError is the error when the endpoint is not available.

func (e EndpointNotAvailableError) Error() string

type InvalidEndpointError ¶ added in v0.9.2

type InvalidEndpointError string

InvalidEndpointError is the error when the endpoint is not a valid url.

func (e InvalidEndpointError) Error() string

type LowBackoffValueError ¶ added in v0.9.2

type LowBackoffValueError int64

LowBackoffValueError is the error when the backoff value is lower than 5

func (e LowBackoffValueError) Error() string

type LowIntervalError ¶ added in v0.9.2

type LowIntervalError time.Duration

LowIntervalError is the error when the interval is zero

func (e LowIntervalError) Error() string

type LowTimeoutError ¶ added in v0.9.2

type LowTimeoutError time.Duration

LowTimeoutError is the error when the interval is zero

func (e LowTimeoutError) Error() string

type Result ¶ added in v0.7.0

type Result struct {
	// ID is the job ID given by the Engine.
	// This ID should not be changed until it is recorded.
	ID token.ID

	//Time is set after the request was successfully read.
	Time time.Time

	// TypeName comes from the configuration, but the Engine might decide
	// to change it.
	TypeName string

	// Content should be json unmarshallable, otherwise the job will be dropped.
	Content []byte

	// Mapper is the mapper set in the reader.
	Mapper datatype.Mapper
}

Result is constructed every time a new data is fetched.