mirror of https://github.com/ethereum/go-ethereum
cmd, dashboard, log: log collection and exploration (#17097)
* cmd, dashboard, internal, log, node: logging feature * cmd, dashboard, internal, log: requested changes * dashboard, vendor: gofmt, govendor, use vendored file watcher * dashboard, log: gofmt -s -w, goimports * dashboard, log: gosimplepull/16734/head
Kurkó Mihály
6 years ago
committed by
Péter Szilágyi
parent
2eedbe799f
commit
a9835c1816
File diff suppressed because one or more lines are too long
@ -0,0 +1,310 @@ |
|||||||
|
// @flow |
||||||
|
|
||||||
|
// Copyright 2018 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/>. |
||||||
|
|
||||||
|
import React, {Component} from 'react'; |
||||||
|
|
||||||
|
import List, {ListItem} from 'material-ui/List'; |
||||||
|
import type {Record, Content, LogsMessage, Logs as LogsType} from '../types/content'; |
||||||
|
|
||||||
|
// requestBand says how wide is the top/bottom zone, eg. 0.1 means 10% of the container height. |
||||||
|
const requestBand = 0.05; |
||||||
|
|
||||||
|
// fieldPadding is a global map with maximum field value lengths seen until now |
||||||
|
// to allow padding log contexts in a bit smarter way. |
||||||
|
const fieldPadding = new Map(); |
||||||
|
|
||||||
|
// createChunk creates an HTML formatted object, which displays the given array similarly to |
||||||
|
// the server side terminal. |
||||||
|
const createChunk = (records: Array<Record>) => { |
||||||
|
let content = ''; |
||||||
|
records.forEach((record) => { |
||||||
|
const {t, ctx} = record; |
||||||
|
let {lvl, msg} = record; |
||||||
|
let color = '#ce3c23'; |
||||||
|
switch (lvl) { |
||||||
|
case 'trace': |
||||||
|
case 'trce': |
||||||
|
lvl = 'TRACE'; |
||||||
|
color = '#3465a4'; |
||||||
|
break; |
||||||
|
case 'debug': |
||||||
|
case 'dbug': |
||||||
|
lvl = 'DEBUG'; |
||||||
|
color = '#3d989b'; |
||||||
|
break; |
||||||
|
case 'info': |
||||||
|
lvl = 'INFO '; |
||||||
|
color = '#4c8f0f'; |
||||||
|
break; |
||||||
|
case 'warn': |
||||||
|
lvl = 'WARN '; |
||||||
|
color = '#b79a22'; |
||||||
|
break; |
||||||
|
case 'error': |
||||||
|
case 'eror': |
||||||
|
lvl = 'ERROR'; |
||||||
|
color = '#754b70'; |
||||||
|
break; |
||||||
|
case 'crit': |
||||||
|
lvl = 'CRIT '; |
||||||
|
color = '#ce3c23'; |
||||||
|
break; |
||||||
|
default: |
||||||
|
lvl = ''; |
||||||
|
} |
||||||
|
const time = new Date(t); |
||||||
|
if (lvl === '' || !(time instanceof Date) || isNaN(time) || typeof msg !== 'string' || !Array.isArray(ctx)) { |
||||||
|
content += '<span style="color:#ce3c23">Invalid log record</span><br />'; |
||||||
|
return; |
||||||
|
} |
||||||
|
if (ctx.length > 0) { |
||||||
|
msg += ' '.repeat(Math.max(40 - msg.length, 0)); |
||||||
|
} |
||||||
|
const month = `0${time.getMonth() + 1}`.slice(-2); |
||||||
|
const date = `0${time.getDate()}`.slice(-2); |
||||||
|
const hours = `0${time.getHours()}`.slice(-2); |
||||||
|
const minutes = `0${time.getMinutes()}`.slice(-2); |
||||||
|
const seconds = `0${time.getSeconds()}`.slice(-2); |
||||||
|
content += `<span style="color:${color}">${lvl}</span>[${month}-${date}|${hours}:${minutes}:${seconds}] ${msg}`; |
||||||
|
|
||||||
|
for (let i = 0; i < ctx.length; i += 2) { |
||||||
|
const key = ctx[i]; |
||||||
|
const val = ctx[i + 1]; |
||||||
|
let padding = fieldPadding.get(key); |
||||||
|
if (typeof padding !== 'number' || padding < val.length) { |
||||||
|
padding = val.length; |
||||||
|
fieldPadding.set(key, padding); |
||||||
|
} |
||||||
|
let p = ''; |
||||||
|
if (i < ctx.length - 2) { |
||||||
|
p = ' '.repeat(padding - val.length); |
||||||
|
} |
||||||
|
content += ` <span style="color:${color}">${key}</span>=${val}${p}`; |
||||||
|
} |
||||||
|
content += '<br />'; |
||||||
|
}); |
||||||
|
return content; |
||||||
|
}; |
||||||
|
|
||||||
|
// inserter is a state updater function for the main component, which inserts the new log chunk into the chunk array. |
||||||
|
// limit is the maximum length of the chunk array, used in order to prevent the browser from OOM. |
||||||
|
export const inserter = (limit: number) => (update: LogsMessage, prev: LogsType) => { |
||||||
|
prev.topChanged = 0; |
||||||
|
prev.bottomChanged = 0; |
||||||
|
if (!Array.isArray(update.chunk) || update.chunk.length < 1) { |
||||||
|
return prev; |
||||||
|
} |
||||||
|
if (!Array.isArray(prev.chunks)) { |
||||||
|
prev.chunks = []; |
||||||
|
} |
||||||
|
const content = createChunk(update.chunk); |
||||||
|
if (!update.source) { |
||||||
|
// In case of stream chunk. |
||||||
|
if (!prev.endBottom) { |
||||||
|
return prev; |
||||||
|
} |
||||||
|
if (prev.chunks.length < 1) { |
||||||
|
// This should never happen, because the first chunk is always a non-stream chunk. |
||||||
|
return [{content, name: '00000000000000.log'}]; |
||||||
|
} |
||||||
|
prev.chunks[prev.chunks.length - 1].content += content; |
||||||
|
prev.bottomChanged = 1; |
||||||
|
return prev; |
||||||
|
} |
||||||
|
const chunk = { |
||||||
|
content, |
||||||
|
name: update.source.name, |
||||||
|
}; |
||||||
|
if (prev.chunks.length > 0 && update.source.name < prev.chunks[0].name) { |
||||||
|
if (update.source.last) { |
||||||
|
prev.endTop = true; |
||||||
|
} |
||||||
|
if (prev.chunks.length >= limit) { |
||||||
|
prev.endBottom = false; |
||||||
|
prev.chunks.splice(limit - 1, prev.chunks.length - limit + 1); |
||||||
|
prev.bottomChanged = -1; |
||||||
|
} |
||||||
|
prev.chunks = [chunk, ...prev.chunks]; |
||||||
|
prev.topChanged = 1; |
||||||
|
return prev; |
||||||
|
} |
||||||
|
if (update.source.last) { |
||||||
|
prev.endBottom = true; |
||||||
|
} |
||||||
|
if (prev.chunks.length >= limit) { |
||||||
|
prev.endTop = false; |
||||||
|
prev.chunks.splice(0, prev.chunks.length - limit + 1); |
||||||
|
prev.topChanged = -1; |
||||||
|
} |
||||||
|
prev.chunks = [...prev.chunks, chunk]; |
||||||
|
prev.bottomChanged = 1; |
||||||
|
return prev; |
||||||
|
}; |
||||||
|
|
||||||
|
// styles contains the constant styles of the component. |
||||||
|
const styles = { |
||||||
|
logListItem: { |
||||||
|
padding: 0, |
||||||
|
}, |
||||||
|
logChunk: { |
||||||
|
color: 'white', |
||||||
|
fontFamily: 'monospace', |
||||||
|
whiteSpace: 'nowrap', |
||||||
|
width: 0, |
||||||
|
}, |
||||||
|
}; |
||||||
|
|
||||||
|
export type Props = { |
||||||
|
container: Object, |
||||||
|
content: Content, |
||||||
|
shouldUpdate: Object, |
||||||
|
send: string => void, |
||||||
|
}; |
||||||
|
|
||||||
|
type State = { |
||||||
|
requestAllowed: boolean, |
||||||
|
}; |
||||||
|
|
||||||
|
// Logs renders the log page. |
||||||
|
class Logs extends Component<Props, State> { |
||||||
|
constructor(props: Props) { |
||||||
|
super(props); |
||||||
|
this.content = React.createRef(); |
||||||
|
this.state = { |
||||||
|
requestAllowed: true, |
||||||
|
}; |
||||||
|
} |
||||||
|
|
||||||
|
componentDidMount() { |
||||||
|
const {container} = this.props; |
||||||
|
container.scrollTop = container.scrollHeight - container.clientHeight; |
||||||
|
} |
||||||
|
|
||||||
|
// onScroll is triggered by the parent component's scroll event, and sends requests if the scroll position is |
||||||
|
// at the top or at the bottom. |
||||||
|
onScroll = () => { |
||||||
|
if (!this.state.requestAllowed || typeof this.content === 'undefined') { |
||||||
|
return; |
||||||
|
} |
||||||
|
const {logs} = this.props.content; |
||||||
|
if (logs.chunks.length < 1) { |
||||||
|
return; |
||||||
|
} |
||||||
|
if (this.atTop()) { |
||||||
|
if (!logs.endTop) { |
||||||
|
this.setState({requestAllowed: false}); |
||||||
|
this.props.send(JSON.stringify({ |
||||||
|
Logs: { |
||||||
|
Name: logs.chunks[0].name, |
||||||
|
Past: true, |
||||||
|
}, |
||||||
|
})); |
||||||
|
} |
||||||
|
} else if (this.atBottom()) { |
||||||
|
if (!logs.endBottom) { |
||||||
|
this.setState({requestAllowed: false}); |
||||||
|
this.props.send(JSON.stringify({ |
||||||
|
Logs: { |
||||||
|
Name: logs.chunks[logs.chunks.length - 1].name, |
||||||
|
Past: false, |
||||||
|
}, |
||||||
|
})); |
||||||
|
} |
||||||
|
} |
||||||
|
}; |
||||||
|
|
||||||
|
// atTop checks if the scroll position it at the top of the container. |
||||||
|
atTop = () => this.props.container.scrollTop <= this.props.container.scrollHeight * requestBand; |
||||||
|
|
||||||
|
// atBottom checks if the scroll position it at the bottom of the container. |
||||||
|
atBottom = () => { |
||||||
|
const {container} = this.props; |
||||||
|
return container.scrollHeight - container.scrollTop <= |
||||||
|
container.clientHeight + container.scrollHeight * requestBand; |
||||||
|
}; |
||||||
|
|
||||||
|
// beforeUpdate is called by the parent component, saves the previous scroll position |
||||||
|
// and the height of the first log chunk, which can be deleted during the insertion. |
||||||
|
beforeUpdate = () => { |
||||||
|
let firstHeight = 0; |
||||||
|
if (this.content && this.content.children[0] && this.content.children[0].children[0]) { |
||||||
|
firstHeight = this.content.children[0].children[0].clientHeight; |
||||||
|
} |
||||||
|
return { |
||||||
|
scrollTop: this.props.container.scrollTop, |
||||||
|
firstHeight, |
||||||
|
}; |
||||||
|
}; |
||||||
|
|
||||||
|
// didUpdate is called by the parent component, which provides the container. Sends the first request if the |
||||||
|
// visible part of the container isn't full, and resets the scroll position in order to avoid jumping when new |
||||||
|
// chunk is inserted. |
||||||
|
didUpdate = (prevProps, prevState, snapshot) => { |
||||||
|
if (typeof this.props.shouldUpdate.logs === 'undefined' || typeof this.content === 'undefined' || snapshot === null) { |
||||||
|
return; |
||||||
|
} |
||||||
|
const {logs} = this.props.content; |
||||||
|
const {container} = this.props; |
||||||
|
if (typeof container === 'undefined' || logs.chunks.length < 1) { |
||||||
|
return; |
||||||
|
} |
||||||
|
if (this.content.clientHeight < container.clientHeight) { |
||||||
|
// Only enters here at the beginning, when there isn't enough log to fill the container |
||||||
|
// and the scroll bar doesn't appear. |
||||||
|
if (!logs.endTop) { |
||||||
|
this.setState({requestAllowed: false}); |
||||||
|
this.props.send(JSON.stringify({ |
||||||
|
Logs: { |
||||||
|
Name: logs.chunks[0].name, |
||||||
|
Past: true, |
||||||
|
}, |
||||||
|
})); |
||||||
|
} |
||||||
|
return; |
||||||
|
} |
||||||
|
const chunks = this.content.children[0].children; |
||||||
|
let {scrollTop} = snapshot; |
||||||
|
if (logs.topChanged > 0) { |
||||||
|
scrollTop += chunks[0].clientHeight; |
||||||
|
} else if (logs.bottomChanged > 0) { |
||||||
|
if (logs.topChanged < 0) { |
||||||
|
scrollTop -= snapshot.firstHeight; |
||||||
|
} else if (logs.endBottom && this.atBottom()) { |
||||||
|
scrollTop = container.scrollHeight - container.clientHeight; |
||||||
|
} |
||||||
|
} |
||||||
|
container.scrollTop = scrollTop; |
||||||
|
this.setState({requestAllowed: true}); |
||||||
|
}; |
||||||
|
|
||||||
|
render() { |
||||||
|
return ( |
||||||
|
<div ref={(ref) => { this.content = ref; }}> |
||||||
|
<List> |
||||||
|
{this.props.content.logs.chunks.map((c, index) => ( |
||||||
|
<ListItem style={styles.logListItem} key={index}> |
||||||
|
<div style={styles.logChunk} dangerouslySetInnerHTML={{__html: c.content}} /> |
||||||
|
</ListItem> |
||||||
|
))} |
||||||
|
</List> |
||||||
|
</div> |
||||||
|
); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
export default Logs; |
||||||
@ -0,0 +1,288 @@ |
|||||||
|
// Copyright 2018 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 dashboard |
||||||
|
|
||||||
|
import ( |
||||||
|
"bytes" |
||||||
|
"encoding/json" |
||||||
|
"io/ioutil" |
||||||
|
"os" |
||||||
|
"path/filepath" |
||||||
|
"regexp" |
||||||
|
"sort" |
||||||
|
"time" |
||||||
|
|
||||||
|
"github.com/ethereum/go-ethereum/log" |
||||||
|
"github.com/mohae/deepcopy" |
||||||
|
"github.com/rjeczalik/notify" |
||||||
|
) |
||||||
|
|
||||||
|
var emptyChunk = json.RawMessage("[]") |
||||||
|
|
||||||
|
// prepLogs creates a JSON array from the given log record buffer.
|
||||||
|
// Returns the prepared array and the position of the last '\n'
|
||||||
|
// character in the original buffer, or -1 if it doesn't contain any.
|
||||||
|
func prepLogs(buf []byte) (json.RawMessage, int) { |
||||||
|
b := make(json.RawMessage, 1, len(buf)+1) |
||||||
|
b[0] = '[' |
||||||
|
b = append(b, buf...) |
||||||
|
last := -1 |
||||||
|
for i := 1; i < len(b); i++ { |
||||||
|
if b[i] == '\n' { |
||||||
|
b[i] = ',' |
||||||
|
last = i |
||||||
|
} |
||||||
|
} |
||||||
|
if last < 0 { |
||||||
|
return emptyChunk, -1 |
||||||
|
} |
||||||
|
b[last] = ']' |
||||||
|
return b[:last+1], last - 1 |
||||||
|
} |
||||||
|
|
||||||
|
// handleLogRequest searches for the log file specified by the timestamp of the
|
||||||
|
// request, creates a JSON array out of it and sends it to the requesting client.
|
||||||
|
func (db *Dashboard) handleLogRequest(r *LogsRequest, c *client) { |
||||||
|
files, err := ioutil.ReadDir(db.logdir) |
||||||
|
if err != nil { |
||||||
|
log.Warn("Failed to open logdir", "path", db.logdir, "err", err) |
||||||
|
return |
||||||
|
} |
||||||
|
re := regexp.MustCompile(`\.log$`) |
||||||
|
fileNames := make([]string, 0, len(files)) |
||||||
|
for _, f := range files { |
||||||
|
if f.Mode().IsRegular() && re.MatchString(f.Name()) { |
||||||
|
fileNames = append(fileNames, f.Name()) |
||||||
|
} |
||||||
|
} |
||||||
|
if len(fileNames) < 1 { |
||||||
|
log.Warn("No log files in logdir", "path", db.logdir) |
||||||
|
return |
||||||
|
} |
||||||
|
idx := sort.Search(len(fileNames), func(idx int) bool { |
||||||
|
// Returns the smallest index such as fileNames[idx] >= r.Name,
|
||||||
|
// if there is no such index, returns n.
|
||||||
|
return fileNames[idx] >= r.Name |
||||||
|
}) |
||||||
|
|
||||||
|
switch { |
||||||
|
case idx < 0: |
||||||
|
return |
||||||
|
case idx == 0 && r.Past: |
||||||
|
return |
||||||
|
case idx >= len(fileNames): |
||||||
|
return |
||||||
|
case r.Past: |
||||||
|
idx-- |
||||||
|
case idx == len(fileNames)-1 && fileNames[idx] == r.Name: |
||||||
|
return |
||||||
|
case idx == len(fileNames)-1 || (idx == len(fileNames)-2 && fileNames[idx] == r.Name): |
||||||
|
// The last file is continuously updated, and its chunks are streamed,
|
||||||
|
// so in order to avoid log record duplication on the client side, it is
|
||||||
|
// handled differently. Its actual content is always saved in the history.
|
||||||
|
db.lock.Lock() |
||||||
|
if db.history.Logs != nil { |
||||||
|
c.msg <- &Message{ |
||||||
|
Logs: db.history.Logs, |
||||||
|
} |
||||||
|
} |
||||||
|
db.lock.Unlock() |
||||||
|
return |
||||||
|
case fileNames[idx] == r.Name: |
||||||
|
idx++ |
||||||
|
} |
||||||
|
|
||||||
|
path := filepath.Join(db.logdir, fileNames[idx]) |
||||||
|
var buf []byte |
||||||
|
if buf, err = ioutil.ReadFile(path); err != nil { |
||||||
|
log.Warn("Failed to read file", "path", path, "err", err) |
||||||
|
return |
||||||
|
} |
||||||
|
chunk, end := prepLogs(buf) |
||||||
|
if end < 0 { |
||||||
|
log.Warn("The file doesn't contain valid logs", "path", path) |
||||||
|
return |
||||||
|
} |
||||||
|
c.msg <- &Message{ |
||||||
|
Logs: &LogsMessage{ |
||||||
|
Source: &LogFile{ |
||||||
|
Name: fileNames[idx], |
||||||
|
Last: r.Past && idx == 0, |
||||||
|
}, |
||||||
|
Chunk: chunk, |
||||||
|
}, |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// streamLogs watches the file system, and when the logger writes
|
||||||
|
// the new log records into the files, picks them up, then makes
|
||||||
|
// JSON array out of them and sends them to the clients.
|
||||||
|
func (db *Dashboard) streamLogs() { |
||||||
|
defer db.wg.Done() |
||||||
|
var ( |
||||||
|
err error |
||||||
|
errc chan error |
||||||
|
) |
||||||
|
defer func() { |
||||||
|
if errc == nil { |
||||||
|
errc = <-db.quit |
||||||
|
} |
||||||
|
errc <- err |
||||||
|
}() |
||||||
|
|
||||||
|
files, err := ioutil.ReadDir(db.logdir) |
||||||
|
if err != nil { |
||||||
|
log.Warn("Failed to open logdir", "path", db.logdir, "err", err) |
||||||
|
return |
||||||
|
} |
||||||
|
var ( |
||||||
|
opened *os.File // File descriptor for the opened active log file.
|
||||||
|
buf []byte // Contains the recently written log chunks, which are not sent to the clients yet.
|
||||||
|
) |
||||||
|
|
||||||
|
// The log records are always written into the last file in alphabetical order, because of the timestamp.
|
||||||
|
re := regexp.MustCompile(`\.log$`) |
||||||
|
i := len(files) - 1 |
||||||
|
for i >= 0 && (!files[i].Mode().IsRegular() || !re.MatchString(files[i].Name())) { |
||||||
|
i-- |
||||||
|
} |
||||||
|
if i < 0 { |
||||||
|
log.Warn("No log files in logdir", "path", db.logdir) |
||||||
|
return |
||||||
|
} |
||||||
|
if opened, err = os.OpenFile(filepath.Join(db.logdir, files[i].Name()), os.O_RDONLY, 0600); err != nil { |
||||||
|
log.Warn("Failed to open file", "name", files[i].Name(), "err", err) |
||||||
|
return |
||||||
|
} |
||||||
|
defer opened.Close() // Close the lastly opened file.
|
||||||
|
fi, err := opened.Stat() |
||||||
|
if err != nil { |
||||||
|
log.Warn("Problem with file", "name", opened.Name(), "err", err) |
||||||
|
return |
||||||
|
} |
||||||
|
db.lock.Lock() |
||||||
|
db.history.Logs = &LogsMessage{ |
||||||
|
Source: &LogFile{ |
||||||
|
Name: fi.Name(), |
||||||
|
Last: true, |
||||||
|
}, |
||||||
|
Chunk: emptyChunk, |
||||||
|
} |
||||||
|
db.lock.Unlock() |
||||||
|
|
||||||
|
watcher := make(chan notify.EventInfo, 10) |
||||||
|
if err := notify.Watch(db.logdir, watcher, notify.Create); err != nil { |
||||||
|
log.Warn("Failed to create file system watcher", "err", err) |
||||||
|
return |
||||||
|
} |
||||||
|
defer notify.Stop(watcher) |
||||||
|
|
||||||
|
ticker := time.NewTicker(db.config.Refresh) |
||||||
|
defer ticker.Stop() |
||||||
|
|
||||||
|
loop: |
||||||
|
for err == nil || errc == nil { |
||||||
|
select { |
||||||
|
case event := <-watcher: |
||||||
|
// Make sure that new log file was created.
|
||||||
|
if !re.Match([]byte(event.Path())) { |
||||||
|
break |
||||||
|
} |
||||||
|
if opened == nil { |
||||||
|
log.Warn("The last log file is not opened") |
||||||
|
break loop |
||||||
|
} |
||||||
|
// The new log file's name is always greater,
|
||||||
|
// because it is created using the actual log record's time.
|
||||||
|
if opened.Name() >= event.Path() { |
||||||
|
break |
||||||
|
} |
||||||
|
// Read the rest of the previously opened file.
|
||||||
|
chunk, err := ioutil.ReadAll(opened) |
||||||
|
if err != nil { |
||||||
|
log.Warn("Failed to read file", "name", opened.Name(), "err", err) |
||||||
|
break loop |
||||||
|
} |
||||||
|
buf = append(buf, chunk...) |
||||||
|
opened.Close() |
||||||
|
|
||||||
|
if chunk, last := prepLogs(buf); last >= 0 { |
||||||
|
// Send the rest of the previously opened file.
|
||||||
|
db.sendToAll(&Message{ |
||||||
|
Logs: &LogsMessage{ |
||||||
|
Chunk: chunk, |
||||||
|
}, |
||||||
|
}) |
||||||
|
} |
||||||
|
if opened, err = os.OpenFile(event.Path(), os.O_RDONLY, 0644); err != nil { |
||||||
|
log.Warn("Failed to open file", "name", event.Path(), "err", err) |
||||||
|
break loop |
||||||
|
} |
||||||
|
buf = buf[:0] |
||||||
|
|
||||||
|
// Change the last file in the history.
|
||||||
|
fi, err := opened.Stat() |
||||||
|
if err != nil { |
||||||
|
log.Warn("Problem with file", "name", opened.Name(), "err", err) |
||||||
|
break loop |
||||||
|
} |
||||||
|
db.lock.Lock() |
||||||
|
db.history.Logs.Source.Name = fi.Name() |
||||||
|
db.history.Logs.Chunk = emptyChunk |
||||||
|
db.lock.Unlock() |
||||||
|
case <-ticker.C: // Send log updates to the client.
|
||||||
|
if opened == nil { |
||||||
|
log.Warn("The last log file is not opened") |
||||||
|
break loop |
||||||
|
} |
||||||
|
// Read the new logs created since the last read.
|
||||||
|
chunk, err := ioutil.ReadAll(opened) |
||||||
|
if err != nil { |
||||||
|
log.Warn("Failed to read file", "name", opened.Name(), "err", err) |
||||||
|
break loop |
||||||
|
} |
||||||
|
b := append(buf, chunk...) |
||||||
|
|
||||||
|
chunk, last := prepLogs(b) |
||||||
|
if last < 0 { |
||||||
|
break |
||||||
|
} |
||||||
|
// Only keep the invalid part of the buffer, which can be valid after the next read.
|
||||||
|
buf = b[last+1:] |
||||||
|
|
||||||
|
var l *LogsMessage |
||||||
|
// Update the history.
|
||||||
|
db.lock.Lock() |
||||||
|
if bytes.Equal(db.history.Logs.Chunk, emptyChunk) { |
||||||
|
db.history.Logs.Chunk = chunk |
||||||
|
l = deepcopy.Copy(db.history.Logs).(*LogsMessage) |
||||||
|
} else { |
||||||
|
b = make([]byte, len(db.history.Logs.Chunk)+len(chunk)-1) |
||||||
|
copy(b, db.history.Logs.Chunk) |
||||||
|
b[len(db.history.Logs.Chunk)-1] = ',' |
||||||
|
copy(b[len(db.history.Logs.Chunk):], chunk[1:]) |
||||||
|
db.history.Logs.Chunk = b |
||||||
|
l = &LogsMessage{Chunk: chunk} |
||||||
|
} |
||||||
|
db.lock.Unlock() |
||||||
|
|
||||||
|
db.sendToAll(&Message{Logs: l}) |
||||||
|
case errc = <-db.quit: |
||||||
|
break loop |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,21 @@ |
|||||||
|
The MIT License (MIT) |
||||||
|
|
||||||
|
Copyright (c) 2014 Joel |
||||||
|
|
||||||
|
Permission is hereby granted, free of charge, to any person obtaining a copy |
||||||
|
of this software and associated documentation files (the "Software"), to deal |
||||||
|
in the Software without restriction, including without limitation the rights |
||||||
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
||||||
|
copies of the Software, and to permit persons to whom the Software is |
||||||
|
furnished to do so, subject to the following conditions: |
||||||
|
|
||||||
|
The above copyright notice and this permission notice shall be included in all |
||||||
|
copies or substantial portions of the Software. |
||||||
|
|
||||||
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
||||||
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||||||
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
||||||
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
||||||
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
||||||
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
||||||
|
SOFTWARE. |
||||||
@ -0,0 +1,8 @@ |
|||||||
|
deepCopy |
||||||
|
======== |
||||||
|
[](https://godoc.org/github.com/mohae/deepcopy)[](https://travis-ci.org/mohae/deepcopy) |
||||||
|
|
||||||
|
DeepCopy makes deep copies of things: unexported field values are not copied. |
||||||
|
|
||||||
|
## Usage |
||||||
|
cpy := deepcopy.Copy(orig) |
||||||
@ -0,0 +1,125 @@ |
|||||||
|
// deepcopy makes deep copies of things. A standard copy will copy the
|
||||||
|
// pointers: deep copy copies the values pointed to. Unexported field
|
||||||
|
// values are not copied.
|
||||||
|
//
|
||||||
|
// Copyright (c)2014-2016, Joel Scoble (github.com/mohae), all rights reserved.
|
||||||
|
// License: MIT, for more details check the included LICENSE file.
|
||||||
|
package deepcopy |
||||||
|
|
||||||
|
import ( |
||||||
|
"reflect" |
||||||
|
"time" |
||||||
|
) |
||||||
|
|
||||||
|
// Interface for delegating copy process to type
|
||||||
|
type Interface interface { |
||||||
|
DeepCopy() interface{} |
||||||
|
} |
||||||
|
|
||||||
|
// Iface is an alias to Copy; this exists for backwards compatibility reasons.
|
||||||
|
func Iface(iface interface{}) interface{} { |
||||||
|
return Copy(iface) |
||||||
|
} |
||||||
|
|
||||||
|
// Copy creates a deep copy of whatever is passed to it and returns the copy
|
||||||
|
// in an interface{}. The returned value will need to be asserted to the
|
||||||
|
// correct type.
|
||||||
|
func Copy(src interface{}) interface{} { |
||||||
|
if src == nil { |
||||||
|
return nil |
||||||
|
} |
||||||
|
|
||||||
|
// Make the interface a reflect.Value
|
||||||
|
original := reflect.ValueOf(src) |
||||||
|
|
||||||
|
// Make a copy of the same type as the original.
|
||||||
|
cpy := reflect.New(original.Type()).Elem() |
||||||
|
|
||||||
|
// Recursively copy the original.
|
||||||
|
copyRecursive(original, cpy) |
||||||
|
|
||||||
|
// Return the copy as an interface.
|
||||||
|
return cpy.Interface() |
||||||
|
} |
||||||
|
|
||||||
|
// copyRecursive does the actual copying of the interface. It currently has
|
||||||
|
// limited support for what it can handle. Add as needed.
|
||||||
|
func copyRecursive(original, cpy reflect.Value) { |
||||||
|
// check for implement deepcopy.Interface
|
||||||
|
if original.CanInterface() { |
||||||
|
if copier, ok := original.Interface().(Interface); ok { |
||||||
|
cpy.Set(reflect.ValueOf(copier.DeepCopy())) |
||||||
|
return |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// handle according to original's Kind
|
||||||
|
switch original.Kind() { |
||||||
|
case reflect.Ptr: |
||||||
|
// Get the actual value being pointed to.
|
||||||
|
originalValue := original.Elem() |
||||||
|
|
||||||
|
// if it isn't valid, return.
|
||||||
|
if !originalValue.IsValid() { |
||||||
|
return |
||||||
|
} |
||||||
|
cpy.Set(reflect.New(originalValue.Type())) |
||||||
|
copyRecursive(originalValue, cpy.Elem()) |
||||||
|
|
||||||
|
case reflect.Interface: |
||||||
|
// If this is a nil, don't do anything
|
||||||
|
if original.IsNil() { |
||||||
|
return |
||||||
|
} |
||||||
|
// Get the value for the interface, not the pointer.
|
||||||
|
originalValue := original.Elem() |
||||||
|
|
||||||
|
// Get the value by calling Elem().
|
||||||
|
copyValue := reflect.New(originalValue.Type()).Elem() |
||||||
|
copyRecursive(originalValue, copyValue) |
||||||
|
cpy.Set(copyValue) |
||||||
|
|
||||||
|
case reflect.Struct: |
||||||
|
t, ok := original.Interface().(time.Time) |
||||||
|
if ok { |
||||||
|
cpy.Set(reflect.ValueOf(t)) |
||||||
|
return |
||||||
|
} |
||||||
|
// Go through each field of the struct and copy it.
|
||||||
|
for i := 0; i < original.NumField(); i++ { |
||||||
|
// The Type's StructField for a given field is checked to see if StructField.PkgPath
|
||||||
|
// is set to determine if the field is exported or not because CanSet() returns false
|
||||||
|
// for settable fields. I'm not sure why. -mohae
|
||||||
|
if original.Type().Field(i).PkgPath != "" { |
||||||
|
continue |
||||||
|
} |
||||||
|
copyRecursive(original.Field(i), cpy.Field(i)) |
||||||
|
} |
||||||
|
|
||||||
|
case reflect.Slice: |
||||||
|
if original.IsNil() { |
||||||
|
return |
||||||
|
} |
||||||
|
// Make a new slice and copy each element.
|
||||||
|
cpy.Set(reflect.MakeSlice(original.Type(), original.Len(), original.Cap())) |
||||||
|
for i := 0; i < original.Len(); i++ { |
||||||
|
copyRecursive(original.Index(i), cpy.Index(i)) |
||||||
|
} |
||||||
|
|
||||||
|
case reflect.Map: |
||||||
|
if original.IsNil() { |
||||||
|
return |
||||||
|
} |
||||||
|
cpy.Set(reflect.MakeMap(original.Type())) |
||||||
|
for _, key := range original.MapKeys() { |
||||||
|
originalValue := original.MapIndex(key) |
||||||
|
copyValue := reflect.New(originalValue.Type()).Elem() |
||||||
|
copyRecursive(originalValue, copyValue) |
||||||
|
copyKey := Copy(key.Interface()) |
||||||
|
cpy.SetMapIndex(reflect.ValueOf(copyKey), copyValue) |
||||||
|
} |
||||||
|
|
||||||
|
default: |
||||||
|
cpy.Set(original) |
||||||
|
} |
||||||
|
} |
||||||
Loading…
Reference in new issue