Exemple #1
0
func (r *Reader) Init(config jsonstruct.JSONStruct) error {
	port := config.IntWithDefault(Port, DefaultPort)
	remoteAddr := config.StringWithDefault(RemoteWriterAddr, DefaultRemoteWriterAddr)
	resp, err := http.DefaultClient.Get(fmt.Sprintf("http://%s:%d/", remoteAddr, port))
	if err != nil {
		return err
	}

	r.sseReader = vitosse.NewReadCloser(resp.Body)

	return nil
}
Exemple #2
0
func (s *Scheme) Init(config jsonstruct.JSONStruct) error {
	s.messagesPerSecond = config.IntWithDefault(MessagesPerSecond, DefaultMessagesPerSecond)
	expectedMessagesPerSecond := config.IntWithDefault(ExpectedMessagesPerSecond, DefaultExpectedMessagesPerSecond)
	s.bytesPerMessage = config.IntWithDefault(BytesPerMessage, DefaultBytesPerMessage)

	var err error
	s.reportCycle, err = config.DurationWithDefault(ReportCycle, DefaultReportCycle)
	if err != nil {
		return err
	}

	if expectedMessagesPerSecond == 0 {
		expectedMessagesPerSecond = s.messagesPerSecond
	}

	s.buffer = make([]byte, s.bytesPerMessage)
	if s.messagesPerSecond > 0 {
		s.tickerTime = time.Second / time.Duration(s.messagesPerSecond)
	}

	s.done.Add(1)

	if s.reporter == nil {
		s.reporter = &ReporterImpl{}
	}
	s.reporter.Init(expectedMessagesPerSecond, s.reportCycle)

	return nil
}
Exemple #3
0
func (r *Reader) Init(config jsonstruct.JSONStruct) error {
	port := config.IntWithDefault(Port, DefaultPort)
	laddr, err := net.ResolveUDPAddr("udp4", fmt.Sprintf(":%d", port))
	if err != nil {
		return err
	}

	r.connection, err = net.ListenUDP("udp4", laddr)
	if err != nil {
		return err
	}

	return nil
}
Exemple #4
0
func (w *Writer) Init(config jsonstruct.JSONStruct) error {
	port := config.IntWithDefault(Port, DefaultPort)
	remoteAddr := config.StringWithDefault(RemoteReaderAddr, DefaultRemoteReaderAddr)
	raddr, err := net.ResolveUDPAddr("udp4", net.JoinHostPort(remoteAddr, strconv.Itoa(port)))
	if err != nil {
		return err
	}

	w.connection, err = net.DialUDP("udp4", nil, raddr)
	if err != nil {
		return err
	}

	return nil
}
Exemple #5
0
func (s *Scheme) Init(config jsonstruct.JSONStruct) error {
	s.messagesPerRun = config.IntWithDefault(MessagesPerRun, DefaultMessagesPerRun)
	s.bytesPerMessage = config.IntWithDefault(BytesPerMessage, DefaultBytesPerMessage)
	s.buffer = make([]byte, s.bytesPerMessage)

	var err error
	s.waitForLastMessage, err = config.DurationWithDefault(WaitForLastMessage, DefaultWaitForLastMessage)
	if err != nil {
		return err
	}

	s.warmupMessagesPerRun = config.IntWithDefault(WarmupMessagesPerRun, DefaultWarmupMessagesPerRun)
	s.warmupWait, err = config.DurationWithDefault(WarmupWait, DefaultWarmupWait)
	if err != nil {
		return err
	}

	return nil
}
Exemple #6
0
func (w *Writer) Init(config jsonstruct.JSONStruct) error {
	port := config.IntWithDefault(Port, DefaultPort)
	server := &http.Server{
		Addr:    fmt.Sprintf("localhost:%d", port),
		Handler: http.HandlerFunc(w.handle),
	}

	go func() {
		err := server.ListenAndServe()
		if err != nil {
			logs.Logger.Warning("Error when starting server, %e", err.Error())
		}
	}()

	w.messages = make(chan []byte)
	w.responses = make(chan response, 1)

	return nil
}
Exemple #7
0
	"net/http"
	"time"

	"github.com/myshkin5/jsonstruct"
	"github.com/myshkin5/netspel/adapters/sse"
	vitosse "github.com/vito/go-sse/sse"

	. "github.com/onsi/ginkgo"
	. "github.com/onsi/gomega"
)

var _ = Describe("Reader", func() {
	var (
		port            int
		sleepBeforeSend time.Duration
		events          []*vitosse.Event
		config          jsonstruct.JSONStruct
		reader          sse.Reader
	)

	handle := func(w http.ResponseWriter, r *http.Request) {
		defer GinkgoRecover()

		w.Header().Set("Content-Type", "text/event-stream; charset=utf-8")
		w.Header().Set("Cache-Control", "no-cache")
		w.Header().Set("Connection", "keep-alive")
		w.WriteHeader(http.StatusOK)
		w.Write([]byte("\n"))
		flusher := w.(http.Flusher)
		flusher.Flush()
Exemple #8
0
package jsonstruct_test

import (
	"encoding/json"
	"time"

	"github.com/myshkin5/jsonstruct"

	. "github.com/onsi/ginkgo"
	. "github.com/onsi/gomega"
)

var _ = Describe("Setters", func() {
	var (
		values jsonstruct.JSONStruct
	)

	Describe("SetString()", func() {
		It("overrides existing values", func() {
			err := json.Unmarshal([]byte(`{
				"this": "that",
				"parent": {
					"child": "value"
				}
			}`), &values)

			Expect(err).NotTo(HaveOccurred())

			Expect(values.SetString(".this", "something else")).To(Succeed())

			value, ok := values.String(".this")
Exemple #9
0
	"github.com/myshkin5/jsonstruct"
	"github.com/myshkin5/netspel/schemes/internal/mocks"
	"github.com/myshkin5/netspel/schemes/streaming"

	"sync"
	"time"

	. "github.com/onsi/ginkgo"
	. "github.com/onsi/gomega"
)

var _ = Describe("Scheme", func() {
	var (
		writer   *mocks.MockWriter
		reader   *mocks.MockReader
		scheme   *streaming.Scheme
		config   jsonstruct.JSONStruct
		reporter *mockReporter
	)

	BeforeEach(func() {
		writer = mocks.NewMockWriter()
		reader = mocks.NewMockReader()
		scheme = &streaming.Scheme{}
		config = jsonstruct.New()
		reporter = &mockReporter{
			reports: make(chan streaming.Report, 100),
		}
		scheme.SetReporter(reporter)
	})
Exemple #10
0
	"errors"
	"sync"
	"time"

	"github.com/myshkin5/jsonstruct"
	"github.com/myshkin5/netspel/schemes/internal/mocks"
	"github.com/myshkin5/netspel/schemes/simple"

	. "github.com/onsi/ginkgo"
	. "github.com/onsi/gomega"
)

var _ = Describe("Scheme", func() {
	var (
		writer *mocks.MockWriter
		reader *mocks.MockReader
		scheme *simple.Scheme
		config jsonstruct.JSONStruct
	)

	BeforeEach(func() {
		writer = mocks.NewMockWriter()
		reader = mocks.NewMockReader()
		scheme = &simple.Scheme{}
		config = jsonstruct.New()
		config.SetInt(simple.BytesPerMessage, 1000)
		config.SetInt(simple.MessagesPerRun, 100)
		config.SetString(simple.WaitForLastMessage, "100ms")
	})

	Context("with a short wait time", func() {
		JustBeforeEach(func() {