mirror of https://github.com/ethereum/go-ethereum
Péter Szilágyi
8 years ago
parent
47af53f9aa
commit
d4fd06c3dc
@ -1,191 +0,0 @@ |
||||
Apache License |
||||
Version 2.0, January 2004 |
||||
http://www.apache.org/licenses/ |
||||
|
||||
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION |
||||
|
||||
1. Definitions. |
||||
|
||||
"License" shall mean the terms and conditions for use, reproduction, and |
||||
distribution as defined by Sections 1 through 9 of this document. |
||||
|
||||
"Licensor" shall mean the copyright owner or entity authorized by the copyright |
||||
owner that is granting the License. |
||||
|
||||
"Legal Entity" shall mean the union of the acting entity and all other entities |
||||
that control, are controlled by, or are under common control with that entity. |
||||
For the purposes of this definition, "control" means (i) the power, direct or |
||||
indirect, to cause the direction or management of such entity, whether by |
||||
contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the |
||||
outstanding shares, or (iii) beneficial ownership of such entity. |
||||
|
||||
"You" (or "Your") shall mean an individual or Legal Entity exercising |
||||
permissions granted by this License. |
||||
|
||||
"Source" form shall mean the preferred form for making modifications, including |
||||
but not limited to software source code, documentation source, and configuration |
||||
files. |
||||
|
||||
"Object" form shall mean any form resulting from mechanical transformation or |
||||
translation of a Source form, including but not limited to compiled object code, |
||||
generated documentation, and conversions to other media types. |
||||
|
||||
"Work" shall mean the work of authorship, whether in Source or Object form, made |
||||
available under the License, as indicated by a copyright notice that is included |
||||
in or attached to the work (an example is provided in the Appendix below). |
||||
|
||||
"Derivative Works" shall mean any work, whether in Source or Object form, that |
||||
is based on (or derived from) the Work and for which the editorial revisions, |
||||
annotations, elaborations, or other modifications represent, as a whole, an |
||||
original work of authorship. For the purposes of this License, Derivative Works |
||||
shall not include works that remain separable from, or merely link (or bind by |
||||
name) to the interfaces of, the Work and Derivative Works thereof. |
||||
|
||||
"Contribution" shall mean any work of authorship, including the original version |
||||
of the Work and any modifications or additions to that Work or Derivative Works |
||||
thereof, that is intentionally submitted to Licensor for inclusion in the Work |
||||
by the copyright owner or by an individual or Legal Entity authorized to submit |
||||
on behalf of the copyright owner. For the purposes of this definition, |
||||
"submitted" means any form of electronic, verbal, or written communication sent |
||||
to the Licensor or its representatives, including but not limited to |
||||
communication on electronic mailing lists, source code control systems, and |
||||
issue tracking systems that are managed by, or on behalf of, the Licensor for |
||||
the purpose of discussing and improving the Work, but excluding communication |
||||
that is conspicuously marked or otherwise designated in writing by the copyright |
||||
owner as "Not a Contribution." |
||||
|
||||
"Contributor" shall mean Licensor and any individual or Legal Entity on behalf |
||||
of whom a Contribution has been received by Licensor and subsequently |
||||
incorporated within the Work. |
||||
|
||||
2. Grant of Copyright License. |
||||
|
||||
Subject to the terms and conditions of this License, each Contributor hereby |
||||
grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, |
||||
irrevocable copyright license to reproduce, prepare Derivative Works of, |
||||
publicly display, publicly perform, sublicense, and distribute the Work and such |
||||
Derivative Works in Source or Object form. |
||||
|
||||
3. Grant of Patent License. |
||||
|
||||
Subject to the terms and conditions of this License, each Contributor hereby |
||||
grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, |
||||
irrevocable (except as stated in this section) patent license to make, have |
||||
made, use, offer to sell, sell, import, and otherwise transfer the Work, where |
||||
such license applies only to those patent claims licensable by such Contributor |
||||
that are necessarily infringed by their Contribution(s) alone or by combination |
||||
of their Contribution(s) with the Work to which such Contribution(s) was |
||||
submitted. If You institute patent litigation against any entity (including a |
||||
cross-claim or counterclaim in a lawsuit) alleging that the Work or a |
||||
Contribution incorporated within the Work constitutes direct or contributory |
||||
patent infringement, then any patent licenses granted to You under this License |
||||
for that Work shall terminate as of the date such litigation is filed. |
||||
|
||||
4. Redistribution. |
||||
|
||||
You may reproduce and distribute copies of the Work or Derivative Works thereof |
||||
in any medium, with or without modifications, and in Source or Object form, |
||||
provided that You meet the following conditions: |
||||
|
||||
You must give any other recipients of the Work or Derivative Works a copy of |
||||
this License; and |
||||
You must cause any modified files to carry prominent notices stating that You |
||||
changed the files; and |
||||
You must retain, in the Source form of any Derivative Works that You distribute, |
||||
all copyright, patent, trademark, and attribution notices from the Source form |
||||
of the Work, excluding those notices that do not pertain to any part of the |
||||
Derivative Works; and |
||||
If the Work includes a "NOTICE" text file as part of its distribution, then any |
||||
Derivative Works that You distribute must include a readable copy of the |
||||
attribution notices contained within such NOTICE file, excluding those notices |
||||
that do not pertain to any part of the Derivative Works, in at least one of the |
||||
following places: within a NOTICE text file distributed as part of the |
||||
Derivative Works; within the Source form or documentation, if provided along |
||||
with the Derivative Works; or, within a display generated by the Derivative |
||||
Works, if and wherever such third-party notices normally appear. The contents of |
||||
the NOTICE file are for informational purposes only and do not modify the |
||||
License. You may add Your own attribution notices within Derivative Works that |
||||
You distribute, alongside or as an addendum to the NOTICE text from the Work, |
||||
provided that such additional attribution notices cannot be construed as |
||||
modifying the License. |
||||
You may add Your own copyright statement to Your modifications and may provide |
||||
additional or different license terms and conditions for use, reproduction, or |
||||
distribution of Your modifications, or for any such Derivative Works as a whole, |
||||
provided Your use, reproduction, and distribution of the Work otherwise complies |
||||
with the conditions stated in this License. |
||||
|
||||
5. Submission of Contributions. |
||||
|
||||
Unless You explicitly state otherwise, any Contribution intentionally submitted |
||||
for inclusion in the Work by You to the Licensor shall be under the terms and |
||||
conditions of this License, without any additional terms or conditions. |
||||
Notwithstanding the above, nothing herein shall supersede or modify the terms of |
||||
any separate license agreement you may have executed with Licensor regarding |
||||
such Contributions. |
||||
|
||||
6. Trademarks. |
||||
|
||||
This License does not grant permission to use the trade names, trademarks, |
||||
service marks, or product names of the Licensor, except as required for |
||||
reasonable and customary use in describing the origin of the Work and |
||||
reproducing the content of the NOTICE file. |
||||
|
||||
7. Disclaimer of Warranty. |
||||
|
||||
Unless required by applicable law or agreed to in writing, Licensor provides the |
||||
Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, |
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, |
||||
including, without limitation, any warranties or conditions of TITLE, |
||||
NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are |
||||
solely responsible for determining the appropriateness of using or |
||||
redistributing the Work and assume any risks associated with Your exercise of |
||||
permissions under this License. |
||||
|
||||
8. Limitation of Liability. |
||||
|
||||
In no event and under no legal theory, whether in tort (including negligence), |
||||
contract, or otherwise, unless required by applicable law (such as deliberate |
||||
and grossly negligent acts) or agreed to in writing, shall any Contributor be |
||||
liable to You for damages, including any direct, indirect, special, incidental, |
||||
or consequential damages of any character arising as a result of this License or |
||||
out of the use or inability to use the Work (including but not limited to |
||||
damages for loss of goodwill, work stoppage, computer failure or malfunction, or |
||||
any and all other commercial damages or losses), even if such Contributor has |
||||
been advised of the possibility of such damages. |
||||
|
||||
9. Accepting Warranty or Additional Liability. |
||||
|
||||
While redistributing the Work or Derivative Works thereof, You may choose to |
||||
offer, and charge a fee for, acceptance of support, warranty, indemnity, or |
||||
other liability obligations and/or rights consistent with this License. However, |
||||
in accepting such obligations, You may act only on Your own behalf and on Your |
||||
sole responsibility, not on behalf of any other Contributor, and only if You |
||||
agree to indemnify, defend, and hold each Contributor harmless for any liability |
||||
incurred by, or claims asserted against, such Contributor by reason of your |
||||
accepting any such warranty or additional liability. |
||||
|
||||
END OF TERMS AND CONDITIONS |
||||
|
||||
APPENDIX: How to apply the Apache License to your work |
||||
|
||||
To apply the Apache License to your work, attach the following boilerplate |
||||
notice, with the fields enclosed by brackets "[]" replaced with your own |
||||
identifying information. (Don't include the brackets!) The text should be |
||||
enclosed in the appropriate comment syntax for the file format. We also |
||||
recommend that a file or class name and description of purpose be included on |
||||
the same "printed page" as the copyright notice for easier identification within |
||||
third-party archives. |
||||
|
||||
Copyright [yyyy] [name of copyright owner] |
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License"); |
||||
you may not use this file except in compliance with the License. |
||||
You may obtain a copy of the License at |
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0 |
||||
|
||||
Unless required by applicable law or agreed to in writing, software |
||||
distributed under the License is distributed on an "AS IS" BASIS, |
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
||||
See the License for the specific language governing permissions and |
||||
limitations under the License. |
||||
@ -1,44 +0,0 @@ |
||||
glog |
||||
==== |
||||
|
||||
Leveled execution logs for Go. |
||||
|
||||
This is an efficient pure Go implementation of leveled logs in the |
||||
manner of the open source C++ package |
||||
http://code.google.com/p/google-glog |
||||
|
||||
By binding methods to booleans it is possible to use the log package |
||||
without paying the expense of evaluating the arguments to the log. |
||||
Through the -vmodule flag, the package also provides fine-grained |
||||
control over logging at the file level. |
||||
|
||||
The comment from glog.go introduces the ideas: |
||||
|
||||
Package glog implements logging analogous to the Google-internal |
||||
C++ INFO/ERROR/V setup. It provides functions Info, Warning, |
||||
Error, Fatal, plus formatting variants such as Infof. It |
||||
also provides V-style logging controlled by the -v and |
||||
-vmodule=file=2 flags. |
||||
|
||||
Basic examples: |
||||
|
||||
glog.Info("Prepare to repel boarders") |
||||
|
||||
glog.Fatalf("Initialization failed: %s", err) |
||||
|
||||
See the documentation for the V function for an explanation |
||||
of these examples: |
||||
|
||||
if glog.V(2) { |
||||
glog.Info("Starting transaction...") |
||||
} |
||||
|
||||
glog.V(2).Infoln("Processed", nItems, "elements") |
||||
|
||||
|
||||
The repository contains an open source version of the log package |
||||
used inside Google. The master copy of the source lives inside |
||||
Google, not here. The code in this repo is for export only and is not itself |
||||
under development. Feature requests will be ignored. |
||||
|
||||
Send bug reports to golang-nuts@googlegroups.com. |
||||
File diff suppressed because it is too large
Load Diff
@ -1,128 +0,0 @@ |
||||
// Go support for leveled logs, analogous to https://code.google.com/p/google-glog/
|
||||
//
|
||||
// Copyright 2013 Google Inc. All Rights Reserved.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
// File I/O for logs.
|
||||
|
||||
package glog |
||||
|
||||
import ( |
||||
"errors" |
||||
"fmt" |
||||
"os" |
||||
"os/user" |
||||
"path/filepath" |
||||
"strings" |
||||
"sync" |
||||
"time" |
||||
) |
||||
|
||||
// MaxSize is the maximum size of a log file in bytes.
|
||||
var MaxSize uint64 = 1024 * 1024 * 1800 |
||||
|
||||
// logDirs lists the candidate directories for new log files.
|
||||
var logDirs []string |
||||
|
||||
// If non-empty, overrides the choice of directory in which to write logs.
|
||||
// See createLogDirs for the full list of possible destinations.
|
||||
//var logDir = flag.String("log_dir", "", "If non-empty, write log files in this directory")
|
||||
var logDir *string = new(string) |
||||
|
||||
func SetLogDir(str string) { |
||||
*logDir = str |
||||
} |
||||
|
||||
func createLogDirs() { |
||||
if *logDir != "" { |
||||
logDirs = append(logDirs, *logDir) |
||||
} |
||||
logDirs = append(logDirs, os.TempDir()) |
||||
} |
||||
|
||||
var ( |
||||
pid = os.Getpid() |
||||
program = filepath.Base(os.Args[0]) |
||||
host = "unknownhost" |
||||
userName = "unknownuser" |
||||
) |
||||
|
||||
func init() { |
||||
h, err := os.Hostname() |
||||
if err == nil { |
||||
host = shortHostname(h) |
||||
} |
||||
|
||||
current, err := user.Current() |
||||
if err == nil { |
||||
userName = current.Username |
||||
} |
||||
|
||||
// Sanitize userName since it may contain filepath separators on Windows.
|
||||
userName = strings.Replace(userName, `\`, "_", -1) |
||||
} |
||||
|
||||
// shortHostname returns its argument, truncating at the first period.
|
||||
// For instance, given "www.google.com" it returns "www".
|
||||
func shortHostname(hostname string) string { |
||||
if i := strings.Index(hostname, "."); i >= 0 { |
||||
return hostname[:i] |
||||
} |
||||
return hostname |
||||
} |
||||
|
||||
// logName returns a new log file name containing tag, with start time t, and
|
||||
// the name for the symlink for tag.
|
||||
func logName(tag string, t time.Time) (name, link string) { |
||||
name = fmt.Sprintf("%s.%s.%s.log.%s.%04d%02d%02d-%02d%02d%02d.%d", |
||||
program, |
||||
host, |
||||
userName, |
||||
tag, |
||||
t.Year(), |
||||
t.Month(), |
||||
t.Day(), |
||||
t.Hour(), |
||||
t.Minute(), |
||||
t.Second(), |
||||
pid) |
||||
return name, program + "." + tag |
||||
} |
||||
|
||||
var onceLogDirs sync.Once |
||||
|
||||
// create creates a new log file and returns the file and its filename, which
|
||||
// contains tag ("INFO", "FATAL", etc.) and t. If the file is created
|
||||
// successfully, create also attempts to update the symlink for that tag, ignoring
|
||||
// errors.
|
||||
func create(tag string, t time.Time) (f *os.File, filename string, err error) { |
||||
onceLogDirs.Do(createLogDirs) |
||||
if len(logDirs) == 0 { |
||||
return nil, "", errors.New("log: no log dirs") |
||||
} |
||||
name, link := logName(tag, t) |
||||
var lastErr error |
||||
for _, dir := range logDirs { |
||||
fname := filepath.Join(dir, name) |
||||
f, err := os.Create(fname) |
||||
if err == nil { |
||||
symlink := filepath.Join(dir, link) |
||||
os.Remove(symlink) // ignore err
|
||||
os.Symlink(name, symlink) // ignore err
|
||||
return f, fname, nil |
||||
} |
||||
lastErr = err |
||||
} |
||||
return nil, "", fmt.Errorf("log: cannot create log: %v", lastErr) |
||||
} |
||||
@ -1,436 +0,0 @@ |
||||
// Go support for leveled logs, analogous to https://code.google.com/p/google-glog/
|
||||
//
|
||||
// Copyright 2013 Google Inc. All Rights Reserved.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
package glog |
||||
|
||||
import ( |
||||
"bytes" |
||||
"fmt" |
||||
stdLog "log" |
||||
"path/filepath" |
||||
"runtime" |
||||
"strconv" |
||||
"strings" |
||||
"testing" |
||||
"time" |
||||
) |
||||
|
||||
// Test that shortHostname works as advertised.
|
||||
func TestShortHostname(t *testing.T) { |
||||
for hostname, expect := range map[string]string{ |
||||
"": "", |
||||
"host": "host", |
||||
"host.google.com": "host", |
||||
} { |
||||
if got := shortHostname(hostname); expect != got { |
||||
t.Errorf("shortHostname(%q): expected %q, got %q", hostname, expect, got) |
||||
} |
||||
} |
||||
} |
||||
|
||||
// flushBuffer wraps a bytes.Buffer to satisfy flushSyncWriter.
|
||||
type flushBuffer struct { |
||||
bytes.Buffer |
||||
} |
||||
|
||||
func (f *flushBuffer) Flush() error { |
||||
return nil |
||||
} |
||||
|
||||
func (f *flushBuffer) Sync() error { |
||||
return nil |
||||
} |
||||
|
||||
// swap sets the log writers and returns the old array.
|
||||
func (l *loggingT) swap(writers [numSeverity]flushSyncWriter) (old [numSeverity]flushSyncWriter) { |
||||
l.mu.Lock() |
||||
defer l.mu.Unlock() |
||||
old = l.file |
||||
for i, w := range writers { |
||||
logging.file[i] = w |
||||
} |
||||
return |
||||
} |
||||
|
||||
// newBuffers sets the log writers to all new byte buffers and returns the old array.
|
||||
func (l *loggingT) newBuffers() [numSeverity]flushSyncWriter { |
||||
return l.swap([numSeverity]flushSyncWriter{new(flushBuffer), new(flushBuffer), new(flushBuffer), new(flushBuffer)}) |
||||
} |
||||
|
||||
// contents returns the specified log value as a string.
|
||||
func contents(s severity) string { |
||||
return logging.file[s].(*flushBuffer).String() |
||||
} |
||||
|
||||
// contains reports whether the string is contained in the log.
|
||||
func contains(s severity, str string, t *testing.T) bool { |
||||
return strings.Contains(contents(s), str) |
||||
} |
||||
|
||||
// setFlags configures the logging flags how the test expects them.
|
||||
func setFlags() { |
||||
logging.toStderr = false |
||||
} |
||||
|
||||
// Test that Info works as advertised.
|
||||
func TestInfo(t *testing.T) { |
||||
setFlags() |
||||
defer logging.swap(logging.newBuffers()) |
||||
Info("test") |
||||
if !contains(infoLog, "I", t) { |
||||
t.Errorf("Info has wrong character: %q", contents(infoLog)) |
||||
} |
||||
if !contains(infoLog, "test", t) { |
||||
t.Error("Info failed") |
||||
} |
||||
} |
||||
|
||||
func TestInfoDepth(t *testing.T) { |
||||
setFlags() |
||||
defer logging.swap(logging.newBuffers()) |
||||
|
||||
f := func() { InfoDepth(1, "depth-test1") } |
||||
|
||||
// The next three lines must stay together
|
||||
_, _, wantLine, _ := runtime.Caller(0) |
||||
InfoDepth(0, "depth-test0") |
||||
f() |
||||
|
||||
msgs := strings.Split(strings.TrimSuffix(contents(infoLog), "\n"), "\n") |
||||
if len(msgs) != 2 { |
||||
t.Fatalf("Got %d lines, expected 2", len(msgs)) |
||||
} |
||||
|
||||
for i, m := range msgs { |
||||
if !strings.HasPrefix(m, "I") { |
||||
t.Errorf("InfoDepth[%d] has wrong character: %q", i, m) |
||||
} |
||||
w := fmt.Sprintf("depth-test%d", i) |
||||
if !strings.Contains(m, w) { |
||||
t.Errorf("InfoDepth[%d] missing %q: %q", i, w, m) |
||||
} |
||||
|
||||
// pull out the line number (between : and ])
|
||||
msg := m[strings.LastIndex(m, ":")+1:] |
||||
x := strings.Index(msg, "]") |
||||
if x < 0 { |
||||
t.Errorf("InfoDepth[%d]: missing ']': %q", i, m) |
||||
continue |
||||
} |
||||
line, err := strconv.Atoi(msg[:x]) |
||||
if err != nil { |
||||
t.Errorf("InfoDepth[%d]: bad line number: %q", i, m) |
||||
continue |
||||
} |
||||
wantLine++ |
||||
if wantLine != line { |
||||
t.Errorf("InfoDepth[%d]: got line %d, want %d", i, line, wantLine) |
||||
} |
||||
} |
||||
} |
||||
|
||||
func init() { |
||||
CopyStandardLogTo("INFO") |
||||
} |
||||
|
||||
// Test that CopyStandardLogTo panics on bad input.
|
||||
func TestCopyStandardLogToPanic(t *testing.T) { |
||||
defer func() { |
||||
if s, ok := recover().(string); !ok || !strings.Contains(s, "LOG") { |
||||
t.Errorf(`CopyStandardLogTo("LOG") should have panicked: %v`, s) |
||||
} |
||||
}() |
||||
CopyStandardLogTo("LOG") |
||||
} |
||||
|
||||
// Test that using the standard log package logs to INFO.
|
||||
func TestStandardLog(t *testing.T) { |
||||
setFlags() |
||||
defer logging.swap(logging.newBuffers()) |
||||
stdLog.Print("test") |
||||
if !contains(infoLog, "I", t) { |
||||
t.Errorf("Info has wrong character: %q", contents(infoLog)) |
||||
} |
||||
if !contains(infoLog, "test", t) { |
||||
t.Error("Info failed") |
||||
} |
||||
} |
||||
|
||||
// Test that the header has the correct format.
|
||||
func TestHeader(t *testing.T) { |
||||
setFlags() |
||||
defer logging.swap(logging.newBuffers()) |
||||
defer func(previous func() time.Time) { timeNow = previous }(timeNow) |
||||
timeNow = func() time.Time { |
||||
return time.Date(2006, 1, 2, 15, 4, 5, .067890e9, time.Local) |
||||
} |
||||
pid = 1234 |
||||
Info("test") |
||||
var line int |
||||
format := "I0102 15:04:05.067890 logger/glog/glog_test.go:%d] test\n" |
||||
n, err := fmt.Sscanf(contents(infoLog), format, &line) |
||||
if n != 1 || err != nil { |
||||
t.Errorf("log format error: %d elements, error %s:\n%s", n, err, contents(infoLog)) |
||||
} |
||||
// Scanf treats multiple spaces as equivalent to a single space,
|
||||
// so check for correct space-padding also.
|
||||
want := fmt.Sprintf(format, line) |
||||
if contents(infoLog) != want { |
||||
t.Errorf("log format error: got:\n\t%q\nwant:\t%q", contents(infoLog), want) |
||||
} |
||||
} |
||||
|
||||
// Test that an Error log goes to Warning and Info.
|
||||
// Even in the Info log, the source character will be E, so the data should
|
||||
// all be identical.
|
||||
func TestError(t *testing.T) { |
||||
setFlags() |
||||
defer logging.swap(logging.newBuffers()) |
||||
Error("test") |
||||
if !contains(errorLog, "E", t) { |
||||
t.Errorf("Error has wrong character: %q", contents(errorLog)) |
||||
} |
||||
if !contains(errorLog, "test", t) { |
||||
t.Error("Error failed") |
||||
} |
||||
str := contents(errorLog) |
||||
if !contains(warningLog, str, t) { |
||||
t.Error("Warning failed") |
||||
} |
||||
if !contains(infoLog, str, t) { |
||||
t.Error("Info failed") |
||||
} |
||||
} |
||||
|
||||
// Test that a Warning log goes to Info.
|
||||
// Even in the Info log, the source character will be W, so the data should
|
||||
// all be identical.
|
||||
func TestWarning(t *testing.T) { |
||||
setFlags() |
||||
defer logging.swap(logging.newBuffers()) |
||||
Warning("test") |
||||
if !contains(warningLog, "W", t) { |
||||
t.Errorf("Warning has wrong character: %q", contents(warningLog)) |
||||
} |
||||
if !contains(warningLog, "test", t) { |
||||
t.Error("Warning failed") |
||||
} |
||||
str := contents(warningLog) |
||||
if !contains(infoLog, str, t) { |
||||
t.Error("Info failed") |
||||
} |
||||
} |
||||
|
||||
// Test that a V log goes to Info.
|
||||
func TestV(t *testing.T) { |
||||
setFlags() |
||||
defer logging.swap(logging.newBuffers()) |
||||
logging.verbosity.Set("2") |
||||
defer logging.verbosity.Set("0") |
||||
V(2).Info("test") |
||||
if !contains(infoLog, "I", t) { |
||||
t.Errorf("Info has wrong character: %q", contents(infoLog)) |
||||
} |
||||
if !contains(infoLog, "test", t) { |
||||
t.Error("Info failed") |
||||
} |
||||
} |
||||
|
||||
// Test that a vmodule enables a log in this file.
|
||||
func TestVmoduleOn(t *testing.T) { |
||||
setFlags() |
||||
defer logging.swap(logging.newBuffers()) |
||||
logging.vmodule.Set("glog_test.go=2") |
||||
defer logging.vmodule.Set("") |
||||
if !V(1) { |
||||
t.Error("V not enabled for 1") |
||||
} |
||||
if !V(2) { |
||||
t.Error("V not enabled for 2") |
||||
} |
||||
if V(3) { |
||||
t.Error("V enabled for 3") |
||||
} |
||||
V(2).Info("test") |
||||
if !contains(infoLog, "I", t) { |
||||
t.Errorf("Info has wrong character: %q", contents(infoLog)) |
||||
} |
||||
if !contains(infoLog, "test", t) { |
||||
t.Error("Info failed") |
||||
} |
||||
} |
||||
|
||||
// Test that a vmodule of another file does not enable a log in this file.
|
||||
func TestVmoduleOff(t *testing.T) { |
||||
setFlags() |
||||
defer logging.swap(logging.newBuffers()) |
||||
logging.vmodule.Set("notthisfile=2") |
||||
defer logging.vmodule.Set("") |
||||
for i := 1; i <= 3; i++ { |
||||
if V(Level(i)) { |
||||
t.Errorf("V enabled for %d", i) |
||||
} |
||||
} |
||||
V(2).Info("test") |
||||
if contents(infoLog) != "" { |
||||
t.Error("V logged incorrectly") |
||||
} |
||||
} |
||||
|
||||
var patternTests = []struct{ input, want string }{ |
||||
{"foo/bar/x.go", ".*/foo/bar/x\\.go$"}, |
||||
{"foo/*/x.go", ".*/foo(/.*)?/x\\.go$"}, |
||||
{"foo/*", ".*/foo(/.*)?/[^/]+\\.go$"}, |
||||
} |
||||
|
||||
func TestCompileModulePattern(t *testing.T) { |
||||
for _, test := range patternTests { |
||||
re, err := compileModulePattern(test.input) |
||||
if err != nil { |
||||
t.Fatalf("%s: %v", test.input, err) |
||||
} |
||||
if re.String() != test.want { |
||||
t.Errorf("mismatch for %q: got %q, want %q", test.input, re.String(), test.want) |
||||
} |
||||
} |
||||
} |
||||
|
||||
// vGlobs are patterns that match/don't match this file at V=2.
|
||||
var vGlobs = map[string]bool{ |
||||
// Easy to test the numeric match here.
|
||||
"glog_test.go=1": false, // If -vmodule sets V to 1, V(2) will fail.
|
||||
"glog_test.go=2": true, |
||||
"glog_test.go=3": true, // If -vmodule sets V to 1, V(3) will succeed.
|
||||
|
||||
// Import path prefix matching
|
||||
"logger/glog=1": false, |
||||
"logger/glog=2": true, |
||||
"logger/glog=3": true, |
||||
|
||||
// Import path glob matching
|
||||
"logger/*=1": false, |
||||
"logger/*=2": true, |
||||
"logger/*=3": true, |
||||
|
||||
// These all use 2 and check the patterns.
|
||||
"*=2": true, |
||||
} |
||||
|
||||
// Test that vmodule globbing works as advertised.
|
||||
func testVmoduleGlob(pat string, match bool, t *testing.T) { |
||||
setFlags() |
||||
defer logging.swap(logging.newBuffers()) |
||||
defer logging.vmodule.Set("") |
||||
logging.vmodule.Set(pat) |
||||
if V(2) != Verbose(match) { |
||||
t.Errorf("incorrect match for %q: got %t expected %t", pat, V(2), match) |
||||
} |
||||
} |
||||
|
||||
// Test that a vmodule globbing works as advertised.
|
||||
func TestVmoduleGlob(t *testing.T) { |
||||
for glob, match := range vGlobs { |
||||
testVmoduleGlob(glob, match, t) |
||||
} |
||||
} |
||||
|
||||
func TestRollover(t *testing.T) { |
||||
setFlags() |
||||
var err error |
||||
defer func(previous func(error)) { logExitFunc = previous }(logExitFunc) |
||||
logExitFunc = func(e error) { |
||||
err = e |
||||
} |
||||
defer func(previous uint64) { MaxSize = previous }(MaxSize) |
||||
MaxSize = 512 |
||||
|
||||
Info("x") // Be sure we have a file.
|
||||
info, ok := logging.file[infoLog].(*syncBuffer) |
||||
if !ok { |
||||
t.Fatal("info wasn't created") |
||||
} |
||||
if err != nil { |
||||
t.Fatalf("info has initial error: %v", err) |
||||
} |
||||
fname0 := info.file.Name() |
||||
Info(strings.Repeat("x", int(MaxSize))) // force a rollover
|
||||
if err != nil { |
||||
t.Fatalf("info has error after big write: %v", err) |
||||
} |
||||
|
||||
// Make sure the next log file gets a file name with a different
|
||||
// time stamp.
|
||||
//
|
||||
// TODO: determine whether we need to support subsecond log
|
||||
// rotation. C++ does not appear to handle this case (nor does it
|
||||
// handle Daylight Savings Time properly).
|
||||
time.Sleep(1 * time.Second) |
||||
|
||||
Info("x") // create a new file
|
||||
if err != nil { |
||||
t.Fatalf("error after rotation: %v", err) |
||||
} |
||||
fname1 := info.file.Name() |
||||
if fname0 == fname1 { |
||||
t.Errorf("info.f.Name did not change: %v", fname0) |
||||
} |
||||
if info.nbytes >= MaxSize { |
||||
t.Errorf("file size was not reset: %d", info.nbytes) |
||||
} |
||||
} |
||||
|
||||
func TestLogBacktraceAt(t *testing.T) { |
||||
setFlags() |
||||
defer logging.swap(logging.newBuffers()) |
||||
// The peculiar style of this code simplifies line counting and maintenance of the
|
||||
// tracing block below.
|
||||
var infoLine string |
||||
setTraceLocation := func(file string, line int, ok bool, delta int) { |
||||
if !ok { |
||||
t.Fatal("could not get file:line") |
||||
} |
||||
_, file = filepath.Split(file) |
||||
infoLine = fmt.Sprintf("%s:%d", file, line+delta) |
||||
err := logging.traceLocation.Set(infoLine) |
||||
if err != nil { |
||||
t.Fatal("error setting log_backtrace_at: ", err) |
||||
} |
||||
} |
||||
{ |
||||
// Start of tracing block. These lines know about each other's relative position.
|
||||
_, file, line, ok := runtime.Caller(0) |
||||
setTraceLocation(file, line, ok, +2) // Two lines between Caller and Info calls.
|
||||
Info("we want a stack trace here") |
||||
} |
||||
numAppearances := strings.Count(contents(infoLog), infoLine) |
||||
if numAppearances < 2 { |
||||
// Need 2 appearances, one in the log header and one in the trace:
|
||||
// log_test.go:281: I0511 16:36:06.952398 02238 log_test.go:280] we want a stack trace here
|
||||
// ...
|
||||
// github.com/glog/glog_test.go:280 (0x41ba91)
|
||||
// ...
|
||||
// We could be more precise but that would require knowing the details
|
||||
// of the traceback format, which may not be dependable.
|
||||
t.Fatal("got no trace back; log is ", contents(infoLog)) |
||||
} |
||||
} |
||||
|
||||
func BenchmarkHeader(b *testing.B) { |
||||
for i := 0; i < b.N; i++ { |
||||
buf, _, _ := logging.header(infoLog, 0) |
||||
logging.putBuffer(buf) |
||||
} |
||||
} |
||||
@ -1,27 +0,0 @@ |
||||
// Copyright 2015 The go-ethereum Authors
|
||||
// This file is part of the go-ethereum library.
|
||||
//
|
||||
// The go-ethereum library is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Lesser General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// The go-ethereum library 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 Lesser General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Lesser General Public License
|
||||
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
package logger |
||||
|
||||
const ( |
||||
Error = iota + 1 |
||||
Warn |
||||
Info |
||||
Debug |
||||
Detail |
||||
|
||||
Ridiculousness = 100 |
||||
) |
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue