10621592127

Committed 29 Aug 2024 07:42PM UTC coverage: 40.184% (+2.3%) from 37.886%

Build # 10621592127

Build Type

push

github

Committed by

web-flow

Commit Message

adding genconfig tests (#1411)

* feat: adding tests to genconfig and removing support to cloudfront provider

* feat: replacing cloudfront default provider by akamai

* fix: typo

* fix: return cloudfront as defaultProviderID for masqueradesets

* Revert "feat: replacing cloudfront default provider by akamai"

This reverts commit 64ffecba5.

* fix: wrong default variable replaced

* fix: adding genconfig verifyHostname field

* fix: adding ommitempty tag to verifyHostname

* feat: bulding genconfig

Run Details

69 of 88 new or added lines in 1 file covered. (78.41%)

1 existing line in 1 file now uncovered.

3981 of 9907 relevant lines covered (40.18%)

55.15 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

48.39

/logging/logging.go

// Package logging configures the golog subsystem for use with Lantern
// Import this to make sure golog is initialized before you log.
package logging

import (
        "fmt"
        "io"
        "io/ioutil"
        "math"
        "os"
        "path/filepath"
        "sort"
        "strings"
        "sync"
        "sync/atomic"
        "time"

        "github.com/getlantern/errors"
        "github.com/getlantern/golog"
        "github.com/getlantern/rotator"

        "github.com/getlantern/flashlight/v7/util"
)

const (
        logTimestampFormat = "Jan 02 15:04:05.000"
)

var (
        log          = golog.LoggerFor("flashlight.logging")
        processStart = time.Now()

        logFile  io.WriteCloser
        errorPWC io.WriteCloser
        debugPWC io.WriteCloser

        actualLogDir   string
        actualLogDirMx sync.RWMutex

        resetLogs atomic.Value
)

func init() {
        resetLogs.Store(func() {})
}

// FlashlightLogger is a logger that uses golog.Logger to log messages. It
// implements a logging interface that packages like quicproxy use.
// See here for more info:
// - https://github.com/getlantern/quicproxy/blob/d393da079842dda222d5c0ddbc1ba33e55c46e8b/README.md#L40
type FlashlightLogger struct{ golog.Logger }

func (l FlashlightLogger) Printf(format string, a ...any) { l.Logger.Debugf(format, a...) }
func (l FlashlightLogger) Infof(format string, a ...any)  { l.Logger.Debugf(format, a...) }
func (l FlashlightLogger) Errorf(format string, a ...any) { l.Logger.Errorf(format, a...) }

// RotatedLogsUnder creates rotated file logger under logdir using the given appName
func RotatedLogsUnder(appName, logdir string) (io.WriteCloser, error) {
        actualLogDirMx.Lock()
        actualLogDir = logdir
        actualLogDirMx.Unlock()

        if _, err := os.Stat(logdir); err != nil {
                if os.IsNotExist(err) {
                        // Create log dir
                        if err := os.MkdirAll(logdir, 0755); err != nil {
                                return nil, errors.New("Unable to create logdir at %s: %s", logdir, err)
                        }
                }
        }

        rotator := rotator.NewSizeRotator(filepath.Join(logdir, strings.ToLower(appName)+".log"))
        // Set log files to 4 MB
        rotator.RotationSize = 4 * 1024 * 1024
        // Keep up to 5 log files
        rotator.MaxRotation = 5

        return rotator, nil
}

// Timestamped writes the current time and the duration since process start to
// the writer, used by golog.SetPrepender().
func Timestamped(w io.Writer) {
        ts := time.Now()
        runningSecs := ts.Sub(processStart).Seconds()
        secs := int(math.Mod(runningSecs, 60))
        mins := int(runningSecs / 60)
        fmt.Fprintf(w, "%s - %dm%ds ", ts.In(time.UTC).Format(logTimestampFormat), mins, secs)
}

// EnableFileLogging configures golog to write to rotated files under the
// logdir for the given appName, in addition to standard outputs.
func EnableFileLogging(appName, logdir string) {
        err := EnableFileLoggingWith(os.Stdout, os.Stderr, appName, logdir, 100, 1000)
        if err != nil {
                log.Error(err)
        }
}

// EnableFileLoggingWith is similar to EnableFileLogging but allows overriding
// standard outputs and setting buffer depths for error and debug log channels.
func EnableFileLoggingWith(werr io.WriteCloser, wout io.WriteCloser, appName, logdir string, debugBufferDepth, errorBufferDepth int) error {
        golog.SetPrepender(Timestamped)
        rotator, err := RotatedLogsUnder(appName, logdir)
        if err != nil {
                return err
        }

        logFile = rotator
        errorPWC = newPipedWriteCloser(NonStopWriteCloser(werr, logFile), errorBufferDepth)
        debugPWC = newPipedWriteCloser(NonStopWriteCloser(wout, logFile), debugBufferDepth)
        resetLogs.Store(golog.SetOutputs(errorPWC, debugPWC))
        return nil
}

type pipedWriteCloser struct {
        nSkipped uint64
        closing  uint32 // 1 means true
        w        io.WriteCloser
        ch       chan []byte
        chClosed chan struct{}
}

func (w *pipedWriteCloser) Write(b []byte) (int, error) {
        if atomic.LoadUint32(&w.closing) > 0 {
                return len(b), nil
        }
        buf := make([]byte, len(b))
        // Have to copy the slice as the caller may reuse it before it's consumed
        // by the write goroutine.
        copy(buf, b)
        select {
        case w.ch <- buf:
                skipped := atomic.LoadUint64(&w.nSkipped)
                if skipped > 0 {
                        select {
                        case w.ch <- []byte(fmt.Sprintf("...%d message(s) skipped...\n", skipped)):
                                // Note: Race condition could cause the message being printed
                                // several times, but that's acceptable.
                                atomic.StoreUint64(&w.nSkipped, 0)
                        default:
                        }
                }
        default:
                // Intentionally not returning the buffer to pool, to prevent the pool
                // from expanding indefinitely.
                atomic.AddUint64(&w.nSkipped, 1)
        }
        return len(b), nil
}

func (w *pipedWriteCloser) Close() error {
        if !atomic.CompareAndSwapUint32(&w.closing, 0, 1) {
                // Closing in progress or done
                return nil
        }
        close(w.ch)
        <-w.chClosed
        return w.w.Close()
}

// newPipedWriteCloser wraps a WriteCloser to sequentialize writes from
// different goroutines into a single goroutine. Write errors won't be
// propagated back to the caller goroutine and pending writes more than
// nPending will be dropped silently.
func newPipedWriteCloser(w io.WriteCloser, nPending int) io.WriteCloser {
        pwc := &pipedWriteCloser{0, 0, w,
                make(chan []byte, nPending),
                make(chan struct{}),
        }
        go func() {
                for b := range pwc.ch {
                        pwc.w.Write(b)
                }
                close(pwc.chClosed)
        }()
        return pwc
}

// ZipLogFiles zips the Lantern log files to the writer. All files will be
// placed under the folder in the archieve.  It will stop and return if the
// newly added file would make the extracted files exceed maxBytes in total.
//
// It also returns up to maxTextBytes of plain text from the end of the most recent log file.
func ZipLogFiles(w io.Writer, underFolder string, maxBytes int64, maxTextBytes int64) (string, error) {
        actualLogDirMx.RLock()
        logdir := actualLogDir
        actualLogDirMx.RUnlock()

        return ZipLogFilesFrom(w, maxBytes, maxTextBytes, map[string]string{"logs": logdir})
}

// ZipLogFilesFrom zips the log files from the given dirs to the writer. It will
// stop and return if the newly added file would make the extracted files exceed
// maxBytes in total.
//
// It also returns up to maxTextBytes of plain text from the end of the most recent log file.
func ZipLogFilesFrom(w io.Writer, maxBytes int64, maxTextBytes int64, dirs map[string]string) (string, error) {
        globs := make(map[string]string, len(dirs))
        for baseDir, dir := range dirs {
                globs[baseDir] = fmt.Sprintf(filepath.Join(dir, "*"))
        }
        err := util.ZipFiles(w, util.ZipOptions{
                Globs:    globs,
                MaxBytes: maxBytes,
        })
        if err != nil {
                return "", err
        }

        if maxTextBytes <= 0 {
                return "", nil
        }

        // Get info for all log files
        allFiles := make(byDate, 0)
        for _, glob := range globs {
                matched, err := filepath.Glob(glob)
                if err != nil {
                        log.Errorf("Unable to list files at glob %v: %v", glob, err)
                        continue
                }
                for _, file := range matched {
                        fi, err := os.Stat(file)
                        if err != nil {
                                log.Errorf("Unable to stat file %v: %v", file, err)
                                continue
                        }
                        allFiles = append(allFiles, &fileInfo{
                                file:    file,
                                size:    fi.Size(),
                                modTime: fi.ModTime().Unix(),
                        })
                }
        }

        if len(allFiles) > 0 {
                // Sort by recency
                sort.Sort(allFiles)

                mostRecent := allFiles[0]
                log.Debugf("Grabbing log tail from %v", mostRecent.file)

                mostRecentFile, err := os.Open(mostRecent.file)
                if err != nil {
                        log.Errorf("Unable to open most recent log file %v: %v", mostRecent.file, err)
                        return "", nil
                }
                defer mostRecentFile.Close()

                seekTo := mostRecent.size - maxTextBytes
                if seekTo > 0 {
                        log.Debugf("Seeking to %d in %v", seekTo, mostRecent.file)
                        _, err = mostRecentFile.Seek(seekTo, os.SEEK_CUR)
                        if err != nil {
                                log.Errorf("Unable to seek to tail of file %v: %v", mostRecent.file, err)
                                return "", nil
                        }
                }
                tail, err := ioutil.ReadAll(mostRecentFile)
                if err != nil {
                        log.Errorf("Unable to read tail of file %v: %v", mostRecent.file, err)
                        return "", nil
                }

                log.Debugf("Got %d bytes of log tail from %v", len(tail), mostRecent.file)
                return string(tail), nil
        }

        return "", nil
}

// Close stops logging.
func Close() error {
        if errorPWC != nil {
                errorPWC.Close()
        }
        if debugPWC != nil {
                debugPWC.Close()
        }
        if logFile != nil {
                logFile.Close()
        }

        resetLogs.Load().(func())()

        return nil
}

type nonStopWriteCloser struct {
        writers []io.WriteCloser
}

// NonStopWriteCloser creates a WriteCloser that duplicates its writes to all
// the provided WriteClosers, even if errors encountered while writing. It
// doesn't close the provided WriteClosers.
func NonStopWriteCloser(writers ...io.WriteCloser) io.WriteCloser {
        w := make([]io.WriteCloser, len(writers))
        copy(w, writers)
        return &nonStopWriteCloser{w}
}

// Write implements the method from io.Writer.
// It never fails and always return the length of bytes passed in
func (t *nonStopWriteCloser) Write(p []byte) (int, error) {
        for _, w := range t.writers {
                // intentionally not checking for errors
                _, _ = w.Write(p)
        }
        return len(p), nil
}

func (t *nonStopWriteCloser) Close() error {
        return nil
}

type fileInfo struct {
        file    string
        size    int64
        modTime int64
}
type byDate []*fileInfo

func (a byDate) Len() int           { return len(a) }
func (a byDate) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
func (a byDate) Less(i, j int) bool { return a[i].modTime > a[j].modTime }

1	// Package logging configures the golog subsystem for use with Lantern
2	// Import this to make sure golog is initialized before you log.
3	package logging
4
5	import (
6	"fmt"
7	"io"
8	"io/ioutil"
9	"math"
10	"os"
11	"path/filepath"
12	"sort"
13	"strings"
14	"sync"
15	"sync/atomic"
16	"time"
17
18	"github.com/getlantern/errors"
19	"github.com/getlantern/golog"
20	"github.com/getlantern/rotator"
21
22	"github.com/getlantern/flashlight/v7/util"
23	)
24
25	const (
26	logTimestampFormat = "Jan 02 15:04:05.000"
27	)
28
29	var (
30	log = golog.LoggerFor("flashlight.logging")
31	processStart = time.Now()
32
33	logFile io.WriteCloser
34	errorPWC io.WriteCloser
35	debugPWC io.WriteCloser
36
37	actualLogDir string
38	actualLogDirMx sync.RWMutex
39
40	resetLogs atomic.Value
41	)
42
43	func init() {	1✔
44	resetLogs.Store(func() {})	1✔
45	}
46
47	// FlashlightLogger is a logger that uses golog.Logger to log messages. It
48	// implements a logging interface that packages like quicproxy use.
49	// See here for more info:
50	// - https://github.com/getlantern/quicproxy/blob/d393da079842dda222d5c0ddbc1ba33e55c46e8b/README.md#L40
51	type FlashlightLogger struct{ golog.Logger }
52
53	func (l FlashlightLogger) Printf(format string, a ...any) { l.Logger.Debugf(format, a...) }	×
54	func (l FlashlightLogger) Infof(format string, a ...any) { l.Logger.Debugf(format, a...) }	×
55	func (l FlashlightLogger) Errorf(format string, a ...any) { l.Logger.Errorf(format, a...) }	×
56
57	// RotatedLogsUnder creates rotated file logger under logdir using the given appName
58	func RotatedLogsUnder(appName, logdir string) (io.WriteCloser, error) {	10✔
59	actualLogDirMx.Lock()	10✔
60	actualLogDir = logdir	10✔
61	actualLogDirMx.Unlock()	10✔
62		10✔
63	if _, err := os.Stat(logdir); err != nil {	10✔
64	if os.IsNotExist(err) {	×
65	// Create log dir	×
66	if err := os.MkdirAll(logdir, 0755); err != nil {	×
67	return nil, errors.New("Unable to create logdir at %s: %s", logdir, err)	×
68	}	×
69	}
70	}
71
72	rotator := rotator.NewSizeRotator(filepath.Join(logdir, strings.ToLower(appName)+".log"))	10✔
73	// Set log files to 4 MB	10✔
74	rotator.RotationSize = 4 * 1024 * 1024	10✔
75	// Keep up to 5 log files	10✔
76	rotator.MaxRotation = 5	10✔
77		10✔
78	return rotator, nil	10✔
79	}
80
81	// Timestamped writes the current time and the duration since process start to
82	// the writer, used by golog.SetPrepender().
83	func Timestamped(w io.Writer) {	×
84	ts := time.Now()	×
85	runningSecs := ts.Sub(processStart).Seconds()	×
86	secs := int(math.Mod(runningSecs, 60))	×
87	mins := int(runningSecs / 60)	×
88	fmt.Fprintf(w, "%s - %dm%ds ", ts.In(time.UTC).Format(logTimestampFormat), mins, secs)	×
89	}	×
90
91	// EnableFileLogging configures golog to write to rotated files under the
92	// logdir for the given appName, in addition to standard outputs.
93	func EnableFileLogging(appName, logdir string) {	10✔
94	err := EnableFileLoggingWith(os.Stdout, os.Stderr, appName, logdir, 100, 1000)	10✔
95	if err != nil {	10✔
96	log.Error(err)	×
97	}	×
98	}
99
100	// EnableFileLoggingWith is similar to EnableFileLogging but allows overriding
101	// standard outputs and setting buffer depths for error and debug log channels.
102	func EnableFileLoggingWith(werr io.WriteCloser, wout io.WriteCloser, appName, logdir string, debugBufferDepth, errorBufferDepth int) error {	10✔
103	golog.SetPrepender(Timestamped)	10✔
104	rotator, err := RotatedLogsUnder(appName, logdir)	10✔
105	if err != nil {	10✔
106	return err	×
107	}	×
108
109	logFile = rotator	10✔
110	errorPWC = newPipedWriteCloser(NonStopWriteCloser(werr, logFile), errorBufferDepth)	10✔
111	debugPWC = newPipedWriteCloser(NonStopWriteCloser(wout, logFile), debugBufferDepth)	10✔
112	resetLogs.Store(golog.SetOutputs(errorPWC, debugPWC))	10✔
113	return nil	10✔
114	}
115
116	type pipedWriteCloser struct {
117	nSkipped uint64
118	closing uint32 // 1 means true
119	w io.WriteCloser
120	ch chan []byte
121	chClosed chan struct{}
122	}
123
124	func (w *pipedWriteCloser) Write(b []byte) (int, error) {	1,100✔
125	if atomic.LoadUint32(&w.closing) > 0 {	1,100✔
126	return len(b), nil	×
127	}	×
128	buf := make([]byte, len(b))	1,100✔
129	// Have to copy the slice as the caller may reuse it before it's consumed	1,100✔
130	// by the write goroutine.	1,100✔
131	copy(buf, b)	1,100✔
132	select {	1,100✔
133	case w.ch <- buf:	515✔
134	skipped := atomic.LoadUint64(&w.nSkipped)	515✔
135	if skipped > 0 {	533✔
136	select {	18✔
137	case w.ch <- []byte(fmt.Sprintf("...%d message(s) skipped...\n", skipped)):	18✔
138	// Note: Race condition could cause the message being printed	18✔
139	// several times, but that's acceptable.	18✔
140	atomic.StoreUint64(&w.nSkipped, 0)	18✔
UNCOV 141	default:	×
142	}
143	}
144	default:	585✔
145	// Intentionally not returning the buffer to pool, to prevent the pool	585✔
146	// from expanding indefinitely.	585✔
147	atomic.AddUint64(&w.nSkipped, 1)	585✔
148	}
149	return len(b), nil	1,100✔
150	}
151
152	func (w *pipedWriteCloser) Close() error {	22✔
153	if !atomic.CompareAndSwapUint32(&w.closing, 0, 1) {	22✔
154	// Closing in progress or done	×
155	return nil	×
156	}	×
157	close(w.ch)	22✔
158	<-w.chClosed	22✔
159	return w.w.Close()	22✔
160	}
161
162	// newPipedWriteCloser wraps a WriteCloser to sequentialize writes from
163	// different goroutines into a single goroutine. Write errors won't be
164	// propagated back to the caller goroutine and pending writes more than
165	// nPending will be dropped silently.
166	func newPipedWriteCloser(w io.WriteCloser, nPending int) io.WriteCloser {	22✔
167	pwc := &pipedWriteCloser{0, 0, w,	22✔
168	make(chan []byte, nPending),	22✔
169	make(chan struct{}),	22✔
170	}	22✔
171	go func() {	44✔
172	for b := range pwc.ch {	555✔
173	pwc.w.Write(b)	533✔
174	}	533✔
175	close(pwc.chClosed)	22✔
176	}()
177	return pwc	22✔
178	}
179
180	// ZipLogFiles zips the Lantern log files to the writer. All files will be
181	// placed under the folder in the archieve. It will stop and return if the
182	// newly added file would make the extracted files exceed maxBytes in total.
183	//
184	// It also returns up to maxTextBytes of plain text from the end of the most recent log file.
185	func ZipLogFiles(w io.Writer, underFolder string, maxBytes int64, maxTextBytes int64) (string, error) {	×
186	actualLogDirMx.RLock()	×
187	logdir := actualLogDir	×
188	actualLogDirMx.RUnlock()	×
189		×
190	return ZipLogFilesFrom(w, maxBytes, maxTextBytes, map[string]string{"logs": logdir})	×
191	}	×
192
193	// ZipLogFilesFrom zips the log files from the given dirs to the writer. It will
194	// stop and return if the newly added file would make the extracted files exceed
195	// maxBytes in total.
196	//
197	// It also returns up to maxTextBytes of plain text from the end of the most recent log file.
198	func ZipLogFilesFrom(w io.Writer, maxBytes int64, maxTextBytes int64, dirs map[string]string) (string, error) {	×
199	globs := make(map[string]string, len(dirs))	×
200	for baseDir, dir := range dirs {	×
201	globs[baseDir] = fmt.Sprintf(filepath.Join(dir, "*"))	×
202	}	×
203	err := util.ZipFiles(w, util.ZipOptions{	×
204	Globs: globs,	×
205	MaxBytes: maxBytes,	×
206	})	×
207	if err != nil {	×
208	return "", err	×
209	}	×
210
211	if maxTextBytes <= 0 {	×
212	return "", nil	×
213	}	×
214
215	// Get info for all log files
216	allFiles := make(byDate, 0)	×
217	for _, glob := range globs {	×
218	matched, err := filepath.Glob(glob)	×
219	if err != nil {	×
220	log.Errorf("Unable to list files at glob %v: %v", glob, err)	×
221	continue	×
222	}
223	for _, file := range matched {	×
224	fi, err := os.Stat(file)	×
225	if err != nil {	×
226	log.Errorf("Unable to stat file %v: %v", file, err)	×
227	continue	×
228	}
229	allFiles = append(allFiles, &fileInfo{	×
230	file: file,	×
231	size: fi.Size(),	×
232	modTime: fi.ModTime().Unix(),	×
233	})	×
234	}
235	}
236
237	if len(allFiles) > 0 {	×
238	// Sort by recency	×
239	sort.Sort(allFiles)	×
240		×
241	mostRecent := allFiles[0]	×
242	log.Debugf("Grabbing log tail from %v", mostRecent.file)	×
243		×
244	mostRecentFile, err := os.Open(mostRecent.file)	×
245	if err != nil {	×
246	log.Errorf("Unable to open most recent log file %v: %v", mostRecent.file, err)	×
247	return "", nil	×
248	}	×
249	defer mostRecentFile.Close()	×
250		×
251	seekTo := mostRecent.size - maxTextBytes	×
252	if seekTo > 0 {	×
253	log.Debugf("Seeking to %d in %v", seekTo, mostRecent.file)	×
254	_, err = mostRecentFile.Seek(seekTo, os.SEEK_CUR)	×
255	if err != nil {	×
256	log.Errorf("Unable to seek to tail of file %v: %v", mostRecent.file, err)	×
257	return "", nil	×
258	}	×
259	}
260	tail, err := ioutil.ReadAll(mostRecentFile)	×
261	if err != nil {	×
262	log.Errorf("Unable to read tail of file %v: %v", mostRecent.file, err)	×
263	return "", nil	×
264	}	×
265
266	log.Debugf("Got %d bytes of log tail from %v", len(tail), mostRecent.file)	×
267	return string(tail), nil	×
268	}
269
270	return "", nil	×
271	}
272
273	// Close stops logging.
274	func Close() error {	10✔
275	if errorPWC != nil {	20✔
276	errorPWC.Close()	10✔
277	}	10✔
278	if debugPWC != nil {	20✔
279	debugPWC.Close()	10✔
280	}	10✔
281	if logFile != nil {	20✔
282	logFile.Close()	10✔
283	}	10✔
284
285	resetLogs.Load().(func())()	10✔
286		10✔
287	return nil	10✔
288	}
289
290	type nonStopWriteCloser struct {
291	writers []io.WriteCloser
292	}
293
294	// NonStopWriteCloser creates a WriteCloser that duplicates its writes to all
295	// the provided WriteClosers, even if errors encountered while writing. It
296	// doesn't close the provided WriteClosers.
297	func NonStopWriteCloser(writers ...io.WriteCloser) io.WriteCloser {	21✔
298	w := make([]io.WriteCloser, len(writers))	21✔
299	copy(w, writers)	21✔
300	return &nonStopWriteCloser{w}	21✔
301	}	21✔
302
303	// Write implements the method from io.Writer.
304	// It never fails and always return the length of bytes passed in
305	func (t *nonStopWriteCloser) Write(p []byte) (int, error) {	1✔
306	for _, w := range t.writers {	3✔
307	// intentionally not checking for errors	2✔
308	_, _ = w.Write(p)	2✔
309	}	2✔
310	return len(p), nil	1✔
311	}
312
313	func (t *nonStopWriteCloser) Close() error {	21✔
314	return nil	21✔
315	}	21✔
316
317	type fileInfo struct {
318	file string
319	size int64
320	modTime int64
321	}
322	type byDate []*fileInfo
323
324	func (a byDate) Len() int { return len(a) }	×
325	func (a byDate) Swap(i, j int) { a[i], a[j] = a[j], a[i] }	×
326	func (a byDate) Less(i, j int) bool { return a[i].modTime > a[j].modTime }	×

getlantern / flashlight / 10621592127

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous