multisender

README

MultiSender - Go Module for Simultaneous Writing to Multiple io.Writer Instances

MultiSender is a Go module that enables simultaneous writing to multiple io.Writer instances. It provides a MultiSenderWriter type and a MultiSender type to facilitate efficient and parallelized writing.

Installation

To use this module in your Go project, you can run:

go get github.com/NIR3X/multisender

Usage

package main

import (
	"io"
	"net/http"
	"path/filepath"
	"time"

	"github.com/NIR3X/filecache"
	"github.com/NIR3X/filewatcher"
	"github.com/NIR3X/logger"
)

const (
	fileCacheMaxSize          = 2 * 1024 * 1024
	fileWatcherUpdateInterval = 1 * time.Second
	rootDir                   = "www"
)

func main() {
	fileCache := filecache.NewFileCache(fileCacheMaxSize)
	multiSender := NewMultiSender(fileCache)
	fileWatcher := filewatcher.NewFileWatcher(fileWatcherUpdateInterval, func(path string, isDir bool) { // created
		if isDir {
			return
		}
		err := fileCache.Update(path)
		if err != nil {
			logger.Eprintln(err)
		}
	}, func(path string, isDir bool) { // removed
		if isDir {
			return
		}
		fileCache.Delete(path)
	}, func(path string, isDir bool) { // modified
		if isDir {
			return
		}
		err := fileCache.Update(path)
		if err != nil {
			logger.Eprintln(err)
		}
	})
	defer fileWatcher.Close()
	err := fileWatcher.Watch(rootDir)
	if err != nil {
		logger.Eprintln(err)
		return
	}
	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		path := r.URL.Path
		if path == "/" {
			path = "/index.html"
		}
		path = filepath.Join(rootDir, path)
		reader, ident := fileCache.GetCached(path)
		switch ident {
		case filecache.Cached:
			_, err = io.Copy(w, reader)
			if err != nil {
				logger.Eprintln(err)
			}
		case filecache.Piped:
			multiSenderWriter := multiSender.Add(path, w)
			multiSenderWriter.Wait()
		}
	})
	logger.Println("Listening on port 8000...")
	err = http.ListenAndServe(":8000", nil)
	if err != nil {
		logger.Eprintln(err)
		return
	}
}

License

This program is Free Software: You can use, study share and improve it at your will. Specifically you can redistribute and/or modify it under the terms of the GNU Affero General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

Documentation

Index

• type MultiSender
  • func NewMultiSender(fileCache *filecache.FileCache, accumulationTime ...time.Duration) *MultiSender
  • func (m *MultiSender) Add(path string, w io.Writer) *MultiSenderWriter
• type MultiSenderWriter
  • func NewMultiSenderWriter() *MultiSenderWriter
  • func (m *MultiSenderWriter) Wait()
  • func (m *MultiSenderWriter) Write(p []uint8) (n int, err error)

Types

type MultiSender

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

func NewMultiSender

func NewMultiSender(fileCache *filecache.FileCache, accumulationTime ...time.Duration) *MultiSender

func (*MultiSender) Add

func (m *MultiSender) Add(path string, w io.Writer) *MultiSenderWriter

type MultiSenderWriter

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

func NewMultiSenderWriter

func NewMultiSenderWriter() *MultiSenderWriter

func (*MultiSenderWriter) Wait

func (m *MultiSenderWriter) Wait()

func (*MultiSenderWriter) Write

func (m *MultiSenderWriter) Write(p []uint8) (n int, err error)