mirror of
https://github.com/superseriousbusiness/gotosocial
synced 2024-12-08 14:36:32 +01:00
5e2bf0bdca
* [chore] Remove years from all license headers Years or year ranges aren't required in license headers. Many projects have removed them in recent years and it avoids a bit of yearly toil. In many cases our copyright claim was also a bit dodgy since we added the 2021-2023 header to files created after 2021 but you can't claim copyright into the past that way. * [chore] Add license header check This ensures a license header is always added to any new file. This avoids maintainers/reviewers needing to remember to check for and ask for it in case a contribution doesn't include it. * [chore] Add missing license headers * [chore] Further updates to license header * Use the more common // indentend comment format * Remove the hack we had for the linter now that we use the // format * Add SPDX license identifier
192 lines
4.0 KiB
Go
192 lines
4.0 KiB
Go
// GoToSocial
|
|
// Copyright (C) GoToSocial Authors admin@gotosocial.org
|
|
// SPDX-License-Identifier: AGPL-3.0-or-later
|
|
//
|
|
// This program is free software: you can redistribute it 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.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Affero General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Affero General Public License
|
|
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
package iotools
|
|
|
|
import (
|
|
"io"
|
|
"os"
|
|
)
|
|
|
|
// ReadFnCloser takes an io.Reader and wraps it to use the provided function to implement io.Closer.
|
|
func ReadFnCloser(r io.Reader, close func() error) io.ReadCloser {
|
|
return &readFnCloser{
|
|
Reader: r,
|
|
close: close,
|
|
}
|
|
}
|
|
|
|
type readFnCloser struct {
|
|
io.Reader
|
|
close func() error
|
|
}
|
|
|
|
func (r *readFnCloser) Close() error {
|
|
return r.close()
|
|
}
|
|
|
|
// WriteFnCloser takes an io.Writer and wraps it to use the provided function to implement io.Closer.
|
|
func WriteFnCloser(w io.Writer, close func() error) io.WriteCloser {
|
|
return &writeFnCloser{
|
|
Writer: w,
|
|
close: close,
|
|
}
|
|
}
|
|
|
|
type writeFnCloser struct {
|
|
io.Writer
|
|
close func() error
|
|
}
|
|
|
|
func (r *writeFnCloser) Close() error {
|
|
return r.close()
|
|
}
|
|
|
|
// SilentReader wraps an io.Reader to silence any
|
|
// error output during reads. Instead they are stored
|
|
// and accessible (not concurrency safe!) via .Error().
|
|
type SilentReader struct {
|
|
io.Reader
|
|
err error
|
|
}
|
|
|
|
// SilenceReader wraps an io.Reader within SilentReader{}.
|
|
func SilenceReader(r io.Reader) *SilentReader {
|
|
return &SilentReader{Reader: r}
|
|
}
|
|
|
|
func (r *SilentReader) Read(b []byte) (int, error) {
|
|
n, err := r.Reader.Read(b)
|
|
if err != nil {
|
|
// Store error for now
|
|
if r.err == nil {
|
|
r.err = err
|
|
}
|
|
|
|
// Pretend we're happy
|
|
// to continue reading.
|
|
n = len(b)
|
|
}
|
|
return n, nil
|
|
}
|
|
|
|
func (r *SilentReader) Error() error {
|
|
return r.err
|
|
}
|
|
|
|
// SilentWriter wraps an io.Writer to silence any
|
|
// error output during writes. Instead they are stored
|
|
// and accessible (not concurrency safe!) via .Error().
|
|
type SilentWriter struct {
|
|
io.Writer
|
|
err error
|
|
}
|
|
|
|
// SilenceWriter wraps an io.Writer within SilentWriter{}.
|
|
func SilenceWriter(w io.Writer) *SilentWriter {
|
|
return &SilentWriter{Writer: w}
|
|
}
|
|
|
|
func (w *SilentWriter) Write(b []byte) (int, error) {
|
|
n, err := w.Writer.Write(b)
|
|
if err != nil {
|
|
// Store error for now
|
|
if w.err == nil {
|
|
w.err = err
|
|
}
|
|
|
|
// Pretend we're happy
|
|
// to continue writing.
|
|
n = len(b)
|
|
}
|
|
return n, nil
|
|
}
|
|
|
|
func (w *SilentWriter) Error() error {
|
|
return w.err
|
|
}
|
|
|
|
func StreamReadFunc(read func(io.Reader) error) io.Writer {
|
|
// In-memory stream.
|
|
pr, pw := io.Pipe()
|
|
|
|
go func() {
|
|
var err error
|
|
|
|
defer func() {
|
|
// Always pass along error.
|
|
pr.CloseWithError(err)
|
|
}()
|
|
|
|
// Start reading.
|
|
err = read(pr)
|
|
}()
|
|
|
|
return pw
|
|
}
|
|
|
|
func StreamWriteFunc(write func(io.Writer) error) io.Reader {
|
|
// In-memory stream.
|
|
pr, pw := io.Pipe()
|
|
|
|
go func() {
|
|
var err error
|
|
|
|
defer func() {
|
|
// Always pass along error.
|
|
pw.CloseWithError(err)
|
|
}()
|
|
|
|
// Start writing.
|
|
err = write(pw)
|
|
}()
|
|
|
|
return pr
|
|
}
|
|
|
|
type tempFileSeeker struct {
|
|
io.Reader
|
|
io.Seeker
|
|
tmp *os.File
|
|
}
|
|
|
|
func (tfs *tempFileSeeker) Close() error {
|
|
tfs.tmp.Close()
|
|
return os.Remove(tfs.tmp.Name())
|
|
}
|
|
|
|
// TempFileSeeker converts the provided Reader into a ReadSeekCloser
|
|
// by using an underlying temporary file. Callers should call the Close
|
|
// function when they're done with the TempFileSeeker, to release +
|
|
// clean up the temporary file.
|
|
func TempFileSeeker(r io.Reader) (io.ReadSeekCloser, error) {
|
|
tmp, err := os.CreateTemp(os.TempDir(), "gotosocial-")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if _, err := io.Copy(tmp, r); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &tempFileSeeker{
|
|
Reader: tmp,
|
|
Seeker: tmp,
|
|
tmp: tmp,
|
|
}, nil
|
|
}
|