forked from mirror/go-ethereum
Péter Szilágyi
6 years ago
parent
36f81118f6
commit
29bc982d75
@ -1,351 +0,0 @@ |
||||
// Copyright 2015 The go-ethereum Authors
|
||||
// This file is part of go-ethereum.
|
||||
//
|
||||
// go-ethereum is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// go-ethereum 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 General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
package main |
||||
|
||||
import ( |
||||
"fmt" |
||||
"math" |
||||
"reflect" |
||||
"runtime" |
||||
"sort" |
||||
"strings" |
||||
"time" |
||||
|
||||
"github.com/ethereum/go-ethereum/cmd/utils" |
||||
"github.com/ethereum/go-ethereum/node" |
||||
"github.com/ethereum/go-ethereum/rpc" |
||||
"github.com/gizak/termui" |
||||
"gopkg.in/urfave/cli.v1" |
||||
) |
||||
|
||||
var ( |
||||
monitorCommandAttachFlag = cli.StringFlag{ |
||||
Name: "attach", |
||||
Value: node.DefaultIPCEndpoint(clientIdentifier), |
||||
Usage: "API endpoint to attach to", |
||||
} |
||||
monitorCommandRowsFlag = cli.IntFlag{ |
||||
Name: "rows", |
||||
Value: 5, |
||||
Usage: "Maximum rows in the chart grid", |
||||
} |
||||
monitorCommandRefreshFlag = cli.IntFlag{ |
||||
Name: "refresh", |
||||
Value: 3, |
||||
Usage: "Refresh interval in seconds", |
||||
} |
||||
monitorCommand = cli.Command{ |
||||
Action: utils.MigrateFlags(monitor), // keep track of migration progress
|
||||
Name: "monitor", |
||||
Usage: "Monitor and visualize node metrics", |
||||
ArgsUsage: " ", |
||||
Category: "MONITOR COMMANDS", |
||||
Description: ` |
||||
The Geth monitor is a tool to collect and visualize various internal metrics |
||||
gathered by the node, supporting different chart types as well as the capacity |
||||
to display multiple metrics simultaneously. |
||||
`, |
||||
Flags: []cli.Flag{ |
||||
monitorCommandAttachFlag, |
||||
monitorCommandRowsFlag, |
||||
monitorCommandRefreshFlag, |
||||
}, |
||||
} |
||||
) |
||||
|
||||
// monitor starts a terminal UI based monitoring tool for the requested metrics.
|
||||
func monitor(ctx *cli.Context) error { |
||||
var ( |
||||
client *rpc.Client |
||||
err error |
||||
) |
||||
// Attach to an Ethereum node over IPC or RPC
|
||||
endpoint := ctx.String(monitorCommandAttachFlag.Name) |
||||
if client, err = dialRPC(endpoint); err != nil { |
||||
utils.Fatalf("Unable to attach to geth node: %v", err) |
||||
} |
||||
defer client.Close() |
||||
|
||||
// Retrieve all the available metrics and resolve the user pattens
|
||||
metrics, err := retrieveMetrics(client) |
||||
if err != nil { |
||||
utils.Fatalf("Failed to retrieve system metrics: %v", err) |
||||
} |
||||
monitored := resolveMetrics(metrics, ctx.Args()) |
||||
if len(monitored) == 0 { |
||||
list := expandMetrics(metrics, "") |
||||
sort.Strings(list) |
||||
|
||||
if len(list) > 0 { |
||||
utils.Fatalf("No metrics specified.\n\nAvailable:\n - %s", strings.Join(list, "\n - ")) |
||||
} else { |
||||
utils.Fatalf("No metrics collected by geth (--%s).\n", utils.MetricsEnabledFlag.Name) |
||||
} |
||||
} |
||||
sort.Strings(monitored) |
||||
if cols := len(monitored) / ctx.Int(monitorCommandRowsFlag.Name); cols > 6 { |
||||
utils.Fatalf("Requested metrics (%d) spans more that 6 columns:\n - %s", len(monitored), strings.Join(monitored, "\n - ")) |
||||
} |
||||
// Create and configure the chart UI defaults
|
||||
if err := termui.Init(); err != nil { |
||||
utils.Fatalf("Unable to initialize terminal UI: %v", err) |
||||
} |
||||
defer termui.Close() |
||||
|
||||
rows := len(monitored) |
||||
if max := ctx.Int(monitorCommandRowsFlag.Name); rows > max { |
||||
rows = max |
||||
} |
||||
cols := (len(monitored) + rows - 1) / rows |
||||
for i := 0; i < rows; i++ { |
||||
termui.Body.AddRows(termui.NewRow()) |
||||
} |
||||
// Create each individual data chart
|
||||
footer := termui.NewPar("") |
||||
footer.Block.Border = true |
||||
footer.Height = 3 |
||||
|
||||
charts := make([]*termui.LineChart, len(monitored)) |
||||
units := make([]int, len(monitored)) |
||||
data := make([][]float64, len(monitored)) |
||||
for i := 0; i < len(monitored); i++ { |
||||
charts[i] = createChart((termui.TermHeight() - footer.Height) / rows) |
||||
row := termui.Body.Rows[i%rows] |
||||
row.Cols = append(row.Cols, termui.NewCol(12/cols, 0, charts[i])) |
||||
} |
||||
termui.Body.AddRows(termui.NewRow(termui.NewCol(12, 0, footer))) |
||||
|
||||
refreshCharts(client, monitored, data, units, charts, ctx, footer) |
||||
termui.Body.Align() |
||||
termui.Render(termui.Body) |
||||
|
||||
// Watch for various system events, and periodically refresh the charts
|
||||
termui.Handle("/sys/kbd/C-c", func(termui.Event) { |
||||
termui.StopLoop() |
||||
}) |
||||
termui.Handle("/sys/wnd/resize", func(termui.Event) { |
||||
termui.Body.Width = termui.TermWidth() |
||||
for _, chart := range charts { |
||||
chart.Height = (termui.TermHeight() - footer.Height) / rows |
||||
} |
||||
termui.Body.Align() |
||||
termui.Render(termui.Body) |
||||
}) |
||||
go func() { |
||||
tick := time.NewTicker(time.Duration(ctx.Int(monitorCommandRefreshFlag.Name)) * time.Second) |
||||
for range tick.C { |
||||
if refreshCharts(client, monitored, data, units, charts, ctx, footer) { |
||||
termui.Body.Align() |
||||
} |
||||
termui.Render(termui.Body) |
||||
} |
||||
}() |
||||
termui.Loop() |
||||
return nil |
||||
} |
||||
|
||||
// retrieveMetrics contacts the attached geth node and retrieves the entire set
|
||||
// of collected system metrics.
|
||||
func retrieveMetrics(client *rpc.Client) (map[string]interface{}, error) { |
||||
var metrics map[string]interface{} |
||||
err := client.Call(&metrics, "debug_metrics", true) |
||||
return metrics, err |
||||
} |
||||
|
||||
// resolveMetrics takes a list of input metric patterns, and resolves each to one
|
||||
// or more canonical metric names.
|
||||
func resolveMetrics(metrics map[string]interface{}, patterns []string) []string { |
||||
var res []string |
||||
for _, pattern := range patterns { |
||||
res = append(res, resolveMetric(metrics, pattern, "")...) |
||||
} |
||||
return res |
||||
} |
||||
|
||||
// resolveMetrics takes a single of input metric pattern, and resolves it to one
|
||||
// or more canonical metric names.
|
||||
func resolveMetric(metrics map[string]interface{}, pattern string, path string) []string { |
||||
var results []string |
||||
|
||||
// If a nested metric was requested, recurse optionally branching (via comma)
|
||||
parts := strings.SplitN(pattern, "/", 2) |
||||
if len(parts) > 1 { |
||||
for _, variation := range strings.Split(parts[0], ",") { |
||||
submetrics, ok := metrics[variation].(map[string]interface{}) |
||||
if !ok { |
||||
utils.Fatalf("Failed to retrieve system metrics: %s", path+variation) |
||||
return nil |
||||
} |
||||
results = append(results, resolveMetric(submetrics, parts[1], path+variation+"/")...) |
||||
} |
||||
return results |
||||
} |
||||
// Depending what the last link is, return or expand
|
||||
for _, variation := range strings.Split(pattern, ",") { |
||||
switch metric := metrics[variation].(type) { |
||||
case float64: |
||||
// Final metric value found, return as singleton
|
||||
results = append(results, path+variation) |
||||
|
||||
case map[string]interface{}: |
||||
results = append(results, expandMetrics(metric, path+variation+"/")...) |
||||
|
||||
default: |
||||
utils.Fatalf("Metric pattern resolved to unexpected type: %v", reflect.TypeOf(metric)) |
||||
return nil |
||||
} |
||||
} |
||||
return results |
||||
} |
||||
|
||||
// expandMetrics expands the entire tree of metrics into a flat list of paths.
|
||||
func expandMetrics(metrics map[string]interface{}, path string) []string { |
||||
// Iterate over all fields and expand individually
|
||||
var list []string |
||||
for name, metric := range metrics { |
||||
switch metric := metric.(type) { |
||||
case float64: |
||||
// Final metric value found, append to list
|
||||
list = append(list, path+name) |
||||
|
||||
case map[string]interface{}: |
||||
// Tree of metrics found, expand recursively
|
||||
list = append(list, expandMetrics(metric, path+name+"/")...) |
||||
|
||||
default: |
||||
utils.Fatalf("Metric pattern %s resolved to unexpected type: %v", path+name, reflect.TypeOf(metric)) |
||||
return nil |
||||
} |
||||
} |
||||
return list |
||||
} |
||||
|
||||
// fetchMetric iterates over the metrics map and retrieves a specific one.
|
||||
func fetchMetric(metrics map[string]interface{}, metric string) float64 { |
||||
parts := strings.Split(metric, "/") |
||||
for _, part := range parts[:len(parts)-1] { |
||||
var found bool |
||||
metrics, found = metrics[part].(map[string]interface{}) |
||||
if !found { |
||||
return 0 |
||||
} |
||||
} |
||||
if v, ok := metrics[parts[len(parts)-1]].(float64); ok { |
||||
return v |
||||
} |
||||
return 0 |
||||
} |
||||
|
||||
// refreshCharts retrieves a next batch of metrics, and inserts all the new
|
||||
// values into the active datasets and charts
|
||||
func refreshCharts(client *rpc.Client, metrics []string, data [][]float64, units []int, charts []*termui.LineChart, ctx *cli.Context, footer *termui.Par) (realign bool) { |
||||
values, err := retrieveMetrics(client) |
||||
for i, metric := range metrics { |
||||
if len(data) < 512 { |
||||
data[i] = append([]float64{fetchMetric(values, metric)}, data[i]...) |
||||
} else { |
||||
data[i] = append([]float64{fetchMetric(values, metric)}, data[i][:len(data[i])-1]...) |
||||
} |
||||
if updateChart(metric, data[i], &units[i], charts[i], err) { |
||||
realign = true |
||||
} |
||||
} |
||||
updateFooter(ctx, err, footer) |
||||
return |
||||
} |
||||
|
||||
// updateChart inserts a dataset into a line chart, scaling appropriately as to
|
||||
// not display weird labels, also updating the chart label accordingly.
|
||||
func updateChart(metric string, data []float64, base *int, chart *termui.LineChart, err error) (realign bool) { |
||||
dataUnits := []string{"", "K", "M", "G", "T", "E"} |
||||
timeUnits := []string{"ns", "µs", "ms", "s", "ks", "ms"} |
||||
colors := []termui.Attribute{termui.ColorBlue, termui.ColorCyan, termui.ColorGreen, termui.ColorYellow, termui.ColorRed, termui.ColorRed} |
||||
|
||||
// Extract only part of the data that's actually visible
|
||||
if chart.Width*2 < len(data) { |
||||
data = data[:chart.Width*2] |
||||
} |
||||
// Find the maximum value and scale under 1K
|
||||
high := 0.0 |
||||
if len(data) > 0 { |
||||
high = data[0] |
||||
for _, value := range data[1:] { |
||||
high = math.Max(high, value) |
||||
} |
||||
} |
||||
unit, scale := 0, 1.0 |
||||
for high >= 1000 && unit+1 < len(dataUnits) { |
||||
high, unit, scale = high/1000, unit+1, scale*1000 |
||||
} |
||||
// If the unit changes, re-create the chart (hack to set max height...)
|
||||
if unit != *base { |
||||
realign, *base, *chart = true, unit, *createChart(chart.Height) |
||||
} |
||||
// Update the chart's data points with the scaled values
|
||||
if cap(chart.Data) < len(data) { |
||||
chart.Data = make([]float64, len(data)) |
||||
} |
||||
chart.Data = chart.Data[:len(data)] |
||||
for i, value := range data { |
||||
chart.Data[i] = value / scale |
||||
} |
||||
// Update the chart's label with the scale units
|
||||
units := dataUnits |
||||
if strings.Contains(metric, "/Percentiles/") || strings.Contains(metric, "/pauses/") || strings.Contains(metric, "/time/") { |
||||
units = timeUnits |
||||
} |
||||
chart.BorderLabel = metric |
||||
if len(units[unit]) > 0 { |
||||
chart.BorderLabel += " [" + units[unit] + "]" |
||||
} |
||||
chart.LineColor = colors[unit] | termui.AttrBold |
||||
if err != nil { |
||||
chart.LineColor = termui.ColorRed | termui.AttrBold |
||||
} |
||||
return |
||||
} |
||||
|
||||
// createChart creates an empty line chart with the default configs.
|
||||
func createChart(height int) *termui.LineChart { |
||||
chart := termui.NewLineChart() |
||||
if runtime.GOOS == "windows" { |
||||
chart.Mode = "dot" |
||||
} |
||||
chart.DataLabels = []string{""} |
||||
chart.Height = height |
||||
chart.AxesColor = termui.ColorWhite |
||||
chart.PaddingBottom = -2 |
||||
|
||||
chart.BorderLabelFg = chart.BorderFg | termui.AttrBold |
||||
chart.BorderFg = chart.BorderBg |
||||
|
||||
return chart |
||||
} |
||||
|
||||
// updateFooter updates the footer contents based on any encountered errors.
|
||||
func updateFooter(ctx *cli.Context, err error, footer *termui.Par) { |
||||
// Generate the basic footer
|
||||
refresh := time.Duration(ctx.Int(monitorCommandRefreshFlag.Name)) * time.Second |
||||
footer.Text = fmt.Sprintf("Press Ctrl+C to quit. Refresh interval: %v.", refresh) |
||||
footer.TextFgColor = termui.ThemeAttr("par.fg") | termui.AttrBold |
||||
|
||||
// Append any encountered errors
|
||||
if err != nil { |
||||
footer.Text = fmt.Sprintf("Error: %v.", err) |
||||
footer.TextFgColor = termui.ColorRed | termui.AttrBold |
||||
} |
||||
} |
||||
@ -1,8 +0,0 @@ |
||||
Copyright (c) 2012 Dave Grijalva |
||||
|
||||
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. |
||||
|
||||
@ -1,97 +0,0 @@ |
||||
## Migration Guide from v2 -> v3 |
||||
|
||||
Version 3 adds several new, frequently requested features. To do so, it introduces a few breaking changes. We've worked to keep these as minimal as possible. This guide explains the breaking changes and how you can quickly update your code. |
||||
|
||||
### `Token.Claims` is now an interface type |
||||
|
||||
The most requested feature from the 2.0 verison of this library was the ability to provide a custom type to the JSON parser for claims. This was implemented by introducing a new interface, `Claims`, to replace `map[string]interface{}`. We also included two concrete implementations of `Claims`: `MapClaims` and `StandardClaims`. |
||||
|
||||
`MapClaims` is an alias for `map[string]interface{}` with built in validation behavior. It is the default claims type when using `Parse`. The usage is unchanged except you must type cast the claims property. |
||||
|
||||
The old example for parsing a token looked like this.. |
||||
|
||||
```go |
||||
if token, err := jwt.Parse(tokenString, keyLookupFunc); err == nil { |
||||
fmt.Printf("Token for user %v expires %v", token.Claims["user"], token.Claims["exp"]) |
||||
} |
||||
``` |
||||
|
||||
is now directly mapped to... |
||||
|
||||
```go |
||||
if token, err := jwt.Parse(tokenString, keyLookupFunc); err == nil { |
||||
claims := token.Claims.(jwt.MapClaims) |
||||
fmt.Printf("Token for user %v expires %v", claims["user"], claims["exp"]) |
||||
} |
||||
``` |
||||
|
||||
`StandardClaims` is designed to be embedded in your custom type. You can supply a custom claims type with the new `ParseWithClaims` function. Here's an example of using a custom claims type. |
||||
|
||||
```go |
||||
type MyCustomClaims struct { |
||||
User string |
||||
*StandardClaims |
||||
} |
||||
|
||||
if token, err := jwt.ParseWithClaims(tokenString, &MyCustomClaims{}, keyLookupFunc); err == nil { |
||||
claims := token.Claims.(*MyCustomClaims) |
||||
fmt.Printf("Token for user %v expires %v", claims.User, claims.StandardClaims.ExpiresAt) |
||||
} |
||||
``` |
||||
|
||||
### `ParseFromRequest` has been moved |
||||
|
||||
To keep this library focused on the tokens without becoming overburdened with complex request processing logic, `ParseFromRequest` and its new companion `ParseFromRequestWithClaims` have been moved to a subpackage, `request`. The method signatues have also been augmented to receive a new argument: `Extractor`. |
||||
|
||||
`Extractors` do the work of picking the token string out of a request. The interface is simple and composable. |
||||
|
||||
This simple parsing example: |
||||
|
||||
```go |
||||
if token, err := jwt.ParseFromRequest(tokenString, req, keyLookupFunc); err == nil { |
||||
fmt.Printf("Token for user %v expires %v", token.Claims["user"], token.Claims["exp"]) |
||||
} |
||||
``` |
||||
|
||||
is directly mapped to: |
||||
|
||||
```go |
||||
if token, err := request.ParseFromRequest(req, request.OAuth2Extractor, keyLookupFunc); err == nil { |
||||
claims := token.Claims.(jwt.MapClaims) |
||||
fmt.Printf("Token for user %v expires %v", claims["user"], claims["exp"]) |
||||
} |
||||
``` |
||||
|
||||
There are several concrete `Extractor` types provided for your convenience: |
||||
|
||||
* `HeaderExtractor` will search a list of headers until one contains content. |
||||
* `ArgumentExtractor` will search a list of keys in request query and form arguments until one contains content. |
||||
* `MultiExtractor` will try a list of `Extractors` in order until one returns content. |
||||
* `AuthorizationHeaderExtractor` will look in the `Authorization` header for a `Bearer` token. |
||||
* `OAuth2Extractor` searches the places an OAuth2 token would be specified (per the spec): `Authorization` header and `access_token` argument |
||||
* `PostExtractionFilter` wraps an `Extractor`, allowing you to process the content before it's parsed. A simple example is stripping the `Bearer ` text from a header |
||||
|
||||
|
||||
### RSA signing methods no longer accept `[]byte` keys |
||||
|
||||
Due to a [critical vulnerability](https://auth0.com/blog/2015/03/31/critical-vulnerabilities-in-json-web-token-libraries/), we've decided the convenience of accepting `[]byte` instead of `rsa.PublicKey` or `rsa.PrivateKey` isn't worth the risk of misuse. |
||||
|
||||
To replace this behavior, we've added two helper methods: `ParseRSAPrivateKeyFromPEM(key []byte) (*rsa.PrivateKey, error)` and `ParseRSAPublicKeyFromPEM(key []byte) (*rsa.PublicKey, error)`. These are just simple helpers for unpacking PEM encoded PKCS1 and PKCS8 keys. If your keys are encoded any other way, all you need to do is convert them to the `crypto/rsa` package's types. |
||||
|
||||
```go |
||||
func keyLookupFunc(*Token) (interface{}, error) { |
||||
// Don't forget to validate the alg is what you expect: |
||||
if _, ok := token.Method.(*jwt.SigningMethodRSA); !ok { |
||||
return nil, fmt.Errorf("Unexpected signing method: %v", token.Header["alg"]) |
||||
} |
||||
|
||||
// Look up key |
||||
key, err := lookupPublicKey(token.Header["kid"]) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
// Unpack key from PEM encoded PKCS8 |
||||
return jwt.ParseRSAPublicKeyFromPEM(key) |
||||
} |
||||
``` |
||||
@ -1,85 +0,0 @@ |
||||
A [go](http://www.golang.org) (or 'golang' for search engine friendliness) implementation of [JSON Web Tokens](http://self-issued.info/docs/draft-ietf-oauth-json-web-token.html) |
||||
|
||||
[](https://travis-ci.org/dgrijalva/jwt-go) |
||||
|
||||
**BREAKING CHANGES:*** Version 3.0.0 is here. It includes _a lot_ of changes including a few that break the API. We've tried to break as few things as possible, so there should just be a few type signature changes. A full list of breaking changes is available in `VERSION_HISTORY.md`. See `MIGRATION_GUIDE.md` for more information on updating your code. |
||||
|
||||
**NOTICE:** A vulnerability in JWT was [recently published](https://auth0.com/blog/2015/03/31/critical-vulnerabilities-in-json-web-token-libraries/). As this library doesn't force users to validate the `alg` is what they expected, it's possible your usage is effected. There will be an update soon to remedy this, and it will likey require backwards-incompatible changes to the API. In the short term, please make sure your implementation verifies the `alg` is what you expect. |
||||
|
||||
|
||||
## What the heck is a JWT? |
||||
|
||||
JWT.io has [a great introduction](https://jwt.io/introduction) to JSON Web Tokens. |
||||
|
||||
In short, it's a signed JSON object that does something useful (for example, authentication). It's commonly used for `Bearer` tokens in Oauth 2. A token is made of three parts, separated by `.`'s. The first two parts are JSON objects, that have been [base64url](http://tools.ietf.org/html/rfc4648) encoded. The last part is the signature, encoded the same way. |
||||
|
||||
The first part is called the header. It contains the necessary information for verifying the last part, the signature. For example, which encryption method was used for signing and what key was used. |
||||
|
||||
The part in the middle is the interesting bit. It's called the Claims and contains the actual stuff you care about. Refer to [the RFC](http://self-issued.info/docs/draft-jones-json-web-token.html) for information about reserved keys and the proper way to add your own. |
||||
|
||||
## What's in the box? |
||||
|
||||
This library supports the parsing and verification as well as the generation and signing of JWTs. Current supported signing algorithms are HMAC SHA, RSA, RSA-PSS, and ECDSA, though hooks are present for adding your own. |
||||
|
||||
## Examples |
||||
|
||||
See [the project documentation](https://godoc.org/github.com/dgrijalva/jwt-go) for examples of usage: |
||||
|
||||
* [Simple example of parsing and validating a token](https://godoc.org/github.com/dgrijalva/jwt-go#example-Parse--Hmac) |
||||
* [Simple example of building and signing a token](https://godoc.org/github.com/dgrijalva/jwt-go#example-New--Hmac) |
||||
* [Directory of Examples](https://godoc.org/github.com/dgrijalva/jwt-go#pkg-examples) |
||||
|
||||
## Extensions |
||||
|
||||
This library publishes all the necessary components for adding your own signing methods. Simply implement the `SigningMethod` interface and register a factory method using `RegisterSigningMethod`. |
||||
|
||||
Here's an example of an extension that integrates with the Google App Engine signing tools: https://github.com/someone1/gcp-jwt-go |
||||
|
||||
## Compliance |
||||
|
||||
This library was last reviewed to comply with [RTF 7519](http://www.rfc-editor.org/info/rfc7519) dated May 2015 with a few notable differences: |
||||
|
||||
* In order to protect against accidental use of [Unsecured JWTs](http://self-issued.info/docs/draft-ietf-oauth-json-web-token.html#UnsecuredJWT), tokens using `alg=none` will only be accepted if the constant `jwt.UnsafeAllowNoneSignatureType` is provided as the key. |
||||
|
||||
## Project Status & Versioning |
||||
|
||||
This library is considered production ready. Feedback and feature requests are appreciated. The API should be considered stable. There should be very few backwards-incompatible changes outside of major version updates (and only with good reason). |
||||
|
||||
This project uses [Semantic Versioning 2.0.0](http://semver.org). Accepted pull requests will land on `master`. Periodically, versions will be tagged from `master`. You can find all the releases on [the project releases page](https://github.com/dgrijalva/jwt-go/releases). |
||||
|
||||
While we try to make it obvious when we make breaking changes, there isn't a great mechanism for pushing announcements out to users. You may want to use this alternative package include: `gopkg.in/dgrijalva/jwt-go.v2`. It will do the right thing WRT semantic versioning. |
||||
|
||||
## Usage Tips |
||||
|
||||
### Signing vs Encryption |
||||
|
||||
A token is simply a JSON object that is signed by its author. this tells you exactly two things about the data: |
||||
|
||||
* The author of the token was in the possession of the signing secret |
||||
* The data has not been modified since it was signed |
||||
|
||||
It's important to know that JWT does not provide encryption, which means anyone who has access to the token can read its contents. If you need to protect (encrypt) the data, there is a companion spec, `JWE`, that provides this functionality. JWE is currently outside the scope of this library. |
||||
|
||||
### Choosing a Signing Method |
||||
|
||||
There are several signing methods available, and you should probably take the time to learn about the various options before choosing one. The principal design decision is most likely going to be symmetric vs asymmetric. |
||||
|
||||
Symmetric signing methods, such as HSA, use only a single secret. This is probably the simplest signing method to use since any `[]byte` can be used as a valid secret. They are also slightly computationally faster to use, though this rarely is enough to matter. Symmetric signing methods work the best when both producers and consumers of tokens are trusted, or even the same system. Since the same secret is used to both sign and validate tokens, you can't easily distribute the key for validation. |
||||
|
||||
Asymmetric signing methods, such as RSA, use different keys for signing and verifying tokens. This makes it possible to produce tokens with a private key, and allow any consumer to access the public key for verification. |
||||
|
||||
### JWT and OAuth |
||||
|
||||
It's worth mentioning that OAuth and JWT are not the same thing. A JWT token is simply a signed JSON object. It can be used anywhere such a thing is useful. There is some confusion, though, as JWT is the most common type of bearer token used in OAuth2 authentication. |
||||
|
||||
Without going too far down the rabbit hole, here's a description of the interaction of these technologies: |
||||
|
||||
* OAuth is a protocol for allowing an identity provider to be separate from the service a user is logging in to. For example, whenever you use Facebook to log into a different service (Yelp, Spotify, etc), you are using OAuth. |
||||
* OAuth defines several options for passing around authentication data. One popular method is called a "bearer token". A bearer token is simply a string that _should_ only be held by an authenticated user. Thus, simply presenting this token proves your identity. You can probably derive from here why a JWT might make a good bearer token. |
||||
* Because bearer tokens are used for authentication, it's important they're kept secret. This is why transactions that use bearer tokens typically happen over SSL. |
||||
|
||||
## More |
||||
|
||||
Documentation can be found [on godoc.org](http://godoc.org/github.com/dgrijalva/jwt-go). |
||||
|
||||
The command line utility included in this project (cmd/jwt) provides a straightforward example of token creation and parsing as well as a useful tool for debugging your own integration. You'll also find several implementation examples in to documentation. |
||||
@ -1,105 +0,0 @@ |
||||
## `jwt-go` Version History |
||||
|
||||
#### 3.0.0 |
||||
|
||||
* **Compatibility Breaking Changes**: See MIGRATION_GUIDE.md for tips on updating your code |
||||
* Dropped support for `[]byte` keys when using RSA signing methods. This convenience feature could contribute to security vulnerabilities involving mismatched key types with signing methods. |
||||
* `ParseFromRequest` has been moved to `request` subpackage and usage has changed |
||||
* The `Claims` property on `Token` is now type `Claims` instead of `map[string]interface{}`. The default value is type `MapClaims`, which is an alias to `map[string]interface{}`. This makes it possible to use a custom type when decoding claims. |
||||
* Other Additions and Changes |
||||
* Added `Claims` interface type to allow users to decode the claims into a custom type |
||||
* Added `ParseWithClaims`, which takes a third argument of type `Claims`. Use this function instead of `Parse` if you have a custom type you'd like to decode into. |
||||
* Dramatically improved the functionality and flexibility of `ParseFromRequest`, which is now in the `request` subpackage |
||||
* Added `ParseFromRequestWithClaims` which is the `FromRequest` equivalent of `ParseWithClaims` |
||||
* Added new interface type `Extractor`, which is used for extracting JWT strings from http requests. Used with `ParseFromRequest` and `ParseFromRequestWithClaims`. |
||||
* Added several new, more specific, validation errors to error type bitmask |
||||
* Moved examples from README to executable example files |
||||
* Signing method registry is now thread safe |
||||
* Added new property to `ValidationError`, which contains the raw error returned by calls made by parse/verify (such as those returned by keyfunc or json parser) |
||||
|
||||
#### 2.7.0 |
||||
|
||||
This will likely be the last backwards compatible release before 3.0.0, excluding essential bug fixes. |
||||
|
||||
* Added new option `-show` to the `jwt` command that will just output the decoded token without verifying |
||||
* Error text for expired tokens includes how long it's been expired |
||||
* Fixed incorrect error returned from `ParseRSAPublicKeyFromPEM` |
||||
* Documentation updates |
||||
|
||||
#### 2.6.0 |
||||
|
||||
* Exposed inner error within ValidationError |
||||
* Fixed validation errors when using UseJSONNumber flag |
||||
* Added several unit tests |
||||
|
||||
#### 2.5.0 |
||||
|
||||
* Added support for signing method none. You shouldn't use this. The API tries to make this clear. |
||||
* Updated/fixed some documentation |
||||
* Added more helpful error message when trying to parse tokens that begin with `BEARER ` |
||||
|
||||
#### 2.4.0 |
||||
|
||||
* Added new type, Parser, to allow for configuration of various parsing parameters |
||||
* You can now specify a list of valid signing methods. Anything outside this set will be rejected. |
||||
* You can now opt to use the `json.Number` type instead of `float64` when parsing token JSON |
||||
* Added support for [Travis CI](https://travis-ci.org/dgrijalva/jwt-go) |
||||
* Fixed some bugs with ECDSA parsing |
||||
|
||||
#### 2.3.0 |
||||
|
||||
* Added support for ECDSA signing methods |
||||
* Added support for RSA PSS signing methods (requires go v1.4) |
||||
|
||||
#### 2.2.0 |
||||
|
||||
* Gracefully handle a `nil` `Keyfunc` being passed to `Parse`. Result will now be the parsed token and an error, instead of a panic. |
||||
|
||||
#### 2.1.0 |
||||
|
||||
Backwards compatible API change that was missed in 2.0.0. |
||||
|
||||
* The `SignedString` method on `Token` now takes `interface{}` instead of `[]byte` |
||||
|
||||
#### 2.0.0 |
||||
|
||||
There were two major reasons for breaking backwards compatibility with this update. The first was a refactor required to expand the width of the RSA and HMAC-SHA signing implementations. There will likely be no required code changes to support this change. |
||||
|
||||
The second update, while unfortunately requiring a small change in integration, is required to open up this library to other signing methods. Not all keys used for all signing methods have a single standard on-disk representation. Requiring `[]byte` as the type for all keys proved too limiting. Additionally, this implementation allows for pre-parsed tokens to be reused, which might matter in an application that parses a high volume of tokens with a small set of keys. Backwards compatibilty has been maintained for passing `[]byte` to the RSA signing methods, but they will also accept `*rsa.PublicKey` and `*rsa.PrivateKey`. |
||||
|
||||
It is likely the only integration change required here will be to change `func(t *jwt.Token) ([]byte, error)` to `func(t *jwt.Token) (interface{}, error)` when calling `Parse`. |
||||
|
||||
* **Compatibility Breaking Changes** |
||||
* `SigningMethodHS256` is now `*SigningMethodHMAC` instead of `type struct` |
||||
* `SigningMethodRS256` is now `*SigningMethodRSA` instead of `type struct` |
||||
* `KeyFunc` now returns `interface{}` instead of `[]byte` |
||||
* `SigningMethod.Sign` now takes `interface{}` instead of `[]byte` for the key |
||||
* `SigningMethod.Verify` now takes `interface{}` instead of `[]byte` for the key |
||||
* Renamed type `SigningMethodHS256` to `SigningMethodHMAC`. Specific sizes are now just instances of this type. |
||||
* Added public package global `SigningMethodHS256` |
||||
* Added public package global `SigningMethodHS384` |
||||
* Added public package global `SigningMethodHS512` |
||||
* Renamed type `SigningMethodRS256` to `SigningMethodRSA`. Specific sizes are now just instances of this type. |
||||
* Added public package global `SigningMethodRS256` |
||||
* Added public package global `SigningMethodRS384` |
||||
* Added public package global `SigningMethodRS512` |
||||
* Moved sample private key for HMAC tests from an inline value to a file on disk. Value is unchanged. |
||||
* Refactored the RSA implementation to be easier to read |
||||
* Exposed helper methods `ParseRSAPrivateKeyFromPEM` and `ParseRSAPublicKeyFromPEM` |
||||
|
||||
#### 1.0.2 |
||||
|
||||
* Fixed bug in parsing public keys from certificates |
||||
* Added more tests around the parsing of keys for RS256 |
||||
* Code refactoring in RS256 implementation. No functional changes |
||||
|
||||
#### 1.0.1 |
||||
|
||||
* Fixed panic if RS256 signing method was passed an invalid key |
||||
|
||||
#### 1.0.0 |
||||
|
||||
* First versioned release |
||||
* API stabilized |
||||
* Supports creating, signing, parsing, and validating JWT tokens |
||||
* Supports RS256 and HS256 signing methods |
||||
@ -1,134 +0,0 @@ |
||||
package jwt |
||||
|
||||
import ( |
||||
"crypto/subtle" |
||||
"fmt" |
||||
"time" |
||||
) |
||||
|
||||
// For a type to be a Claims object, it must just have a Valid method that determines
|
||||
// if the token is invalid for any supported reason
|
||||
type Claims interface { |
||||
Valid() error |
||||
} |
||||
|
||||
// Structured version of Claims Section, as referenced at
|
||||
// https://tools.ietf.org/html/rfc7519#section-4.1
|
||||
// See examples for how to use this with your own claim types
|
||||
type StandardClaims struct { |
||||
Audience string `json:"aud,omitempty"` |
||||
ExpiresAt int64 `json:"exp,omitempty"` |
||||
Id string `json:"jti,omitempty"` |
||||
IssuedAt int64 `json:"iat,omitempty"` |
||||
Issuer string `json:"iss,omitempty"` |
||||
NotBefore int64 `json:"nbf,omitempty"` |
||||
Subject string `json:"sub,omitempty"` |
||||
} |
||||
|
||||
// Validates time based claims "exp, iat, nbf".
|
||||
// There is no accounting for clock skew.
|
||||
// As well, if any of the above claims are not in the token, it will still
|
||||
// be considered a valid claim.
|
||||
func (c StandardClaims) Valid() error { |
||||
vErr := new(ValidationError) |
||||
now := TimeFunc().Unix() |
||||
|
||||
// The claims below are optional, by default, so if they are set to the
|
||||
// default value in Go, let's not fail the verification for them.
|
||||
if c.VerifyExpiresAt(now, false) == false { |
||||
delta := time.Unix(now, 0).Sub(time.Unix(c.ExpiresAt, 0)) |
||||
vErr.Inner = fmt.Errorf("token is expired by %v", delta) |
||||
vErr.Errors |= ValidationErrorExpired |
||||
} |
||||
|
||||
if c.VerifyIssuedAt(now, false) == false { |
||||
vErr.Inner = fmt.Errorf("Token used before issued") |
||||
vErr.Errors |= ValidationErrorIssuedAt |
||||
} |
||||
|
||||
if c.VerifyNotBefore(now, false) == false { |
||||
vErr.Inner = fmt.Errorf("token is not valid yet") |
||||
vErr.Errors |= ValidationErrorNotValidYet |
||||
} |
||||
|
||||
if vErr.valid() { |
||||
return nil |
||||
} |
||||
|
||||
return vErr |
||||
} |
||||
|
||||
// Compares the aud claim against cmp.
|
||||
// If required is false, this method will return true if the value matches or is unset
|
||||
func (c *StandardClaims) VerifyAudience(cmp string, req bool) bool { |
||||
return verifyAud(c.Audience, cmp, req) |
||||
} |
||||
|
||||
// Compares the exp claim against cmp.
|
||||
// If required is false, this method will return true if the value matches or is unset
|
||||
func (c *StandardClaims) VerifyExpiresAt(cmp int64, req bool) bool { |
||||
return verifyExp(c.ExpiresAt, cmp, req) |
||||
} |
||||
|
||||
// Compares the iat claim against cmp.
|
||||
// If required is false, this method will return true if the value matches or is unset
|
||||
func (c *StandardClaims) VerifyIssuedAt(cmp int64, req bool) bool { |
||||
return verifyIat(c.IssuedAt, cmp, req) |
||||
} |
||||
|
||||
// Compares the iss claim against cmp.
|
||||
// If required is false, this method will return true if the value matches or is unset
|
||||
func (c *StandardClaims) VerifyIssuer(cmp string, req bool) bool { |
||||
return verifyIss(c.Issuer, cmp, req) |
||||
} |
||||
|
||||
// Compares the nbf claim against cmp.
|
||||
// If required is false, this method will return true if the value matches or is unset
|
||||
func (c *StandardClaims) VerifyNotBefore(cmp int64, req bool) bool { |
||||
return verifyNbf(c.NotBefore, cmp, req) |
||||
} |
||||
|
||||
// ----- helpers
|
||||
|
||||
func verifyAud(aud string, cmp string, required bool) bool { |
||||
if aud == "" { |
||||
return !required |
||||
} |
||||
if subtle.ConstantTimeCompare([]byte(aud), []byte(cmp)) != 0 { |
||||
return true |
||||
} else { |
||||
return false |
||||
} |
||||
} |
||||
|
||||
func verifyExp(exp int64, now int64, required bool) bool { |
||||
if exp == 0 { |
||||
return !required |
||||
} |
||||
return now <= exp |
||||
} |
||||
|
||||
func verifyIat(iat int64, now int64, required bool) bool { |
||||
if iat == 0 { |
||||
return !required |
||||
} |
||||
return now >= iat |
||||
} |
||||
|
||||
func verifyIss(iss string, cmp string, required bool) bool { |
||||
if iss == "" { |
||||
return !required |
||||
} |
||||
if subtle.ConstantTimeCompare([]byte(iss), []byte(cmp)) != 0 { |
||||
return true |
||||
} else { |
||||
return false |
||||
} |
||||
} |
||||
|
||||
func verifyNbf(nbf int64, now int64, required bool) bool { |
||||
if nbf == 0 { |
||||
return !required |
||||
} |
||||
return now >= nbf |
||||
} |
||||
@ -1,4 +0,0 @@ |
||||
// Package jwt is a Go implementation of JSON Web Tokens: http://self-issued.info/docs/draft-jones-json-web-token.html
|
||||
//
|
||||
// See README.md for more info.
|
||||
package jwt |
||||
@ -1,147 +0,0 @@ |
||||
package jwt |
||||
|
||||
import ( |
||||
"crypto" |
||||
"crypto/ecdsa" |
||||
"crypto/rand" |
||||
"errors" |
||||
"math/big" |
||||
) |
||||
|
||||
var ( |
||||
// Sadly this is missing from crypto/ecdsa compared to crypto/rsa
|
||||
ErrECDSAVerification = errors.New("crypto/ecdsa: verification error") |
||||
) |
||||
|
||||
// Implements the ECDSA family of signing methods signing methods
|
||||
type SigningMethodECDSA struct { |
||||
Name string |
||||
Hash crypto.Hash |
||||
KeySize int |
||||
CurveBits int |
||||
} |
||||
|
||||
// Specific instances for EC256 and company
|
||||
var ( |
||||
SigningMethodES256 *SigningMethodECDSA |
||||
SigningMethodES384 *SigningMethodECDSA |
||||
SigningMethodES512 *SigningMethodECDSA |
||||
) |
||||
|
||||
func init() { |
||||
// ES256
|
||||
SigningMethodES256 = &SigningMethodECDSA{"ES256", crypto.SHA256, 32, 256} |
||||
RegisterSigningMethod(SigningMethodES256.Alg(), func() SigningMethod { |
||||
return SigningMethodES256 |
||||
}) |
||||
|
||||
// ES384
|
||||
SigningMethodES384 = &SigningMethodECDSA{"ES384", crypto.SHA384, 48, 384} |
||||
RegisterSigningMethod(SigningMethodES384.Alg(), func() SigningMethod { |
||||
return SigningMethodES384 |
||||
}) |
||||
|
||||
// ES512
|
||||
SigningMethodES512 = &SigningMethodECDSA{"ES512", crypto.SHA512, 66, 521} |
||||
RegisterSigningMethod(SigningMethodES512.Alg(), func() SigningMethod { |
||||
return SigningMethodES512 |
||||
}) |
||||
} |
||||
|
||||
func (m *SigningMethodECDSA) Alg() string { |
||||
return m.Name |
||||
} |
||||
|
||||
// Implements the Verify method from SigningMethod
|
||||
// For this verify method, key must be an ecdsa.PublicKey struct
|
||||
func (m *SigningMethodECDSA) Verify(signingString, signature string, key interface{}) error { |
||||
var err error |
||||
|
||||
// Decode the signature
|
||||
var sig []byte |
||||
if sig, err = DecodeSegment(signature); err != nil { |
||||
return err |
||||
} |
||||
|
||||
// Get the key
|
||||
var ecdsaKey *ecdsa.PublicKey |
||||
switch k := key.(type) { |
||||
case *ecdsa.PublicKey: |
||||
ecdsaKey = k |
||||
default: |
||||
return ErrInvalidKeyType |
||||
} |
||||
|
||||
if len(sig) != 2*m.KeySize { |
||||
return ErrECDSAVerification |
||||
} |
||||
|
||||
r := big.NewInt(0).SetBytes(sig[:m.KeySize]) |
||||
s := big.NewInt(0).SetBytes(sig[m.KeySize:]) |
||||
|
||||
// Create hasher
|
||||
if !m.Hash.Available() { |
||||
return ErrHashUnavailable |
||||
} |
||||
hasher := m.Hash.New() |
||||
hasher.Write([]byte(signingString)) |
||||
|
||||
// Verify the signature
|
||||
if verifystatus := ecdsa.Verify(ecdsaKey, hasher.Sum(nil), r, s); verifystatus == true { |
||||
return nil |
||||
} else { |
||||
return ErrECDSAVerification |
||||
} |
||||
} |
||||
|
||||
// Implements the Sign method from SigningMethod
|
||||
// For this signing method, key must be an ecdsa.PrivateKey struct
|
||||
func (m *SigningMethodECDSA) Sign(signingString string, key interface{}) (string, error) { |
||||
// Get the key
|
||||
var ecdsaKey *ecdsa.PrivateKey |
||||
switch k := key.(type) { |
||||
case *ecdsa.PrivateKey: |
||||
ecdsaKey = k |
||||
default: |
||||
return "", ErrInvalidKeyType |
||||
} |
||||
|
||||
// Create the hasher
|
||||
if !m.Hash.Available() { |
||||
return "", ErrHashUnavailable |
||||
} |
||||
|
||||
hasher := m.Hash.New() |
||||
hasher.Write([]byte(signingString)) |
||||
|
||||
// Sign the string and return r, s
|
||||
if r, s, err := ecdsa.Sign(rand.Reader, ecdsaKey, hasher.Sum(nil)); err == nil { |
||||
curveBits := ecdsaKey.Curve.Params().BitSize |
||||
|
||||
if m.CurveBits != curveBits { |
||||
return "", ErrInvalidKey |
||||
} |
||||
|
||||
keyBytes := curveBits / 8 |
||||
if curveBits%8 > 0 { |
||||
keyBytes += 1 |
||||
} |
||||
|
||||
// We serialize the outpus (r and s) into big-endian byte arrays and pad
|
||||
// them with zeros on the left to make sure the sizes work out. Both arrays
|
||||
// must be keyBytes long, and the output must be 2*keyBytes long.
|
||||
rBytes := r.Bytes() |
||||
rBytesPadded := make([]byte, keyBytes) |
||||
copy(rBytesPadded[keyBytes-len(rBytes):], rBytes) |
||||
|
||||
sBytes := s.Bytes() |
||||
sBytesPadded := make([]byte, keyBytes) |
||||
copy(sBytesPadded[keyBytes-len(sBytes):], sBytes) |
||||
|
||||
out := append(rBytesPadded, sBytesPadded...) |
||||
|
||||
return EncodeSegment(out), nil |
||||
} else { |
||||
return "", err |
||||
} |
||||
} |
||||
@ -1,67 +0,0 @@ |
||||
package jwt |
||||
|
||||
import ( |
||||
"crypto/ecdsa" |
||||
"crypto/x509" |
||||
"encoding/pem" |
||||
"errors" |
||||
) |
||||
|
||||
var ( |
||||
ErrNotECPublicKey = errors.New("Key is not a valid ECDSA public key") |
||||
ErrNotECPrivateKey = errors.New("Key is not a valid ECDSA private key") |
||||
) |
||||
|
||||
// Parse PEM encoded Elliptic Curve Private Key Structure
|
||||
func ParseECPrivateKeyFromPEM(key []byte) (*ecdsa.PrivateKey, error) { |
||||
var err error |
||||
|
||||
// Parse PEM block
|
||||
var block *pem.Block |
||||
if block, _ = pem.Decode(key); block == nil { |
||||
return nil, ErrKeyMustBePEMEncoded |
||||
} |
||||
|
||||
// Parse the key
|
||||
var parsedKey interface{} |
||||
if parsedKey, err = x509.ParseECPrivateKey(block.Bytes); err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
var pkey *ecdsa.PrivateKey |
||||
var ok bool |
||||
if pkey, ok = parsedKey.(*ecdsa.PrivateKey); !ok { |
||||
return nil, ErrNotECPrivateKey |
||||
} |
||||
|
||||
return pkey, nil |
||||
} |
||||
|
||||
// Parse PEM encoded PKCS1 or PKCS8 public key
|
||||
func ParseECPublicKeyFromPEM(key []byte) (*ecdsa.PublicKey, error) { |
||||
var err error |
||||
|
||||
// Parse PEM block
|
||||
var block *pem.Block |
||||
if block, _ = pem.Decode(key); block == nil { |
||||
return nil, ErrKeyMustBePEMEncoded |
||||
} |
||||
|
||||
// Parse the key
|
||||
var parsedKey interface{} |
||||
if parsedKey, err = x509.ParsePKIXPublicKey(block.Bytes); err != nil { |
||||
if cert, err := x509.ParseCertificate(block.Bytes); err == nil { |
||||
parsedKey = cert.PublicKey |
||||
} else { |
||||
return nil, err |
||||
} |
||||
} |
||||
|
||||
var pkey *ecdsa.PublicKey |
||||
var ok bool |
||||
if pkey, ok = parsedKey.(*ecdsa.PublicKey); !ok { |
||||
return nil, ErrNotECPublicKey |
||||
} |
||||
|
||||
return pkey, nil |
||||
} |
||||
@ -1,59 +0,0 @@ |
||||
package jwt |
||||
|
||||
import ( |
||||
"errors" |
||||
) |
||||
|
||||
// Error constants
|
||||
var ( |
||||
ErrInvalidKey = errors.New("key is invalid") |
||||
ErrInvalidKeyType = errors.New("key is of invalid type") |
||||
ErrHashUnavailable = errors.New("the requested hash function is unavailable") |
||||
) |
||||
|
||||
// The errors that might occur when parsing and validating a token
|
||||
const ( |
||||
ValidationErrorMalformed uint32 = 1 << iota // Token is malformed
|
||||
ValidationErrorUnverifiable // Token could not be verified because of signing problems
|
||||
ValidationErrorSignatureInvalid // Signature validation failed
|
||||
|
||||
// Standard Claim validation errors
|
||||
ValidationErrorAudience // AUD validation failed
|
||||
ValidationErrorExpired // EXP validation failed
|
||||
ValidationErrorIssuedAt // IAT validation failed
|
||||
ValidationErrorIssuer // ISS validation failed
|
||||
ValidationErrorNotValidYet // NBF validation failed
|
||||
ValidationErrorId // JTI validation failed
|
||||
ValidationErrorClaimsInvalid // Generic claims validation error
|
||||
) |
||||
|
||||
// Helper for constructing a ValidationError with a string error message
|
||||
func NewValidationError(errorText string, errorFlags uint32) *ValidationError { |
||||
return &ValidationError{ |
||||
text: errorText, |
||||
Errors: errorFlags, |
||||
} |
||||
} |
||||
|
||||
// The error from Parse if token is not valid
|
||||
type ValidationError struct { |
||||
Inner error // stores the error returned by external dependencies, i.e.: KeyFunc
|
||||
Errors uint32 // bitfield. see ValidationError... constants
|
||||
text string // errors that do not have a valid error just have text
|
||||
} |
||||
|
||||
// Validation error is an error type
|
||||
func (e ValidationError) Error() string { |
||||
if e.Inner != nil { |
||||
return e.Inner.Error() |
||||
} else if e.text != "" { |
||||
return e.text |
||||
} else { |
||||
return "token is invalid" |
||||
} |
||||
} |
||||
|
||||
// No errors
|
||||
func (e *ValidationError) valid() bool { |
||||
return e.Errors == 0 |
||||
} |
||||
@ -1,94 +0,0 @@ |
||||
package jwt |
||||
|
||||
import ( |
||||
"crypto" |
||||
"crypto/hmac" |
||||
"errors" |
||||
) |
||||
|
||||
// Implements the HMAC-SHA family of signing methods signing methods
|
||||
type SigningMethodHMAC struct { |
||||
Name string |
||||
Hash crypto.Hash |
||||
} |
||||
|
||||
// Specific instances for HS256 and company
|
||||
var ( |
||||
SigningMethodHS256 *SigningMethodHMAC |
||||
SigningMethodHS384 *SigningMethodHMAC |
||||
SigningMethodHS512 *SigningMethodHMAC |
||||
ErrSignatureInvalid = errors.New("signature is invalid") |
||||
) |
||||
|
||||
func init() { |
||||
// HS256
|
||||
SigningMethodHS256 = &SigningMethodHMAC{"HS256", crypto.SHA256} |
||||
RegisterSigningMethod(SigningMethodHS256.Alg(), func() SigningMethod { |
||||
return SigningMethodHS256 |
||||
}) |
||||
|
||||
// HS384
|
||||
SigningMethodHS384 = &SigningMethodHMAC{"HS384", crypto.SHA384} |
||||
RegisterSigningMethod(SigningMethodHS384.Alg(), func() SigningMethod { |
||||
return SigningMethodHS384 |
||||
}) |
||||
|
||||
// HS512
|
||||
SigningMethodHS512 = &SigningMethodHMAC{"HS512", crypto.SHA512} |
||||
RegisterSigningMethod(SigningMethodHS512.Alg(), func() SigningMethod { |
||||
return SigningMethodHS512 |
||||
}) |
||||
} |
||||
|
||||
func (m *SigningMethodHMAC) Alg() string { |
||||
return m.Name |
||||
} |
||||
|
||||
// Verify the signature of HSXXX tokens. Returns nil if the signature is valid.
|
||||
func (m *SigningMethodHMAC) Verify(signingString, signature string, key interface{}) error { |
||||
// Verify the key is the right type
|
||||
keyBytes, ok := key.([]byte) |
||||
if !ok { |
||||
return ErrInvalidKeyType |
||||
} |
||||
|
||||
// Decode signature, for comparison
|
||||
sig, err := DecodeSegment(signature) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
|
||||
// Can we use the specified hashing method?
|
||||
if !m.Hash.Available() { |
||||
return ErrHashUnavailable |
||||
} |
||||
|
||||
// This signing method is symmetric, so we validate the signature
|
||||
// by reproducing the signature from the signing string and key, then
|
||||
// comparing that against the provided signature.
|
||||
hasher := hmac.New(m.Hash.New, keyBytes) |
||||
hasher.Write([]byte(signingString)) |
||||
if !hmac.Equal(sig, hasher.Sum(nil)) { |
||||
return ErrSignatureInvalid |
||||
} |
||||
|
||||
// No validation errors. Signature is good.
|
||||
return nil |
||||
} |
||||
|
||||
// Implements the Sign method from SigningMethod for this signing method.
|
||||
// Key must be []byte
|
||||
func (m *SigningMethodHMAC) Sign(signingString string, key interface{}) (string, error) { |
||||
if keyBytes, ok := key.([]byte); ok { |
||||
if !m.Hash.Available() { |
||||
return "", ErrHashUnavailable |
||||
} |
||||
|
||||
hasher := hmac.New(m.Hash.New, keyBytes) |
||||
hasher.Write([]byte(signingString)) |
||||
|
||||
return EncodeSegment(hasher.Sum(nil)), nil |
||||
} |
||||
|
||||
return "", ErrInvalidKey |
||||
} |
||||
@ -1,94 +0,0 @@ |
||||
package jwt |
||||
|
||||
import ( |
||||
"encoding/json" |
||||
"errors" |
||||
// "fmt"
|
||||
) |
||||
|
||||
// Claims type that uses the map[string]interface{} for JSON decoding
|
||||
// This is the default claims type if you don't supply one
|
||||
type MapClaims map[string]interface{} |
||||
|
||||
// Compares the aud claim against cmp.
|
||||
// If required is false, this method will return true if the value matches or is unset
|
||||
func (m MapClaims) VerifyAudience(cmp string, req bool) bool { |
||||
aud, _ := m["aud"].(string) |
||||
return verifyAud(aud, cmp, req) |
||||
} |
||||
|
||||
// Compares the exp claim against cmp.
|
||||
// If required is false, this method will return true if the value matches or is unset
|
||||
func (m MapClaims) VerifyExpiresAt(cmp int64, req bool) bool { |
||||
switch exp := m["exp"].(type) { |
||||
case float64: |
||||
return verifyExp(int64(exp), cmp, req) |
||||
case json.Number: |
||||
v, _ := exp.Int64() |
||||
return verifyExp(v, cmp, req) |
||||
} |
||||
return req == false |
||||
} |
||||
|
||||
// Compares the iat claim against cmp.
|
||||
// If required is false, this method will return true if the value matches or is unset
|
||||
func (m MapClaims) VerifyIssuedAt(cmp int64, req bool) bool { |
||||
switch iat := m["iat"].(type) { |
||||
case float64: |
||||
return verifyIat(int64(iat), cmp, req) |
||||
case json.Number: |
||||
v, _ := iat.Int64() |
||||
return verifyIat(v, cmp, req) |
||||
} |
||||
return req == false |
||||
} |
||||
|
||||
// Compares the iss claim against cmp.
|
||||
// If required is false, this method will return true if the value matches or is unset
|
||||
func (m MapClaims) VerifyIssuer(cmp string, req bool) bool { |
||||
iss, _ := m["iss"].(string) |
||||
return verifyIss(iss, cmp, req) |
||||
} |
||||
|
||||
// Compares the nbf claim against cmp.
|
||||
// If required is false, this method will return true if the value matches or is unset
|
||||
func (m MapClaims) VerifyNotBefore(cmp int64, req bool) bool { |
||||
switch nbf := m["nbf"].(type) { |
||||
case float64: |
||||
return verifyNbf(int64(nbf), cmp, req) |
||||
case json.Number: |
||||
v, _ := nbf.Int64() |
||||
return verifyNbf(v, cmp, req) |
||||
} |
||||
return req == false |
||||
} |
||||
|
||||
// Validates time based claims "exp, iat, nbf".
|
||||
// There is no accounting for clock skew.
|
||||
// As well, if any of the above claims are not in the token, it will still
|
||||
// be considered a valid claim.
|
||||
func (m MapClaims) Valid() error { |
||||
vErr := new(ValidationError) |
||||
now := TimeFunc().Unix() |
||||
|
||||
if m.VerifyExpiresAt(now, false) == false { |
||||
vErr.Inner = errors.New("Token is expired") |
||||
vErr.Errors |= ValidationErrorExpired |
||||
} |
||||
|
||||
if m.VerifyIssuedAt(now, false) == false { |
||||
vErr.Inner = errors.New("Token used before issued") |
||||
vErr.Errors |= ValidationErrorIssuedAt |
||||
} |
||||
|
||||
if m.VerifyNotBefore(now, false) == false { |
||||
vErr.Inner = errors.New("Token is not valid yet") |
||||
vErr.Errors |= ValidationErrorNotValidYet |
||||
} |
||||
|
||||
if vErr.valid() { |
||||
return nil |
||||
} |
||||
|
||||
return vErr |
||||
} |
||||
@ -1,52 +0,0 @@ |
||||
package jwt |
||||
|
||||
// Implements the none signing method. This is required by the spec
|
||||
// but you probably should never use it.
|
||||
var SigningMethodNone *signingMethodNone |
||||
|
||||
const UnsafeAllowNoneSignatureType unsafeNoneMagicConstant = "none signing method allowed" |
||||
|
||||
var NoneSignatureTypeDisallowedError error |
||||
|
||||
type signingMethodNone struct{} |
||||
type unsafeNoneMagicConstant string |
||||
|
||||
func init() { |
||||
SigningMethodNone = &signingMethodNone{} |
||||
NoneSignatureTypeDisallowedError = NewValidationError("'none' signature type is not allowed", ValidationErrorSignatureInvalid) |
||||
|
||||
RegisterSigningMethod(SigningMethodNone.Alg(), func() SigningMethod { |
||||
return SigningMethodNone |
||||
}) |
||||
} |
||||
|
||||
func (m *signingMethodNone) Alg() string { |
||||
return "none" |
||||
} |
||||
|
||||
// Only allow 'none' alg type if UnsafeAllowNoneSignatureType is specified as the key
|
||||
func (m *signingMethodNone) Verify(signingString, signature string, key interface{}) (err error) { |
||||
// Key must be UnsafeAllowNoneSignatureType to prevent accidentally
|
||||
// accepting 'none' signing method
|
||||
if _, ok := key.(unsafeNoneMagicConstant); !ok { |
||||
return NoneSignatureTypeDisallowedError |
||||
} |
||||
// If signing method is none, signature must be an empty string
|
||||
if signature != "" { |
||||
return NewValidationError( |
||||
"'none' signing method with non-empty signature", |
||||
ValidationErrorSignatureInvalid, |
||||
) |
||||
} |
||||
|
||||
// Accept 'none' signing method.
|
||||
return nil |
||||
} |
||||
|
||||
// Only allow 'none' signing if UnsafeAllowNoneSignatureType is specified as the key
|
||||
func (m *signingMethodNone) Sign(signingString string, key interface{}) (string, error) { |
||||
if _, ok := key.(unsafeNoneMagicConstant); ok { |
||||
return "", nil |
||||
} |
||||
return "", NoneSignatureTypeDisallowedError |
||||
} |
||||
@ -1,131 +0,0 @@ |
||||
package jwt |
||||
|
||||
import ( |
||||
"bytes" |
||||
"encoding/json" |
||||
"fmt" |
||||
"strings" |
||||
) |
||||
|
||||
type Parser struct { |
||||
ValidMethods []string // If populated, only these methods will be considered valid
|
||||
UseJSONNumber bool // Use JSON Number format in JSON decoder
|
||||
SkipClaimsValidation bool // Skip claims validation during token parsing
|
||||
} |
||||
|
||||
// Parse, validate, and return a token.
|
||||
// keyFunc will receive the parsed token and should return the key for validating.
|
||||
// If everything is kosher, err will be nil
|
||||
func (p *Parser) Parse(tokenString string, keyFunc Keyfunc) (*Token, error) { |
||||
return p.ParseWithClaims(tokenString, MapClaims{}, keyFunc) |
||||
} |
||||
|
||||
func (p *Parser) ParseWithClaims(tokenString string, claims Claims, keyFunc Keyfunc) (*Token, error) { |
||||
parts := strings.Split(tokenString, ".") |
||||
if len(parts) != 3 { |
||||
return nil, NewValidationError("token contains an invalid number of segments", ValidationErrorMalformed) |
||||
} |
||||
|
||||
var err error |
||||
token := &Token{Raw: tokenString} |
||||
|
||||
// parse Header
|
||||
var headerBytes []byte |
||||
if headerBytes, err = DecodeSegment(parts[0]); err != nil { |
||||
if strings.HasPrefix(strings.ToLower(tokenString), "bearer ") { |
||||
return token, NewValidationError("tokenstring should not contain 'bearer '", ValidationErrorMalformed) |
||||
} |
||||
return token, &ValidationError{Inner: err, Errors: ValidationErrorMalformed} |
||||
} |
||||
if err = json.Unmarshal(headerBytes, &token.Header); err != nil { |
||||
return token, &ValidationError{Inner: err, Errors: ValidationErrorMalformed} |
||||
} |
||||
|
||||
// parse Claims
|
||||
var claimBytes []byte |
||||
token.Claims = claims |
||||
|
||||
if claimBytes, err = DecodeSegment(parts[1]); err != nil { |
||||
return token, &ValidationError{Inner: err, Errors: ValidationErrorMalformed} |
||||
} |
||||
dec := json.NewDecoder(bytes.NewBuffer(claimBytes)) |
||||
if p.UseJSONNumber { |
||||
dec.UseNumber() |
||||
} |
||||
// JSON Decode. Special case for map type to avoid weird pointer behavior
|
||||
if c, ok := token.Claims.(MapClaims); ok { |
||||
err = dec.Decode(&c) |
||||
} else { |
||||
err = dec.Decode(&claims) |
||||
} |
||||
// Handle decode error
|
||||
if err != nil { |
||||
return token, &ValidationError{Inner: err, Errors: ValidationErrorMalformed} |
||||
} |
||||
|
||||
// Lookup signature method
|
||||
if method, ok := token.Header["alg"].(string); ok { |
||||
if token.Method = GetSigningMethod(method); token.Method == nil { |
||||
return token, NewValidationError("signing method (alg) is unavailable.", ValidationErrorUnverifiable) |
||||
} |
||||
} else { |
||||
return token, NewValidationError("signing method (alg) is unspecified.", ValidationErrorUnverifiable) |
||||
} |
||||
|
||||
// Verify signing method is in the required set
|
||||
if p.ValidMethods != nil { |
||||
var signingMethodValid = false |
||||
var alg = token.Method.Alg() |
||||
for _, m := range p.ValidMethods { |
||||
if m == alg { |
||||
signingMethodValid = true |
||||
break |
||||
} |
||||
} |
||||
if !signingMethodValid { |
||||
// signing method is not in the listed set
|
||||
return token, NewValidationError(fmt.Sprintf("signing method %v is invalid", alg), ValidationErrorSignatureInvalid) |
||||
} |
||||
} |
||||
|
||||
// Lookup key
|
||||
var key interface{} |
||||
if keyFunc == nil { |
||||
// keyFunc was not provided. short circuiting validation
|
||||
return token, NewValidationError("no Keyfunc was provided.", ValidationErrorUnverifiable) |
||||
} |
||||
if key, err = keyFunc(token); err != nil { |
||||
// keyFunc returned an error
|
||||
return token, &ValidationError{Inner: err, Errors: ValidationErrorUnverifiable} |
||||
} |
||||
|
||||
vErr := &ValidationError{} |
||||
|
||||
// Validate Claims
|
||||
if !p.SkipClaimsValidation { |
||||
if err := token.Claims.Valid(); err != nil { |
||||
|
||||
// If the Claims Valid returned an error, check if it is a validation error,
|
||||
// If it was another error type, create a ValidationError with a generic ClaimsInvalid flag set
|
||||
if e, ok := err.(*ValidationError); !ok { |
||||
vErr = &ValidationError{Inner: err, Errors: ValidationErrorClaimsInvalid} |
||||
} else { |
||||
vErr = e |
||||
} |
||||
} |
||||
} |
||||
|
||||
// Perform validation
|
||||
token.Signature = parts[2] |
||||
if err = token.Method.Verify(strings.Join(parts[0:2], "."), token.Signature, key); err != nil { |
||||
vErr.Inner = err |
||||
vErr.Errors |= ValidationErrorSignatureInvalid |
||||
} |
||||
|
||||
if vErr.valid() { |
||||
token.Valid = true |
||||
return token, nil |
||||
} |
||||
|
||||
return token, vErr |
||||
} |
||||
@ -1,100 +0,0 @@ |
||||
package jwt |
||||
|
||||
import ( |
||||
"crypto" |
||||
"crypto/rand" |
||||
"crypto/rsa" |
||||
) |
||||
|
||||
// Implements the RSA family of signing methods signing methods
|
||||
type SigningMethodRSA struct { |
||||
Name string |
||||
Hash crypto.Hash |
||||
} |
||||
|
||||
// Specific instances for RS256 and company
|
||||
var ( |
||||
SigningMethodRS256 *SigningMethodRSA |
||||
SigningMethodRS384 *SigningMethodRSA |
||||
SigningMethodRS512 *SigningMethodRSA |
||||
) |
||||
|
||||
func init() { |
||||
// RS256
|
||||
SigningMethodRS256 = &SigningMethodRSA{"RS256", crypto.SHA256} |
||||
RegisterSigningMethod(SigningMethodRS256.Alg(), func() SigningMethod { |
||||
return SigningMethodRS256 |
||||
}) |
||||
|
||||
// RS384
|
||||
SigningMethodRS384 = &SigningMethodRSA{"RS384", crypto.SHA384} |
||||
RegisterSigningMethod(SigningMethodRS384.Alg(), func() SigningMethod { |
||||
return SigningMethodRS384 |
||||
}) |
||||
|
||||
// RS512
|
||||
SigningMethodRS512 = &SigningMethodRSA{"RS512", crypto.SHA512} |
||||
RegisterSigningMethod(SigningMethodRS512.Alg(), func() SigningMethod { |
||||
return SigningMethodRS512 |
||||
}) |
||||
} |
||||
|
||||
func (m *SigningMethodRSA) Alg() string { |
||||
return m.Name |
||||
} |
||||
|
||||
// Implements the Verify method from SigningMethod
|
||||
// For this signing method, must be an rsa.PublicKey structure.
|
||||
func (m *SigningMethodRSA) Verify(signingString, signature string, key interface{}) error { |
||||
var err error |
||||
|
||||
// Decode the signature
|
||||
var sig []byte |
||||
if sig, err = DecodeSegment(signature); err != nil { |
||||
return err |
||||
} |
||||
|
||||
var rsaKey *rsa.PublicKey |
||||
var ok bool |
||||
|
||||
if rsaKey, ok = key.(*rsa.PublicKey); !ok { |
||||
return ErrInvalidKeyType |
||||
} |
||||
|
||||
// Create hasher
|
||||
if !m.Hash.Available() { |
||||
return ErrHashUnavailable |
||||
} |
||||
hasher := m.Hash.New() |
||||
hasher.Write([]byte(signingString)) |
||||
|
||||
// Verify the signature
|
||||
return rsa.VerifyPKCS1v15(rsaKey, m.Hash, hasher.Sum(nil), sig) |
||||
} |
||||
|
||||
// Implements the Sign method from SigningMethod
|
||||
// For this signing method, must be an rsa.PrivateKey structure.
|
||||
func (m *SigningMethodRSA) Sign(signingString string, key interface{}) (string, error) { |
||||
var rsaKey *rsa.PrivateKey |
||||
var ok bool |
||||
|
||||
// Validate type of key
|
||||
if rsaKey, ok = key.(*rsa.PrivateKey); !ok { |
||||
return "", ErrInvalidKey |
||||
} |
||||
|
||||
// Create the hasher
|
||||
if !m.Hash.Available() { |
||||
return "", ErrHashUnavailable |
||||
} |
||||
|
||||
hasher := m.Hash.New() |
||||
hasher.Write([]byte(signingString)) |
||||
|
||||
// Sign the string and return the encoded bytes
|
||||
if sigBytes, err := rsa.SignPKCS1v15(rand.Reader, rsaKey, m.Hash, hasher.Sum(nil)); err == nil { |
||||
return EncodeSegment(sigBytes), nil |
||||
} else { |
||||
return "", err |
||||
} |
||||
} |
||||
@ -1,126 +0,0 @@ |
||||
// +build go1.4
|
||||
|
||||
package jwt |
||||
|
||||
import ( |
||||
"crypto" |
||||
"crypto/rand" |
||||
"crypto/rsa" |
||||
) |
||||
|
||||
// Implements the RSAPSS family of signing methods signing methods
|
||||
type SigningMethodRSAPSS struct { |
||||
*SigningMethodRSA |
||||
Options *rsa.PSSOptions |
||||
} |
||||
|
||||
// Specific instances for RS/PS and company
|
||||
var ( |
||||
SigningMethodPS256 *SigningMethodRSAPSS |
||||
SigningMethodPS384 *SigningMethodRSAPSS |
||||
SigningMethodPS512 *SigningMethodRSAPSS |
||||
) |
||||
|
||||
func init() { |
||||
// PS256
|
||||
SigningMethodPS256 = &SigningMethodRSAPSS{ |
||||
&SigningMethodRSA{ |
||||
Name: "PS256", |
||||
Hash: crypto.SHA256, |
||||
}, |
||||
&rsa.PSSOptions{ |
||||
SaltLength: rsa.PSSSaltLengthAuto, |
||||
Hash: crypto.SHA256, |
||||
}, |
||||
} |
||||
RegisterSigningMethod(SigningMethodPS256.Alg(), func() SigningMethod { |
||||
return SigningMethodPS256 |
||||
}) |
||||
|
||||
// PS384
|
||||
SigningMethodPS384 = &SigningMethodRSAPSS{ |
||||
&SigningMethodRSA{ |
||||
Name: "PS384", |
||||
Hash: crypto.SHA384, |
||||
}, |
||||
&rsa.PSSOptions{ |
||||
SaltLength: rsa.PSSSaltLengthAuto, |
||||
Hash: crypto.SHA384, |
||||
}, |
||||
} |
||||
RegisterSigningMethod(SigningMethodPS384.Alg(), func() SigningMethod { |
||||
return SigningMethodPS384 |
||||
}) |
||||
|
||||
// PS512
|
||||
SigningMethodPS512 = &SigningMethodRSAPSS{ |
||||
&SigningMethodRSA{ |
||||
Name: "PS512", |
||||
Hash: crypto.SHA512, |
||||
}, |
||||
&rsa.PSSOptions{ |
||||
SaltLength: rsa.PSSSaltLengthAuto, |
||||
Hash: crypto.SHA512, |
||||
}, |
||||
} |
||||
RegisterSigningMethod(SigningMethodPS512.Alg(), func() SigningMethod { |
||||
return SigningMethodPS512 |
||||
}) |
||||
} |
||||
|
||||
// Implements the Verify method from SigningMethod
|
||||
// For this verify method, key must be an rsa.PublicKey struct
|
||||
func (m *SigningMethodRSAPSS) Verify(signingString, signature string, key interface{}) error { |
||||
var err error |
||||
|
||||
// Decode the signature
|
||||
var sig []byte |
||||
if sig, err = DecodeSegment(signature); err != nil { |
||||
return err |
||||
} |
||||
|
||||
var rsaKey *rsa.PublicKey |
||||
switch k := key.(type) { |
||||
case *rsa.PublicKey: |
||||
rsaKey = k |
||||
default: |
||||
return ErrInvalidKey |
||||
} |
||||
|
||||
// Create hasher
|
||||
if !m.Hash.Available() { |
||||
return ErrHashUnavailable |
||||
} |
||||
hasher := m.Hash.New() |
||||
hasher.Write([]byte(signingString)) |
||||
|
||||
return rsa.VerifyPSS(rsaKey, m.Hash, hasher.Sum(nil), sig, m.Options) |
||||
} |
||||
|
||||
// Implements the Sign method from SigningMethod
|
||||
// For this signing method, key must be an rsa.PrivateKey struct
|
||||
func (m *SigningMethodRSAPSS) Sign(signingString string, key interface{}) (string, error) { |
||||
var rsaKey *rsa.PrivateKey |
||||
|
||||
switch k := key.(type) { |
||||
case *rsa.PrivateKey: |
||||
rsaKey = k |
||||
default: |
||||
return "", ErrInvalidKeyType |
||||
} |
||||
|
||||
// Create the hasher
|
||||
if !m.Hash.Available() { |
||||
return "", ErrHashUnavailable |
||||
} |
||||
|
||||
hasher := m.Hash.New() |
||||
hasher.Write([]byte(signingString)) |
||||
|
||||
// Sign the string and return the encoded bytes
|
||||
if sigBytes, err := rsa.SignPSS(rand.Reader, rsaKey, m.Hash, hasher.Sum(nil), m.Options); err == nil { |
||||
return EncodeSegment(sigBytes), nil |
||||
} else { |
||||
return "", err |
||||
} |
||||
} |
||||
@ -1,69 +0,0 @@ |
||||
package jwt |
||||
|
||||
import ( |
||||
"crypto/rsa" |
||||
"crypto/x509" |
||||
"encoding/pem" |
||||
"errors" |
||||
) |
||||
|
||||
var ( |
||||
ErrKeyMustBePEMEncoded = errors.New("Invalid Key: Key must be PEM encoded PKCS1 or PKCS8 private key") |
||||
ErrNotRSAPrivateKey = errors.New("Key is not a valid RSA private key") |
||||
ErrNotRSAPublicKey = errors.New("Key is not a valid RSA public key") |
||||
) |
||||
|
||||
// Parse PEM encoded PKCS1 or PKCS8 private key
|
||||
func ParseRSAPrivateKeyFromPEM(key []byte) (*rsa.PrivateKey, error) { |
||||
var err error |
||||
|
||||
// Parse PEM block
|
||||
var block *pem.Block |
||||
if block, _ = pem.Decode(key); block == nil { |
||||
return nil, ErrKeyMustBePEMEncoded |
||||
} |
||||
|
||||
var parsedKey interface{} |
||||
if parsedKey, err = x509.ParsePKCS1PrivateKey(block.Bytes); err != nil { |
||||
if parsedKey, err = x509.ParsePKCS8PrivateKey(block.Bytes); err != nil { |
||||
return nil, err |
||||
} |
||||
} |
||||
|
||||
var pkey *rsa.PrivateKey |
||||
var ok bool |
||||
if pkey, ok = parsedKey.(*rsa.PrivateKey); !ok { |
||||
return nil, ErrNotRSAPrivateKey |
||||
} |
||||
|
||||
return pkey, nil |
||||
} |
||||
|
||||
// Parse PEM encoded PKCS1 or PKCS8 public key
|
||||
func ParseRSAPublicKeyFromPEM(key []byte) (*rsa.PublicKey, error) { |
||||
var err error |
||||
|
||||
// Parse PEM block
|
||||
var block *pem.Block |
||||
if block, _ = pem.Decode(key); block == nil { |
||||
return nil, ErrKeyMustBePEMEncoded |
||||
} |
||||
|
||||
// Parse the key
|
||||
var parsedKey interface{} |
||||
if parsedKey, err = x509.ParsePKIXPublicKey(block.Bytes); err != nil { |
||||
if cert, err := x509.ParseCertificate(block.Bytes); err == nil { |
||||
parsedKey = cert.PublicKey |
||||
} else { |
||||
return nil, err |
||||
} |
||||
} |
||||
|
||||
var pkey *rsa.PublicKey |
||||
var ok bool |
||||
if pkey, ok = parsedKey.(*rsa.PublicKey); !ok { |
||||
return nil, ErrNotRSAPublicKey |
||||
} |
||||
|
||||
return pkey, nil |
||||
} |
||||
@ -1,35 +0,0 @@ |
||||
package jwt |
||||
|
||||
import ( |
||||
"sync" |
||||
) |
||||
|
||||
var signingMethods = map[string]func() SigningMethod{} |
||||
var signingMethodLock = new(sync.RWMutex) |
||||
|
||||
// Implement SigningMethod to add new methods for signing or verifying tokens.
|
||||
type SigningMethod interface { |
||||
Verify(signingString, signature string, key interface{}) error // Returns nil if signature is valid
|
||||
Sign(signingString string, key interface{}) (string, error) // Returns encoded signature or error
|
||||
Alg() string // returns the alg identifier for this method (example: 'HS256')
|
||||
} |
||||
|
||||
// Register the "alg" name and a factory function for signing method.
|
||||
// This is typically done during init() in the method's implementation
|
||||
func RegisterSigningMethod(alg string, f func() SigningMethod) { |
||||
signingMethodLock.Lock() |
||||
defer signingMethodLock.Unlock() |
||||
|
||||
signingMethods[alg] = f |
||||
} |
||||
|
||||
// Get a signing method from an "alg" string
|
||||
func GetSigningMethod(alg string) (method SigningMethod) { |
||||
signingMethodLock.RLock() |
||||
defer signingMethodLock.RUnlock() |
||||
|
||||
if methodF, ok := signingMethods[alg]; ok { |
||||
method = methodF() |
||||
} |
||||
return |
||||
} |
||||
@ -1,108 +0,0 @@ |
||||
package jwt |
||||
|
||||
import ( |
||||
"encoding/base64" |
||||
"encoding/json" |
||||
"strings" |
||||
"time" |
||||
) |
||||
|
||||
// TimeFunc provides the current time when parsing token to validate "exp" claim (expiration time).
|
||||
// You can override it to use another time value. This is useful for testing or if your
|
||||
// server uses a different time zone than your tokens.
|
||||
var TimeFunc = time.Now |
||||
|
||||
// Parse methods use this callback function to supply
|
||||
// the key for verification. The function receives the parsed,
|
||||
// but unverified Token. This allows you to use properties in the
|
||||
// Header of the token (such as `kid`) to identify which key to use.
|
||||
type Keyfunc func(*Token) (interface{}, error) |
||||
|
||||
// A JWT Token. Different fields will be used depending on whether you're
|
||||
// creating or parsing/verifying a token.
|
||||
type Token struct { |
||||
Raw string // The raw token. Populated when you Parse a token
|
||||
Method SigningMethod // The signing method used or to be used
|
||||
Header map[string]interface{} // The first segment of the token
|
||||
Claims Claims // The second segment of the token
|
||||
Signature string // The third segment of the token. Populated when you Parse a token
|
||||
Valid bool // Is the token valid? Populated when you Parse/Verify a token
|
||||
} |
||||
|
||||
// Create a new Token. Takes a signing method
|
||||
func New(method SigningMethod) *Token { |
||||
return NewWithClaims(method, MapClaims{}) |
||||
} |
||||
|
||||
func NewWithClaims(method SigningMethod, claims Claims) *Token { |
||||
return &Token{ |
||||
Header: map[string]interface{}{ |
||||
"typ": "JWT", |
||||
"alg": method.Alg(), |
||||
}, |
||||
Claims: claims, |
||||
Method: method, |
||||
} |
||||
} |
||||
|
||||
// Get the complete, signed token
|
||||
func (t *Token) SignedString(key interface{}) (string, error) { |
||||
var sig, sstr string |
||||
var err error |
||||
if sstr, err = t.SigningString(); err != nil { |
||||
return "", err |
||||
} |
||||
if sig, err = t.Method.Sign(sstr, key); err != nil { |
||||
return "", err |
||||
} |
||||
return strings.Join([]string{sstr, sig}, "."), nil |
||||
} |
||||
|
||||
// Generate the signing string. This is the
|
||||
// most expensive part of the whole deal. Unless you
|
||||
// need this for something special, just go straight for
|
||||
// the SignedString.
|
||||
func (t *Token) SigningString() (string, error) { |
||||
var err error |
||||
parts := make([]string, 2) |
||||
for i, _ := range parts { |
||||
var jsonValue []byte |
||||
if i == 0 { |
||||
if jsonValue, err = json.Marshal(t.Header); err != nil { |
||||
return "", err |
||||
} |
||||
} else { |
||||
if jsonValue, err = json.Marshal(t.Claims); err != nil { |
||||
return "", err |
||||
} |
||||
} |
||||
|
||||
parts[i] = EncodeSegment(jsonValue) |
||||
} |
||||
return strings.Join(parts, "."), nil |
||||
} |
||||
|
||||
// Parse, validate, and return a token.
|
||||
// keyFunc will receive the parsed token and should return the key for validating.
|
||||
// If everything is kosher, err will be nil
|
||||
func Parse(tokenString string, keyFunc Keyfunc) (*Token, error) { |
||||
return new(Parser).Parse(tokenString, keyFunc) |
||||
} |
||||
|
||||
func ParseWithClaims(tokenString string, claims Claims, keyFunc Keyfunc) (*Token, error) { |
||||
return new(Parser).ParseWithClaims(tokenString, claims, keyFunc) |
||||
} |
||||
|
||||
// Encode JWT specific base64url encoding with padding stripped
|
||||
func EncodeSegment(seg []byte) string { |
||||
return strings.TrimRight(base64.URLEncoding.EncodeToString(seg), "=") |
||||
} |
||||
|
||||
// Decode JWT specific base64url encoding with padding stripped
|
||||
func DecodeSegment(seg string) ([]byte, error) { |
||||
if l := len(seg) % 4; l > 0 { |
||||
seg += strings.Repeat("=", 4-l) |
||||
} |
||||
|
||||
return base64.URLEncoding.DecodeString(seg) |
||||
} |
||||
@ -1,22 +0,0 @@ |
||||
The MIT License (MIT) |
||||
|
||||
Copyright (c) 2015 Zack Guo |
||||
|
||||
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. |
||||
|
||||
@ -1,151 +0,0 @@ |
||||
# termui [](https://travis-ci.org/gizak/termui) [](https://godoc.org/github.com/gizak/termui) |
||||
|
||||
<img src="./_example/dashboard.gif" alt="demo cast under osx 10.10; Terminal.app; Menlo Regular 12pt.)" width="80%"> |
||||
|
||||
`termui` is a cross-platform, easy-to-compile, and fully-customizable terminal dashboard. It is inspired by [blessed-contrib](https://github.com/yaronn/blessed-contrib), but purely in Go. |
||||
|
||||
Now version v2 has arrived! It brings new event system, new theme system, new `Buffer` interface and specific colour text rendering. (some docs are missing, but it will be completed soon!) |
||||
|
||||
## Installation |
||||
|
||||
`master` mirrors v2 branch, to install: |
||||
|
||||
go get -u github.com/gizak/termui |
||||
|
||||
It is recommanded to use locked deps by using [glide](https://glide.sh): move to `termui` src directory then run `glide up`. |
||||
|
||||
For the compatible reason, you can choose to install the legacy version of `termui`: |
||||
|
||||
go get gopkg.in/gizak/termui.v1 |
||||
|
||||
## Usage |
||||
|
||||
### Layout |
||||
|
||||
To use `termui`, the very first thing you may want to know is how to manage layout. `termui` offers two ways of doing this, known as absolute layout and grid layout. |
||||
|
||||
__Absolute layout__ |
||||
|
||||
Each widget has an underlying block structure which basically is a box model. It has border, label and padding properties. A border of a widget can be chosen to hide or display (with its border label), you can pick a different front/back colour for the border as well. To display such a widget at a specific location in terminal window, you need to assign `.X`, `.Y`, `.Height`, `.Width` values for each widget before sending it to `.Render`. Let's demonstrate these by a code snippet: |
||||
|
||||
`````go |
||||
import ui "github.com/gizak/termui" // <- ui shortcut, optional |
||||
|
||||
func main() { |
||||
err := ui.Init() |
||||
if err != nil { |
||||
panic(err) |
||||
} |
||||
defer ui.Close() |
||||
|
||||
p := ui.NewPar(":PRESS q TO QUIT DEMO") |
||||
p.Height = 3 |
||||
p.Width = 50 |
||||
p.TextFgColor = ui.ColorWhite |
||||
p.BorderLabel = "Text Box" |
||||
p.BorderFg = ui.ColorCyan |
||||
|
||||
g := ui.NewGauge() |
||||
g.Percent = 50 |
||||
g.Width = 50 |
||||
g.Height = 3 |
||||
g.Y = 11 |
||||
g.BorderLabel = "Gauge" |
||||
g.BarColor = ui.ColorRed |
||||
g.BorderFg = ui.ColorWhite |
||||
g.BorderLabelFg = ui.ColorCyan |
||||
|
||||
ui.Render(p, g) // feel free to call Render, it's async and non-block |
||||
|
||||
// event handler... |
||||
} |
||||
````` |
||||
|
||||
Note that components can be overlapped (I'd rather call this a feature...), `Render(rs ...Renderer)` renders its args from left to right (i.e. each component's weight is arising from left to right). |
||||
|
||||
__Grid layout:__ |
||||
|
||||
<img src="./_example/grid.gif" alt="grid" width="60%"> |
||||
|
||||
Grid layout uses [12 columns grid system](http://www.w3schools.com/bootstrap/bootstrap_grid_system.asp) with expressive syntax. To use `Grid`, all we need to do is build a widget tree consisting of `Row`s and `Col`s (Actually a `Col` is also a `Row` but with a widget endpoint attached). |
||||
|
||||
```go |
||||
import ui "github.com/gizak/termui" |
||||
// init and create widgets... |
||||
|
||||
// build |
||||
ui.Body.AddRows( |
||||
ui.NewRow( |
||||
ui.NewCol(6, 0, widget0), |
||||
ui.NewCol(6, 0, widget1)), |
||||
ui.NewRow( |
||||
ui.NewCol(3, 0, widget2), |
||||
ui.NewCol(3, 0, widget30, widget31, widget32), |
||||
ui.NewCol(6, 0, widget4))) |
||||
|
||||
// calculate layout |
||||
ui.Body.Align() |
||||
|
||||
ui.Render(ui.Body) |
||||
``` |
||||
|
||||
### Events |
||||
|
||||
`termui` ships with a http-like event mux handling system. All events are channeled up from different sources (typing, click, windows resize, custom event) and then encoded as universal `Event` object. `Event.Path` indicates the event type and `Event.Data` stores the event data struct. Add a handler to a certain event is easy as below: |
||||
|
||||
```go |
||||
// handle key q pressing |
||||
ui.Handle("/sys/kbd/q", func(ui.Event) { |
||||
// press q to quit |
||||
ui.StopLoop() |
||||
}) |
||||
|
||||
ui.Handle("/sys/kbd/C-x", func(ui.Event) { |
||||
// handle Ctrl + x combination |
||||
}) |
||||
|
||||
ui.Handle("/sys/kbd", func(ui.Event) { |
||||
// handle all other key pressing |
||||
}) |
||||
|
||||
// handle a 1s timer |
||||
ui.Handle("/timer/1s", func(e ui.Event) { |
||||
t := e.Data.(ui.EvtTimer) |
||||
// t is a EvtTimer |
||||
if t.Count%2 ==0 { |
||||
// do something |
||||
} |
||||
}) |
||||
|
||||
ui.Loop() // block until StopLoop is called |
||||
``` |
||||
|
||||
### Widgets |
||||
|
||||
Click image to see the corresponding demo codes. |
||||
|
||||
[<img src="./_example/par.png" alt="par" type="image/png" width="45%">](https://github.com/gizak/termui/blob/master/_example/par.go) |
||||
[<img src="./_example/list.png" alt="list" type="image/png" width="45%">](https://github.com/gizak/termui/blob/master/_example/list.go) |
||||
[<img src="./_example/gauge.png" alt="gauge" type="image/png" width="45%">](https://github.com/gizak/termui/blob/master/_example/gauge.go) |
||||
[<img src="./_example/linechart.png" alt="linechart" type="image/png" width="45%">](https://github.com/gizak/termui/blob/master/_example/linechart.go) |
||||
[<img src="./_example/barchart.png" alt="barchart" type="image/png" width="45%">](https://github.com/gizak/termui/blob/master/_example/barchart.go) |
||||
[<img src="./_example/mbarchart.png" alt="barchart" type="image/png" width="45%">](https://github.com/gizak/termui/blob/master/_example/mbarchart.go) |
||||
[<img src="./_example/sparklines.png" alt="sparklines" type="image/png" width="45%">](https://github.com/gizak/termui/blob/master/_example/sparklines.go) |
||||
[<img src="./_example/table.png" alt="table" type="image/png" width="45%">](https://github.com/gizak/termui/blob/master/_example/table.go) |
||||
|
||||
## GoDoc |
||||
|
||||
[godoc](https://godoc.org/github.com/gizak/termui) |
||||
|
||||
## TODO |
||||
|
||||
- [x] Grid layout |
||||
- [x] Event system |
||||
- [x] Canvas widget |
||||
- [x] Refine APIs |
||||
- [ ] Focusable widgets |
||||
|
||||
## Changelog |
||||
|
||||
## License |
||||
This library is under the [MIT License](http://opensource.org/licenses/MIT) |
||||
@ -1,149 +0,0 @@ |
||||
// Copyright 2017 Zack Guo <zack.y.guo@gmail.com>. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license that can
|
||||
// be found in the LICENSE file.
|
||||
|
||||
package termui |
||||
|
||||
import "fmt" |
||||
|
||||
// BarChart creates multiple bars in a widget:
|
||||
/* |
||||
bc := termui.NewBarChart() |
||||
data := []int{3, 2, 5, 3, 9, 5} |
||||
bclabels := []string{"S0", "S1", "S2", "S3", "S4", "S5"} |
||||
bc.BorderLabel = "Bar Chart" |
||||
bc.Data = data |
||||
bc.Width = 26 |
||||
bc.Height = 10 |
||||
bc.DataLabels = bclabels |
||||
bc.TextColor = termui.ColorGreen |
||||
bc.BarColor = termui.ColorRed |
||||
bc.NumColor = termui.ColorYellow |
||||
*/ |
||||
type BarChart struct { |
||||
Block |
||||
BarColor Attribute |
||||
TextColor Attribute |
||||
NumColor Attribute |
||||
Data []int |
||||
DataLabels []string |
||||
BarWidth int |
||||
BarGap int |
||||
CellChar rune |
||||
labels [][]rune |
||||
dataNum [][]rune |
||||
numBar int |
||||
scale float64 |
||||
max int |
||||
} |
||||
|
||||
// NewBarChart returns a new *BarChart with current theme.
|
||||
func NewBarChart() *BarChart { |
||||
bc := &BarChart{Block: *NewBlock()} |
||||
bc.BarColor = ThemeAttr("barchart.bar.bg") |
||||
bc.NumColor = ThemeAttr("barchart.num.fg") |
||||
bc.TextColor = ThemeAttr("barchart.text.fg") |
||||
bc.BarGap = 1 |
||||
bc.BarWidth = 3 |
||||
bc.CellChar = ' ' |
||||
return bc |
||||
} |
||||
|
||||
func (bc *BarChart) layout() { |
||||
bc.numBar = bc.innerArea.Dx() / (bc.BarGap + bc.BarWidth) |
||||
bc.labels = make([][]rune, bc.numBar) |
||||
bc.dataNum = make([][]rune, len(bc.Data)) |
||||
|
||||
for i := 0; i < bc.numBar && i < len(bc.DataLabels) && i < len(bc.Data); i++ { |
||||
bc.labels[i] = trimStr2Runes(bc.DataLabels[i], bc.BarWidth) |
||||
n := bc.Data[i] |
||||
s := fmt.Sprint(n) |
||||
bc.dataNum[i] = trimStr2Runes(s, bc.BarWidth) |
||||
} |
||||
|
||||
//bc.max = bc.Data[0] // what if Data is nil? Sometimes when bar graph is nill it produces panic with panic: runtime error: index out of range
|
||||
// Asign a negative value to get maxvalue auto-populates
|
||||
if bc.max == 0 { |
||||
bc.max = -1 |
||||
} |
||||
for i := 0; i < len(bc.Data); i++ { |
||||
if bc.max < bc.Data[i] { |
||||
bc.max = bc.Data[i] |
||||
} |
||||
} |
||||
bc.scale = float64(bc.max) / float64(bc.innerArea.Dy()-1) |
||||
} |
||||
|
||||
func (bc *BarChart) SetMax(max int) { |
||||
|
||||
if max > 0 { |
||||
bc.max = max |
||||
} |
||||
} |
||||
|
||||
// Buffer implements Bufferer interface.
|
||||
func (bc *BarChart) Buffer() Buffer { |
||||
buf := bc.Block.Buffer() |
||||
bc.layout() |
||||
|
||||
for i := 0; i < bc.numBar && i < len(bc.Data) && i < len(bc.DataLabels); i++ { |
||||
h := int(float64(bc.Data[i]) / bc.scale) |
||||
oftX := i * (bc.BarWidth + bc.BarGap) |
||||
|
||||
barBg := bc.Bg |
||||
barFg := bc.BarColor |
||||
|
||||
if bc.CellChar == ' ' { |
||||
barBg = bc.BarColor |
||||
barFg = ColorDefault |
||||
if bc.BarColor == ColorDefault { // the same as above
|
||||
barBg |= AttrReverse |
||||
} |
||||
} |
||||
|
||||
// plot bar
|
||||
for j := 0; j < bc.BarWidth; j++ { |
||||
for k := 0; k < h; k++ { |
||||
c := Cell{ |
||||
Ch: bc.CellChar, |
||||
Bg: barBg, |
||||
Fg: barFg, |
||||
} |
||||
|
||||
x := bc.innerArea.Min.X + i*(bc.BarWidth+bc.BarGap) + j |
||||
y := bc.innerArea.Min.Y + bc.innerArea.Dy() - 2 - k |
||||
buf.Set(x, y, c) |
||||
} |
||||
} |
||||
// plot text
|
||||
for j, k := 0, 0; j < len(bc.labels[i]); j++ { |
||||
w := charWidth(bc.labels[i][j]) |
||||
c := Cell{ |
||||
Ch: bc.labels[i][j], |
||||
Bg: bc.Bg, |
||||
Fg: bc.TextColor, |
||||
} |
||||
y := bc.innerArea.Min.Y + bc.innerArea.Dy() - 1 |
||||
x := bc.innerArea.Min.X + oftX + k |
||||
buf.Set(x, y, c) |
||||
k += w |
||||
} |
||||
// plot num
|
||||
for j := 0; j < len(bc.dataNum[i]); j++ { |
||||
c := Cell{ |
||||
Ch: bc.dataNum[i][j], |
||||
Fg: bc.NumColor, |
||||
Bg: barBg, |
||||
} |
||||
|
||||
if h == 0 { |
||||
c.Bg = bc.Bg |
||||
} |
||||
x := bc.innerArea.Min.X + oftX + (bc.BarWidth-len(bc.dataNum[i]))/2 + j |
||||
y := bc.innerArea.Min.Y + bc.innerArea.Dy() - 2 |
||||
buf.Set(x, y, c) |
||||
} |
||||
} |
||||
|
||||
return buf |
||||
} |
||||
@ -1,240 +0,0 @@ |
||||
// Copyright 2017 Zack Guo <zack.y.guo@gmail.com>. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license that can
|
||||
// be found in the LICENSE file.
|
||||
|
||||
package termui |
||||
|
||||
import "image" |
||||
|
||||
// Hline is a horizontal line.
|
||||
type Hline struct { |
||||
X int |
||||
Y int |
||||
Len int |
||||
Fg Attribute |
||||
Bg Attribute |
||||
} |
||||
|
||||
// Vline is a vertical line.
|
||||
type Vline struct { |
||||
X int |
||||
Y int |
||||
Len int |
||||
Fg Attribute |
||||
Bg Attribute |
||||
} |
||||
|
||||
// Buffer draws a horizontal line.
|
||||
func (l Hline) Buffer() Buffer { |
||||
if l.Len <= 0 { |
||||
return NewBuffer() |
||||
} |
||||
return NewFilledBuffer(l.X, l.Y, l.X+l.Len, l.Y+1, HORIZONTAL_LINE, l.Fg, l.Bg) |
||||
} |
||||
|
||||
// Buffer draws a vertical line.
|
||||
func (l Vline) Buffer() Buffer { |
||||
if l.Len <= 0 { |
||||
return NewBuffer() |
||||
} |
||||
return NewFilledBuffer(l.X, l.Y, l.X+1, l.Y+l.Len, VERTICAL_LINE, l.Fg, l.Bg) |
||||
} |
||||
|
||||
// Buffer draws a box border.
|
||||
func (b Block) drawBorder(buf Buffer) { |
||||
if !b.Border { |
||||
return |
||||
} |
||||
|
||||
min := b.area.Min |
||||
max := b.area.Max |
||||
|
||||
x0 := min.X |
||||
y0 := min.Y |
||||
x1 := max.X - 1 |
||||
y1 := max.Y - 1 |
||||
|
||||
// draw lines
|
||||
if b.BorderTop { |
||||
buf.Merge(Hline{x0, y0, x1 - x0, b.BorderFg, b.BorderBg}.Buffer()) |
||||
} |
||||
if b.BorderBottom { |
||||
buf.Merge(Hline{x0, y1, x1 - x0, b.BorderFg, b.BorderBg}.Buffer()) |
||||
} |
||||
if b.BorderLeft { |
||||
buf.Merge(Vline{x0, y0, y1 - y0, b.BorderFg, b.BorderBg}.Buffer()) |
||||
} |
||||
if b.BorderRight { |
||||
buf.Merge(Vline{x1, y0, y1 - y0, b.BorderFg, b.BorderBg}.Buffer()) |
||||
} |
||||
|
||||
// draw corners
|
||||
if b.BorderTop && b.BorderLeft && b.area.Dx() > 0 && b.area.Dy() > 0 { |
||||
buf.Set(x0, y0, Cell{TOP_LEFT, b.BorderFg, b.BorderBg}) |
||||
} |
||||
if b.BorderTop && b.BorderRight && b.area.Dx() > 1 && b.area.Dy() > 0 { |
||||
buf.Set(x1, y0, Cell{TOP_RIGHT, b.BorderFg, b.BorderBg}) |
||||
} |
||||
if b.BorderBottom && b.BorderLeft && b.area.Dx() > 0 && b.area.Dy() > 1 { |
||||
buf.Set(x0, y1, Cell{BOTTOM_LEFT, b.BorderFg, b.BorderBg}) |
||||
} |
||||
if b.BorderBottom && b.BorderRight && b.area.Dx() > 1 && b.area.Dy() > 1 { |
||||
buf.Set(x1, y1, Cell{BOTTOM_RIGHT, b.BorderFg, b.BorderBg}) |
||||
} |
||||
} |
||||
|
||||
func (b Block) drawBorderLabel(buf Buffer) { |
||||
maxTxtW := b.area.Dx() - 2 |
||||
tx := DTrimTxCls(DefaultTxBuilder.Build(b.BorderLabel, b.BorderLabelFg, b.BorderLabelBg), maxTxtW) |
||||
|
||||
for i, w := 0, 0; i < len(tx); i++ { |
||||
buf.Set(b.area.Min.X+1+w, b.area.Min.Y, tx[i]) |
||||
w += tx[i].Width() |
||||
} |
||||
} |
||||
|
||||
// Block is a base struct for all other upper level widgets,
|
||||
// consider it as css: display:block.
|
||||
// Normally you do not need to create it manually.
|
||||
type Block struct { |
||||
area image.Rectangle |
||||
innerArea image.Rectangle |
||||
X int |
||||
Y int |
||||
Border bool |
||||
BorderFg Attribute |
||||
BorderBg Attribute |
||||
BorderLeft bool |
||||
BorderRight bool |
||||
BorderTop bool |
||||
BorderBottom bool |
||||
BorderLabel string |
||||
BorderLabelFg Attribute |
||||
BorderLabelBg Attribute |
||||
Display bool |
||||
Bg Attribute |
||||
Width int |
||||
Height int |
||||
PaddingTop int |
||||
PaddingBottom int |
||||
PaddingLeft int |
||||
PaddingRight int |
||||
id string |
||||
Float Align |
||||
} |
||||
|
||||
// NewBlock returns a *Block which inherits styles from current theme.
|
||||
func NewBlock() *Block { |
||||
b := Block{} |
||||
b.Display = true |
||||
b.Border = true |
||||
b.BorderLeft = true |
||||
b.BorderRight = true |
||||
b.BorderTop = true |
||||
b.BorderBottom = true |
||||
b.BorderBg = ThemeAttr("border.bg") |
||||
b.BorderFg = ThemeAttr("border.fg") |
||||
b.BorderLabelBg = ThemeAttr("label.bg") |
||||
b.BorderLabelFg = ThemeAttr("label.fg") |
||||
b.Bg = ThemeAttr("block.bg") |
||||
b.Width = 2 |
||||
b.Height = 2 |
||||
b.id = GenId() |
||||
b.Float = AlignNone |
||||
return &b |
||||
} |
||||
|
||||
func (b Block) Id() string { |
||||
return b.id |
||||
} |
||||
|
||||
// Align computes box model
|
||||
func (b *Block) Align() { |
||||
// outer
|
||||
b.area.Min.X = 0 |
||||
b.area.Min.Y = 0 |
||||
b.area.Max.X = b.Width |
||||
b.area.Max.Y = b.Height |
||||
|
||||
// float
|
||||
b.area = AlignArea(TermRect(), b.area, b.Float) |
||||
b.area = MoveArea(b.area, b.X, b.Y) |
||||
|
||||
// inner
|
||||
b.innerArea.Min.X = b.area.Min.X + b.PaddingLeft |
||||
b.innerArea.Min.Y = b.area.Min.Y + b.PaddingTop |
||||
b.innerArea.Max.X = b.area.Max.X - b.PaddingRight |
||||
b.innerArea.Max.Y = b.area.Max.Y - b.PaddingBottom |
||||
|
||||
if b.Border { |
||||
if b.BorderLeft { |
||||
b.innerArea.Min.X++ |
||||
} |
||||
if b.BorderRight { |
||||
b.innerArea.Max.X-- |
||||
} |
||||
if b.BorderTop { |
||||
b.innerArea.Min.Y++ |
||||
} |
||||
if b.BorderBottom { |
||||
b.innerArea.Max.Y-- |
||||
} |
||||
} |
||||
} |
||||
|
||||
// InnerBounds returns the internal bounds of the block after aligning and
|
||||
// calculating the padding and border, if any.
|
||||
func (b *Block) InnerBounds() image.Rectangle { |
||||
b.Align() |
||||
return b.innerArea |
||||
} |
||||
|
||||
// Buffer implements Bufferer interface.
|
||||
// Draw background and border (if any).
|
||||
func (b *Block) Buffer() Buffer { |
||||
b.Align() |
||||
|
||||
buf := NewBuffer() |
||||
buf.SetArea(b.area) |
||||
buf.Fill(' ', ColorDefault, b.Bg) |
||||
|
||||
b.drawBorder(buf) |
||||
b.drawBorderLabel(buf) |
||||
|
||||
return buf |
||||
} |
||||
|
||||
// GetHeight implements GridBufferer.
|
||||
// It returns current height of the block.
|
||||
func (b Block) GetHeight() int { |
||||
return b.Height |
||||
} |
||||
|
||||
// SetX implements GridBufferer interface, which sets block's x position.
|
||||
func (b *Block) SetX(x int) { |
||||
b.X = x |
||||
} |
||||
|
||||
// SetY implements GridBufferer interface, it sets y position for block.
|
||||
func (b *Block) SetY(y int) { |
||||
b.Y = y |
||||
} |
||||
|
||||
// SetWidth implements GridBuffer interface, it sets block's width.
|
||||
func (b *Block) SetWidth(w int) { |
||||
b.Width = w |
||||
} |
||||
|
||||
func (b Block) InnerWidth() int { |
||||
return b.innerArea.Dx() |
||||
} |
||||
|
||||
func (b Block) InnerHeight() int { |
||||
return b.innerArea.Dy() |
||||
} |
||||
|
||||
func (b Block) InnerX() int { |
||||
return b.innerArea.Min.X |
||||
} |
||||
|
||||
func (b Block) InnerY() int { return b.innerArea.Min.Y } |
||||
@ -1,20 +0,0 @@ |
||||
// Copyright 2017 Zack Guo <zack.y.guo@gmail.com>. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license that can
|
||||
// be found in the LICENSE file.
|
||||
|
||||
// +build !windows
|
||||
|
||||
package termui |
||||
|
||||
const TOP_RIGHT = '┐' |
||||
const VERTICAL_LINE = '│' |
||||
const HORIZONTAL_LINE = '─' |
||||
const TOP_LEFT = '┌' |
||||
const BOTTOM_RIGHT = '┘' |
||||
const BOTTOM_LEFT = '└' |
||||
const VERTICAL_LEFT = '┤' |
||||
const VERTICAL_RIGHT = '├' |
||||
const HORIZONTAL_DOWN = '┬' |
||||
const HORIZONTAL_UP = '┴' |
||||
const QUOTA_LEFT = '«' |
||||
const QUOTA_RIGHT = '»' |
||||
@ -1,14 +0,0 @@ |
||||
// Copyright 2017 Zack Guo <zack.y.guo@gmail.com>. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license that can
|
||||
// be found in the LICENSE file.
|
||||
|
||||
// +build windows
|
||||
|
||||
package termui |
||||
|
||||
const TOP_RIGHT = '+' |
||||
const VERTICAL_LINE = '|' |
||||
const HORIZONTAL_LINE = '-' |
||||
const TOP_LEFT = '+' |
||||
const BOTTOM_RIGHT = '+' |
||||
const BOTTOM_LEFT = '+' |
||||
@ -1,106 +0,0 @@ |
||||
// Copyright 2017 Zack Guo <zack.y.guo@gmail.com>. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license that can
|
||||
// be found in the LICENSE file.
|
||||
|
||||
package termui |
||||
|
||||
import "image" |
||||
|
||||
// Cell is a rune with assigned Fg and Bg
|
||||
type Cell struct { |
||||
Ch rune |
||||
Fg Attribute |
||||
Bg Attribute |
||||
} |
||||
|
||||
// Buffer is a renderable rectangle cell data container.
|
||||
type Buffer struct { |
||||
Area image.Rectangle // selected drawing area
|
||||
CellMap map[image.Point]Cell |
||||
} |
||||
|
||||
// At returns the cell at (x,y).
|
||||
func (b Buffer) At(x, y int) Cell { |
||||
return b.CellMap[image.Pt(x, y)] |
||||
} |
||||
|
||||
// Set assigns a char to (x,y)
|
||||
func (b Buffer) Set(x, y int, c Cell) { |
||||
b.CellMap[image.Pt(x, y)] = c |
||||
} |
||||
|
||||
// Bounds returns the domain for which At can return non-zero color.
|
||||
func (b Buffer) Bounds() image.Rectangle { |
||||
x0, y0, x1, y1 := 0, 0, 0, 0 |
||||
for p := range b.CellMap { |
||||
if p.X > x1 { |
||||
x1 = p.X |
||||
} |
||||
if p.X < x0 { |
||||
x0 = p.X |
||||
} |
||||
if p.Y > y1 { |
||||
y1 = p.Y |
||||
} |
||||
if p.Y < y0 { |
||||
y0 = p.Y |
||||
} |
||||
} |
||||
return image.Rect(x0, y0, x1+1, y1+1) |
||||
} |
||||
|
||||
// SetArea assigns a new rect area to Buffer b.
|
||||
func (b *Buffer) SetArea(r image.Rectangle) { |
||||
b.Area.Max = r.Max |
||||
b.Area.Min = r.Min |
||||
} |
||||
|
||||
// Sync sets drawing area to the buffer's bound
|
||||
func (b *Buffer) Sync() { |
||||
b.SetArea(b.Bounds()) |
||||
} |
||||
|
||||
// NewCell returns a new cell
|
||||
func NewCell(ch rune, fg, bg Attribute) Cell { |
||||
return Cell{ch, fg, bg} |
||||
} |
||||
|
||||
// Merge merges bs Buffers onto b
|
||||
func (b *Buffer) Merge(bs ...Buffer) { |
||||
for _, buf := range bs { |
||||
for p, v := range buf.CellMap { |
||||
b.Set(p.X, p.Y, v) |
||||
} |
||||
b.SetArea(b.Area.Union(buf.Area)) |
||||
} |
||||
} |
||||
|
||||
// NewBuffer returns a new Buffer
|
||||
func NewBuffer() Buffer { |
||||
return Buffer{ |
||||
CellMap: make(map[image.Point]Cell), |
||||
Area: image.Rectangle{}} |
||||
} |
||||
|
||||
// Fill fills the Buffer b with ch,fg and bg.
|
||||
func (b Buffer) Fill(ch rune, fg, bg Attribute) { |
||||
for x := b.Area.Min.X; x < b.Area.Max.X; x++ { |
||||
for y := b.Area.Min.Y; y < b.Area.Max.Y; y++ { |
||||
b.Set(x, y, Cell{ch, fg, bg}) |
||||
} |
||||
} |
||||
} |
||||
|
||||
// NewFilledBuffer returns a new Buffer filled with ch, fb and bg.
|
||||
func NewFilledBuffer(x0, y0, x1, y1 int, ch rune, fg, bg Attribute) Buffer { |
||||
buf := NewBuffer() |
||||
buf.Area.Min = image.Pt(x0, y0) |
||||
buf.Area.Max = image.Pt(x1, y1) |
||||
|
||||
for x := buf.Area.Min.X; x < buf.Area.Max.X; x++ { |
||||
for y := buf.Area.Min.Y; y < buf.Area.Max.Y; y++ { |
||||
buf.Set(x, y, Cell{ch, fg, bg}) |
||||
} |
||||
} |
||||
return buf |
||||
} |
||||
@ -1,72 +0,0 @@ |
||||
// Copyright 2017 Zack Guo <zack.y.guo@gmail.com>. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license that can
|
||||
// be found in the LICENSE file.
|
||||
|
||||
package termui |
||||
|
||||
/* |
||||
dots: |
||||
,___, |
||||
|1 4| |
||||
|2 5| |
||||
|3 6| |
||||
|7 8| |
||||
````` |
||||
*/ |
||||
|
||||
var brailleBase = '\u2800' |
||||
|
||||
var brailleOftMap = [4][2]rune{ |
||||
{'\u0001', '\u0008'}, |
||||
{'\u0002', '\u0010'}, |
||||
{'\u0004', '\u0020'}, |
||||
{'\u0040', '\u0080'}} |
||||
|
||||
// Canvas contains drawing map: i,j -> rune
|
||||
type Canvas map[[2]int]rune |
||||
|
||||
// NewCanvas returns an empty Canvas
|
||||
func NewCanvas() Canvas { |
||||
return make(map[[2]int]rune) |
||||
} |
||||
|
||||
func chOft(x, y int) rune { |
||||
return brailleOftMap[y%4][x%2] |
||||
} |
||||
|
||||
func (c Canvas) rawCh(x, y int) rune { |
||||
if ch, ok := c[[2]int{x, y}]; ok { |
||||
return ch |
||||
} |
||||
return '\u0000' //brailleOffset
|
||||
} |
||||
|
||||
// return coordinate in terminal
|
||||
func chPos(x, y int) (int, int) { |
||||
return y / 4, x / 2 |
||||
} |
||||
|
||||
// Set sets a point (x,y) in the virtual coordinate
|
||||
func (c Canvas) Set(x, y int) { |
||||
i, j := chPos(x, y) |
||||
ch := c.rawCh(i, j) |
||||
ch |= chOft(x, y) |
||||
c[[2]int{i, j}] = ch |
||||
} |
||||
|
||||
// Unset removes point (x,y)
|
||||
func (c Canvas) Unset(x, y int) { |
||||
i, j := chPos(x, y) |
||||
ch := c.rawCh(i, j) |
||||
ch &= ^chOft(x, y) |
||||
c[[2]int{i, j}] = ch |
||||
} |
||||
|
||||
// Buffer returns un-styled points
|
||||
func (c Canvas) Buffer() Buffer { |
||||
buf := NewBuffer() |
||||
for k, v := range c { |
||||
buf.Set(k[0], k[1], Cell{Ch: v + brailleBase}) |
||||
} |
||||
return buf |
||||
} |
||||
@ -1,54 +0,0 @@ |
||||
#!/usr/bin/env python3 |
||||
|
||||
import re |
||||
import os |
||||
import io |
||||
|
||||
copyright = """// Copyright 2017 Zack Guo <zack.y.guo@gmail.com>. All rights reserved. |
||||
// Use of this source code is governed by a MIT license that can |
||||
// be found in the LICENSE file. |
||||
|
||||
""" |
||||
|
||||
exclude_dirs = [".git", "_docs"] |
||||
exclude_files = [] |
||||
include_dirs = [".", "debug", "extra", "test", "_example"] |
||||
|
||||
|
||||
def is_target(fpath): |
||||
if os.path.splitext(fpath)[-1] == ".go": |
||||
return True |
||||
return False |
||||
|
||||
|
||||
def update_copyright(fpath): |
||||
print("processing " + fpath) |
||||
f = io.open(fpath, 'r', encoding='utf-8') |
||||
fstr = f.read() |
||||
f.close() |
||||
|
||||
# remove old |
||||
m = re.search('^// Copyright .+?\r?\n\r?\n', fstr, re.MULTILINE|re.DOTALL) |
||||
if m: |
||||
fstr = fstr[m.end():] |
||||
|
||||
# add new |
||||
fstr = copyright + fstr |
||||
f = io.open(fpath, 'w',encoding='utf-8') |
||||
f.write(fstr) |
||||
f.close() |
||||
|
||||
|
||||
def main(): |
||||
for d in include_dirs: |
||||
files = [ |
||||
os.path.join(d, f) for f in os.listdir(d) |
||||
if os.path.isfile(os.path.join(d, f)) |
||||
] |
||||
for f in files: |
||||
if is_target(f): |
||||
update_copyright(f) |
||||
|
||||
|
||||
if __name__ == '__main__': |
||||
main() |
||||
@ -1,29 +0,0 @@ |
||||
// Copyright 2017 Zack Guo <zack.y.guo@gmail.com>. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license that can
|
||||
// be found in the LICENSE file.
|
||||
|
||||
/* |
||||
Package termui is a library designed for creating command line UI. For more info, goto http://github.com/gizak/termui
|
||||
|
||||
A simplest example: |
||||
package main |
||||
|
||||
import ui "github.com/gizak/termui" |
||||
|
||||
func main() { |
||||
if err:=ui.Init(); err != nil { |
||||
panic(err) |
||||
} |
||||
defer ui.Close() |
||||
|
||||
g := ui.NewGauge() |
||||
g.Percent = 50 |
||||
g.Width = 50 |
||||
g.BorderLabel = "Gauge" |
||||
|
||||
ui.Render(g) |
||||
|
||||
ui.Loop() |
||||
} |
||||
*/ |
||||
package termui |
||||
@ -1,324 +0,0 @@ |
||||
// Copyright 2017 Zack Guo <zack.y.guo@gmail.com>. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license that can
|
||||
// be found in the LICENSE file.
|
||||
|
||||
package termui |
||||
|
||||
import ( |
||||
"path" |
||||
"strconv" |
||||
"sync" |
||||
"time" |
||||
|
||||
"github.com/nsf/termbox-go" |
||||
) |
||||
|
||||
type Event struct { |
||||
Type string |
||||
Path string |
||||
From string |
||||
To string |
||||
Data interface{} |
||||
Time int64 |
||||
} |
||||
|
||||
var sysEvtChs []chan Event |
||||
|
||||
type EvtKbd struct { |
||||
KeyStr string |
||||
} |
||||
|
||||
func evtKbd(e termbox.Event) EvtKbd { |
||||
ek := EvtKbd{} |
||||
|
||||
k := string(e.Ch) |
||||
pre := "" |
||||
mod := "" |
||||
|
||||
if e.Mod == termbox.ModAlt { |
||||
mod = "M-" |
||||
} |
||||
if e.Ch == 0 { |
||||
if e.Key > 0xFFFF-12 { |
||||
k = "<f" + strconv.Itoa(0xFFFF-int(e.Key)+1) + ">" |
||||
} else if e.Key > 0xFFFF-25 { |
||||
ks := []string{"<insert>", "<delete>", "<home>", "<end>", "<previous>", "<next>", "<up>", "<down>", "<left>", "<right>"} |
||||
k = ks[0xFFFF-int(e.Key)-12] |
||||
} |
||||
|
||||
if e.Key <= 0x7F { |
||||
pre = "C-" |
||||
k = string('a' - 1 + int(e.Key)) |
||||
kmap := map[termbox.Key][2]string{ |
||||
termbox.KeyCtrlSpace: {"C-", "<space>"}, |
||||
termbox.KeyBackspace: {"", "<backspace>"}, |
||||
termbox.KeyTab: {"", "<tab>"}, |
||||
termbox.KeyEnter: {"", "<enter>"}, |
||||
termbox.KeyEsc: {"", "<escape>"}, |
||||
termbox.KeyCtrlBackslash: {"C-", "\\"}, |
||||
termbox.KeyCtrlSlash: {"C-", "/"}, |
||||
termbox.KeySpace: {"", "<space>"}, |
||||
termbox.KeyCtrl8: {"C-", "8"}, |
||||
} |
||||
if sk, ok := kmap[e.Key]; ok { |
||||
pre = sk[0] |
||||
k = sk[1] |
||||
} |
||||
} |
||||
} |
||||
|
||||
ek.KeyStr = pre + mod + k |
||||
return ek |
||||
} |
||||
|
||||
func crtTermboxEvt(e termbox.Event) Event { |
||||
systypemap := map[termbox.EventType]string{ |
||||
termbox.EventKey: "keyboard", |
||||
termbox.EventResize: "window", |
||||
termbox.EventMouse: "mouse", |
||||
termbox.EventError: "error", |
||||
termbox.EventInterrupt: "interrupt", |
||||
} |
||||
ne := Event{From: "/sys", Time: time.Now().Unix()} |
||||
typ := e.Type |
||||
ne.Type = systypemap[typ] |
||||
|
||||
switch typ { |
||||
case termbox.EventKey: |
||||
kbd := evtKbd(e) |
||||
ne.Path = "/sys/kbd/" + kbd.KeyStr |
||||
ne.Data = kbd |
||||
case termbox.EventResize: |
||||
wnd := EvtWnd{} |
||||
wnd.Width = e.Width |
||||
wnd.Height = e.Height |
||||
ne.Path = "/sys/wnd/resize" |
||||
ne.Data = wnd |
||||
case termbox.EventError: |
||||
err := EvtErr(e.Err) |
||||
ne.Path = "/sys/err" |
||||
ne.Data = err |
||||
case termbox.EventMouse: |
||||
m := EvtMouse{} |
||||
m.X = e.MouseX |
||||
m.Y = e.MouseY |
||||
ne.Path = "/sys/mouse" |
||||
ne.Data = m |
||||
} |
||||
return ne |
||||
} |
||||
|
||||
type EvtWnd struct { |
||||
Width int |
||||
Height int |
||||
} |
||||
|
||||
type EvtMouse struct { |
||||
X int |
||||
Y int |
||||
Press string |
||||
} |
||||
|
||||
type EvtErr error |
||||
|
||||
func hookTermboxEvt() { |
||||
for { |
||||
e := termbox.PollEvent() |
||||
|
||||
for _, c := range sysEvtChs { |
||||
go func(ch chan Event) { |
||||
ch <- crtTermboxEvt(e) |
||||
}(c) |
||||
} |
||||
} |
||||
} |
||||
|
||||
func NewSysEvtCh() chan Event { |
||||
ec := make(chan Event) |
||||
sysEvtChs = append(sysEvtChs, ec) |
||||
return ec |
||||
} |
||||
|
||||
var DefaultEvtStream = NewEvtStream() |
||||
|
||||
type EvtStream struct { |
||||
sync.RWMutex |
||||
srcMap map[string]chan Event |
||||
stream chan Event |
||||
wg sync.WaitGroup |
||||
sigStopLoop chan Event |
||||
Handlers map[string]func(Event) |
||||
hook func(Event) |
||||
} |
||||
|
||||
func NewEvtStream() *EvtStream { |
||||
return &EvtStream{ |
||||
srcMap: make(map[string]chan Event), |
||||
stream: make(chan Event), |
||||
Handlers: make(map[string]func(Event)), |
||||
sigStopLoop: make(chan Event), |
||||
} |
||||
} |
||||
|
||||
func (es *EvtStream) Init() { |
||||
es.Merge("internal", es.sigStopLoop) |
||||
go func() { |
||||
es.wg.Wait() |
||||
close(es.stream) |
||||
}() |
||||
} |
||||
|
||||
func cleanPath(p string) string { |
||||
if p == "" { |
||||
return "/" |
||||
} |
||||
if p[0] != '/' { |
||||
p = "/" + p |
||||
} |
||||
return path.Clean(p) |
||||
} |
||||
|
||||
func isPathMatch(pattern, path string) bool { |
||||
if len(pattern) == 0 { |
||||
return false |
||||
} |
||||
n := len(pattern) |
||||
return len(path) >= n && path[0:n] == pattern |
||||
} |
||||
|
||||
func (es *EvtStream) Merge(name string, ec chan Event) { |
||||
es.Lock() |
||||
defer es.Unlock() |
||||
|
||||
es.wg.Add(1) |
||||
es.srcMap[name] = ec |
||||
|
||||
go func(a chan Event) { |
||||
for n := range a { |
||||
n.From = name |
||||
es.stream <- n |
||||
} |
||||
es.wg.Done() |
||||
}(ec) |
||||
} |
||||
|
||||
func (es *EvtStream) Handle(path string, handler func(Event)) { |
||||
es.Handlers[cleanPath(path)] = handler |
||||
} |
||||
|
||||
func findMatch(mux map[string]func(Event), path string) string { |
||||
n := -1 |
||||
pattern := "" |
||||
for m := range mux { |
||||
if !isPathMatch(m, path) { |
||||
continue |
||||
} |
||||
if len(m) > n { |
||||
pattern = m |
||||
n = len(m) |
||||
} |
||||
} |
||||
return pattern |
||||
|
||||
} |
||||
|
||||
// Remove all existing defined Handlers from the map
|
||||
func (es *EvtStream) ResetHandlers() { |
||||
for Path, _ := range es.Handlers { |
||||
delete(es.Handlers, Path) |
||||
} |
||||
return |
||||
} |
||||
|
||||
func (es *EvtStream) match(path string) string { |
||||
return findMatch(es.Handlers, path) |
||||
} |
||||
|
||||
func (es *EvtStream) Hook(f func(Event)) { |
||||
es.hook = f |
||||
} |
||||
|
||||
func (es *EvtStream) Loop() { |
||||
for e := range es.stream { |
||||
switch e.Path { |
||||
case "/sig/stoploop": |
||||
return |
||||
} |
||||
go func(a Event) { |
||||
es.RLock() |
||||
defer es.RUnlock() |
||||
if pattern := es.match(a.Path); pattern != "" { |
||||
es.Handlers[pattern](a) |
||||
} |
||||
}(e) |
||||
if es.hook != nil { |
||||
es.hook(e) |
||||
} |
||||
} |
||||
} |
||||
|
||||
func (es *EvtStream) StopLoop() { |
||||
go func() { |
||||
e := Event{ |
||||
Path: "/sig/stoploop", |
||||
} |
||||
es.sigStopLoop <- e |
||||
}() |
||||
} |
||||
|
||||
func Merge(name string, ec chan Event) { |
||||
DefaultEvtStream.Merge(name, ec) |
||||
} |
||||
|
||||
func Handle(path string, handler func(Event)) { |
||||
DefaultEvtStream.Handle(path, handler) |
||||
} |
||||
|
||||
func Loop() { |
||||
DefaultEvtStream.Loop() |
||||
} |
||||
|
||||
func StopLoop() { |
||||
DefaultEvtStream.StopLoop() |
||||
} |
||||
|
||||
type EvtTimer struct { |
||||
Duration time.Duration |
||||
Count uint64 |
||||
} |
||||
|
||||
func NewTimerCh(du time.Duration) chan Event { |
||||
t := make(chan Event) |
||||
|
||||
go func(a chan Event) { |
||||
n := uint64(0) |
||||
for { |
||||
n++ |
||||
time.Sleep(du) |
||||
e := Event{} |
||||
e.Type = "timer" |
||||
e.Path = "/timer/" + du.String() |
||||
e.Time = time.Now().Unix() |
||||
e.Data = EvtTimer{ |
||||
Duration: du, |
||||
Count: n, |
||||
} |
||||
t <- e |
||||
|
||||
} |
||||
}(t) |
||||
return t |
||||
} |
||||
|
||||
var DefaultHandler = func(e Event) { |
||||
} |
||||
|
||||
var usrEvtCh = make(chan Event) |
||||
|
||||
func SendCustomEvt(path string, data interface{}) { |
||||
e := Event{} |
||||
e.Path = path |
||||
e.Data = data |
||||
e.Time = time.Now().Unix() |
||||
usrEvtCh <- e |
||||
} |
||||
@ -1,109 +0,0 @@ |
||||
// Copyright 2017 Zack Guo <zack.y.guo@gmail.com>. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license that can
|
||||
// be found in the LICENSE file.
|
||||
|
||||
package termui |
||||
|
||||
import ( |
||||
"strconv" |
||||
"strings" |
||||
) |
||||
|
||||
// Gauge is a progress bar like widget.
|
||||
// A simple example:
|
||||
/* |
||||
g := termui.NewGauge() |
||||
g.Percent = 40 |
||||
g.Width = 50 |
||||
g.Height = 3 |
||||
g.BorderLabel = "Slim Gauge" |
||||
g.BarColor = termui.ColorRed |
||||
g.PercentColor = termui.ColorBlue |
||||
*/ |
||||
|
||||
const ColorUndef Attribute = Attribute(^uint16(0)) |
||||
|
||||
type Gauge struct { |
||||
Block |
||||
Percent int |
||||
BarColor Attribute |
||||
PercentColor Attribute |
||||
PercentColorHighlighted Attribute |
||||
Label string |
||||
LabelAlign Align |
||||
} |
||||
|
||||
// NewGauge return a new gauge with current theme.
|
||||
func NewGauge() *Gauge { |
||||
g := &Gauge{ |
||||
Block: *NewBlock(), |
||||
PercentColor: ThemeAttr("gauge.percent.fg"), |
||||
BarColor: ThemeAttr("gauge.bar.bg"), |
||||
Label: "{{percent}}%", |
||||
LabelAlign: AlignCenter, |
||||
PercentColorHighlighted: ColorUndef, |
||||
} |
||||
|
||||
g.Width = 12 |
||||
g.Height = 5 |
||||
return g |
||||
} |
||||
|
||||
// Buffer implements Bufferer interface.
|
||||
func (g *Gauge) Buffer() Buffer { |
||||
buf := g.Block.Buffer() |
||||
|
||||
// plot bar
|
||||
w := g.Percent * g.innerArea.Dx() / 100 |
||||
for i := 0; i < g.innerArea.Dy(); i++ { |
||||
for j := 0; j < w; j++ { |
||||
c := Cell{} |
||||
c.Ch = ' ' |
||||
c.Bg = g.BarColor |
||||
if c.Bg == ColorDefault { |
||||
c.Bg |= AttrReverse |
||||
} |
||||
buf.Set(g.innerArea.Min.X+j, g.innerArea.Min.Y+i, c) |
||||
} |
||||
} |
||||
|
||||
// plot percentage
|
||||
s := strings.Replace(g.Label, "{{percent}}", strconv.Itoa(g.Percent), -1) |
||||
pry := g.innerArea.Min.Y + g.innerArea.Dy()/2 |
||||
rs := str2runes(s) |
||||
var pos int |
||||
switch g.LabelAlign { |
||||
case AlignLeft: |
||||
pos = 0 |
||||
|
||||
case AlignCenter: |
||||
pos = (g.innerArea.Dx() - strWidth(s)) / 2 |
||||
|
||||
case AlignRight: |
||||
pos = g.innerArea.Dx() - strWidth(s) - 1 |
||||
} |
||||
pos += g.innerArea.Min.X |
||||
|
||||
for i, v := range rs { |
||||
c := Cell{ |
||||
Ch: v, |
||||
Fg: g.PercentColor, |
||||
} |
||||
|
||||
if w+g.innerArea.Min.X > pos+i { |
||||
c.Bg = g.BarColor |
||||
if c.Bg == ColorDefault { |
||||
c.Bg |= AttrReverse |
||||
} |
||||
|
||||
if g.PercentColorHighlighted != ColorUndef { |
||||
c.Fg = g.PercentColorHighlighted |
||||
} |
||||
} else { |
||||
c.Bg = g.Block.Bg |
||||
} |
||||
|
||||
buf.Set(1+pos+i, pry, c) |
||||
} |
||||
return buf |
||||
} |
||||
@ -1,30 +0,0 @@ |
||||
hash: 7a754ba100256404a978b2fc8738aee337beb822458e4b6060399fb89ebd215c |
||||
updated: 2016-11-03T17:39:24.323773674-04:00 |
||||
imports: |
||||
- name: github.com/maruel/panicparse |
||||
version: ad661195ed0e88491e0f14be6613304e3b1141d6 |
||||
subpackages: |
||||
- stack |
||||
- name: github.com/mattn/go-runewidth |
||||
version: 737072b4e32b7a5018b4a7125da8d12de90e8045 |
||||
- name: github.com/mitchellh/go-wordwrap |
||||
version: ad45545899c7b13c020ea92b2072220eefad42b8 |
||||
- name: github.com/nsf/termbox-go |
||||
version: b6acae516ace002cb8105a89024544a1480655a5 |
||||
- name: golang.org/x/net |
||||
version: 569280fa63be4e201b975e5411e30a92178f0118 |
||||
subpackages: |
||||
- websocket |
||||
testImports: |
||||
- name: github.com/davecgh/go-spew |
||||
version: 346938d642f2ec3594ed81d874461961cd0faa76 |
||||
subpackages: |
||||
- spew |
||||
- name: github.com/pmezard/go-difflib |
||||
version: d8ed2627bdf02c080bf22230dbb337003b7aba2d |
||||
subpackages: |
||||
- difflib |
||||
- name: github.com/stretchr/testify |
||||
version: 976c720a22c8eb4eb6a0b4348ad85ad12491a506 |
||||
subpackages: |
||||
- assert |
||||
@ -1,9 +0,0 @@ |
||||
package: github.com/gizak/termui |
||||
import: |
||||
- package: github.com/mattn/go-runewidth |
||||
- package: github.com/mitchellh/go-wordwrap |
||||
- package: github.com/nsf/termbox-go |
||||
- package: golang.org/x/net |
||||
subpackages: |
||||
- websocket |
||||
- package: github.com/maruel/panicparse |
||||
@ -1,279 +0,0 @@ |
||||
// Copyright 2017 Zack Guo <zack.y.guo@gmail.com>. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license that can
|
||||
// be found in the LICENSE file.
|
||||
|
||||
package termui |
||||
|
||||
// GridBufferer introduces a Bufferer that can be manipulated by Grid.
|
||||
type GridBufferer interface { |
||||
Bufferer |
||||
GetHeight() int |
||||
SetWidth(int) |
||||
SetX(int) |
||||
SetY(int) |
||||
} |
||||
|
||||
// Row builds a layout tree
|
||||
type Row struct { |
||||
Cols []*Row //children
|
||||
Widget GridBufferer // root
|
||||
X int |
||||
Y int |
||||
Width int |
||||
Height int |
||||
Span int |
||||
Offset int |
||||
} |
||||
|
||||
// calculate and set the underlying layout tree's x, y, height and width.
|
||||
func (r *Row) calcLayout() { |
||||
r.assignWidth(r.Width) |
||||
r.Height = r.solveHeight() |
||||
r.assignX(r.X) |
||||
r.assignY(r.Y) |
||||
} |
||||
|
||||
// tell if the node is leaf in the tree.
|
||||
func (r *Row) isLeaf() bool { |
||||
return r.Cols == nil || len(r.Cols) == 0 |
||||
} |
||||
|
||||
func (r *Row) isRenderableLeaf() bool { |
||||
return r.isLeaf() && r.Widget != nil |
||||
} |
||||
|
||||
// assign widgets' (and their parent rows') width recursively.
|
||||
func (r *Row) assignWidth(w int) { |
||||
r.SetWidth(w) |
||||
|
||||
accW := 0 // acc span and offset
|
||||
calcW := make([]int, len(r.Cols)) // calculated width
|
||||
calcOftX := make([]int, len(r.Cols)) // computated start position of x
|
||||
|
||||
for i, c := range r.Cols { |
||||
accW += c.Span + c.Offset |
||||
cw := int(float64(c.Span*r.Width) / 12.0) |
||||
|
||||
if i >= 1 { |
||||
calcOftX[i] = calcOftX[i-1] + |
||||
calcW[i-1] + |
||||
int(float64(r.Cols[i-1].Offset*r.Width)/12.0) |
||||
} |
||||
|
||||
// use up the space if it is the last col
|
||||
if i == len(r.Cols)-1 && accW == 12 { |
||||
cw = r.Width - calcOftX[i] |
||||
} |
||||
calcW[i] = cw |
||||
r.Cols[i].assignWidth(cw) |
||||
} |
||||
} |
||||
|
||||
// bottom up calc and set rows' (and their widgets') height,
|
||||
// return r's total height.
|
||||
func (r *Row) solveHeight() int { |
||||
if r.isRenderableLeaf() { |
||||
r.Height = r.Widget.GetHeight() |
||||
return r.Widget.GetHeight() |
||||
} |
||||
|
||||
maxh := 0 |
||||
if !r.isLeaf() { |
||||
for _, c := range r.Cols { |
||||
nh := c.solveHeight() |
||||
// when embed rows in Cols, row widgets stack up
|
||||
if r.Widget != nil { |
||||
nh += r.Widget.GetHeight() |
||||
} |
||||
if nh > maxh { |
||||
maxh = nh |
||||
} |
||||
} |
||||
} |
||||
|
||||
r.Height = maxh |
||||
return maxh |
||||
} |
||||
|
||||
// recursively assign x position for r tree.
|
||||
func (r *Row) assignX(x int) { |
||||
r.SetX(x) |
||||
|
||||
if !r.isLeaf() { |
||||
acc := 0 |
||||
for i, c := range r.Cols { |
||||
if c.Offset != 0 { |
||||
acc += int(float64(c.Offset*r.Width) / 12.0) |
||||
} |
||||
r.Cols[i].assignX(x + acc) |
||||
acc += c.Width |
||||
} |
||||
} |
||||
} |
||||
|
||||
// recursively assign y position to r.
|
||||
func (r *Row) assignY(y int) { |
||||
r.SetY(y) |
||||
|
||||
if r.isLeaf() { |
||||
return |
||||
} |
||||
|
||||
for i := range r.Cols { |
||||
acc := 0 |
||||
if r.Widget != nil { |
||||
acc = r.Widget.GetHeight() |
||||
} |
||||
r.Cols[i].assignY(y + acc) |
||||
} |
||||
|
||||
} |
||||
|
||||
// GetHeight implements GridBufferer interface.
|
||||
func (r Row) GetHeight() int { |
||||
return r.Height |
||||
} |
||||
|
||||
// SetX implements GridBufferer interface.
|
||||
func (r *Row) SetX(x int) { |
||||
r.X = x |
||||
if r.Widget != nil { |
||||
r.Widget.SetX(x) |
||||
} |
||||
} |
||||
|
||||
// SetY implements GridBufferer interface.
|
||||
func (r *Row) SetY(y int) { |
||||
r.Y = y |
||||
if r.Widget != nil { |
||||
r.Widget.SetY(y) |
||||
} |
||||
} |
||||
|
||||
// SetWidth implements GridBufferer interface.
|
||||
func (r *Row) SetWidth(w int) { |
||||
r.Width = w |
||||
if r.Widget != nil { |
||||
r.Widget.SetWidth(w) |
||||
} |
||||
} |
||||
|
||||
// Buffer implements Bufferer interface,
|
||||
// recursively merge all widgets buffer
|
||||
func (r *Row) Buffer() Buffer { |
||||
merged := NewBuffer() |
||||
|
||||
if r.isRenderableLeaf() { |
||||
return r.Widget.Buffer() |
||||
} |
||||
|
||||
// for those are not leaves but have a renderable widget
|
||||
if r.Widget != nil { |
||||
merged.Merge(r.Widget.Buffer()) |
||||
} |
||||
|
||||
// collect buffer from children
|
||||
if !r.isLeaf() { |
||||
for _, c := range r.Cols { |
||||
merged.Merge(c.Buffer()) |
||||
} |
||||
} |
||||
|
||||
return merged |
||||
} |
||||
|
||||
// Grid implements 12 columns system.
|
||||
// A simple example:
|
||||
/* |
||||
import ui "github.com/gizak/termui" |
||||
// init and create widgets...
|
||||
|
||||
// build
|
||||
ui.Body.AddRows( |
||||
ui.NewRow( |
||||
ui.NewCol(6, 0, widget0), |
||||
ui.NewCol(6, 0, widget1)), |
||||
ui.NewRow( |
||||
ui.NewCol(3, 0, widget2), |
||||
ui.NewCol(3, 0, widget30, widget31, widget32), |
||||
ui.NewCol(6, 0, widget4))) |
||||
|
||||
// calculate layout
|
||||
ui.Body.Align() |
||||
|
||||
ui.Render(ui.Body) |
||||
*/ |
||||
type Grid struct { |
||||
Rows []*Row |
||||
Width int |
||||
X int |
||||
Y int |
||||
BgColor Attribute |
||||
} |
||||
|
||||
// NewGrid returns *Grid with given rows.
|
||||
func NewGrid(rows ...*Row) *Grid { |
||||
return &Grid{Rows: rows} |
||||
} |
||||
|
||||
// AddRows appends given rows to Grid.
|
||||
func (g *Grid) AddRows(rs ...*Row) { |
||||
g.Rows = append(g.Rows, rs...) |
||||
} |
||||
|
||||
// NewRow creates a new row out of given columns.
|
||||
func NewRow(cols ...*Row) *Row { |
||||
rs := &Row{Span: 12, Cols: cols} |
||||
return rs |
||||
} |
||||
|
||||
// NewCol accepts: widgets are LayoutBufferer or widgets is A NewRow.
|
||||
// Note that if multiple widgets are provided, they will stack up in the col.
|
||||
func NewCol(span, offset int, widgets ...GridBufferer) *Row { |
||||
r := &Row{Span: span, Offset: offset} |
||||
|
||||
if widgets != nil && len(widgets) == 1 { |
||||
wgt := widgets[0] |
||||
nw, isRow := wgt.(*Row) |
||||
if isRow { |
||||
r.Cols = nw.Cols |
||||
} else { |
||||
r.Widget = wgt |
||||
} |
||||
return r |
||||
} |
||||
|
||||
r.Cols = []*Row{} |
||||
ir := r |
||||
for _, w := range widgets { |
||||
nr := &Row{Span: 12, Widget: w} |
||||
ir.Cols = []*Row{nr} |
||||
ir = nr |
||||
} |
||||
|
||||
return r |
||||
} |
||||
|
||||
// Align calculate each rows' layout.
|
||||
func (g *Grid) Align() { |
||||
h := 0 |
||||
for _, r := range g.Rows { |
||||
r.SetWidth(g.Width) |
||||
r.SetX(g.X) |
||||
r.SetY(g.Y + h) |
||||
r.calcLayout() |
||||
h += r.GetHeight() |
||||
} |
||||
} |
||||
|
||||
// Buffer implments Bufferer interface.
|
||||
func (g Grid) Buffer() Buffer { |
||||
buf := NewBuffer() |
||||
|
||||
for _, r := range g.Rows { |
||||
buf.Merge(r.Buffer()) |
||||
} |
||||
return buf |
||||
} |
||||
|
||||
var Body *Grid |
||||
@ -1,222 +0,0 @@ |
||||
// Copyright 2017 Zack Guo <zack.y.guo@gmail.com>. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license that can
|
||||
// be found in the LICENSE file.
|
||||
|
||||
package termui |
||||
|
||||
import ( |
||||
"regexp" |
||||
"strings" |
||||
|
||||
tm "github.com/nsf/termbox-go" |
||||
) |
||||
import rw "github.com/mattn/go-runewidth" |
||||
|
||||
/* ---------------Port from termbox-go --------------------- */ |
||||
|
||||
// Attribute is printable cell's color and style.
|
||||
type Attribute uint16 |
||||
|
||||
// 8 basic clolrs
|
||||
const ( |
||||
ColorDefault Attribute = iota |
||||
ColorBlack |
||||
ColorRed |
||||
ColorGreen |
||||
ColorYellow |
||||
ColorBlue |
||||
ColorMagenta |
||||
ColorCyan |
||||
ColorWhite |
||||
) |
||||
|
||||
//Have a constant that defines number of colors
|
||||
const NumberofColors = 8 |
||||
|
||||
// Text style
|
||||
const ( |
||||
AttrBold Attribute = 1 << (iota + 9) |
||||
AttrUnderline |
||||
AttrReverse |
||||
) |
||||
|
||||
var ( |
||||
dot = "…" |
||||
dotw = rw.StringWidth(dot) |
||||
) |
||||
|
||||
/* ----------------------- End ----------------------------- */ |
||||
|
||||
func toTmAttr(x Attribute) tm.Attribute { |
||||
return tm.Attribute(x) |
||||
} |
||||
|
||||
func str2runes(s string) []rune { |
||||
return []rune(s) |
||||
} |
||||
|
||||
// Here for backwards-compatibility.
|
||||
func trimStr2Runes(s string, w int) []rune { |
||||
return TrimStr2Runes(s, w) |
||||
} |
||||
|
||||
// TrimStr2Runes trims string to w[-1 rune], appends …, and returns the runes
|
||||
// of that string if string is grather then n. If string is small then w,
|
||||
// return the runes.
|
||||
func TrimStr2Runes(s string, w int) []rune { |
||||
if w <= 0 { |
||||
return []rune{} |
||||
} |
||||
|
||||
sw := rw.StringWidth(s) |
||||
if sw > w { |
||||
return []rune(rw.Truncate(s, w, dot)) |
||||
} |
||||
return str2runes(s) |
||||
} |
||||
|
||||
// TrimStrIfAppropriate trim string to "s[:-1] + …"
|
||||
// if string > width otherwise return string
|
||||
func TrimStrIfAppropriate(s string, w int) string { |
||||
if w <= 0 { |
||||
return "" |
||||
} |
||||
|
||||
sw := rw.StringWidth(s) |
||||
if sw > w { |
||||
return rw.Truncate(s, w, dot) |
||||
} |
||||
|
||||
return s |
||||
} |
||||
|
||||
func strWidth(s string) int { |
||||
return rw.StringWidth(s) |
||||
} |
||||
|
||||
func charWidth(ch rune) int { |
||||
return rw.RuneWidth(ch) |
||||
} |
||||
|
||||
var whiteSpaceRegex = regexp.MustCompile(`\s`) |
||||
|
||||
// StringToAttribute converts text to a termui attribute. You may specifiy more
|
||||
// then one attribute like that: "BLACK, BOLD, ...". All whitespaces
|
||||
// are ignored.
|
||||
func StringToAttribute(text string) Attribute { |
||||
text = whiteSpaceRegex.ReplaceAllString(strings.ToLower(text), "") |
||||
attributes := strings.Split(text, ",") |
||||
result := Attribute(0) |
||||
|
||||
for _, theAttribute := range attributes { |
||||
var match Attribute |
||||
switch theAttribute { |
||||
case "reset", "default": |
||||
match = ColorDefault |
||||
|
||||
case "black": |
||||
match = ColorBlack |
||||
|
||||
case "red": |
||||
match = ColorRed |
||||
|
||||
case "green": |
||||
match = ColorGreen |
||||
|
||||
case "yellow": |
||||
match = ColorYellow |
||||
|
||||
case "blue": |
||||
match = ColorBlue |
||||
|
||||
case "magenta": |
||||
match = ColorMagenta |
||||
|
||||
case "cyan": |
||||
match = ColorCyan |
||||
|
||||
case "white": |
||||
match = ColorWhite |
||||
|
||||
case "bold": |
||||
match = AttrBold |
||||
|
||||
case "underline": |
||||
match = AttrUnderline |
||||
|
||||
case "reverse": |
||||
match = AttrReverse |
||||
} |
||||
|
||||
result |= match |
||||
} |
||||
|
||||
return result |
||||
} |
||||
|
||||
// TextCells returns a coloured text cells []Cell
|
||||
func TextCells(s string, fg, bg Attribute) []Cell { |
||||
cs := make([]Cell, 0, len(s)) |
||||
|
||||
// sequence := MarkdownTextRendererFactory{}.TextRenderer(s).Render(fg, bg)
|
||||
// runes := []rune(sequence.NormalizedText)
|
||||
runes := str2runes(s) |
||||
|
||||
for n := range runes { |
||||
// point, _ := sequence.PointAt(n, 0, 0)
|
||||
// cs = append(cs, Cell{point.Ch, point.Fg, point.Bg})
|
||||
cs = append(cs, Cell{runes[n], fg, bg}) |
||||
} |
||||
return cs |
||||
} |
||||
|
||||
// Width returns the actual screen space the cell takes (usually 1 or 2).
|
||||
func (c Cell) Width() int { |
||||
return charWidth(c.Ch) |
||||
} |
||||
|
||||
// Copy return a copy of c
|
||||
func (c Cell) Copy() Cell { |
||||
return c |
||||
} |
||||
|
||||
// TrimTxCells trims the overflowed text cells sequence.
|
||||
func TrimTxCells(cs []Cell, w int) []Cell { |
||||
if len(cs) <= w { |
||||
return cs |
||||
} |
||||
return cs[:w] |
||||
} |
||||
|
||||
// DTrimTxCls trims the overflowed text cells sequence and append dots at the end.
|
||||
func DTrimTxCls(cs []Cell, w int) []Cell { |
||||
l := len(cs) |
||||
if l <= 0 { |
||||
return []Cell{} |
||||
} |
||||
|
||||
rt := make([]Cell, 0, w) |
||||
csw := 0 |
||||
for i := 0; i < l && csw <= w; i++ { |
||||
c := cs[i] |
||||
cw := c.Width() |
||||
|
||||
if cw+csw < w { |
||||
rt = append(rt, c) |
||||
csw += cw |
||||
} else { |
||||
rt = append(rt, Cell{'…', c.Fg, c.Bg}) |
||||
break |
||||
} |
||||
} |
||||
|
||||
return rt |
||||
} |
||||
|
||||
func CellsToStr(cs []Cell) string { |
||||
str := "" |
||||
for _, c := range cs { |
||||
str += string(c.Ch) |
||||
} |
||||
return str |
||||
} |
||||
@ -1,331 +0,0 @@ |
||||
// Copyright 2017 Zack Guo <zack.y.guo@gmail.com>. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license that can
|
||||
// be found in the LICENSE file.
|
||||
|
||||
package termui |
||||
|
||||
import ( |
||||
"fmt" |
||||
"math" |
||||
) |
||||
|
||||
// only 16 possible combinations, why bother
|
||||
var braillePatterns = map[[2]int]rune{ |
||||
[2]int{0, 0}: '⣀', |
||||
[2]int{0, 1}: '⡠', |
||||
[2]int{0, 2}: '⡐', |
||||
[2]int{0, 3}: '⡈', |
||||
|
||||
[2]int{1, 0}: '⢄', |
||||
[2]int{1, 1}: '⠤', |
||||
[2]int{1, 2}: '⠔', |
||||
[2]int{1, 3}: '⠌', |
||||
|
||||
[2]int{2, 0}: '⢂', |
||||
[2]int{2, 1}: '⠢', |
||||
[2]int{2, 2}: '⠒', |
||||
[2]int{2, 3}: '⠊', |
||||
|
||||
[2]int{3, 0}: '⢁', |
||||
[2]int{3, 1}: '⠡', |
||||
[2]int{3, 2}: '⠑', |
||||
[2]int{3, 3}: '⠉', |
||||
} |
||||
|
||||
var lSingleBraille = [4]rune{'\u2840', '⠄', '⠂', '⠁'} |
||||
var rSingleBraille = [4]rune{'\u2880', '⠠', '⠐', '⠈'} |
||||
|
||||
// LineChart has two modes: braille(default) and dot. Using braille gives 2x capicity as dot mode,
|
||||
// because one braille char can represent two data points.
|
||||
/* |
||||
lc := termui.NewLineChart() |
||||
lc.BorderLabel = "braille-mode Line Chart" |
||||
lc.Data = [1.2, 1.3, 1.5, 1.7, 1.5, 1.6, 1.8, 2.0] |
||||
lc.Width = 50 |
||||
lc.Height = 12 |
||||
lc.AxesColor = termui.ColorWhite |
||||
lc.LineColor = termui.ColorGreen | termui.AttrBold |
||||
// termui.Render(lc)...
|
||||
*/ |
||||
type LineChart struct { |
||||
Block |
||||
Data []float64 |
||||
DataLabels []string // if unset, the data indices will be used
|
||||
Mode string // braille | dot
|
||||
DotStyle rune |
||||
LineColor Attribute |
||||
scale float64 // data span per cell on y-axis
|
||||
AxesColor Attribute |
||||
drawingX int |
||||
drawingY int |
||||
axisYHeight int |
||||
axisXWidth int |
||||
axisYLabelGap int |
||||
axisXLabelGap int |
||||
topValue float64 |
||||
bottomValue float64 |
||||
labelX [][]rune |
||||
labelY [][]rune |
||||
labelYSpace int |
||||
maxY float64 |
||||
minY float64 |
||||
autoLabels bool |
||||
} |
||||
|
||||
// NewLineChart returns a new LineChart with current theme.
|
||||
func NewLineChart() *LineChart { |
||||
lc := &LineChart{Block: *NewBlock()} |
||||
lc.AxesColor = ThemeAttr("linechart.axes.fg") |
||||
lc.LineColor = ThemeAttr("linechart.line.fg") |
||||
lc.Mode = "braille" |
||||
lc.DotStyle = '•' |
||||
lc.axisXLabelGap = 2 |
||||
lc.axisYLabelGap = 1 |
||||
lc.bottomValue = math.Inf(1) |
||||
lc.topValue = math.Inf(-1) |
||||
return lc |
||||
} |
||||
|
||||
// one cell contains two data points
|
||||
// so the capicity is 2x as dot-mode
|
||||
func (lc *LineChart) renderBraille() Buffer { |
||||
buf := NewBuffer() |
||||
|
||||
// return: b -> which cell should the point be in
|
||||
// m -> in the cell, divided into 4 equal height levels, which subcell?
|
||||
getPos := func(d float64) (b, m int) { |
||||
cnt4 := int((d-lc.bottomValue)/(lc.scale/4) + 0.5) |
||||
b = cnt4 / 4 |
||||
m = cnt4 % 4 |
||||
return |
||||
} |
||||
// plot points
|
||||
for i := 0; 2*i+1 < len(lc.Data) && i < lc.axisXWidth; i++ { |
||||
b0, m0 := getPos(lc.Data[2*i]) |
||||
b1, m1 := getPos(lc.Data[2*i+1]) |
||||
|
||||
if b0 == b1 { |
||||
c := Cell{ |
||||
Ch: braillePatterns[[2]int{m0, m1}], |
||||
Bg: lc.Bg, |
||||
Fg: lc.LineColor, |
||||
} |
||||
y := lc.innerArea.Min.Y + lc.innerArea.Dy() - 3 - b0 |
||||
x := lc.innerArea.Min.X + lc.labelYSpace + 1 + i |
||||
buf.Set(x, y, c) |
||||
} else { |
||||
c0 := Cell{Ch: lSingleBraille[m0], |
||||
Fg: lc.LineColor, |
||||
Bg: lc.Bg} |
||||
x0 := lc.innerArea.Min.X + lc.labelYSpace + 1 + i |
||||
y0 := lc.innerArea.Min.Y + lc.innerArea.Dy() - 3 - b0 |
||||
buf.Set(x0, y0, c0) |
||||
|
||||
c1 := Cell{Ch: rSingleBraille[m1], |
||||
Fg: lc.LineColor, |
||||
Bg: lc.Bg} |
||||
x1 := lc.innerArea.Min.X + lc.labelYSpace + 1 + i |
||||
y1 := lc.innerArea.Min.Y + lc.innerArea.Dy() - 3 - b1 |
||||
buf.Set(x1, y1, c1) |
||||
} |
||||
|
||||
} |
||||
return buf |
||||
} |
||||
|
||||
func (lc *LineChart) renderDot() Buffer { |
||||
buf := NewBuffer() |
||||
for i := 0; i < len(lc.Data) && i < lc.axisXWidth; i++ { |
||||
c := Cell{ |
||||
Ch: lc.DotStyle, |
||||
Fg: lc.LineColor, |
||||
Bg: lc.Bg, |
||||
} |
||||
x := lc.innerArea.Min.X + lc.labelYSpace + 1 + i |
||||
y := lc.innerArea.Min.Y + lc.innerArea.Dy() - 3 - int((lc.Data[i]-lc.bottomValue)/lc.scale+0.5) |
||||
buf.Set(x, y, c) |
||||
} |
||||
|
||||
return buf |
||||
} |
||||
|
||||
func (lc *LineChart) calcLabelX() { |
||||
lc.labelX = [][]rune{} |
||||
|
||||
for i, l := 0, 0; i < len(lc.DataLabels) && l < lc.axisXWidth; i++ { |
||||
if lc.Mode == "dot" { |
||||
if l >= len(lc.DataLabels) { |
||||
break |
||||
} |
||||
|
||||
s := str2runes(lc.DataLabels[l]) |
||||
w := strWidth(lc.DataLabels[l]) |
||||
if l+w <= lc.axisXWidth { |
||||
lc.labelX = append(lc.labelX, s) |
||||
} |
||||
l += w + lc.axisXLabelGap |
||||
} else { // braille
|
||||
if 2*l >= len(lc.DataLabels) { |
||||
break |
||||
} |
||||
|
||||
s := str2runes(lc.DataLabels[2*l]) |
||||
w := strWidth(lc.DataLabels[2*l]) |
||||
if l+w <= lc.axisXWidth { |
||||
lc.labelX = append(lc.labelX, s) |
||||
} |
||||
l += w + lc.axisXLabelGap |
||||
|
||||
} |
||||
} |
||||
} |
||||
|
||||
func shortenFloatVal(x float64) string { |
||||
s := fmt.Sprintf("%.2f", x) |
||||
if len(s)-3 > 3 { |
||||
s = fmt.Sprintf("%.2e", x) |
||||
} |
||||
|
||||
if x < 0 { |
||||
s = fmt.Sprintf("%.2f", x) |
||||
} |
||||
return s |
||||
} |
||||
|
||||
func (lc *LineChart) calcLabelY() { |
||||
span := lc.topValue - lc.bottomValue |
||||
lc.scale = span / float64(lc.axisYHeight) |
||||
|
||||
n := (1 + lc.axisYHeight) / (lc.axisYLabelGap + 1) |
||||
lc.labelY = make([][]rune, n) |
||||
maxLen := 0 |
||||
for i := 0; i < n; i++ { |
||||
s := str2runes(shortenFloatVal(lc.bottomValue + float64(i)*span/float64(n))) |
||||
if len(s) > maxLen { |
||||
maxLen = len(s) |
||||
} |
||||
lc.labelY[i] = s |
||||
} |
||||
|
||||
lc.labelYSpace = maxLen |
||||
} |
||||
|
||||
func (lc *LineChart) calcLayout() { |
||||
// set datalabels if it is not provided
|
||||
if (lc.DataLabels == nil || len(lc.DataLabels) == 0) || lc.autoLabels { |
||||
lc.autoLabels = true |
||||
lc.DataLabels = make([]string, len(lc.Data)) |
||||
for i := range lc.Data { |
||||
lc.DataLabels[i] = fmt.Sprint(i) |
||||
} |
||||
} |
||||
|
||||
// lazy increase, to avoid y shaking frequently
|
||||
// update bound Y when drawing is gonna overflow
|
||||
lc.minY = lc.Data[0] |
||||
lc.maxY = lc.Data[0] |
||||
|
||||
// valid visible range
|
||||
vrange := lc.innerArea.Dx() |
||||
if lc.Mode == "braille" { |
||||
vrange = 2 * lc.innerArea.Dx() |
||||
} |
||||
if vrange > len(lc.Data) { |
||||
vrange = len(lc.Data) |
||||
} |
||||
|
||||
for _, v := range lc.Data[:vrange] { |
||||
if v > lc.maxY { |
||||
lc.maxY = v |
||||
} |
||||
if v < lc.minY { |
||||
lc.minY = v |
||||
} |
||||
} |
||||
|
||||
span := lc.maxY - lc.minY |
||||
|
||||
if lc.minY < lc.bottomValue { |
||||
lc.bottomValue = lc.minY - 0.2*span |
||||
} |
||||
|
||||
if lc.maxY > lc.topValue { |
||||
lc.topValue = lc.maxY + 0.2*span |
||||
} |
||||
|
||||
lc.axisYHeight = lc.innerArea.Dy() - 2 |
||||
lc.calcLabelY() |
||||
|
||||
lc.axisXWidth = lc.innerArea.Dx() - 1 - lc.labelYSpace |
||||
lc.calcLabelX() |
||||
|
||||
lc.drawingX = lc.innerArea.Min.X + 1 + lc.labelYSpace |
||||
lc.drawingY = lc.innerArea.Min.Y |
||||
} |
||||
|
||||
func (lc *LineChart) plotAxes() Buffer { |
||||
buf := NewBuffer() |
||||
|
||||
origY := lc.innerArea.Min.Y + lc.innerArea.Dy() - 2 |
||||
origX := lc.innerArea.Min.X + lc.labelYSpace |
||||
|
||||
buf.Set(origX, origY, Cell{Ch: ORIGIN, Fg: lc.AxesColor, Bg: lc.Bg}) |
||||
|
||||
for x := origX + 1; x < origX+lc.axisXWidth; x++ { |
||||
buf.Set(x, origY, Cell{Ch: HDASH, Fg: lc.AxesColor, Bg: lc.Bg}) |
||||
} |
||||
|
||||
for dy := 1; dy <= lc.axisYHeight; dy++ { |
||||
buf.Set(origX, origY-dy, Cell{Ch: VDASH, Fg: lc.AxesColor, Bg: lc.Bg}) |
||||
} |
||||
|
||||
// x label
|
||||
oft := 0 |
||||
for _, rs := range lc.labelX { |
||||
if oft+len(rs) > lc.axisXWidth { |
||||
break |
||||
} |
||||
for j, r := range rs { |
||||
c := Cell{ |
||||
Ch: r, |
||||
Fg: lc.AxesColor, |
||||
Bg: lc.Bg, |
||||
} |
||||
x := origX + oft + j |
||||
y := lc.innerArea.Min.Y + lc.innerArea.Dy() - 1 |
||||
buf.Set(x, y, c) |
||||
} |
||||
oft += len(rs) + lc.axisXLabelGap |
||||
} |
||||
|
||||
// y labels
|
||||
for i, rs := range lc.labelY { |
||||
for j, r := range rs { |
||||
buf.Set( |
||||
lc.innerArea.Min.X+j, |
||||
origY-i*(lc.axisYLabelGap+1), |
||||
Cell{Ch: r, Fg: lc.AxesColor, Bg: lc.Bg}) |
||||
} |
||||
} |
||||
|
||||
return buf |
||||
} |
||||
|
||||
// Buffer implements Bufferer interface.
|
||||
func (lc *LineChart) Buffer() Buffer { |
||||
buf := lc.Block.Buffer() |
||||
|
||||
if lc.Data == nil || len(lc.Data) == 0 { |
||||
return buf |
||||
} |
||||
lc.calcLayout() |
||||
buf.Merge(lc.plotAxes()) |
||||
|
||||
if lc.Mode == "dot" { |
||||
buf.Merge(lc.renderDot()) |
||||
} else { |
||||
buf.Merge(lc.renderBraille()) |
||||
} |
||||
|
||||
return buf |
||||
} |
||||
@ -1,11 +0,0 @@ |
||||
// Copyright 2017 Zack Guo <zack.y.guo@gmail.com>. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license that can
|
||||
// be found in the LICENSE file.
|
||||
|
||||
// +build !windows
|
||||
|
||||
package termui |
||||
|
||||
const VDASH = '┊' |
||||
const HDASH = '┈' |
||||
const ORIGIN = '└' |
||||
@ -1,11 +0,0 @@ |
||||
// Copyright 2017 Zack Guo <zack.y.guo@gmail.com>. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license that can
|
||||
// be found in the LICENSE file.
|
||||
|
||||
// +build windows
|
||||
|
||||
package termui |
||||
|
||||
const VDASH = '|' |
||||
const HDASH = '-' |
||||
const ORIGIN = '+' |
||||
@ -1,89 +0,0 @@ |
||||
// Copyright 2017 Zack Guo <zack.y.guo@gmail.com>. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license that can
|
||||
// be found in the LICENSE file.
|
||||
|
||||
package termui |
||||
|
||||
import "strings" |
||||
|
||||
// List displays []string as its items,
|
||||
// it has a Overflow option (default is "hidden"), when set to "hidden",
|
||||
// the item exceeding List's width is truncated, but when set to "wrap",
|
||||
// the overflowed text breaks into next line.
|
||||
/* |
||||
strs := []string{ |
||||
"[0] github.com/gizak/termui", |
||||
"[1] editbox.go", |
||||
"[2] iterrupt.go", |
||||
"[3] keyboard.go", |
||||
"[4] output.go", |
||||
"[5] random_out.go", |
||||
"[6] dashboard.go", |
||||
"[7] nsf/termbox-go"} |
||||
|
||||
ls := termui.NewList() |
||||
ls.Items = strs |
||||
ls.ItemFgColor = termui.ColorYellow |
||||
ls.BorderLabel = "List" |
||||
ls.Height = 7 |
||||
ls.Width = 25 |
||||
ls.Y = 0 |
||||
*/ |
||||
type List struct { |
||||
Block |
||||
Items []string |
||||
Overflow string |
||||
ItemFgColor Attribute |
||||
ItemBgColor Attribute |
||||
} |
||||
|
||||
// NewList returns a new *List with current theme.
|
||||
func NewList() *List { |
||||
l := &List{Block: *NewBlock()} |
||||
l.Overflow = "hidden" |
||||
l.ItemFgColor = ThemeAttr("list.item.fg") |
||||
l.ItemBgColor = ThemeAttr("list.item.bg") |
||||
return l |
||||
} |
||||
|
||||
// Buffer implements Bufferer interface.
|
||||
func (l *List) Buffer() Buffer { |
||||
buf := l.Block.Buffer() |
||||
|
||||
switch l.Overflow { |
||||
case "wrap": |
||||
cs := DefaultTxBuilder.Build(strings.Join(l.Items, "\n"), l.ItemFgColor, l.ItemBgColor) |
||||
i, j, k := 0, 0, 0 |
||||
for i < l.innerArea.Dy() && k < len(cs) { |
||||
w := cs[k].Width() |
||||
if cs[k].Ch == '\n' || j+w > l.innerArea.Dx() { |
||||
i++ |
||||
j = 0 |
||||
if cs[k].Ch == '\n' { |
||||
k++ |
||||
} |
||||
continue |
||||
} |
||||
buf.Set(l.innerArea.Min.X+j, l.innerArea.Min.Y+i, cs[k]) |
||||
|
||||
k++ |
||||
j++ |
||||
} |
||||
|
||||
case "hidden": |
||||
trimItems := l.Items |
||||
if len(trimItems) > l.innerArea.Dy() { |
||||
trimItems = trimItems[:l.innerArea.Dy()] |
||||
} |
||||
for i, v := range trimItems { |
||||
cs := DTrimTxCls(DefaultTxBuilder.Build(v, l.ItemFgColor, l.ItemBgColor), l.innerArea.Dx()) |
||||
j := 0 |
||||
for _, vv := range cs { |
||||
w := vv.Width() |
||||
buf.Set(l.innerArea.Min.X+j, l.innerArea.Min.Y+i, vv) |
||||
j += w |
||||
} |
||||
} |
||||
} |
||||
return buf |
||||
} |
||||
@ -1,242 +0,0 @@ |
||||
// Copyright 2017 Zack Guo <zack.y.guo@gmail.com>. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license that can
|
||||
// be found in the LICENSE file.
|
||||
|
||||
package termui |
||||
|
||||
import ( |
||||
"fmt" |
||||
) |
||||
|
||||
// This is the implemetation of multi-colored or stacked bar graph. This is different from default barGraph which is implemented in bar.go
|
||||
// Multi-Colored-BarChart creates multiple bars in a widget:
|
||||
/* |
||||
bc := termui.NewMBarChart() |
||||
data := make([][]int, 2) |
||||
data[0] := []int{3, 2, 5, 7, 9, 4} |
||||
data[1] := []int{7, 8, 5, 3, 1, 6} |
||||
bclabels := []string{"S0", "S1", "S2", "S3", "S4", "S5"} |
||||
bc.BorderLabel = "Bar Chart" |
||||
bc.Data = data |
||||
bc.Width = 26 |
||||
bc.Height = 10 |
||||
bc.DataLabels = bclabels |
||||
bc.TextColor = termui.ColorGreen |
||||
bc.BarColor = termui.ColorRed |
||||
bc.NumColor = termui.ColorYellow |
||||
*/ |
||||
type MBarChart struct { |
||||
Block |
||||
BarColor [NumberofColors]Attribute |
||||
TextColor Attribute |
||||
NumColor [NumberofColors]Attribute |
||||
Data [NumberofColors][]int |
||||
DataLabels []string |
||||
BarWidth int |
||||
BarGap int |
||||
labels [][]rune |
||||
dataNum [NumberofColors][][]rune |
||||
numBar int |
||||
scale float64 |
||||
max int |
||||
minDataLen int |
||||
numStack int |
||||
ShowScale bool |
||||
maxScale []rune |
||||
} |
||||
|
||||
// NewBarChart returns a new *BarChart with current theme.
|
||||
func NewMBarChart() *MBarChart { |
||||
bc := &MBarChart{Block: *NewBlock()} |
||||
bc.BarColor[0] = ThemeAttr("mbarchart.bar.bg") |
||||
bc.NumColor[0] = ThemeAttr("mbarchart.num.fg") |
||||
bc.TextColor = ThemeAttr("mbarchart.text.fg") |
||||
bc.BarGap = 1 |
||||
bc.BarWidth = 3 |
||||
return bc |
||||
} |
||||
|
||||
func (bc *MBarChart) layout() { |
||||
bc.numBar = bc.innerArea.Dx() / (bc.BarGap + bc.BarWidth) |
||||
bc.labels = make([][]rune, bc.numBar) |
||||
DataLen := 0 |
||||
LabelLen := len(bc.DataLabels) |
||||
bc.minDataLen = 9999 //Set this to some very hight value so that we find the minimum one We want to know which array among data[][] has got the least length
|
||||
|
||||
// We need to know how many stack/data array data[0] , data[1] are there
|
||||
for i := 0; i < len(bc.Data); i++ { |
||||
if bc.Data[i] == nil { |
||||
break |
||||
} |
||||
DataLen++ |
||||
} |
||||
bc.numStack = DataLen |
||||
|
||||
//We need to know what is the mimimum size of data array data[0] could have 10 elements data[1] could have only 5, so we plot only 5 bar graphs
|
||||
|
||||
for i := 0; i < DataLen; i++ { |
||||
if bc.minDataLen > len(bc.Data[i]) { |
||||
bc.minDataLen = len(bc.Data[i]) |
||||
} |
||||
} |
||||
|
||||
if LabelLen > bc.minDataLen { |
||||
LabelLen = bc.minDataLen |
||||
} |
||||
|
||||
for i := 0; i < LabelLen && i < bc.numBar; i++ { |
||||
bc.labels[i] = trimStr2Runes(bc.DataLabels[i], bc.BarWidth) |
||||
} |
||||
|
||||
for i := 0; i < bc.numStack; i++ { |
||||
bc.dataNum[i] = make([][]rune, len(bc.Data[i])) |
||||
//For each stack of bar calcualte the rune
|
||||
for j := 0; j < LabelLen && i < bc.numBar; j++ { |
||||
n := bc.Data[i][j] |
||||
s := fmt.Sprint(n) |
||||
bc.dataNum[i][j] = trimStr2Runes(s, bc.BarWidth) |
||||
} |
||||
//If color is not defined by default then populate a color that is different from the prevous bar
|
||||
if bc.BarColor[i] == ColorDefault && bc.NumColor[i] == ColorDefault { |
||||
if i == 0 { |
||||
bc.BarColor[i] = ColorBlack |
||||
} else { |
||||
bc.BarColor[i] = bc.BarColor[i-1] + 1 |
||||
if bc.BarColor[i] > NumberofColors { |
||||
bc.BarColor[i] = ColorBlack |
||||
} |
||||
} |
||||
bc.NumColor[i] = (NumberofColors + 1) - bc.BarColor[i] //Make NumColor opposite of barColor for visibility
|
||||
} |
||||
} |
||||
|
||||
//If Max value is not set then we have to populate, this time the max value will be max(sum(d1[0],d2[0],d3[0]) .... sum(d1[n], d2[n], d3[n]))
|
||||
|
||||
if bc.max == 0 { |
||||
bc.max = -1 |
||||
} |
||||
for i := 0; i < bc.minDataLen && i < LabelLen; i++ { |
||||
var dsum int |
||||
for j := 0; j < bc.numStack; j++ { |
||||
dsum += bc.Data[j][i] |
||||
} |
||||
if dsum > bc.max { |
||||
bc.max = dsum |
||||
} |
||||
} |
||||
|
||||
//Finally Calculate max sale
|
||||
if bc.ShowScale { |
||||
s := fmt.Sprintf("%d", bc.max) |
||||
bc.maxScale = trimStr2Runes(s, len(s)) |
||||
bc.scale = float64(bc.max) / float64(bc.innerArea.Dy()-2) |
||||
} else { |
||||
bc.scale = float64(bc.max) / float64(bc.innerArea.Dy()-1) |
||||
} |
||||
|
||||
} |
||||
|
||||
func (bc *MBarChart) SetMax(max int) { |
||||
|
||||
if max > 0 { |
||||
bc.max = max |
||||
} |
||||
} |
||||
|
||||
// Buffer implements Bufferer interface.
|
||||
func (bc *MBarChart) Buffer() Buffer { |
||||
buf := bc.Block.Buffer() |
||||
bc.layout() |
||||
var oftX int |
||||
|
||||
for i := 0; i < bc.numBar && i < bc.minDataLen && i < len(bc.DataLabels); i++ { |
||||
ph := 0 //Previous Height to stack up
|
||||
oftX = i * (bc.BarWidth + bc.BarGap) |
||||
for i1 := 0; i1 < bc.numStack; i1++ { |
||||
h := int(float64(bc.Data[i1][i]) / bc.scale) |
||||
// plot bars
|
||||
for j := 0; j < bc.BarWidth; j++ { |
||||
for k := 0; k < h; k++ { |
||||
c := Cell{ |
||||
Ch: ' ', |
||||
Bg: bc.BarColor[i1], |
||||
} |
||||
if bc.BarColor[i1] == ColorDefault { // when color is default, space char treated as transparent!
|
||||
c.Bg |= AttrReverse |
||||
} |
||||
x := bc.innerArea.Min.X + i*(bc.BarWidth+bc.BarGap) + j |
||||
y := bc.innerArea.Min.Y + bc.innerArea.Dy() - 2 - k - ph |
||||
buf.Set(x, y, c) |
||||
|
||||
} |
||||
} |
||||
ph += h |
||||
} |
||||
// plot text
|
||||
for j, k := 0, 0; j < len(bc.labels[i]); j++ { |
||||
w := charWidth(bc.labels[i][j]) |
||||
c := Cell{ |
||||
Ch: bc.labels[i][j], |
||||
Bg: bc.Bg, |
||||
Fg: bc.TextColor, |
||||
} |
||||
y := bc.innerArea.Min.Y + bc.innerArea.Dy() - 1 |
||||
x := bc.innerArea.Max.X + oftX + ((bc.BarWidth - len(bc.labels[i])) / 2) + k |
||||
buf.Set(x, y, c) |
||||
k += w |
||||
} |
||||
// plot num
|
||||
ph = 0 //re-initialize previous height
|
||||
for i1 := 0; i1 < bc.numStack; i1++ { |
||||
h := int(float64(bc.Data[i1][i]) / bc.scale) |
||||
for j := 0; j < len(bc.dataNum[i1][i]) && h > 0; j++ { |
||||
c := Cell{ |
||||
Ch: bc.dataNum[i1][i][j], |
||||
Fg: bc.NumColor[i1], |
||||
Bg: bc.BarColor[i1], |
||||
} |
||||
if bc.BarColor[i1] == ColorDefault { // the same as above
|
||||
c.Bg |= AttrReverse |
||||
} |
||||
if h == 0 { |
||||
c.Bg = bc.Bg |
||||
} |
||||
x := bc.innerArea.Min.X + oftX + (bc.BarWidth-len(bc.dataNum[i1][i]))/2 + j |
||||
y := bc.innerArea.Min.Y + bc.innerArea.Dy() - 2 - ph |
||||
buf.Set(x, y, c) |
||||
} |
||||
ph += h |
||||
} |
||||
} |
||||
|
||||
if bc.ShowScale { |
||||
//Currently bar graph only supprts data range from 0 to MAX
|
||||
//Plot 0
|
||||
c := Cell{ |
||||
Ch: '0', |
||||
Bg: bc.Bg, |
||||
Fg: bc.TextColor, |
||||
} |
||||
|
||||
y := bc.innerArea.Min.Y + bc.innerArea.Dy() - 2 |
||||
x := bc.X |
||||
buf.Set(x, y, c) |
||||
|
||||
//Plot the maximum sacle value
|
||||
for i := 0; i < len(bc.maxScale); i++ { |
||||
c := Cell{ |
||||
Ch: bc.maxScale[i], |
||||
Bg: bc.Bg, |
||||
Fg: bc.TextColor, |
||||
} |
||||
|
||||
y := bc.innerArea.Min.Y |
||||
x := bc.X + i |
||||
|
||||
buf.Set(x, y, c) |
||||
} |
||||
|
||||
} |
||||
|
||||
return buf |
||||
} |
||||
@ -1,28 +0,0 @@ |
||||
pages: |
||||
- Home: 'index.md' |
||||
- Quickstart: 'quickstart.md' |
||||
- Recipes: 'recipes.md' |
||||
- References: |
||||
- Layouts: 'layouts.md' |
||||
- Components: 'components.md' |
||||
- Events: 'events.md' |
||||
- Themes: 'themes.md' |
||||
- Versions: 'versions.md' |
||||
- About: 'about.md' |
||||
|
||||
site_name: termui |
||||
repo_url: https://github.com/gizak/termui/ |
||||
site_description: 'termui user guide' |
||||
site_author: gizak |
||||
|
||||
docs_dir: '_docs' |
||||
|
||||
theme: readthedocs |
||||
|
||||
markdown_extensions: |
||||
- smarty |
||||
- admonition |
||||
- toc |
||||
|
||||
extra: |
||||
version: 1.0 |
||||
@ -1,73 +0,0 @@ |
||||
// Copyright 2017 Zack Guo <zack.y.guo@gmail.com>. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license that can
|
||||
// be found in the LICENSE file.
|
||||
|
||||
package termui |
||||
|
||||
// Par displays a paragraph.
|
||||
/* |
||||
par := termui.NewPar("Simple Text") |
||||
par.Height = 3 |
||||
par.Width = 17 |
||||
par.BorderLabel = "Label" |
||||
*/ |
||||
type Par struct { |
||||
Block |
||||
Text string |
||||
TextFgColor Attribute |
||||
TextBgColor Attribute |
||||
WrapLength int // words wrap limit. Note it may not work properly with multi-width char
|
||||
} |
||||
|
||||
// NewPar returns a new *Par with given text as its content.
|
||||
func NewPar(s string) *Par { |
||||
return &Par{ |
||||
Block: *NewBlock(), |
||||
Text: s, |
||||
TextFgColor: ThemeAttr("par.text.fg"), |
||||
TextBgColor: ThemeAttr("par.text.bg"), |
||||
WrapLength: 0, |
||||
} |
||||
} |
||||
|
||||
// Buffer implements Bufferer interface.
|
||||
func (p *Par) Buffer() Buffer { |
||||
buf := p.Block.Buffer() |
||||
|
||||
fg, bg := p.TextFgColor, p.TextBgColor |
||||
cs := DefaultTxBuilder.Build(p.Text, fg, bg) |
||||
|
||||
// wrap if WrapLength set
|
||||
if p.WrapLength < 0 { |
||||
cs = wrapTx(cs, p.Width-2) |
||||
} else if p.WrapLength > 0 { |
||||
cs = wrapTx(cs, p.WrapLength) |
||||
} |
||||
|
||||
y, x, n := 0, 0, 0 |
||||
for y < p.innerArea.Dy() && n < len(cs) { |
||||
w := cs[n].Width() |
||||
if cs[n].Ch == '\n' || x+w > p.innerArea.Dx() { |
||||
y++ |
||||
x = 0 // set x = 0
|
||||
if cs[n].Ch == '\n' { |
||||
n++ |
||||
} |
||||
|
||||
if y >= p.innerArea.Dy() { |
||||
buf.Set(p.innerArea.Min.X+p.innerArea.Dx()-1, |
||||
p.innerArea.Min.Y+p.innerArea.Dy()-1, |
||||
Cell{Ch: '…', Fg: p.TextFgColor, Bg: p.TextBgColor}) |
||||
break |
||||
} |
||||
continue |
||||
} |
||||
|
||||
buf.Set(p.innerArea.Min.X+x, p.innerArea.Min.Y+y, cs[n]) |
||||
|
||||
n++ |
||||
x += w |
||||
} |
||||
|
||||
return buf |
||||
} |
||||
@ -1,78 +0,0 @@ |
||||
// Copyright 2017 Zack Guo <zack.y.guo@gmail.com>. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license that can
|
||||
// be found in the LICENSE file.
|
||||
|
||||
package termui |
||||
|
||||
import "image" |
||||
|
||||
// Align is the position of the gauge's label.
|
||||
type Align uint |
||||
|
||||
// All supported positions.
|
||||
const ( |
||||
AlignNone Align = 0 |
||||
AlignLeft Align = 1 << iota |
||||
AlignRight |
||||
AlignBottom |
||||
AlignTop |
||||
AlignCenterVertical |
||||
AlignCenterHorizontal |
||||
AlignCenter = AlignCenterVertical | AlignCenterHorizontal |
||||
) |
||||
|
||||
func AlignArea(parent, child image.Rectangle, a Align) image.Rectangle { |
||||
w, h := child.Dx(), child.Dy() |
||||
|
||||
// parent center
|
||||
pcx, pcy := parent.Min.X+parent.Dx()/2, parent.Min.Y+parent.Dy()/2 |
||||
// child center
|
||||
ccx, ccy := child.Min.X+child.Dx()/2, child.Min.Y+child.Dy()/2 |
||||
|
||||
if a&AlignLeft == AlignLeft { |
||||
child.Min.X = parent.Min.X |
||||
child.Max.X = child.Min.X + w |
||||
} |
||||
|
||||
if a&AlignRight == AlignRight { |
||||
child.Max.X = parent.Max.X |
||||
child.Min.X = child.Max.X - w |
||||
} |
||||
|
||||
if a&AlignBottom == AlignBottom { |
||||
child.Max.Y = parent.Max.Y |
||||
child.Min.Y = child.Max.Y - h |
||||
} |
||||
|
||||
if a&AlignTop == AlignRight { |
||||
child.Min.Y = parent.Min.Y |
||||
child.Max.Y = child.Min.Y + h |
||||
} |
||||
|
||||
if a&AlignCenterHorizontal == AlignCenterHorizontal { |
||||
child.Min.X += pcx - ccx |
||||
child.Max.X = child.Min.X + w |
||||
} |
||||
|
||||
if a&AlignCenterVertical == AlignCenterVertical { |
||||
child.Min.Y += pcy - ccy |
||||
child.Max.Y = child.Min.Y + h |
||||
} |
||||
|
||||
return child |
||||
} |
||||
|
||||
func MoveArea(a image.Rectangle, dx, dy int) image.Rectangle { |
||||
a.Min.X += dx |
||||
a.Max.X += dx |
||||
a.Min.Y += dy |
||||
a.Max.Y += dy |
||||
return a |
||||
} |
||||
|
||||
var termWidth int |
||||
var termHeight int |
||||
|
||||
func TermRect() image.Rectangle { |
||||
return image.Rect(0, 0, termWidth, termHeight) |
||||
} |
||||
@ -1,164 +0,0 @@ |
||||
// Copyright 2017 Zack Guo <zack.y.guo@gmail.com>. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license that can
|
||||
// be found in the LICENSE file.
|
||||
|
||||
package termui |
||||
|
||||
import ( |
||||
"image" |
||||
"io" |
||||
"sync" |
||||
"time" |
||||
|
||||
"fmt" |
||||
|
||||
"os" |
||||
|
||||
"runtime/debug" |
||||
|
||||
"bytes" |
||||
|
||||
"github.com/maruel/panicparse/stack" |
||||
tm "github.com/nsf/termbox-go" |
||||
) |
||||
|
||||
// Bufferer should be implemented by all renderable components.
|
||||
type Bufferer interface { |
||||
Buffer() Buffer |
||||
} |
||||
|
||||
// Init initializes termui library. This function should be called before any others.
|
||||
// After initialization, the library must be finalized by 'Close' function.
|
||||
func Init() error { |
||||
if err := tm.Init(); err != nil { |
||||
return err |
||||
} |
||||
|
||||
sysEvtChs = make([]chan Event, 0) |
||||
go hookTermboxEvt() |
||||
|
||||
renderJobs = make(chan []Bufferer) |
||||
//renderLock = new(sync.RWMutex)
|
||||
|
||||
Body = NewGrid() |
||||
Body.X = 0 |
||||
Body.Y = 0 |
||||
Body.BgColor = ThemeAttr("bg") |
||||
Body.Width = TermWidth() |
||||
|
||||
DefaultEvtStream.Init() |
||||
DefaultEvtStream.Merge("termbox", NewSysEvtCh()) |
||||
DefaultEvtStream.Merge("timer", NewTimerCh(time.Second)) |
||||
DefaultEvtStream.Merge("custom", usrEvtCh) |
||||
|
||||
DefaultEvtStream.Handle("/", DefaultHandler) |
||||
DefaultEvtStream.Handle("/sys/wnd/resize", func(e Event) { |
||||
w := e.Data.(EvtWnd) |
||||
Body.Width = w.Width |
||||
}) |
||||
|
||||
DefaultWgtMgr = NewWgtMgr() |
||||
DefaultEvtStream.Hook(DefaultWgtMgr.WgtHandlersHook()) |
||||
|
||||
go func() { |
||||
for bs := range renderJobs { |
||||
render(bs...) |
||||
} |
||||
}() |
||||
|
||||
return nil |
||||
} |
||||
|
||||
// Close finalizes termui library,
|
||||
// should be called after successful initialization when termui's functionality isn't required anymore.
|
||||
func Close() { |
||||
tm.Close() |
||||
} |
||||
|
||||
var renderLock sync.Mutex |
||||
|
||||
func termSync() { |
||||
renderLock.Lock() |
||||
tm.Sync() |
||||
termWidth, termHeight = tm.Size() |
||||
renderLock.Unlock() |
||||
} |
||||
|
||||
// TermWidth returns the current terminal's width.
|
||||
func TermWidth() int { |
||||
termSync() |
||||
return termWidth |
||||
} |
||||
|
||||
// TermHeight returns the current terminal's height.
|
||||
func TermHeight() int { |
||||
termSync() |
||||
return termHeight |
||||
} |
||||
|
||||
// Render renders all Bufferer in the given order from left to right,
|
||||
// right could overlap on left ones.
|
||||
func render(bs ...Bufferer) { |
||||
defer func() { |
||||
if e := recover(); e != nil { |
||||
Close() |
||||
fmt.Fprintf(os.Stderr, "Captured a panic(value=%v) when rendering Bufferer. Exit termui and clean terminal...\nPrint stack trace:\n\n", e) |
||||
//debug.PrintStack()
|
||||
gs, err := stack.ParseDump(bytes.NewReader(debug.Stack()), os.Stderr) |
||||
if err != nil { |
||||
debug.PrintStack() |
||||
os.Exit(1) |
||||
} |
||||
p := &stack.Palette{} |
||||
buckets := stack.SortBuckets(stack.Bucketize(gs, stack.AnyValue)) |
||||
srcLen, pkgLen := stack.CalcLengths(buckets, false) |
||||
for _, bucket := range buckets { |
||||
io.WriteString(os.Stdout, p.BucketHeader(&bucket, false, len(buckets) > 1)) |
||||
io.WriteString(os.Stdout, p.StackLines(&bucket.Signature, srcLen, pkgLen, false)) |
||||
} |
||||
os.Exit(1) |
||||
} |
||||
}() |
||||
for _, b := range bs { |
||||
|
||||
buf := b.Buffer() |
||||
// set cels in buf
|
||||
for p, c := range buf.CellMap { |
||||
if p.In(buf.Area) { |
||||
|
||||
tm.SetCell(p.X, p.Y, c.Ch, toTmAttr(c.Fg), toTmAttr(c.Bg)) |
||||
|
||||
} |
||||
} |
||||
|
||||
} |
||||
|
||||
renderLock.Lock() |
||||
// render
|
||||
tm.Flush() |
||||
renderLock.Unlock() |
||||
} |
||||
|
||||
func Clear() { |
||||
tm.Clear(tm.ColorDefault, toTmAttr(ThemeAttr("bg"))) |
||||
} |
||||
|
||||
func clearArea(r image.Rectangle, bg Attribute) { |
||||
for i := r.Min.X; i < r.Max.X; i++ { |
||||
for j := r.Min.Y; j < r.Max.Y; j++ { |
||||
tm.SetCell(i, j, ' ', tm.ColorDefault, toTmAttr(bg)) |
||||
} |
||||
} |
||||
} |
||||
|
||||
func ClearArea(r image.Rectangle, bg Attribute) { |
||||
clearArea(r, bg) |
||||
tm.Flush() |
||||
} |
||||
|
||||
var renderJobs chan []Bufferer |
||||
|
||||
func Render(bs ...Bufferer) { |
||||
//go func() { renderJobs <- bs }()
|
||||
renderJobs <- bs |
||||
} |
||||
@ -1,167 +0,0 @@ |
||||
// Copyright 2017 Zack Guo <zack.y.guo@gmail.com>. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license that can
|
||||
// be found in the LICENSE file.
|
||||
|
||||
package termui |
||||
|
||||
// Sparkline is like: ▅▆▂▂▅▇▂▂▃▆▆▆▅▃. The data points should be non-negative integers.
|
||||
/* |
||||
data := []int{4, 2, 1, 6, 3, 9, 1, 4, 2, 15, 14, 9, 8, 6, 10, 13, 15, 12, 10, 5, 3, 6, 1} |
||||
spl := termui.NewSparkline() |
||||
spl.Data = data |
||||
spl.Title = "Sparkline 0" |
||||
spl.LineColor = termui.ColorGreen |
||||
*/ |
||||
type Sparkline struct { |
||||
Data []int |
||||
Height int |
||||
Title string |
||||
TitleColor Attribute |
||||
LineColor Attribute |
||||
displayHeight int |
||||
scale float32 |
||||
max int |
||||
} |
||||
|
||||
// Sparklines is a renderable widget which groups together the given sparklines.
|
||||
/* |
||||
spls := termui.NewSparklines(spl0,spl1,spl2) //...
|
||||
spls.Height = 2 |
||||
spls.Width = 20 |
||||
*/ |
||||
type Sparklines struct { |
||||
Block |
||||
Lines []Sparkline |
||||
displayLines int |
||||
displayWidth int |
||||
} |
||||
|
||||
var sparks = []rune{'▁', '▂', '▃', '▄', '▅', '▆', '▇', '█'} |
||||
|
||||
// Add appends a given Sparkline to s *Sparklines.
|
||||
func (s *Sparklines) Add(sl Sparkline) { |
||||
s.Lines = append(s.Lines, sl) |
||||
} |
||||
|
||||
// NewSparkline returns a unrenderable single sparkline that intended to be added into Sparklines.
|
||||
func NewSparkline() Sparkline { |
||||
return Sparkline{ |
||||
Height: 1, |
||||
TitleColor: ThemeAttr("sparkline.title.fg"), |
||||
LineColor: ThemeAttr("sparkline.line.fg")} |
||||
} |
||||
|
||||
// NewSparklines return a new *Spaklines with given Sparkline(s), you can always add a new Sparkline later.
|
||||
func NewSparklines(ss ...Sparkline) *Sparklines { |
||||
s := &Sparklines{Block: *NewBlock(), Lines: ss} |
||||
return s |
||||
} |
||||
|
||||
func (sl *Sparklines) update() { |
||||
for i, v := range sl.Lines { |
||||
if v.Title == "" { |
||||
sl.Lines[i].displayHeight = v.Height |
||||
} else { |
||||
sl.Lines[i].displayHeight = v.Height + 1 |
||||
} |
||||
} |
||||
sl.displayWidth = sl.innerArea.Dx() |
||||
|
||||
// get how many lines gotta display
|
||||
h := 0 |
||||
sl.displayLines = 0 |
||||
for _, v := range sl.Lines { |
||||
if h+v.displayHeight <= sl.innerArea.Dy() { |
||||
sl.displayLines++ |
||||
} else { |
||||
break |
||||
} |
||||
h += v.displayHeight |
||||
} |
||||
|
||||
for i := 0; i < sl.displayLines; i++ { |
||||
data := sl.Lines[i].Data |
||||
|
||||
max := 0 |
||||
for _, v := range data { |
||||
if max < v { |
||||
max = v |
||||
} |
||||
} |
||||
sl.Lines[i].max = max |
||||
if max != 0 { |
||||
sl.Lines[i].scale = float32(8*sl.Lines[i].Height) / float32(max) |
||||
} else { // when all negative
|
||||
sl.Lines[i].scale = 0 |
||||
} |
||||
} |
||||
} |
||||
|
||||
// Buffer implements Bufferer interface.
|
||||
func (sl *Sparklines) Buffer() Buffer { |
||||
buf := sl.Block.Buffer() |
||||
sl.update() |
||||
|
||||
oftY := 0 |
||||
for i := 0; i < sl.displayLines; i++ { |
||||
l := sl.Lines[i] |
||||
data := l.Data |
||||
|
||||
if len(data) > sl.innerArea.Dx() { |
||||
data = data[len(data)-sl.innerArea.Dx():] |
||||
} |
||||
|
||||
if l.Title != "" { |
||||
rs := trimStr2Runes(l.Title, sl.innerArea.Dx()) |
||||
oftX := 0 |
||||
for _, v := range rs { |
||||
w := charWidth(v) |
||||
c := Cell{ |
||||
Ch: v, |
||||
Fg: l.TitleColor, |
||||
Bg: sl.Bg, |
||||
} |
||||
x := sl.innerArea.Min.X + oftX |
||||
y := sl.innerArea.Min.Y + oftY |
||||
buf.Set(x, y, c) |
||||
oftX += w |
||||
} |
||||
} |
||||
|
||||
for j, v := range data { |
||||
// display height of the data point, zero when data is negative
|
||||
h := int(float32(v)*l.scale + 0.5) |
||||
if v < 0 { |
||||
h = 0 |
||||
} |
||||
|
||||
barCnt := h / 8 |
||||
barMod := h % 8 |
||||
for jj := 0; jj < barCnt; jj++ { |
||||
c := Cell{ |
||||
Ch: ' ', // => sparks[7]
|
||||
Bg: l.LineColor, |
||||
} |
||||
x := sl.innerArea.Min.X + j |
||||
y := sl.innerArea.Min.Y + oftY + l.Height - jj |
||||
|
||||
//p.Bg = sl.BgColor
|
||||
buf.Set(x, y, c) |
||||
} |
||||
if barMod != 0 { |
||||
c := Cell{ |
||||
Ch: sparks[barMod-1], |
||||
Fg: l.LineColor, |
||||
Bg: sl.Bg, |
||||
} |
||||
x := sl.innerArea.Min.X + j |
||||
y := sl.innerArea.Min.Y + oftY + l.Height - barCnt |
||||
buf.Set(x, y, c) |
||||
} |
||||
} |
||||
|
||||
oftY += l.displayHeight |
||||
} |
||||
|
||||
return buf |
||||
} |
||||
@ -1,185 +0,0 @@ |
||||
// Copyright 2017 Zack Guo <zack.y.guo@gmail.com>. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license that can
|
||||
// be found in the LICENSE file.
|
||||
|
||||
package termui |
||||
|
||||
import "strings" |
||||
|
||||
/* Table is like: |
||||
|
||||
┌Awesome Table ────────────────────────────────────────────────┐ |
||||
│ Col0 | Col1 | Col2 | Col3 | Col4 | Col5 | Col6 | |
||||
│──────────────────────────────────────────────────────────────│ |
||||
│ Some Item #1 | AAA | 123 | CCCCC | EEEEE | GGGGG | IIIII | |
||||
│──────────────────────────────────────────────────────────────│ |
||||
│ Some Item #2 | BBB | 456 | DDDDD | FFFFF | HHHHH | JJJJJ | |
||||
└──────────────────────────────────────────────────────────────┘ |
||||
|
||||
Datapoints are a two dimensional array of strings: [][]string |
||||
|
||||
Example: |
||||
data := [][]string{ |
||||
{"Col0", "Col1", "Col3", "Col4", "Col5", "Col6"}, |
||||
{"Some Item #1", "AAA", "123", "CCCCC", "EEEEE", "GGGGG", "IIIII"}, |
||||
{"Some Item #2", "BBB", "456", "DDDDD", "FFFFF", "HHHHH", "JJJJJ"}, |
||||
} |
||||
|
||||
table := termui.NewTable() |
||||
table.Rows = data // type [][]string
|
||||
table.FgColor = termui.ColorWhite |
||||
table.BgColor = termui.ColorDefault |
||||
table.Height = 7 |
||||
table.Width = 62 |
||||
table.Y = 0 |
||||
table.X = 0 |
||||
table.Border = true |
||||
*/ |
||||
|
||||
// Table tracks all the attributes of a Table instance
|
||||
type Table struct { |
||||
Block |
||||
Rows [][]string |
||||
CellWidth []int |
||||
FgColor Attribute |
||||
BgColor Attribute |
||||
FgColors []Attribute |
||||
BgColors []Attribute |
||||
Separator bool |
||||
TextAlign Align |
||||
} |
||||
|
||||
// NewTable returns a new Table instance
|
||||
func NewTable() *Table { |
||||
table := &Table{Block: *NewBlock()} |
||||
table.FgColor = ColorWhite |
||||
table.BgColor = ColorDefault |
||||
table.Separator = true |
||||
return table |
||||
} |
||||
|
||||
// CellsWidth calculates the width of a cell array and returns an int
|
||||
func cellsWidth(cells []Cell) int { |
||||
width := 0 |
||||
for _, c := range cells { |
||||
width += c.Width() |
||||
} |
||||
return width |
||||
} |
||||
|
||||
// Analysis generates and returns an array of []Cell that represent all columns in the Table
|
||||
func (table *Table) Analysis() [][]Cell { |
||||
var rowCells [][]Cell |
||||
length := len(table.Rows) |
||||
if length < 1 { |
||||
return rowCells |
||||
} |
||||
|
||||
if len(table.FgColors) == 0 { |
||||
table.FgColors = make([]Attribute, len(table.Rows)) |
||||
} |
||||
if len(table.BgColors) == 0 { |
||||
table.BgColors = make([]Attribute, len(table.Rows)) |
||||
} |
||||
|
||||
cellWidths := make([]int, len(table.Rows[0])) |
||||
|
||||
for y, row := range table.Rows { |
||||
if table.FgColors[y] == 0 { |
||||
table.FgColors[y] = table.FgColor |
||||
} |
||||
if table.BgColors[y] == 0 { |
||||
table.BgColors[y] = table.BgColor |
||||
} |
||||
for x, str := range row { |
||||
cells := DefaultTxBuilder.Build(str, table.FgColors[y], table.BgColors[y]) |
||||
cw := cellsWidth(cells) |
||||
if cellWidths[x] < cw { |
||||
cellWidths[x] = cw |
||||
} |
||||
rowCells = append(rowCells, cells) |
||||
} |
||||
} |
||||
table.CellWidth = cellWidths |
||||
return rowCells |
||||
} |
||||
|
||||
// SetSize calculates the table size and sets the internal value
|
||||
func (table *Table) SetSize() { |
||||
length := len(table.Rows) |
||||
if table.Separator { |
||||
table.Height = length*2 + 1 |
||||
} else { |
||||
table.Height = length + 2 |
||||
} |
||||
table.Width = 2 |
||||
if length != 0 { |
||||
for _, cellWidth := range table.CellWidth { |
||||
table.Width += cellWidth + 3 |
||||
} |
||||
} |
||||
} |
||||
|
||||
// CalculatePosition ...
|
||||
func (table *Table) CalculatePosition(x int, y int, coordinateX *int, coordinateY *int, cellStart *int) { |
||||
if table.Separator { |
||||
*coordinateY = table.innerArea.Min.Y + y*2 |
||||
} else { |
||||
*coordinateY = table.innerArea.Min.Y + y |
||||
} |
||||
if x == 0 { |
||||
*cellStart = table.innerArea.Min.X |
||||
} else { |
||||
*cellStart += table.CellWidth[x-1] + 3 |
||||
} |
||||
|
||||
switch table.TextAlign { |
||||
case AlignRight: |
||||
*coordinateX = *cellStart + (table.CellWidth[x] - len(table.Rows[y][x])) + 2 |
||||
case AlignCenter: |
||||
*coordinateX = *cellStart + (table.CellWidth[x]-len(table.Rows[y][x]))/2 + 2 |
||||
default: |
||||
*coordinateX = *cellStart + 2 |
||||
} |
||||
} |
||||
|
||||
// Buffer ...
|
||||
func (table *Table) Buffer() Buffer { |
||||
buffer := table.Block.Buffer() |
||||
rowCells := table.Analysis() |
||||
pointerX := table.innerArea.Min.X + 2 |
||||
pointerY := table.innerArea.Min.Y |
||||
borderPointerX := table.innerArea.Min.X |
||||
for y, row := range table.Rows { |
||||
for x := range row { |
||||
table.CalculatePosition(x, y, &pointerX, &pointerY, &borderPointerX) |
||||
background := DefaultTxBuilder.Build(strings.Repeat(" ", table.CellWidth[x]+3), table.BgColors[y], table.BgColors[y]) |
||||
cells := rowCells[y*len(row)+x] |
||||
for i, back := range background { |
||||
buffer.Set(borderPointerX+i, pointerY, back) |
||||
} |
||||
|
||||
coordinateX := pointerX |
||||
for _, printer := range cells { |
||||
buffer.Set(coordinateX, pointerY, printer) |
||||
coordinateX += printer.Width() |
||||
} |
||||
|
||||
if x != 0 { |
||||
dividors := DefaultTxBuilder.Build("|", table.FgColors[y], table.BgColors[y]) |
||||
for _, dividor := range dividors { |
||||
buffer.Set(borderPointerX, pointerY, dividor) |
||||
} |
||||
} |
||||
} |
||||
|
||||
if table.Separator { |
||||
border := DefaultTxBuilder.Build(strings.Repeat("─", table.Width-2), table.FgColor, table.BgColor) |
||||
for i, cell := range border { |
||||
buffer.Set(i+1, pointerY+1, cell) |
||||
} |
||||
} |
||||
} |
||||
|
||||
return buffer |
||||
} |
||||
@ -1,278 +0,0 @@ |
||||
// Copyright 2017 Zack Guo <zack.y.guo@gmail.com>. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license that can
|
||||
// be found in the LICENSE file.
|
||||
|
||||
package termui |
||||
|
||||
import ( |
||||
"regexp" |
||||
"strings" |
||||
|
||||
"github.com/mitchellh/go-wordwrap" |
||||
) |
||||
|
||||
// TextBuilder is a minimal interface to produce text []Cell using specific syntax (markdown).
|
||||
type TextBuilder interface { |
||||
Build(s string, fg, bg Attribute) []Cell |
||||
} |
||||
|
||||
// DefaultTxBuilder is set to be MarkdownTxBuilder.
|
||||
var DefaultTxBuilder = NewMarkdownTxBuilder() |
||||
|
||||
// MarkdownTxBuilder implements TextBuilder interface, using markdown syntax.
|
||||
type MarkdownTxBuilder struct { |
||||
baseFg Attribute |
||||
baseBg Attribute |
||||
plainTx []rune |
||||
markers []marker |
||||
} |
||||
|
||||
type marker struct { |
||||
st int |
||||
ed int |
||||
fg Attribute |
||||
bg Attribute |
||||
} |
||||
|
||||
var colorMap = map[string]Attribute{ |
||||
"red": ColorRed, |
||||
"blue": ColorBlue, |
||||
"black": ColorBlack, |
||||
"cyan": ColorCyan, |
||||
"yellow": ColorYellow, |
||||
"white": ColorWhite, |
||||
"default": ColorDefault, |
||||
"green": ColorGreen, |
||||
"magenta": ColorMagenta, |
||||
} |
||||
|
||||
var attrMap = map[string]Attribute{ |
||||
"bold": AttrBold, |
||||
"underline": AttrUnderline, |
||||
"reverse": AttrReverse, |
||||
} |
||||
|
||||
func rmSpc(s string) string { |
||||
reg := regexp.MustCompile(`\s+`) |
||||
return reg.ReplaceAllString(s, "") |
||||
} |
||||
|
||||
// readAttr translates strings like `fg-red,fg-bold,bg-white` to fg and bg Attribute
|
||||
func (mtb MarkdownTxBuilder) readAttr(s string) (Attribute, Attribute) { |
||||
fg := mtb.baseFg |
||||
bg := mtb.baseBg |
||||
|
||||
updateAttr := func(a Attribute, attrs []string) Attribute { |
||||
for _, s := range attrs { |
||||
// replace the color
|
||||
if c, ok := colorMap[s]; ok { |
||||
a &= 0xFF00 // erase clr 0 ~ 8 bits
|
||||
a |= c // set clr
|
||||
} |
||||
// add attrs
|
||||
if c, ok := attrMap[s]; ok { |
||||
a |= c |
||||
} |
||||
} |
||||
return a |
||||
} |
||||
|
||||
ss := strings.Split(s, ",") |
||||
fgs := []string{} |
||||
bgs := []string{} |
||||
for _, v := range ss { |
||||
subs := strings.Split(v, "-") |
||||
if len(subs) > 1 { |
||||
if subs[0] == "fg" { |
||||
fgs = append(fgs, subs[1]) |
||||
} |
||||
if subs[0] == "bg" { |
||||
bgs = append(bgs, subs[1]) |
||||
} |
||||
} |
||||
} |
||||
|
||||
fg = updateAttr(fg, fgs) |
||||
bg = updateAttr(bg, bgs) |
||||
return fg, bg |
||||
} |
||||
|
||||
func (mtb *MarkdownTxBuilder) reset() { |
||||
mtb.plainTx = []rune{} |
||||
mtb.markers = []marker{} |
||||
} |
||||
|
||||
// parse streams and parses text into normalized text and render sequence.
|
||||
func (mtb *MarkdownTxBuilder) parse(str string) { |
||||
rs := str2runes(str) |
||||
normTx := []rune{} |
||||
square := []rune{} |
||||
brackt := []rune{} |
||||
accSquare := false |
||||
accBrackt := false |
||||
cntSquare := 0 |
||||
|
||||
reset := func() { |
||||
square = []rune{} |
||||
brackt = []rune{} |
||||
accSquare = false |
||||
accBrackt = false |
||||
cntSquare = 0 |
||||
} |
||||
// pipe stacks into normTx and clear
|
||||
rollback := func() { |
||||
normTx = append(normTx, square...) |
||||
normTx = append(normTx, brackt...) |
||||
reset() |
||||
} |
||||
// chop first and last
|
||||
chop := func(s []rune) []rune { |
||||
return s[1 : len(s)-1] |
||||
} |
||||
|
||||
for i, r := range rs { |
||||
switch { |
||||
// stacking brackt
|
||||
case accBrackt: |
||||
brackt = append(brackt, r) |
||||
if ')' == r { |
||||
fg, bg := mtb.readAttr(string(chop(brackt))) |
||||
st := len(normTx) |
||||
ed := len(normTx) + len(square) - 2 |
||||
mtb.markers = append(mtb.markers, marker{st, ed, fg, bg}) |
||||
normTx = append(normTx, chop(square)...) |
||||
reset() |
||||
} else if i+1 == len(rs) { |
||||
rollback() |
||||
} |
||||
// stacking square
|
||||
case accSquare: |
||||
switch { |
||||
// squares closed and followed by a '('
|
||||
case cntSquare == 0 && '(' == r: |
||||
accBrackt = true |
||||
brackt = append(brackt, '(') |
||||
// squares closed but not followed by a '('
|
||||
case cntSquare == 0: |
||||
rollback() |
||||
if '[' == r { |
||||
accSquare = true |
||||
cntSquare = 1 |
||||
brackt = append(brackt, '[') |
||||
} else { |
||||
normTx = append(normTx, r) |
||||
} |
||||
// hit the end
|
||||
case i+1 == len(rs): |
||||
square = append(square, r) |
||||
rollback() |
||||
case '[' == r: |
||||
cntSquare++ |
||||
square = append(square, '[') |
||||
case ']' == r: |
||||
cntSquare-- |
||||
square = append(square, ']') |
||||
// normal char
|
||||
default: |
||||
square = append(square, r) |
||||
} |
||||
// stacking normTx
|
||||
default: |
||||
if '[' == r { |
||||
accSquare = true |
||||
cntSquare = 1 |
||||
square = append(square, '[') |
||||
} else { |
||||
normTx = append(normTx, r) |
||||
} |
||||
} |
||||
} |
||||
|
||||
mtb.plainTx = normTx |
||||
} |
||||
|
||||
func wrapTx(cs []Cell, wl int) []Cell { |
||||
tmpCell := make([]Cell, len(cs)) |
||||
copy(tmpCell, cs) |
||||
|
||||
// get the plaintext
|
||||
plain := CellsToStr(cs) |
||||
|
||||
// wrap
|
||||
plainWrapped := wordwrap.WrapString(plain, uint(wl)) |
||||
|
||||
// find differences and insert
|
||||
finalCell := tmpCell // finalcell will get the inserts and is what is returned
|
||||
|
||||
plainRune := []rune(plain) |
||||
plainWrappedRune := []rune(plainWrapped) |
||||
trigger := "go" |
||||
plainRuneNew := plainRune |
||||
|
||||
for trigger != "stop" { |
||||
plainRune = plainRuneNew |
||||
for i := range plainRune { |
||||
if plainRune[i] == plainWrappedRune[i] { |
||||
trigger = "stop" |
||||
} else if plainRune[i] != plainWrappedRune[i] && plainWrappedRune[i] == 10 { |
||||
trigger = "go" |
||||
cell := Cell{10, 0, 0} |
||||
j := i - 0 |
||||
|
||||
// insert a cell into the []Cell in correct position
|
||||
tmpCell[i] = cell |
||||
|
||||
// insert the newline into plain so we avoid indexing errors
|
||||
plainRuneNew = append(plainRune, 10) |
||||
copy(plainRuneNew[j+1:], plainRuneNew[j:]) |
||||
plainRuneNew[j] = plainWrappedRune[j] |
||||
|
||||
// restart the inner for loop until plain and plain wrapped are
|
||||
// the same; yeah, it's inefficient, but the text amounts
|
||||
// should be small
|
||||
break |
||||
|
||||
} else if plainRune[i] != plainWrappedRune[i] && |
||||
plainWrappedRune[i-1] == 10 && // if the prior rune is a newline
|
||||
plainRune[i] == 32 { // and this rune is a space
|
||||
trigger = "go" |
||||
// need to delete plainRune[i] because it gets rid of an extra
|
||||
// space
|
||||
plainRuneNew = append(plainRune[:i], plainRune[i+1:]...) |
||||
break |
||||
|
||||
} else { |
||||
trigger = "stop" // stops the outer for loop
|
||||
} |
||||
} |
||||
} |
||||
|
||||
finalCell = tmpCell |
||||
|
||||
return finalCell |
||||
} |
||||
|
||||
// Build implements TextBuilder interface.
|
||||
func (mtb MarkdownTxBuilder) Build(s string, fg, bg Attribute) []Cell { |
||||
mtb.baseFg = fg |
||||
mtb.baseBg = bg |
||||
mtb.reset() |
||||
mtb.parse(s) |
||||
cs := make([]Cell, len(mtb.plainTx)) |
||||
for i := range cs { |
||||
cs[i] = Cell{Ch: mtb.plainTx[i], Fg: fg, Bg: bg} |
||||
} |
||||
for _, mrk := range mtb.markers { |
||||
for i := mrk.st; i < mrk.ed; i++ { |
||||
cs[i].Fg = mrk.fg |
||||
cs[i].Bg = mrk.bg |
||||
} |
||||
} |
||||
|
||||
return cs |
||||
} |
||||
|
||||
// NewMarkdownTxBuilder returns a TextBuilder employing markdown syntax.
|
||||
func NewMarkdownTxBuilder() TextBuilder { |
||||
return MarkdownTxBuilder{} |
||||
} |
||||
@ -1,140 +0,0 @@ |
||||
// Copyright 2017 Zack Guo <zack.y.guo@gmail.com>. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license that can
|
||||
// be found in the LICENSE file.
|
||||
|
||||
package termui |
||||
|
||||
import "strings" |
||||
|
||||
/* |
||||
// A ColorScheme represents the current look-and-feel of the dashboard.
|
||||
type ColorScheme struct { |
||||
BodyBg Attribute |
||||
BlockBg Attribute |
||||
HasBorder bool |
||||
BorderFg Attribute |
||||
BorderBg Attribute |
||||
BorderLabelTextFg Attribute |
||||
BorderLabelTextBg Attribute |
||||
ParTextFg Attribute |
||||
ParTextBg Attribute |
||||
SparklineLine Attribute |
||||
SparklineTitle Attribute |
||||
GaugeBar Attribute |
||||
GaugePercent Attribute |
||||
LineChartLine Attribute |
||||
LineChartAxes Attribute |
||||
ListItemFg Attribute |
||||
ListItemBg Attribute |
||||
BarChartBar Attribute |
||||
BarChartText Attribute |
||||
BarChartNum Attribute |
||||
MBarChartBar Attribute |
||||
MBarChartText Attribute |
||||
MBarChartNum Attribute |
||||
TabActiveBg Attribute |
||||
} |
||||
|
||||
// default color scheme depends on the user's terminal setting.
|
||||
var themeDefault = ColorScheme{HasBorder: true} |
||||
|
||||
var themeHelloWorld = ColorScheme{ |
||||
BodyBg: ColorBlack, |
||||
BlockBg: ColorBlack, |
||||
HasBorder: true, |
||||
BorderFg: ColorWhite, |
||||
BorderBg: ColorBlack, |
||||
BorderLabelTextBg: ColorBlack, |
||||
BorderLabelTextFg: ColorGreen, |
||||
ParTextBg: ColorBlack, |
||||
ParTextFg: ColorWhite, |
||||
SparklineLine: ColorMagenta, |
||||
SparklineTitle: ColorWhite, |
||||
GaugeBar: ColorRed, |
||||
GaugePercent: ColorWhite, |
||||
LineChartLine: ColorYellow | AttrBold, |
||||
LineChartAxes: ColorWhite, |
||||
ListItemBg: ColorBlack, |
||||
ListItemFg: ColorYellow, |
||||
BarChartBar: ColorRed, |
||||
BarChartNum: ColorWhite, |
||||
BarChartText: ColorCyan, |
||||
MBarChartBar: ColorRed, |
||||
MBarChartNum: ColorWhite, |
||||
MBarChartText: ColorCyan, |
||||
TabActiveBg: ColorMagenta, |
||||
} |
||||
|
||||
var theme = themeDefault // global dep
|
||||
|
||||
// Theme returns the currently used theme.
|
||||
func Theme() ColorScheme { |
||||
return theme |
||||
} |
||||
|
||||
// SetTheme sets a new, custom theme.
|
||||
func SetTheme(newTheme ColorScheme) { |
||||
theme = newTheme |
||||
} |
||||
|
||||
// UseTheme sets a predefined scheme. Currently available: "hello-world" and
|
||||
// "black-and-white".
|
||||
func UseTheme(th string) { |
||||
switch th { |
||||
case "helloworld": |
||||
theme = themeHelloWorld |
||||
default: |
||||
theme = themeDefault |
||||
} |
||||
} |
||||
*/ |
||||
|
||||
var ColorMap = map[string]Attribute{ |
||||
"fg": ColorWhite, |
||||
"bg": ColorDefault, |
||||
"border.fg": ColorWhite, |
||||
"label.fg": ColorGreen, |
||||
"par.fg": ColorYellow, |
||||
"par.label.bg": ColorWhite, |
||||
} |
||||
|
||||
func ThemeAttr(name string) Attribute { |
||||
return lookUpAttr(ColorMap, name) |
||||
} |
||||
|
||||
func lookUpAttr(clrmap map[string]Attribute, name string) Attribute { |
||||
|
||||
a, ok := clrmap[name] |
||||
if ok { |
||||
return a |
||||
} |
||||
|
||||
ns := strings.Split(name, ".") |
||||
for i := range ns { |
||||
nn := strings.Join(ns[i:len(ns)], ".") |
||||
a, ok = ColorMap[nn] |
||||
if ok { |
||||
break |
||||
} |
||||
} |
||||
|
||||
return a |
||||
} |
||||
|
||||
// 0<=r,g,b <= 5
|
||||
func ColorRGB(r, g, b int) Attribute { |
||||
within := func(n int) int { |
||||
if n < 0 { |
||||
return 0 |
||||
} |
||||
|
||||
if n > 5 { |
||||
return 5 |
||||
} |
||||
|
||||
return n |
||||
} |
||||
|
||||
r, b, g = within(r), within(b), within(g) |
||||
return Attribute(0x0f + 36*r + 6*g + b) |
||||
} |
||||
@ -1,94 +0,0 @@ |
||||
// Copyright 2017 Zack Guo <zack.y.guo@gmail.com>. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license that can
|
||||
// be found in the LICENSE file.
|
||||
|
||||
package termui |
||||
|
||||
import ( |
||||
"fmt" |
||||
"sync" |
||||
) |
||||
|
||||
// event mixins
|
||||
type WgtMgr map[string]WgtInfo |
||||
|
||||
type WgtInfo struct { |
||||
Handlers map[string]func(Event) |
||||
WgtRef Widget |
||||
Id string |
||||
} |
||||
|
||||
type Widget interface { |
||||
Id() string |
||||
} |
||||
|
||||
func NewWgtInfo(wgt Widget) WgtInfo { |
||||
return WgtInfo{ |
||||
Handlers: make(map[string]func(Event)), |
||||
WgtRef: wgt, |
||||
Id: wgt.Id(), |
||||
} |
||||
} |
||||
|
||||
func NewWgtMgr() WgtMgr { |
||||
wm := WgtMgr(make(map[string]WgtInfo)) |
||||
return wm |
||||
|
||||
} |
||||
|
||||
func (wm WgtMgr) AddWgt(wgt Widget) { |
||||
wm[wgt.Id()] = NewWgtInfo(wgt) |
||||
} |
||||
|
||||
func (wm WgtMgr) RmWgt(wgt Widget) { |
||||
wm.RmWgtById(wgt.Id()) |
||||
} |
||||
|
||||
func (wm WgtMgr) RmWgtById(id string) { |
||||
delete(wm, id) |
||||
} |
||||
|
||||
func (wm WgtMgr) AddWgtHandler(id, path string, h func(Event)) { |
||||
if w, ok := wm[id]; ok { |
||||
w.Handlers[path] = h |
||||
} |
||||
} |
||||
|
||||
func (wm WgtMgr) RmWgtHandler(id, path string) { |
||||
if w, ok := wm[id]; ok { |
||||
delete(w.Handlers, path) |
||||
} |
||||
} |
||||
|
||||
var counter struct { |
||||
sync.RWMutex |
||||
count int |
||||
} |
||||
|
||||
func GenId() string { |
||||
counter.Lock() |
||||
defer counter.Unlock() |
||||
|
||||
counter.count += 1 |
||||
return fmt.Sprintf("%d", counter.count) |
||||
} |
||||
|
||||
func (wm WgtMgr) WgtHandlersHook() func(Event) { |
||||
return func(e Event) { |
||||
for _, v := range wm { |
||||
if k := findMatch(v.Handlers, e.Path); k != "" { |
||||
v.Handlers[k](e) |
||||
} |
||||
} |
||||
} |
||||
} |
||||
|
||||
var DefaultWgtMgr WgtMgr |
||||
|
||||
func (b *Block) Handle(path string, handler func(Event)) { |
||||
if _, ok := DefaultWgtMgr[b.Id()]; !ok { |
||||
DefaultWgtMgr.AddWgt(b) |
||||
} |
||||
|
||||
DefaultWgtMgr.AddWgtHandler(b.Id(), path, handler) |
||||
} |
||||
@ -1,635 +0,0 @@ |
||||
// Package client (v2) is the current official Go client for InfluxDB.
|
||||
package client // import "github.com/influxdata/influxdb/client/v2"
|
||||
|
||||
import ( |
||||
"bytes" |
||||
"crypto/tls" |
||||
"encoding/json" |
||||
"errors" |
||||
"fmt" |
||||
"io" |
||||
"io/ioutil" |
||||
"mime" |
||||
"net/http" |
||||
"net/url" |
||||
"strconv" |
||||
"strings" |
||||
"time" |
||||
|
||||
"github.com/influxdata/influxdb/models" |
||||
) |
||||
|
||||
// HTTPConfig is the config data needed to create an HTTP Client.
|
||||
type HTTPConfig struct { |
||||
// Addr should be of the form "http://host:port"
|
||||
// or "http://[ipv6-host%zone]:port".
|
||||
Addr string |
||||
|
||||
// Username is the influxdb username, optional.
|
||||
Username string |
||||
|
||||
// Password is the influxdb password, optional.
|
||||
Password string |
||||
|
||||
// UserAgent is the http User Agent, defaults to "InfluxDBClient".
|
||||
UserAgent string |
||||
|
||||
// Timeout for influxdb writes, defaults to no timeout.
|
||||
Timeout time.Duration |
||||
|
||||
// InsecureSkipVerify gets passed to the http client, if true, it will
|
||||
// skip https certificate verification. Defaults to false.
|
||||
InsecureSkipVerify bool |
||||
|
||||
// TLSConfig allows the user to set their own TLS config for the HTTP
|
||||
// Client. If set, this option overrides InsecureSkipVerify.
|
||||
TLSConfig *tls.Config |
||||
} |
||||
|
||||
// BatchPointsConfig is the config data needed to create an instance of the BatchPoints struct.
|
||||
type BatchPointsConfig struct { |
||||
// Precision is the write precision of the points, defaults to "ns".
|
||||
Precision string |
||||
|
||||
// Database is the database to write points to.
|
||||
Database string |
||||
|
||||
// RetentionPolicy is the retention policy of the points.
|
||||
RetentionPolicy string |
||||
|
||||
// Write consistency is the number of servers required to confirm write.
|
||||
WriteConsistency string |
||||
} |
||||
|
||||
// Client is a client interface for writing & querying the database.
|
||||
type Client interface { |
||||
// Ping checks that status of cluster, and will always return 0 time and no
|
||||
// error for UDP clients.
|
||||
Ping(timeout time.Duration) (time.Duration, string, error) |
||||
|
||||
// Write takes a BatchPoints object and writes all Points to InfluxDB.
|
||||
Write(bp BatchPoints) error |
||||
|
||||
// Query makes an InfluxDB Query on the database. This will fail if using
|
||||
// the UDP client.
|
||||
Query(q Query) (*Response, error) |
||||
|
||||
// Close releases any resources a Client may be using.
|
||||
Close() error |
||||
} |
||||
|
||||
// NewHTTPClient returns a new Client from the provided config.
|
||||
// Client is safe for concurrent use by multiple goroutines.
|
||||
func NewHTTPClient(conf HTTPConfig) (Client, error) { |
||||
if conf.UserAgent == "" { |
||||
conf.UserAgent = "InfluxDBClient" |
||||
} |
||||
|
||||
u, err := url.Parse(conf.Addr) |
||||
if err != nil { |
||||
return nil, err |
||||
} else if u.Scheme != "http" && u.Scheme != "https" { |
||||
m := fmt.Sprintf("Unsupported protocol scheme: %s, your address"+ |
||||
" must start with http:// or https://", u.Scheme) |
||||
return nil, errors.New(m) |
||||
} |
||||
|
||||
tr := &http.Transport{ |
||||
TLSClientConfig: &tls.Config{ |
||||
InsecureSkipVerify: conf.InsecureSkipVerify, |
||||
}, |
||||
} |
||||
if conf.TLSConfig != nil { |
||||
tr.TLSClientConfig = conf.TLSConfig |
||||
} |
||||
return &client{ |
||||
url: *u, |
||||
username: conf.Username, |
||||
password: conf.Password, |
||||
useragent: conf.UserAgent, |
||||
httpClient: &http.Client{ |
||||
Timeout: conf.Timeout, |
||||
Transport: tr, |
||||
}, |
||||
transport: tr, |
||||
}, nil |
||||
} |
||||
|
||||
// Ping will check to see if the server is up with an optional timeout on waiting for leader.
|
||||
// Ping returns how long the request took, the version of the server it connected to, and an error if one occurred.
|
||||
func (c *client) Ping(timeout time.Duration) (time.Duration, string, error) { |
||||
now := time.Now() |
||||
u := c.url |
||||
u.Path = "ping" |
||||
|
||||
req, err := http.NewRequest("GET", u.String(), nil) |
||||
if err != nil { |
||||
return 0, "", err |
||||
} |
||||
|
||||
req.Header.Set("User-Agent", c.useragent) |
||||
|
||||
if c.username != "" { |
||||
req.SetBasicAuth(c.username, c.password) |
||||
} |
||||
|
||||
if timeout > 0 { |
||||
params := req.URL.Query() |
||||
params.Set("wait_for_leader", fmt.Sprintf("%.0fs", timeout.Seconds())) |
||||
req.URL.RawQuery = params.Encode() |
||||
} |
||||
|
||||
resp, err := c.httpClient.Do(req) |
||||
if err != nil { |
||||
return 0, "", err |
||||
} |
||||
defer resp.Body.Close() |
||||
|
||||
body, err := ioutil.ReadAll(resp.Body) |
||||
if err != nil { |
||||
return 0, "", err |
||||
} |
||||
|
||||
if resp.StatusCode != http.StatusNoContent { |
||||
var err = fmt.Errorf(string(body)) |
||||
return 0, "", err |
||||
} |
||||
|
||||
version := resp.Header.Get("X-Influxdb-Version") |
||||
return time.Since(now), version, nil |
||||
} |
||||
|
||||
// Close releases the client's resources.
|
||||
func (c *client) Close() error { |
||||
c.transport.CloseIdleConnections() |
||||
return nil |
||||
} |
||||
|
||||
// client is safe for concurrent use as the fields are all read-only
|
||||
// once the client is instantiated.
|
||||
type client struct { |
||||
// N.B - if url.UserInfo is accessed in future modifications to the
|
||||
// methods on client, you will need to syncronise access to url.
|
||||
url url.URL |
||||
username string |
||||
password string |
||||
useragent string |
||||
httpClient *http.Client |
||||
transport *http.Transport |
||||
} |
||||
|
||||
// BatchPoints is an interface into a batched grouping of points to write into
|
||||
// InfluxDB together. BatchPoints is NOT thread-safe, you must create a separate
|
||||
// batch for each goroutine.
|
||||
type BatchPoints interface { |
||||
// AddPoint adds the given point to the Batch of points.
|
||||
AddPoint(p *Point) |
||||
// AddPoints adds the given points to the Batch of points.
|
||||
AddPoints(ps []*Point) |
||||
// Points lists the points in the Batch.
|
||||
Points() []*Point |
||||
|
||||
// Precision returns the currently set precision of this Batch.
|
||||
Precision() string |
||||
// SetPrecision sets the precision of this batch.
|
||||
SetPrecision(s string) error |
||||
|
||||
// Database returns the currently set database of this Batch.
|
||||
Database() string |
||||
// SetDatabase sets the database of this Batch.
|
||||
SetDatabase(s string) |
||||
|
||||
// WriteConsistency returns the currently set write consistency of this Batch.
|
||||
WriteConsistency() string |
||||
// SetWriteConsistency sets the write consistency of this Batch.
|
||||
SetWriteConsistency(s string) |
||||
|
||||
// RetentionPolicy returns the currently set retention policy of this Batch.
|
||||
RetentionPolicy() string |
||||
// SetRetentionPolicy sets the retention policy of this Batch.
|
||||
SetRetentionPolicy(s string) |
||||
} |
||||
|
||||
// NewBatchPoints returns a BatchPoints interface based on the given config.
|
||||
func NewBatchPoints(conf BatchPointsConfig) (BatchPoints, error) { |
||||
if conf.Precision == "" { |
||||
conf.Precision = "ns" |
||||
} |
||||
if _, err := time.ParseDuration("1" + conf.Precision); err != nil { |
||||
return nil, err |
||||
} |
||||
bp := &batchpoints{ |
||||
database: conf.Database, |
||||
precision: conf.Precision, |
||||
retentionPolicy: conf.RetentionPolicy, |
||||
writeConsistency: conf.WriteConsistency, |
||||
} |
||||
return bp, nil |
||||
} |
||||
|
||||
type batchpoints struct { |
||||
points []*Point |
||||
database string |
||||
precision string |
||||
retentionPolicy string |
||||
writeConsistency string |
||||
} |
||||
|
||||
func (bp *batchpoints) AddPoint(p *Point) { |
||||
bp.points = append(bp.points, p) |
||||
} |
||||
|
||||
func (bp *batchpoints) AddPoints(ps []*Point) { |
||||
bp.points = append(bp.points, ps...) |
||||
} |
||||
|
||||
func (bp *batchpoints) Points() []*Point { |
||||
return bp.points |
||||
} |
||||
|
||||
func (bp *batchpoints) Precision() string { |
||||
return bp.precision |
||||
} |
||||
|
||||
func (bp *batchpoints) Database() string { |
||||
return bp.database |
||||
} |
||||
|
||||
func (bp *batchpoints) WriteConsistency() string { |
||||
return bp.writeConsistency |
||||
} |
||||
|
||||
func (bp *batchpoints) RetentionPolicy() string { |
||||
return bp.retentionPolicy |
||||
} |
||||
|
||||
func (bp *batchpoints) SetPrecision(p string) error { |
||||
if _, err := time.ParseDuration("1" + p); err != nil { |
||||
return err |
||||
} |
||||
bp.precision = p |
||||
return nil |
||||
} |
||||
|
||||
func (bp *batchpoints) SetDatabase(db string) { |
||||
bp.database = db |
||||
} |
||||
|
||||
func (bp *batchpoints) SetWriteConsistency(wc string) { |
||||
bp.writeConsistency = wc |
||||
} |
||||
|
||||
func (bp *batchpoints) SetRetentionPolicy(rp string) { |
||||
bp.retentionPolicy = rp |
||||
} |
||||
|
||||
// Point represents a single data point.
|
||||
type Point struct { |
||||
pt models.Point |
||||
} |
||||
|
||||
// NewPoint returns a point with the given timestamp. If a timestamp is not
|
||||
// given, then data is sent to the database without a timestamp, in which case
|
||||
// the server will assign local time upon reception. NOTE: it is recommended to
|
||||
// send data with a timestamp.
|
||||
func NewPoint( |
||||
name string, |
||||
tags map[string]string, |
||||
fields map[string]interface{}, |
||||
t ...time.Time, |
||||
) (*Point, error) { |
||||
var T time.Time |
||||
if len(t) > 0 { |
||||
T = t[0] |
||||
} |
||||
|
||||
pt, err := models.NewPoint(name, models.NewTags(tags), fields, T) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
return &Point{ |
||||
pt: pt, |
||||
}, nil |
||||
} |
||||
|
||||
// String returns a line-protocol string of the Point.
|
||||
func (p *Point) String() string { |
||||
return p.pt.String() |
||||
} |
||||
|
||||
// PrecisionString returns a line-protocol string of the Point,
|
||||
// with the timestamp formatted for the given precision.
|
||||
func (p *Point) PrecisionString(precison string) string { |
||||
return p.pt.PrecisionString(precison) |
||||
} |
||||
|
||||
// Name returns the measurement name of the point.
|
||||
func (p *Point) Name() string { |
||||
return string(p.pt.Name()) |
||||
} |
||||
|
||||
// Tags returns the tags associated with the point.
|
||||
func (p *Point) Tags() map[string]string { |
||||
return p.pt.Tags().Map() |
||||
} |
||||
|
||||
// Time return the timestamp for the point.
|
||||
func (p *Point) Time() time.Time { |
||||
return p.pt.Time() |
||||
} |
||||
|
||||
// UnixNano returns timestamp of the point in nanoseconds since Unix epoch.
|
||||
func (p *Point) UnixNano() int64 { |
||||
return p.pt.UnixNano() |
||||
} |
||||
|
||||
// Fields returns the fields for the point.
|
||||
func (p *Point) Fields() (map[string]interface{}, error) { |
||||
return p.pt.Fields() |
||||
} |
||||
|
||||
// NewPointFrom returns a point from the provided models.Point.
|
||||
func NewPointFrom(pt models.Point) *Point { |
||||
return &Point{pt: pt} |
||||
} |
||||
|
||||
func (c *client) Write(bp BatchPoints) error { |
||||
var b bytes.Buffer |
||||
|
||||
for _, p := range bp.Points() { |
||||
if _, err := b.WriteString(p.pt.PrecisionString(bp.Precision())); err != nil { |
||||
return err |
||||
} |
||||
|
||||
if err := b.WriteByte('\n'); err != nil { |
||||
return err |
||||
} |
||||
} |
||||
|
||||
u := c.url |
||||
u.Path = "write" |
||||
req, err := http.NewRequest("POST", u.String(), &b) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
req.Header.Set("Content-Type", "") |
||||
req.Header.Set("User-Agent", c.useragent) |
||||
if c.username != "" { |
||||
req.SetBasicAuth(c.username, c.password) |
||||
} |
||||
|
||||
params := req.URL.Query() |
||||
params.Set("db", bp.Database()) |
||||
params.Set("rp", bp.RetentionPolicy()) |
||||
params.Set("precision", bp.Precision()) |
||||
params.Set("consistency", bp.WriteConsistency()) |
||||
req.URL.RawQuery = params.Encode() |
||||
|
||||
resp, err := c.httpClient.Do(req) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
defer resp.Body.Close() |
||||
|
||||
body, err := ioutil.ReadAll(resp.Body) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
|
||||
if resp.StatusCode != http.StatusNoContent && resp.StatusCode != http.StatusOK { |
||||
var err = fmt.Errorf(string(body)) |
||||
return err |
||||
} |
||||
|
||||
return nil |
||||
} |
||||
|
||||
// Query defines a query to send to the server.
|
||||
type Query struct { |
||||
Command string |
||||
Database string |
||||
Precision string |
||||
Chunked bool |
||||
ChunkSize int |
||||
Parameters map[string]interface{} |
||||
} |
||||
|
||||
// NewQuery returns a query object.
|
||||
// The database and precision arguments can be empty strings if they are not needed for the query.
|
||||
func NewQuery(command, database, precision string) Query { |
||||
return Query{ |
||||
Command: command, |
||||
Database: database, |
||||
Precision: precision, |
||||
Parameters: make(map[string]interface{}), |
||||
} |
||||
} |
||||
|
||||
// NewQueryWithParameters returns a query object.
|
||||
// The database and precision arguments can be empty strings if they are not needed for the query.
|
||||
// parameters is a map of the parameter names used in the command to their values.
|
||||
func NewQueryWithParameters(command, database, precision string, parameters map[string]interface{}) Query { |
||||
return Query{ |
||||
Command: command, |
||||
Database: database, |
||||
Precision: precision, |
||||
Parameters: parameters, |
||||
} |
||||
} |
||||
|
||||
// Response represents a list of statement results.
|
||||
type Response struct { |
||||
Results []Result |
||||
Err string `json:"error,omitempty"` |
||||
} |
||||
|
||||
// Error returns the first error from any statement.
|
||||
// It returns nil if no errors occurred on any statements.
|
||||
func (r *Response) Error() error { |
||||
if r.Err != "" { |
||||
return fmt.Errorf(r.Err) |
||||
} |
||||
for _, result := range r.Results { |
||||
if result.Err != "" { |
||||
return fmt.Errorf(result.Err) |
||||
} |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
// Message represents a user message.
|
||||
type Message struct { |
||||
Level string |
||||
Text string |
||||
} |
||||
|
||||
// Result represents a resultset returned from a single statement.
|
||||
type Result struct { |
||||
Series []models.Row |
||||
Messages []*Message |
||||
Err string `json:"error,omitempty"` |
||||
} |
||||
|
||||
// Query sends a command to the server and returns the Response.
|
||||
func (c *client) Query(q Query) (*Response, error) { |
||||
u := c.url |
||||
u.Path = "query" |
||||
|
||||
jsonParameters, err := json.Marshal(q.Parameters) |
||||
|
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
req, err := http.NewRequest("POST", u.String(), nil) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
req.Header.Set("Content-Type", "") |
||||
req.Header.Set("User-Agent", c.useragent) |
||||
|
||||
if c.username != "" { |
||||
req.SetBasicAuth(c.username, c.password) |
||||
} |
||||
|
||||
params := req.URL.Query() |
||||
params.Set("q", q.Command) |
||||
params.Set("db", q.Database) |
||||
params.Set("params", string(jsonParameters)) |
||||
if q.Chunked { |
||||
params.Set("chunked", "true") |
||||
if q.ChunkSize > 0 { |
||||
params.Set("chunk_size", strconv.Itoa(q.ChunkSize)) |
||||
} |
||||
} |
||||
|
||||
if q.Precision != "" { |
||||
params.Set("epoch", q.Precision) |
||||
} |
||||
req.URL.RawQuery = params.Encode() |
||||
|
||||
resp, err := c.httpClient.Do(req) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
defer resp.Body.Close() |
||||
|
||||
// If we lack a X-Influxdb-Version header, then we didn't get a response from influxdb
|
||||
// but instead some other service. If the error code is also a 500+ code, then some
|
||||
// downstream loadbalancer/proxy/etc had an issue and we should report that.
|
||||
if resp.Header.Get("X-Influxdb-Version") == "" && resp.StatusCode >= http.StatusInternalServerError { |
||||
body, err := ioutil.ReadAll(resp.Body) |
||||
if err != nil || len(body) == 0 { |
||||
return nil, fmt.Errorf("received status code %d from downstream server", resp.StatusCode) |
||||
} |
||||
|
||||
return nil, fmt.Errorf("received status code %d from downstream server, with response body: %q", resp.StatusCode, body) |
||||
} |
||||
|
||||
// If we get an unexpected content type, then it is also not from influx direct and therefore
|
||||
// we want to know what we received and what status code was returned for debugging purposes.
|
||||
if cType, _, _ := mime.ParseMediaType(resp.Header.Get("Content-Type")); cType != "application/json" { |
||||
// Read up to 1kb of the body to help identify downstream errors and limit the impact of things
|
||||
// like downstream serving a large file
|
||||
body, err := ioutil.ReadAll(io.LimitReader(resp.Body, 1024)) |
||||
if err != nil || len(body) == 0 { |
||||
return nil, fmt.Errorf("expected json response, got empty body, with status: %v", resp.StatusCode) |
||||
} |
||||
|
||||
return nil, fmt.Errorf("expected json response, got %q, with status: %v and response body: %q", cType, resp.StatusCode, body) |
||||
} |
||||
|
||||
var response Response |
||||
if q.Chunked { |
||||
cr := NewChunkedResponse(resp.Body) |
||||
for { |
||||
r, err := cr.NextResponse() |
||||
if err != nil { |
||||
// If we got an error while decoding the response, send that back.
|
||||
return nil, err |
||||
} |
||||
|
||||
if r == nil { |
||||
break |
||||
} |
||||
|
||||
response.Results = append(response.Results, r.Results...) |
||||
if r.Err != "" { |
||||
response.Err = r.Err |
||||
break |
||||
} |
||||
} |
||||
} else { |
||||
dec := json.NewDecoder(resp.Body) |
||||
dec.UseNumber() |
||||
decErr := dec.Decode(&response) |
||||
|
||||
// ignore this error if we got an invalid status code
|
||||
if decErr != nil && decErr.Error() == "EOF" && resp.StatusCode != http.StatusOK { |
||||
decErr = nil |
||||
} |
||||
// If we got a valid decode error, send that back
|
||||
if decErr != nil { |
||||
return nil, fmt.Errorf("unable to decode json: received status code %d err: %s", resp.StatusCode, decErr) |
||||
} |
||||
} |
||||
|
||||
// If we don't have an error in our json response, and didn't get statusOK
|
||||
// then send back an error
|
||||
if resp.StatusCode != http.StatusOK && response.Error() == nil { |
||||
return &response, fmt.Errorf("received status code %d from server", resp.StatusCode) |
||||
} |
||||
return &response, nil |
||||
} |
||||
|
||||
// duplexReader reads responses and writes it to another writer while
|
||||
// satisfying the reader interface.
|
||||
type duplexReader struct { |
||||
r io.Reader |
||||
w io.Writer |
||||
} |
||||
|
||||
func (r *duplexReader) Read(p []byte) (n int, err error) { |
||||
n, err = r.r.Read(p) |
||||
if err == nil { |
||||
r.w.Write(p[:n]) |
||||
} |
||||
return n, err |
||||
} |
||||
|
||||
// ChunkedResponse represents a response from the server that
|
||||
// uses chunking to stream the output.
|
||||
type ChunkedResponse struct { |
||||
dec *json.Decoder |
||||
duplex *duplexReader |
||||
buf bytes.Buffer |
||||
} |
||||
|
||||
// NewChunkedResponse reads a stream and produces responses from the stream.
|
||||
func NewChunkedResponse(r io.Reader) *ChunkedResponse { |
||||
resp := &ChunkedResponse{} |
||||
resp.duplex = &duplexReader{r: r, w: &resp.buf} |
||||
resp.dec = json.NewDecoder(resp.duplex) |
||||
resp.dec.UseNumber() |
||||
return resp |
||||
} |
||||
|
||||
// NextResponse reads the next line of the stream and returns a response.
|
||||
func (r *ChunkedResponse) NextResponse() (*Response, error) { |
||||
var response Response |
||||
|
||||
if err := r.dec.Decode(&response); err != nil { |
||||
if err == io.EOF { |
||||
return nil, nil |
||||
} |
||||
// A decoding error happened. This probably means the server crashed
|
||||
// and sent a last-ditch error message to us. Ensure we have read the
|
||||
// entirety of the connection to get any remaining error text.
|
||||
io.Copy(ioutil.Discard, r.duplex) |
||||
return nil, errors.New(strings.TrimSpace(r.buf.String())) |
||||
} |
||||
|
||||
r.buf.Reset() |
||||
return &response, nil |
||||
} |
||||
@ -1,112 +0,0 @@ |
||||
package client |
||||
|
||||
import ( |
||||
"fmt" |
||||
"io" |
||||
"net" |
||||
"time" |
||||
) |
||||
|
||||
const ( |
||||
// UDPPayloadSize is a reasonable default payload size for UDP packets that
|
||||
// could be travelling over the internet.
|
||||
UDPPayloadSize = 512 |
||||
) |
||||
|
||||
// UDPConfig is the config data needed to create a UDP Client.
|
||||
type UDPConfig struct { |
||||
// Addr should be of the form "host:port"
|
||||
// or "[ipv6-host%zone]:port".
|
||||
Addr string |
||||
|
||||
// PayloadSize is the maximum size of a UDP client message, optional
|
||||
// Tune this based on your network. Defaults to UDPPayloadSize.
|
||||
PayloadSize int |
||||
} |
||||
|
||||
// NewUDPClient returns a client interface for writing to an InfluxDB UDP
|
||||
// service from the given config.
|
||||
func NewUDPClient(conf UDPConfig) (Client, error) { |
||||
var udpAddr *net.UDPAddr |
||||
udpAddr, err := net.ResolveUDPAddr("udp", conf.Addr) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
conn, err := net.DialUDP("udp", nil, udpAddr) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
payloadSize := conf.PayloadSize |
||||
if payloadSize == 0 { |
||||
payloadSize = UDPPayloadSize |
||||
} |
||||
|
||||
return &udpclient{ |
||||
conn: conn, |
||||
payloadSize: payloadSize, |
||||
}, nil |
||||
} |
||||
|
||||
// Close releases the udpclient's resources.
|
||||
func (uc *udpclient) Close() error { |
||||
return uc.conn.Close() |
||||
} |
||||
|
||||
type udpclient struct { |
||||
conn io.WriteCloser |
||||
payloadSize int |
||||
} |
||||
|
||||
func (uc *udpclient) Write(bp BatchPoints) error { |
||||
var b = make([]byte, 0, uc.payloadSize) // initial buffer size, it will grow as needed
|
||||
var d, _ = time.ParseDuration("1" + bp.Precision()) |
||||
|
||||
var delayedError error |
||||
|
||||
var checkBuffer = func(n int) { |
||||
if len(b) > 0 && len(b)+n > uc.payloadSize { |
||||
if _, err := uc.conn.Write(b); err != nil { |
||||
delayedError = err |
||||
} |
||||
b = b[:0] |
||||
} |
||||
} |
||||
|
||||
for _, p := range bp.Points() { |
||||
p.pt.Round(d) |
||||
pointSize := p.pt.StringSize() + 1 // include newline in size
|
||||
//point := p.pt.RoundedString(d) + "\n"
|
||||
|
||||
checkBuffer(pointSize) |
||||
|
||||
if p.Time().IsZero() || pointSize <= uc.payloadSize { |
||||
b = p.pt.AppendString(b) |
||||
b = append(b, '\n') |
||||
continue |
||||
} |
||||
|
||||
points := p.pt.Split(uc.payloadSize - 1) // account for newline character
|
||||
for _, sp := range points { |
||||
checkBuffer(sp.StringSize() + 1) |
||||
b = sp.AppendString(b) |
||||
b = append(b, '\n') |
||||
} |
||||
} |
||||
|
||||
if len(b) > 0 { |
||||
if _, err := uc.conn.Write(b); err != nil { |
||||
return err |
||||
} |
||||
} |
||||
return delayedError |
||||
} |
||||
|
||||
func (uc *udpclient) Query(q Query) (*Response, error) { |
||||
return nil, fmt.Errorf("Querying via UDP is not supported") |
||||
} |
||||
|
||||
func (uc *udpclient) Ping(timeout time.Duration) (time.Duration, string, error) { |
||||
return 0, "", nil |
||||
} |
||||
@ -1,15 +0,0 @@ |
||||
# Copyright 2014 Marc-Antoine Ruel. All rights reserved. |
||||
# Use of this source code is governed under the Apache License, Version 2.0 |
||||
# that can be found in the LICENSE file. |
||||
|
||||
sudo: false |
||||
language: go |
||||
|
||||
go: |
||||
- tip |
||||
|
||||
before_install: |
||||
- go get github.com/maruel/pre-commit-go/cmd/pcg |
||||
|
||||
script: |
||||
- pcg |
||||
@ -1,201 +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: |
||||
|
||||
(a) You must give any other recipients of the Work or |
||||
Derivative Works a copy of this License; and |
||||
|
||||
(b) You must cause any modified files to carry prominent notices |
||||
stating that You changed the files; and |
||||
|
||||
(c) 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 |
||||
|
||||
(d) 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 2015 Marc-Antoine Ruel |
||||
|
||||
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,123 +0,0 @@ |
||||
panicparse |
||||
========== |
||||
|
||||
Parses panic stack traces, densifies and deduplicates goroutines with similar |
||||
stack traces. Helps debugging crashes and deadlocks in heavily parallelized |
||||
process. |
||||
|
||||
[](https://travis-ci.org/maruel/panicparse) |
||||
|
||||
panicparse helps make sense of Go crash dumps: |
||||
|
||||
 |
||||
|
||||
|
||||
Features |
||||
-------- |
||||
|
||||
* >50% more compact output than original stack dump yet more readable. |
||||
* Exported symbols are bold, private symbols are darker. |
||||
* Stdlib is green, main is yellow, rest is red. |
||||
* Deduplicates redundant goroutine stacks. Useful for large server crashes. |
||||
* Arguments as pointer IDs instead of raw pointer values. |
||||
* Pushes stdlib-only stacks at the bottom to help focus on important code. |
||||
* Usable as a library! |
||||
[](https://godoc.org/github.com/maruel/panicparse/stack) |
||||
* Warning: please pin the version (e.g. vendor it). Breaking changes are |
||||
not planned but may happen. |
||||
* Parses the source files if available to augment the output. |
||||
* Works on Windows. |
||||
|
||||
|
||||
Installation |
||||
------------ |
||||
|
||||
go get github.com/maruel/panicparse/cmd/pp |
||||
|
||||
|
||||
Usage |
||||
----- |
||||
|
||||
### Piping a stack trace from another process |
||||
|
||||
#### TL;DR |
||||
|
||||
* Ubuntu (bash v4 or zsh): `|&` |
||||
* OSX, [install bash 4+](README.md#updating-bash-on-osx), then: `|&` |
||||
* Windows _or_ OSX with stock bash v3: `2>&1 |` |
||||
* [Fish](http://fishshell.com/) shell: `^|` |
||||
|
||||
|
||||
#### Longer version |
||||
|
||||
`pp` streams its stdin to stdout as long as it doesn't detect any panic. |
||||
`panic()` and Go's native deadlock detector [print to |
||||
stderr](https://golang.org/src/runtime/panic1.go) via the native [`print()` |
||||
function](https://golang.org/pkg/builtin/#print). |
||||
|
||||
|
||||
**Bash v4** or **zsh**: `|&` tells the shell to redirect stderr to stdout, |
||||
it's an alias for `2>&1 |` ([bash |
||||
v4](https://www.gnu.org/software/bash/manual/bash.html#Pipelines), |
||||
[zsh](http://zsh.sourceforge.net/Doc/Release/Shell-Grammar.html#Simple-Commands-_0026-Pipelines)): |
||||
|
||||
go test -v |&pp |
||||
|
||||
|
||||
**Windows or OSX native bash** [(which is |
||||
3.2.57)](http://meta.ath0.com/2012/02/05/apples-great-gpl-purge/): They don't |
||||
have this shortcut, so use the long form: |
||||
|
||||
go test -v 2>&1 | pp |
||||
|
||||
|
||||
**Fish**: It uses [^ for stderr |
||||
redirection](http://fishshell.com/docs/current/tutorial.html#tut_pipes_and_redirections) |
||||
so the shortcut is `^|`: |
||||
|
||||
go test -v ^|pp |
||||
|
||||
|
||||
**PowerShell**: [It has broken `2>&1` redirection](https://connect.microsoft.com/PowerShell/feedback/details/765551/in-powershell-v3-you-cant-redirect-stderr-to-stdout-without-generating-error-records). The workaround is to shell out to cmd.exe. :( |
||||
|
||||
|
||||
### Investigate deadlock |
||||
|
||||
On POSIX, use `Ctrl-\` to send SIGQUIT to your process, `pp` will ignore |
||||
the signal and will parse the stack trace. |
||||
|
||||
|
||||
### Parsing from a file |
||||
|
||||
To dump to a file then parse, pass the file path of a stack trace |
||||
|
||||
go test 2> stack.txt |
||||
pp stack.txt |
||||
|
||||
|
||||
Tips |
||||
---- |
||||
|
||||
### GOTRACEBACK |
||||
|
||||
Starting with Go 1.6, [`GOTRACEBACK`](https://golang.org/pkg/runtime/) defaults |
||||
to `single` instead of `all` / `1` that was used in 1.5 and before. To get all |
||||
goroutines trace and not just the crashing one, set the environment variable: |
||||
|
||||
export GOTRACEBACK=all |
||||
|
||||
or `set GOTRACEBACK=all` on Windows. Probably worth to put it in your `.bashrc`. |
||||
|
||||
|
||||
### Updating bash on OSX |
||||
|
||||
Install bash v4+ on OSX via [homebrew](http://brew.sh) or |
||||
[macports](https://www.macports.org/). Your future self will appreciate having |
||||
done that. |
||||
|
||||
|
||||
### If you have `/usr/bin/pp` installed |
||||
|
||||
You may have the Perl PAR Packager installed. Use long name `panicparse` then; |
||||
|
||||
go get github.com/maruel/panicparse |
||||
@ -1,291 +0,0 @@ |
||||
// Copyright 2015 Marc-Antoine Ruel. All rights reserved.
|
||||
// Use of this source code is governed under the Apache License, Version 2.0
|
||||
// that can be found in the LICENSE file.
|
||||
|
||||
// This file contains the code to process sources, to be able to deduct the
|
||||
// original types.
|
||||
|
||||
package stack |
||||
|
||||
import ( |
||||
"bytes" |
||||
"fmt" |
||||
"go/ast" |
||||
"go/parser" |
||||
"go/token" |
||||
"io/ioutil" |
||||
"log" |
||||
"math" |
||||
"strings" |
||||
) |
||||
|
||||
// cache is a cache of sources on the file system.
|
||||
type cache struct { |
||||
files map[string][]byte |
||||
parsed map[string]*parsedFile |
||||
} |
||||
|
||||
// Augment processes source files to improve calls to be more descriptive.
|
||||
//
|
||||
// It modifies goroutines in place.
|
||||
func Augment(goroutines []Goroutine) { |
||||
c := &cache{} |
||||
for i := range goroutines { |
||||
c.augmentGoroutine(&goroutines[i]) |
||||
} |
||||
} |
||||
|
||||
// augmentGoroutine processes source files to improve call to be more
|
||||
// descriptive.
|
||||
//
|
||||
// It modifies the routine.
|
||||
func (c *cache) augmentGoroutine(goroutine *Goroutine) { |
||||
if c.files == nil { |
||||
c.files = map[string][]byte{} |
||||
} |
||||
if c.parsed == nil { |
||||
c.parsed = map[string]*parsedFile{} |
||||
} |
||||
// For each call site, look at the next call and populate it. Then we can
|
||||
// walk back and reformat things.
|
||||
for i := range goroutine.Stack.Calls { |
||||
c.load(goroutine.Stack.Calls[i].SourcePath) |
||||
} |
||||
|
||||
// Once all loaded, we can look at the next call when available.
|
||||
for i := 1; i < len(goroutine.Stack.Calls); i++ { |
||||
// Get the AST from the previous call and process the call line with it.
|
||||
if f := c.getFuncAST(&goroutine.Stack.Calls[i]); f != nil { |
||||
processCall(&goroutine.Stack.Calls[i], f) |
||||
} |
||||
} |
||||
} |
||||
|
||||
// Private stuff.
|
||||
|
||||
// load loads a source file and parses the AST tree. Failures are ignored.
|
||||
func (c *cache) load(fileName string) { |
||||
if _, ok := c.parsed[fileName]; ok { |
||||
return |
||||
} |
||||
c.parsed[fileName] = nil |
||||
if !strings.HasSuffix(fileName, ".go") { |
||||
// Ignore C and assembly.
|
||||
c.files[fileName] = nil |
||||
return |
||||
} |
||||
log.Printf("load(%s)", fileName) |
||||
if _, ok := c.files[fileName]; !ok { |
||||
var err error |
||||
if c.files[fileName], err = ioutil.ReadFile(fileName); err != nil { |
||||
log.Printf("Failed to read %s: %s", fileName, err) |
||||
c.files[fileName] = nil |
||||
return |
||||
} |
||||
} |
||||
fset := token.NewFileSet() |
||||
src := c.files[fileName] |
||||
parsed, err := parser.ParseFile(fset, fileName, src, 0) |
||||
if err != nil { |
||||
log.Printf("Failed to parse %s: %s", fileName, err) |
||||
return |
||||
} |
||||
// Convert the line number into raw file offset.
|
||||
offsets := []int{0, 0} |
||||
start := 0 |
||||
for l := 1; start < len(src); l++ { |
||||
start += bytes.IndexByte(src[start:], '\n') + 1 |
||||
offsets = append(offsets, start) |
||||
} |
||||
c.parsed[fileName] = &parsedFile{offsets, parsed} |
||||
} |
||||
|
||||
func (c *cache) getFuncAST(call *Call) *ast.FuncDecl { |
||||
if p := c.parsed[call.SourcePath]; p != nil { |
||||
return p.getFuncAST(call.Func.Name(), call.Line) |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
type parsedFile struct { |
||||
lineToByteOffset []int |
||||
parsed *ast.File |
||||
} |
||||
|
||||
// getFuncAST gets the callee site function AST representation for the code
|
||||
// inside the function f at line l.
|
||||
func (p *parsedFile) getFuncAST(f string, l int) (d *ast.FuncDecl) { |
||||
// Walk the AST to find the lineToByteOffset that fits the line number.
|
||||
var lastFunc *ast.FuncDecl |
||||
var found ast.Node |
||||
// Inspect() goes depth first. This means for example that a function like:
|
||||
// func a() {
|
||||
// b := func() {}
|
||||
// c()
|
||||
// }
|
||||
//
|
||||
// Were we are looking at the c() call can return confused values. It is
|
||||
// important to look at the actual ast.Node hierarchy.
|
||||
ast.Inspect(p.parsed, func(n ast.Node) bool { |
||||
if d != nil { |
||||
return false |
||||
} |
||||
if n == nil { |
||||
return true |
||||
} |
||||
if found != nil { |
||||
// We are walking up.
|
||||
} |
||||
if int(n.Pos()) >= p.lineToByteOffset[l] { |
||||
// We are expecting a ast.CallExpr node. It can be harder to figure out
|
||||
// when there are multiple calls on a single line, as the stack trace
|
||||
// doesn't have file byte offset information, only line based.
|
||||
// gofmt will always format to one function call per line but there can
|
||||
// be edge cases, like:
|
||||
// a = A{Foo(), Bar()}
|
||||
d = lastFunc |
||||
//p.processNode(call, n)
|
||||
return false |
||||
} else if f, ok := n.(*ast.FuncDecl); ok { |
||||
lastFunc = f |
||||
} |
||||
return true |
||||
}) |
||||
return |
||||
} |
||||
|
||||
func name(n ast.Node) string { |
||||
if _, ok := n.(*ast.InterfaceType); ok { |
||||
return "interface{}" |
||||
} |
||||
if i, ok := n.(*ast.Ident); ok { |
||||
return i.Name |
||||
} |
||||
if _, ok := n.(*ast.FuncType); ok { |
||||
return "func" |
||||
} |
||||
if s, ok := n.(*ast.SelectorExpr); ok { |
||||
return s.Sel.Name |
||||
} |
||||
// TODO(maruel): Implement anything missing.
|
||||
return "<unknown>" |
||||
} |
||||
|
||||
// fieldToType returns the type name and whether if it's an ellipsis.
|
||||
func fieldToType(f *ast.Field) (string, bool) { |
||||
switch arg := f.Type.(type) { |
||||
case *ast.ArrayType: |
||||
return "[]" + name(arg.Elt), false |
||||
case *ast.Ellipsis: |
||||
return name(arg.Elt), true |
||||
case *ast.FuncType: |
||||
// Do not print the function signature to not overload the trace.
|
||||
return "func", false |
||||
case *ast.Ident: |
||||
return arg.Name, false |
||||
case *ast.InterfaceType: |
||||
return "interface{}", false |
||||
case *ast.SelectorExpr: |
||||
return arg.Sel.Name, false |
||||
case *ast.StarExpr: |
||||
return "*" + name(arg.X), false |
||||
default: |
||||
// TODO(maruel): Implement anything missing.
|
||||
return "<unknown>", false |
||||
} |
||||
} |
||||
|
||||
// extractArgumentsType returns the name of the type of each input argument.
|
||||
func extractArgumentsType(f *ast.FuncDecl) ([]string, bool) { |
||||
var fields []*ast.Field |
||||
if f.Recv != nil { |
||||
if len(f.Recv.List) != 1 { |
||||
panic("Expect only one receiver; please fix panicparse's code") |
||||
} |
||||
// If it is an object receiver (vs a pointer receiver), its address is not
|
||||
// printed in the stack trace so it needs to be ignored.
|
||||
if _, ok := f.Recv.List[0].Type.(*ast.StarExpr); ok { |
||||
fields = append(fields, f.Recv.List[0]) |
||||
} |
||||
} |
||||
var types []string |
||||
extra := false |
||||
for _, arg := range append(fields, f.Type.Params.List...) { |
||||
// Assert that extra is only set on the last item of fields?
|
||||
var t string |
||||
t, extra = fieldToType(arg) |
||||
mult := len(arg.Names) |
||||
if mult == 0 { |
||||
mult = 1 |
||||
} |
||||
for i := 0; i < mult; i++ { |
||||
types = append(types, t) |
||||
} |
||||
} |
||||
return types, extra |
||||
} |
||||
|
||||
// processCall walks the function and populate call accordingly.
|
||||
func processCall(call *Call, f *ast.FuncDecl) { |
||||
values := make([]uint64, len(call.Args.Values)) |
||||
for i := range call.Args.Values { |
||||
values[i] = call.Args.Values[i].Value |
||||
} |
||||
index := 0 |
||||
pop := func() uint64 { |
||||
if len(values) != 0 { |
||||
x := values[0] |
||||
values = values[1:] |
||||
index++ |
||||
return x |
||||
} |
||||
return 0 |
||||
} |
||||
popName := func() string { |
||||
n := call.Args.Values[index].Name |
||||
v := pop() |
||||
if len(n) == 0 { |
||||
return fmt.Sprintf("0x%x", v) |
||||
} |
||||
return n |
||||
} |
||||
|
||||
types, extra := extractArgumentsType(f) |
||||
for i := 0; len(values) != 0; i++ { |
||||
var t string |
||||
if i >= len(types) { |
||||
if !extra { |
||||
// These are unexpected value! Print them as hex.
|
||||
call.Args.Processed = append(call.Args.Processed, popName()) |
||||
continue |
||||
} |
||||
t = types[len(types)-1] |
||||
} else { |
||||
t = types[i] |
||||
} |
||||
switch t { |
||||
case "float32": |
||||
call.Args.Processed = append(call.Args.Processed, fmt.Sprintf("%g", math.Float32frombits(uint32(pop())))) |
||||
case "float64": |
||||
call.Args.Processed = append(call.Args.Processed, fmt.Sprintf("%g", math.Float64frombits(pop()))) |
||||
case "int", "int8", "int16", "int32", "int64", "uint", "uint8", "uint16", "uint32", "uint64": |
||||
call.Args.Processed = append(call.Args.Processed, fmt.Sprintf("%d", pop())) |
||||
case "string": |
||||
call.Args.Processed = append(call.Args.Processed, fmt.Sprintf("%s(%s, len=%d)", t, popName(), pop())) |
||||
default: |
||||
if strings.HasPrefix(t, "*") { |
||||
call.Args.Processed = append(call.Args.Processed, fmt.Sprintf("%s(%s)", t, popName())) |
||||
} else if strings.HasPrefix(t, "[]") { |
||||
call.Args.Processed = append(call.Args.Processed, fmt.Sprintf("%s(%s len=%d cap=%d)", t, popName(), pop(), pop())) |
||||
} else { |
||||
// Assumes it's an interface. For now, discard the object value, which
|
||||
// is probably not a good idea.
|
||||
call.Args.Processed = append(call.Args.Processed, fmt.Sprintf("%s(%s)", t, popName())) |
||||
pop() |
||||
} |
||||
} |
||||
if len(values) == 0 && call.Args.Elided { |
||||
return |
||||
} |
||||
} |
||||
} |
||||
@ -1,832 +0,0 @@ |
||||
// Copyright 2015 Marc-Antoine Ruel. All rights reserved.
|
||||
// Use of this source code is governed under the Apache License, Version 2.0
|
||||
// that can be found in the LICENSE file.
|
||||
|
||||
// Package stack analyzes stack dump of Go processes and simplifies it.
|
||||
//
|
||||
// It is mostly useful on servers will large number of identical goroutines,
|
||||
// making the crash dump harder to read than strictly necesary.
|
||||
package stack |
||||
|
||||
import ( |
||||
"bufio" |
||||
"bytes" |
||||
"errors" |
||||
"fmt" |
||||
"io" |
||||
"math" |
||||
"net/url" |
||||
"os" |
||||
"path/filepath" |
||||
"regexp" |
||||
"runtime" |
||||
"sort" |
||||
"strconv" |
||||
"strings" |
||||
"unicode" |
||||
"unicode/utf8" |
||||
) |
||||
|
||||
const lockedToThread = "locked to thread" |
||||
|
||||
var ( |
||||
// TODO(maruel): Handle corrupted stack cases:
|
||||
// - missed stack barrier
|
||||
// - found next stack barrier at 0x123; expected
|
||||
// - runtime: unexpected return pc for FUNC_NAME called from 0x123
|
||||
|
||||
reRoutineHeader = regexp.MustCompile("^goroutine (\\d+) \\[([^\\]]+)\\]\\:\n$") |
||||
reMinutes = regexp.MustCompile("^(\\d+) minutes$") |
||||
reUnavail = regexp.MustCompile("^(?:\t| +)goroutine running on other thread; stack unavailable") |
||||
// See gentraceback() in src/runtime/traceback.go for more information.
|
||||
// - Sometimes the source file comes up as "<autogenerated>". It is the
|
||||
// compiler than generated these, not the runtime.
|
||||
// - The tab may be replaced with spaces when a user copy-paste it, handle
|
||||
// this transparently.
|
||||
// - "runtime.gopanic" is explicitly replaced with "panic" by gentraceback().
|
||||
// - The +0x123 byte offset is printed when frame.pc > _func.entry. _func is
|
||||
// generated by the linker.
|
||||
// - The +0x123 byte offset is not included with generated code, e.g. unnamed
|
||||
// functions "func·006()" which is generally go func() { ... }()
|
||||
// statements. Since the _func is generated at runtime, it's probably why
|
||||
// _func.entry is not set.
|
||||
// - C calls may have fp=0x123 sp=0x123 appended. I think it normally happens
|
||||
// when a signal is not correctly handled. It is printed with m.throwing>0.
|
||||
// These are discarded.
|
||||
// - For cgo, the source file may be "??".
|
||||
reFile = regexp.MustCompile("^(?:\t| +)(\\?\\?|\\<autogenerated\\>|.+\\.(?:c|go|s))\\:(\\d+)(?:| \\+0x[0-9a-f]+)(?:| fp=0x[0-9a-f]+ sp=0x[0-9a-f]+)\n$") |
||||
// Sadly, it doesn't note the goroutine number so we could cascade them per
|
||||
// parenthood.
|
||||
reCreated = regexp.MustCompile("^created by (.+)\n$") |
||||
reFunc = regexp.MustCompile("^(.+)\\((.*)\\)\n$") |
||||
reElided = regexp.MustCompile("^\\.\\.\\.additional frames elided\\.\\.\\.\n$") |
||||
// Include frequent GOROOT value on Windows, distro provided and user
|
||||
// installed path. This simplifies the user's life when processing a trace
|
||||
// generated on another VM.
|
||||
// TODO(maruel): Guess the path automatically via traces containing the
|
||||
// 'runtime' package, which is very frequent. This would be "less bad" than
|
||||
// throwing up random values at the parser.
|
||||
goroots = []string{runtime.GOROOT(), "c:/go", "/usr/lib/go", "/usr/local/go"} |
||||
) |
||||
|
||||
// Similarity is the level at which two call lines arguments must match to be
|
||||
// considered similar enough to coalesce them.
|
||||
type Similarity int |
||||
|
||||
const ( |
||||
// ExactFlags requires same bits (e.g. Locked).
|
||||
ExactFlags Similarity = iota |
||||
// ExactLines requests the exact same arguments on the call line.
|
||||
ExactLines |
||||
// AnyPointer considers different pointers a similar call line.
|
||||
AnyPointer |
||||
// AnyValue accepts any value as similar call line.
|
||||
AnyValue |
||||
) |
||||
|
||||
// Function is a function call.
|
||||
//
|
||||
// Go stack traces print a mangled function call, this wrapper unmangle the
|
||||
// string before printing and adds other filtering methods.
|
||||
type Function struct { |
||||
Raw string |
||||
} |
||||
|
||||
// String is the fully qualified function name.
|
||||
//
|
||||
// Sadly Go is a bit confused when the package name doesn't match the directory
|
||||
// containing the source file and will use the directory name instead of the
|
||||
// real package name.
|
||||
func (f Function) String() string { |
||||
s, _ := url.QueryUnescape(f.Raw) |
||||
return s |
||||
} |
||||
|
||||
// Name is the naked function name.
|
||||
func (f Function) Name() string { |
||||
parts := strings.SplitN(filepath.Base(f.Raw), ".", 2) |
||||
if len(parts) == 1 { |
||||
return parts[0] |
||||
} |
||||
return parts[1] |
||||
} |
||||
|
||||
// PkgName is the package name for this function reference.
|
||||
func (f Function) PkgName() string { |
||||
parts := strings.SplitN(filepath.Base(f.Raw), ".", 2) |
||||
if len(parts) == 1 { |
||||
return "" |
||||
} |
||||
s, _ := url.QueryUnescape(parts[0]) |
||||
return s |
||||
} |
||||
|
||||
// PkgDotName returns "<package>.<func>" format.
|
||||
func (f Function) PkgDotName() string { |
||||
parts := strings.SplitN(filepath.Base(f.Raw), ".", 2) |
||||
s, _ := url.QueryUnescape(parts[0]) |
||||
if len(parts) == 1 { |
||||
return parts[0] |
||||
} |
||||
if s != "" || parts[1] != "" { |
||||
return s + "." + parts[1] |
||||
} |
||||
return "" |
||||
} |
||||
|
||||
// IsExported returns true if the function is exported.
|
||||
func (f Function) IsExported() bool { |
||||
name := f.Name() |
||||
parts := strings.Split(name, ".") |
||||
r, _ := utf8.DecodeRuneInString(parts[len(parts)-1]) |
||||
if unicode.ToUpper(r) == r { |
||||
return true |
||||
} |
||||
return f.PkgName() == "main" && name == "main" |
||||
} |
||||
|
||||
// Arg is an argument on a Call.
|
||||
type Arg struct { |
||||
Value uint64 // Value is the raw value as found in the stack trace
|
||||
Name string // Name is a pseudo name given to the argument
|
||||
} |
||||
|
||||
// IsPtr returns true if we guess it's a pointer. It's only a guess, it can be
|
||||
// easily be confused by a bitmask.
|
||||
func (a *Arg) IsPtr() bool { |
||||
// Assumes all pointers are above 16Mb and positive.
|
||||
return a.Value > 16*1024*1024 && a.Value < math.MaxInt64 |
||||
} |
||||
|
||||
func (a Arg) String() string { |
||||
if a.Name != "" { |
||||
return a.Name |
||||
} |
||||
if a.Value == 0 { |
||||
return "0" |
||||
} |
||||
return fmt.Sprintf("0x%x", a.Value) |
||||
} |
||||
|
||||
// Args is a series of function call arguments.
|
||||
type Args struct { |
||||
Values []Arg // Values is the arguments as shown on the stack trace. They are mangled via simplification.
|
||||
Processed []string // Processed is the arguments generated from processing the source files. It can have a length lower than Values.
|
||||
Elided bool // If set, it means there was a trailing ", ..."
|
||||
} |
||||
|
||||
func (a Args) String() string { |
||||
var v []string |
||||
if len(a.Processed) != 0 { |
||||
v = make([]string, 0, len(a.Processed)) |
||||
for _, item := range a.Processed { |
||||
v = append(v, item) |
||||
} |
||||
} else { |
||||
v = make([]string, 0, len(a.Values)) |
||||
for _, item := range a.Values { |
||||
v = append(v, item.String()) |
||||
} |
||||
} |
||||
if a.Elided { |
||||
v = append(v, "...") |
||||
} |
||||
return strings.Join(v, ", ") |
||||
} |
||||
|
||||
// Equal returns true only if both arguments are exactly equal.
|
||||
func (a *Args) Equal(r *Args) bool { |
||||
if a.Elided != r.Elided || len(a.Values) != len(r.Values) { |
||||
return false |
||||
} |
||||
for i, l := range a.Values { |
||||
if l != r.Values[i] { |
||||
return false |
||||
} |
||||
} |
||||
return true |
||||
} |
||||
|
||||
// Similar returns true if the two Args are equal or almost but not quite
|
||||
// equal.
|
||||
func (a *Args) Similar(r *Args, similar Similarity) bool { |
||||
if a.Elided != r.Elided || len(a.Values) != len(r.Values) { |
||||
return false |
||||
} |
||||
if similar == AnyValue { |
||||
return true |
||||
} |
||||
for i, l := range a.Values { |
||||
switch similar { |
||||
case ExactFlags, ExactLines: |
||||
if l != r.Values[i] { |
||||
return false |
||||
} |
||||
default: |
||||
if l.IsPtr() != r.Values[i].IsPtr() || (!l.IsPtr() && l != r.Values[i]) { |
||||
return false |
||||
} |
||||
} |
||||
} |
||||
return true |
||||
} |
||||
|
||||
// Merge merges two similar Args, zapping out differences.
|
||||
func (a *Args) Merge(r *Args) Args { |
||||
out := Args{ |
||||
Values: make([]Arg, len(a.Values)), |
||||
Elided: a.Elided, |
||||
} |
||||
for i, l := range a.Values { |
||||
if l != r.Values[i] { |
||||
out.Values[i].Name = "*" |
||||
out.Values[i].Value = l.Value |
||||
} else { |
||||
out.Values[i] = l |
||||
} |
||||
} |
||||
return out |
||||
} |
||||
|
||||
// Call is an item in the stack trace.
|
||||
type Call struct { |
||||
SourcePath string // Full path name of the source file
|
||||
Line int // Line number
|
||||
Func Function // Fully qualified function name (encoded).
|
||||
Args Args // Call arguments
|
||||
} |
||||
|
||||
// Equal returns true only if both calls are exactly equal.
|
||||
func (c *Call) Equal(r *Call) bool { |
||||
return c.SourcePath == r.SourcePath && c.Line == r.Line && c.Func == r.Func && c.Args.Equal(&r.Args) |
||||
} |
||||
|
||||
// Similar returns true if the two Call are equal or almost but not quite
|
||||
// equal.
|
||||
func (c *Call) Similar(r *Call, similar Similarity) bool { |
||||
return c.SourcePath == r.SourcePath && c.Line == r.Line && c.Func == r.Func && c.Args.Similar(&r.Args, similar) |
||||
} |
||||
|
||||
// Merge merges two similar Call, zapping out differences.
|
||||
func (c *Call) Merge(r *Call) Call { |
||||
return Call{ |
||||
SourcePath: c.SourcePath, |
||||
Line: c.Line, |
||||
Func: c.Func, |
||||
Args: c.Args.Merge(&r.Args), |
||||
} |
||||
} |
||||
|
||||
// SourceName returns the base file name of the source file.
|
||||
func (c *Call) SourceName() string { |
||||
return filepath.Base(c.SourcePath) |
||||
} |
||||
|
||||
// SourceLine returns "source.go:line", including only the base file name.
|
||||
func (c *Call) SourceLine() string { |
||||
return fmt.Sprintf("%s:%d", c.SourceName(), c.Line) |
||||
} |
||||
|
||||
// FullSourceLine returns "/path/to/source.go:line".
|
||||
func (c *Call) FullSourceLine() string { |
||||
return fmt.Sprintf("%s:%d", c.SourcePath, c.Line) |
||||
} |
||||
|
||||
// PkgSource is one directory plus the file name of the source file.
|
||||
func (c *Call) PkgSource() string { |
||||
return filepath.Join(filepath.Base(filepath.Dir(c.SourcePath)), c.SourceName()) |
||||
} |
||||
|
||||
const testMainSource = "_test" + string(os.PathSeparator) + "_testmain.go" |
||||
|
||||
// IsStdlib returns true if it is a Go standard library function. This includes
|
||||
// the 'go test' generated main executable.
|
||||
func (c *Call) IsStdlib() bool { |
||||
for _, goroot := range goroots { |
||||
if strings.HasPrefix(c.SourcePath, goroot) { |
||||
return true |
||||
} |
||||
} |
||||
// Consider _test/_testmain.go as stdlib since it's injected by "go test".
|
||||
return c.PkgSource() == testMainSource |
||||
} |
||||
|
||||
// IsPkgMain returns true if it is in the main package.
|
||||
func (c *Call) IsPkgMain() bool { |
||||
return c.Func.PkgName() == "main" |
||||
} |
||||
|
||||
// Stack is a call stack.
|
||||
type Stack struct { |
||||
Calls []Call // Call stack. First is original function, last is leaf function.
|
||||
Elided bool // Happens when there's >100 items in Stack, currently hardcoded in package runtime.
|
||||
} |
||||
|
||||
// Equal returns true on if both call stacks are exactly equal.
|
||||
func (s *Stack) Equal(r *Stack) bool { |
||||
if len(s.Calls) != len(r.Calls) || s.Elided != r.Elided { |
||||
return false |
||||
} |
||||
for i := range s.Calls { |
||||
if !s.Calls[i].Equal(&r.Calls[i]) { |
||||
return false |
||||
} |
||||
} |
||||
return true |
||||
} |
||||
|
||||
// Similar returns true if the two Stack are equal or almost but not quite
|
||||
// equal.
|
||||
func (s *Stack) Similar(r *Stack, similar Similarity) bool { |
||||
if len(s.Calls) != len(r.Calls) || s.Elided != r.Elided { |
||||
return false |
||||
} |
||||
for i := range s.Calls { |
||||
if !s.Calls[i].Similar(&r.Calls[i], similar) { |
||||
return false |
||||
} |
||||
} |
||||
return true |
||||
} |
||||
|
||||
// Merge merges two similar Stack, zapping out differences.
|
||||
func (s *Stack) Merge(r *Stack) *Stack { |
||||
// Assumes similar stacks have the same length.
|
||||
out := &Stack{ |
||||
Calls: make([]Call, len(s.Calls)), |
||||
Elided: s.Elided, |
||||
} |
||||
for i := range s.Calls { |
||||
out.Calls[i] = s.Calls[i].Merge(&r.Calls[i]) |
||||
} |
||||
return out |
||||
} |
||||
|
||||
// Less compares two Stack, where the ones that are less are more
|
||||
// important, so they come up front. A Stack with more private functions is
|
||||
// 'less' so it is at the top. Inversely, a Stack with only public
|
||||
// functions is 'more' so it is at the bottom.
|
||||
func (s *Stack) Less(r *Stack) bool { |
||||
lStdlib := 0 |
||||
lPrivate := 0 |
||||
for _, c := range s.Calls { |
||||
if c.IsStdlib() { |
||||
lStdlib++ |
||||
} else { |
||||
lPrivate++ |
||||
} |
||||
} |
||||
rStdlib := 0 |
||||
rPrivate := 0 |
||||
for _, s := range r.Calls { |
||||
if s.IsStdlib() { |
||||
rStdlib++ |
||||
} else { |
||||
rPrivate++ |
||||
} |
||||
} |
||||
if lPrivate > rPrivate { |
||||
return true |
||||
} |
||||
if lPrivate < rPrivate { |
||||
return false |
||||
} |
||||
if lStdlib > rStdlib { |
||||
return false |
||||
} |
||||
if lStdlib < rStdlib { |
||||
return true |
||||
} |
||||
|
||||
// Stack lengths are the same.
|
||||
for x := range s.Calls { |
||||
if s.Calls[x].Func.Raw < r.Calls[x].Func.Raw { |
||||
return true |
||||
} |
||||
if s.Calls[x].Func.Raw > r.Calls[x].Func.Raw { |
||||
return true |
||||
} |
||||
if s.Calls[x].PkgSource() < r.Calls[x].PkgSource() { |
||||
return true |
||||
} |
||||
if s.Calls[x].PkgSource() > r.Calls[x].PkgSource() { |
||||
return true |
||||
} |
||||
if s.Calls[x].Line < r.Calls[x].Line { |
||||
return true |
||||
} |
||||
if s.Calls[x].Line > r.Calls[x].Line { |
||||
return true |
||||
} |
||||
} |
||||
return false |
||||
} |
||||
|
||||
// Signature represents the signature of one or multiple goroutines.
|
||||
//
|
||||
// It is effectively the stack trace plus the goroutine internal bits, like
|
||||
// it's state, if it is thread locked, which call site created this goroutine,
|
||||
// etc.
|
||||
type Signature struct { |
||||
// Use git grep 'gopark(|unlock)\(' to find them all plus everything listed
|
||||
// in runtime/traceback.go. Valid values includes:
|
||||
// - chan send, chan receive, select
|
||||
// - finalizer wait, mark wait (idle),
|
||||
// - Concurrent GC wait, GC sweep wait, force gc (idle)
|
||||
// - IO wait, panicwait
|
||||
// - semacquire, semarelease
|
||||
// - sleep, timer goroutine (idle)
|
||||
// - trace reader (blocked)
|
||||
// Stuck cases:
|
||||
// - chan send (nil chan), chan receive (nil chan), select (no cases)
|
||||
// Runnable states:
|
||||
// - idle, runnable, running, syscall, waiting, dead, enqueue, copystack,
|
||||
// Scan states:
|
||||
// - scan, scanrunnable, scanrunning, scansyscall, scanwaiting, scandead,
|
||||
// scanenqueue
|
||||
State string |
||||
CreatedBy Call // Which other goroutine which created this one.
|
||||
SleepMin int // Wait time in minutes, if applicable.
|
||||
SleepMax int // Wait time in minutes, if applicable.
|
||||
Stack Stack |
||||
Locked bool // Locked to an OS thread.
|
||||
} |
||||
|
||||
// Equal returns true only if both signatures are exactly equal.
|
||||
func (s *Signature) Equal(r *Signature) bool { |
||||
if s.State != r.State || !s.CreatedBy.Equal(&r.CreatedBy) || s.Locked != r.Locked || s.SleepMin != r.SleepMin || s.SleepMax != r.SleepMax { |
||||
return false |
||||
} |
||||
return s.Stack.Equal(&r.Stack) |
||||
} |
||||
|
||||
// Similar returns true if the two Signature are equal or almost but not quite
|
||||
// equal.
|
||||
func (s *Signature) Similar(r *Signature, similar Similarity) bool { |
||||
if s.State != r.State || !s.CreatedBy.Similar(&r.CreatedBy, similar) { |
||||
return false |
||||
} |
||||
if similar == ExactFlags && s.Locked != r.Locked { |
||||
return false |
||||
} |
||||
return s.Stack.Similar(&r.Stack, similar) |
||||
} |
||||
|
||||
// Merge merges two similar Signature, zapping out differences.
|
||||
func (s *Signature) Merge(r *Signature) *Signature { |
||||
min := s.SleepMin |
||||
if r.SleepMin < min { |
||||
min = r.SleepMin |
||||
} |
||||
max := s.SleepMax |
||||
if r.SleepMax > max { |
||||
max = r.SleepMax |
||||
} |
||||
return &Signature{ |
||||
State: s.State, // Drop right side.
|
||||
CreatedBy: s.CreatedBy, // Drop right side.
|
||||
SleepMin: min, |
||||
SleepMax: max, |
||||
Stack: *s.Stack.Merge(&r.Stack), |
||||
Locked: s.Locked || r.Locked, // TODO(maruel): This is weirdo.
|
||||
} |
||||
} |
||||
|
||||
// Less compares two Signature, where the ones that are less are more
|
||||
// important, so they come up front. A Signature with more private functions is
|
||||
// 'less' so it is at the top. Inversely, a Signature with only public
|
||||
// functions is 'more' so it is at the bottom.
|
||||
func (s *Signature) Less(r *Signature) bool { |
||||
if s.Stack.Less(&r.Stack) { |
||||
return true |
||||
} |
||||
if r.Stack.Less(&s.Stack) { |
||||
return false |
||||
} |
||||
if s.Locked && !r.Locked { |
||||
return true |
||||
} |
||||
if r.Locked && !s.Locked { |
||||
return false |
||||
} |
||||
if s.State < r.State { |
||||
return true |
||||
} |
||||
if s.State > r.State { |
||||
return false |
||||
} |
||||
return false |
||||
} |
||||
|
||||
// Goroutine represents the state of one goroutine, including the stack trace.
|
||||
type Goroutine struct { |
||||
Signature // It's stack trace, internal bits, state, which call site created it, etc.
|
||||
ID int // Goroutine ID.
|
||||
First bool // First is the goroutine first printed, normally the one that crashed.
|
||||
} |
||||
|
||||
// Bucketize returns the number of similar goroutines.
|
||||
func Bucketize(goroutines []Goroutine, similar Similarity) map[*Signature][]Goroutine { |
||||
out := map[*Signature][]Goroutine{} |
||||
// O(n²). Fix eventually.
|
||||
for _, routine := range goroutines { |
||||
found := false |
||||
for key := range out { |
||||
// When a match is found, this effectively drops the other goroutine ID.
|
||||
if key.Similar(&routine.Signature, similar) { |
||||
found = true |
||||
if !key.Equal(&routine.Signature) { |
||||
// Almost but not quite equal. There's different pointers passed
|
||||
// around but the same values. Zap out the different values.
|
||||
newKey := key.Merge(&routine.Signature) |
||||
out[newKey] = append(out[key], routine) |
||||
delete(out, key) |
||||
} else { |
||||
out[key] = append(out[key], routine) |
||||
} |
||||
break |
||||
} |
||||
} |
||||
if !found { |
||||
key := &Signature{} |
||||
*key = routine.Signature |
||||
out[key] = []Goroutine{routine} |
||||
} |
||||
} |
||||
return out |
||||
} |
||||
|
||||
// Bucket is a stack trace signature and the list of goroutines that fits this
|
||||
// signature.
|
||||
type Bucket struct { |
||||
Signature |
||||
Routines []Goroutine |
||||
} |
||||
|
||||
// First returns true if it contains the first goroutine, e.g. the ones that
|
||||
// likely generated the panic() call, if any.
|
||||
func (b *Bucket) First() bool { |
||||
for _, r := range b.Routines { |
||||
if r.First { |
||||
return true |
||||
} |
||||
} |
||||
return false |
||||
} |
||||
|
||||
// Less does reverse sort.
|
||||
func (b *Bucket) Less(r *Bucket) bool { |
||||
if b.First() { |
||||
return true |
||||
} |
||||
if r.First() { |
||||
return false |
||||
} |
||||
return b.Signature.Less(&r.Signature) |
||||
} |
||||
|
||||
// Buckets is a list of Bucket sorted by repeation count.
|
||||
type Buckets []Bucket |
||||
|
||||
func (b Buckets) Len() int { |
||||
return len(b) |
||||
} |
||||
|
||||
func (b Buckets) Less(i, j int) bool { |
||||
return b[i].Less(&b[j]) |
||||
} |
||||
|
||||
func (b Buckets) Swap(i, j int) { |
||||
b[j], b[i] = b[i], b[j] |
||||
} |
||||
|
||||
// SortBuckets creates a list of Bucket from each goroutine stack trace count.
|
||||
func SortBuckets(buckets map[*Signature][]Goroutine) Buckets { |
||||
out := make(Buckets, 0, len(buckets)) |
||||
for signature, count := range buckets { |
||||
out = append(out, Bucket{*signature, count}) |
||||
} |
||||
sort.Sort(out) |
||||
return out |
||||
} |
||||
|
||||
// scanLines is similar to bufio.ScanLines except that it:
|
||||
// - doesn't drop '\n'
|
||||
// - doesn't strip '\r'
|
||||
// - returns when the data is bufio.MaxScanTokenSize bytes
|
||||
func scanLines(data []byte, atEOF bool) (advance int, token []byte, err error) { |
||||
if atEOF && len(data) == 0 { |
||||
return 0, nil, nil |
||||
} |
||||
if i := bytes.IndexByte(data, '\n'); i >= 0 { |
||||
return i + 1, data[0 : i+1], nil |
||||
} |
||||
if atEOF { |
||||
return len(data), data, nil |
||||
} |
||||
if len(data) >= bufio.MaxScanTokenSize { |
||||
// Returns the line even if it is not at EOF nor has a '\n', otherwise the
|
||||
// scanner will return bufio.ErrTooLong which is definitely not what we
|
||||
// want.
|
||||
return len(data), data, nil |
||||
} |
||||
return 0, nil, nil |
||||
} |
||||
|
||||
// ParseDump processes the output from runtime.Stack().
|
||||
//
|
||||
// It supports piping from another command and assumes there is junk before the
|
||||
// actual stack trace. The junk is streamed to out.
|
||||
func ParseDump(r io.Reader, out io.Writer) ([]Goroutine, error) { |
||||
goroutines := make([]Goroutine, 0, 16) |
||||
var goroutine *Goroutine |
||||
scanner := bufio.NewScanner(r) |
||||
scanner.Split(scanLines) |
||||
// TODO(maruel): Use a formal state machine. Patterns follows:
|
||||
// - reRoutineHeader
|
||||
// Either:
|
||||
// - reUnavail
|
||||
// - reFunc + reFile in a loop
|
||||
// - reElided
|
||||
// Optionally ends with:
|
||||
// - reCreated + reFile
|
||||
// Between each goroutine stack dump: an empty line
|
||||
created := false |
||||
// firstLine is the first line after the reRoutineHeader header line.
|
||||
firstLine := false |
||||
for scanner.Scan() { |
||||
line := scanner.Text() |
||||
if line == "\n" { |
||||
if goroutine != nil { |
||||
goroutine = nil |
||||
continue |
||||
} |
||||
} else if line[len(line)-1] == '\n' { |
||||
if goroutine == nil { |
||||
if match := reRoutineHeader.FindStringSubmatch(line); match != nil { |
||||
if id, err := strconv.Atoi(match[1]); err == nil { |
||||
// See runtime/traceback.go.
|
||||
// "<state>, \d+ minutes, locked to thread"
|
||||
items := strings.Split(match[2], ", ") |
||||
sleep := 0 |
||||
locked := false |
||||
for i := 1; i < len(items); i++ { |
||||
if items[i] == lockedToThread { |
||||
locked = true |
||||
continue |
||||
} |
||||
// Look for duration, if any.
|
||||
if match2 := reMinutes.FindStringSubmatch(items[i]); match2 != nil { |
||||
sleep, _ = strconv.Atoi(match2[1]) |
||||
} |
||||
} |
||||
goroutines = append(goroutines, Goroutine{ |
||||
Signature: Signature{ |
||||
State: items[0], |
||||
SleepMin: sleep, |
||||
SleepMax: sleep, |
||||
Locked: locked, |
||||
}, |
||||
ID: id, |
||||
First: len(goroutines) == 0, |
||||
}) |
||||
goroutine = &goroutines[len(goroutines)-1] |
||||
firstLine = true |
||||
continue |
||||
} |
||||
} |
||||
} else { |
||||
if firstLine { |
||||
firstLine = false |
||||
if match := reUnavail.FindStringSubmatch(line); match != nil { |
||||
// Generate a fake stack entry.
|
||||
goroutine.Stack.Calls = []Call{{SourcePath: "<unavailable>"}} |
||||
continue |
||||
} |
||||
} |
||||
|
||||
if match := reFile.FindStringSubmatch(line); match != nil { |
||||
// Triggers after a reFunc or a reCreated.
|
||||
num, err := strconv.Atoi(match[2]) |
||||
if err != nil { |
||||
return goroutines, fmt.Errorf("failed to parse int on line: \"%s\"", line) |
||||
} |
||||
if created { |
||||
created = false |
||||
goroutine.CreatedBy.SourcePath = match[1] |
||||
goroutine.CreatedBy.Line = num |
||||
} else { |
||||
i := len(goroutine.Stack.Calls) - 1 |
||||
if i < 0 { |
||||
return goroutines, errors.New("unexpected order") |
||||
} |
||||
goroutine.Stack.Calls[i].SourcePath = match[1] |
||||
goroutine.Stack.Calls[i].Line = num |
||||
} |
||||
continue |
||||
} |
||||
|
||||
if match := reCreated.FindStringSubmatch(line); match != nil { |
||||
created = true |
||||
goroutine.CreatedBy.Func.Raw = match[1] |
||||
continue |
||||
} |
||||
|
||||
if match := reFunc.FindStringSubmatch(line); match != nil { |
||||
args := Args{} |
||||
for _, a := range strings.Split(match[2], ", ") { |
||||
if a == "..." { |
||||
args.Elided = true |
||||
continue |
||||
} |
||||
if a == "" { |
||||
// Remaining values were dropped.
|
||||
break |
||||
} |
||||
v, err := strconv.ParseUint(a, 0, 64) |
||||
if err != nil { |
||||
return goroutines, fmt.Errorf("failed to parse int on line: \"%s\"", line) |
||||
} |
||||
args.Values = append(args.Values, Arg{Value: v}) |
||||
} |
||||
goroutine.Stack.Calls = append(goroutine.Stack.Calls, Call{Func: Function{match[1]}, Args: args}) |
||||
continue |
||||
} |
||||
|
||||
if match := reElided.FindStringSubmatch(line); match != nil { |
||||
goroutine.Stack.Elided = true |
||||
continue |
||||
} |
||||
} |
||||
} |
||||
_, _ = io.WriteString(out, line) |
||||
goroutine = nil |
||||
} |
||||
nameArguments(goroutines) |
||||
return goroutines, scanner.Err() |
||||
} |
||||
|
||||
// Private stuff.
|
||||
|
||||
func nameArguments(goroutines []Goroutine) { |
||||
// Set a name for any pointer occuring more than once.
|
||||
type object struct { |
||||
args []*Arg |
||||
inPrimary bool |
||||
id int |
||||
} |
||||
objects := map[uint64]object{} |
||||
// Enumerate all the arguments.
|
||||
for i := range goroutines { |
||||
for j := range goroutines[i].Stack.Calls { |
||||
for k := range goroutines[i].Stack.Calls[j].Args.Values { |
||||
arg := goroutines[i].Stack.Calls[j].Args.Values[k] |
||||
if arg.IsPtr() { |
||||
objects[arg.Value] = object{ |
||||
args: append(objects[arg.Value].args, &goroutines[i].Stack.Calls[j].Args.Values[k]), |
||||
inPrimary: objects[arg.Value].inPrimary || i == 0, |
||||
} |
||||
} |
||||
} |
||||
} |
||||
// CreatedBy.Args is never set.
|
||||
} |
||||
order := uint64Slice{} |
||||
for k, obj := range objects { |
||||
if len(obj.args) > 1 && obj.inPrimary { |
||||
order = append(order, k) |
||||
} |
||||
} |
||||
sort.Sort(order) |
||||
nextID := 1 |
||||
for _, k := range order { |
||||
for _, arg := range objects[k].args { |
||||
arg.Name = fmt.Sprintf("#%d", nextID) |
||||
} |
||||
nextID++ |
||||
} |
||||
|
||||
// Now do the rest. This is done so the output is deterministic.
|
||||
order = uint64Slice{} |
||||
for k := range objects { |
||||
order = append(order, k) |
||||
} |
||||
sort.Sort(order) |
||||
for _, k := range order { |
||||
// Process the remaining pointers, they were not referenced by primary
|
||||
// thread so will have higher IDs.
|
||||
if objects[k].inPrimary { |
||||
continue |
||||
} |
||||
for _, arg := range objects[k].args { |
||||
arg.Name = fmt.Sprintf("#%d", nextID) |
||||
} |
||||
nextID++ |
||||
} |
||||
} |
||||
|
||||
type uint64Slice []uint64 |
||||
|
||||
func (a uint64Slice) Len() int { return len(a) } |
||||
func (a uint64Slice) Swap(i, j int) { a[i], a[j] = a[j], a[i] } |
||||
func (a uint64Slice) Less(i, j int) bool { return a[i] < a[j] } |
||||
@ -1,139 +0,0 @@ |
||||
// Copyright 2016 Marc-Antoine Ruel. All rights reserved.
|
||||
// Use of this source code is governed under the Apache License, Version 2.0
|
||||
// that can be found in the LICENSE file.
|
||||
|
||||
package stack |
||||
|
||||
import ( |
||||
"fmt" |
||||
"strings" |
||||
) |
||||
|
||||
// Palette defines the color used.
|
||||
//
|
||||
// An empty object Palette{} can be used to disable coloring.
|
||||
type Palette struct { |
||||
EOLReset string |
||||
|
||||
// Routine header.
|
||||
RoutineFirst string // The first routine printed.
|
||||
Routine string // Following routines.
|
||||
CreatedBy string |
||||
|
||||
// Call line.
|
||||
Package string |
||||
SourceFile string |
||||
FunctionStdLib string |
||||
FunctionStdLibExported string |
||||
FunctionMain string |
||||
FunctionOther string |
||||
FunctionOtherExported string |
||||
Arguments string |
||||
} |
||||
|
||||
// CalcLengths returns the maximum length of the source lines and package names.
|
||||
func CalcLengths(buckets Buckets, fullPath bool) (int, int) { |
||||
srcLen := 0 |
||||
pkgLen := 0 |
||||
for _, bucket := range buckets { |
||||
for _, line := range bucket.Signature.Stack.Calls { |
||||
l := 0 |
||||
if fullPath { |
||||
l = len(line.FullSourceLine()) |
||||
} else { |
||||
l = len(line.SourceLine()) |
||||
} |
||||
if l > srcLen { |
||||
srcLen = l |
||||
} |
||||
l = len(line.Func.PkgName()) |
||||
if l > pkgLen { |
||||
pkgLen = l |
||||
} |
||||
} |
||||
} |
||||
return srcLen, pkgLen |
||||
} |
||||
|
||||
// functionColor returns the color to be used for the function name based on
|
||||
// the type of package the function is in.
|
||||
func (p *Palette) functionColor(line *Call) string { |
||||
if line.IsStdlib() { |
||||
if line.Func.IsExported() { |
||||
return p.FunctionStdLibExported |
||||
} |
||||
return p.FunctionStdLib |
||||
} else if line.IsPkgMain() { |
||||
return p.FunctionMain |
||||
} else if line.Func.IsExported() { |
||||
return p.FunctionOtherExported |
||||
} |
||||
return p.FunctionOther |
||||
} |
||||
|
||||
// routineColor returns the color for the header of the goroutines bucket.
|
||||
func (p *Palette) routineColor(bucket *Bucket, multipleBuckets bool) string { |
||||
if bucket.First() && multipleBuckets { |
||||
return p.RoutineFirst |
||||
} |
||||
return p.Routine |
||||
} |
||||
|
||||
// BucketHeader prints the header of a goroutine signature.
|
||||
func (p *Palette) BucketHeader(bucket *Bucket, fullPath, multipleBuckets bool) string { |
||||
extra := "" |
||||
if bucket.SleepMax != 0 { |
||||
if bucket.SleepMin != bucket.SleepMax { |
||||
extra += fmt.Sprintf(" [%d~%d minutes]", bucket.SleepMin, bucket.SleepMax) |
||||
} else { |
||||
extra += fmt.Sprintf(" [%d minutes]", bucket.SleepMax) |
||||
} |
||||
} |
||||
if bucket.Locked { |
||||
extra += " [locked]" |
||||
} |
||||
created := bucket.CreatedBy.Func.PkgDotName() |
||||
if created != "" { |
||||
created += " @ " |
||||
if fullPath { |
||||
created += bucket.CreatedBy.FullSourceLine() |
||||
} else { |
||||
created += bucket.CreatedBy.SourceLine() |
||||
} |
||||
extra += p.CreatedBy + " [Created by " + created + "]" |
||||
} |
||||
return fmt.Sprintf( |
||||
"%s%d: %s%s%s\n", |
||||
p.routineColor(bucket, multipleBuckets), len(bucket.Routines), |
||||
bucket.State, extra, |
||||
p.EOLReset) |
||||
} |
||||
|
||||
// callLine prints one stack line.
|
||||
func (p *Palette) callLine(line *Call, srcLen, pkgLen int, fullPath bool) string { |
||||
src := "" |
||||
if fullPath { |
||||
src = line.FullSourceLine() |
||||
} else { |
||||
src = line.SourceLine() |
||||
} |
||||
return fmt.Sprintf( |
||||
" %s%-*s %s%-*s %s%s%s(%s)%s", |
||||
p.Package, pkgLen, line.Func.PkgName(), |
||||
p.SourceFile, srcLen, src, |
||||
p.functionColor(line), line.Func.Name(), |
||||
p.Arguments, line.Args, |
||||
p.EOLReset) |
||||
} |
||||
|
||||
// StackLines prints one complete stack trace, without the header.
|
||||
func (p *Palette) StackLines(signature *Signature, srcLen, pkgLen int, fullPath bool) string { |
||||
out := make([]string, len(signature.Stack.Calls)) |
||||
for i := range signature.Stack.Calls { |
||||
out[i] = p.callLine(&signature.Stack.Calls[i], srcLen, pkgLen, fullPath) |
||||
} |
||||
if signature.Stack.Elided { |
||||
out = append(out, " (...)") |
||||
} |
||||
return strings.Join(out, "\n") + "\n" |
||||
} |
||||
@ -1,17 +0,0 @@ |
||||
vendors: |
||||
- path: github.com/kr/pretty |
||||
rev: 737b74a46c4bf788349f72cb256fed10aea4d0ac |
||||
- path: github.com/kr/text |
||||
rev: 7cafcd837844e784b526369c9bce262804aebc60 |
||||
- path: github.com/maruel/ut |
||||
rev: a9c9f15ccfa6f8b90182a53df32f4745586fbae3 |
||||
- path: github.com/mattn/go-colorable |
||||
rev: 9056b7a9f2d1f2d96498d6d146acd1f9d5ed3d59 |
||||
- path: github.com/mattn/go-isatty |
||||
rev: 56b76bdf51f7708750eac80fa38b952bb9f32639 |
||||
- path: github.com/mgutz/ansi |
||||
rev: c286dcecd19ff979eeb73ea444e479b903f2cfcb |
||||
- path: github.com/pmezard/go-difflib |
||||
rev: 792786c7400a136282c1664665ae0a8db921c6c2 |
||||
- path: golang.org/x/sys |
||||
rev: a646d33e2ee3172a661fc09bca23bb4889a41bc8 |
||||
@ -1,21 +0,0 @@ |
||||
The MIT License (MIT) |
||||
|
||||
Copyright (c) 2014 Mitchell Hashimoto |
||||
|
||||
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. |
||||
@ -1,39 +0,0 @@ |
||||
# go-wordwrap |
||||
|
||||
`go-wordwrap` (Golang package: `wordwrap`) is a package for Go that |
||||
automatically wraps words into multiple lines. The primary use case for this |
||||
is in formatting CLI output, but of course word wrapping is a generally useful |
||||
thing to do. |
||||
|
||||
## Installation and Usage |
||||
|
||||
Install using `go get github.com/mitchellh/go-wordwrap`. |
||||
|
||||
Full documentation is available at |
||||
http://godoc.org/github.com/mitchellh/go-wordwrap |
||||
|
||||
Below is an example of its usage ignoring errors: |
||||
|
||||
```go |
||||
wrapped := wordwrap.WrapString("foo bar baz", 3) |
||||
fmt.Println(wrapped) |
||||
``` |
||||
|
||||
Would output: |
||||
|
||||
``` |
||||
foo |
||||
bar |
||||
baz |
||||
``` |
||||
|
||||
## Word Wrap Algorithm |
||||
|
||||
This library doesn't use any clever algorithm for word wrapping. The wrapping |
||||
is actually very naive: whenever there is whitespace or an explicit linebreak. |
||||
The goal of this library is for word wrapping CLI output, so the input is |
||||
typically pretty well controlled human language. Because of this, the naive |
||||
approach typically works just fine. |
||||
|
||||
In the future, we'd like to make the algorithm more advanced. We would do |
||||
so without breaking the API. |
||||
@ -1,73 +0,0 @@ |
||||
package wordwrap |
||||
|
||||
import ( |
||||
"bytes" |
||||
"unicode" |
||||
) |
||||
|
||||
// WrapString wraps the given string within lim width in characters.
|
||||
//
|
||||
// Wrapping is currently naive and only happens at white-space. A future
|
||||
// version of the library will implement smarter wrapping. This means that
|
||||
// pathological cases can dramatically reach past the limit, such as a very
|
||||
// long word.
|
||||
func WrapString(s string, lim uint) string { |
||||
// Initialize a buffer with a slightly larger size to account for breaks
|
||||
init := make([]byte, 0, len(s)) |
||||
buf := bytes.NewBuffer(init) |
||||
|
||||
var current uint |
||||
var wordBuf, spaceBuf bytes.Buffer |
||||
|
||||
for _, char := range s { |
||||
if char == '\n' { |
||||
if wordBuf.Len() == 0 { |
||||
if current+uint(spaceBuf.Len()) > lim { |
||||
current = 0 |
||||
} else { |
||||
current += uint(spaceBuf.Len()) |
||||
spaceBuf.WriteTo(buf) |
||||
} |
||||
spaceBuf.Reset() |
||||
} else { |
||||
current += uint(spaceBuf.Len() + wordBuf.Len()) |
||||
spaceBuf.WriteTo(buf) |
||||
spaceBuf.Reset() |
||||
wordBuf.WriteTo(buf) |
||||
wordBuf.Reset() |
||||
} |
||||
buf.WriteRune(char) |
||||
current = 0 |
||||
} else if unicode.IsSpace(char) { |
||||
if spaceBuf.Len() == 0 || wordBuf.Len() > 0 { |
||||
current += uint(spaceBuf.Len() + wordBuf.Len()) |
||||
spaceBuf.WriteTo(buf) |
||||
spaceBuf.Reset() |
||||
wordBuf.WriteTo(buf) |
||||
wordBuf.Reset() |
||||
} |
||||
|
||||
spaceBuf.WriteRune(char) |
||||
} else { |
||||
|
||||
wordBuf.WriteRune(char) |
||||
|
||||
if current+uint(spaceBuf.Len()+wordBuf.Len()) > lim && uint(wordBuf.Len()) < lim { |
||||
buf.WriteRune('\n') |
||||
current = 0 |
||||
spaceBuf.Reset() |
||||
} |
||||
} |
||||
} |
||||
|
||||
if wordBuf.Len() == 0 { |
||||
if current+uint(spaceBuf.Len()) <= lim { |
||||
spaceBuf.WriteTo(buf) |
||||
} |
||||
} else { |
||||
spaceBuf.WriteTo(buf) |
||||
wordBuf.WriteTo(buf) |
||||
} |
||||
|
||||
return buf.String() |
||||
} |
||||
@ -1,4 +0,0 @@ |
||||
# Please keep this file sorted. |
||||
|
||||
Georg Reinke <guelfey@googlemail.com> |
||||
nsf <no.smile.face@gmail.com> |
||||
@ -1,19 +0,0 @@ |
||||
Copyright (C) 2012 termbox-go authors |
||||
|
||||
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. |
||||
@ -1,31 +0,0 @@ |
||||
## Termbox |
||||
Termbox is a library that provides a minimalistic API which allows the programmer to write text-based user interfaces. The library is crossplatform and has both terminal-based implementations on *nix operating systems and a winapi console based implementation for windows operating systems. The basic idea is an abstraction of the greatest common subset of features available on all major terminals and other terminal-like APIs in a minimalistic fashion. Small API means it is easy to implement, test, maintain and learn it, that's what makes the termbox a distinct library in its area. |
||||
|
||||
### Installation |
||||
Install and update this go package with `go get -u github.com/nsf/termbox-go` |
||||
|
||||
### Examples |
||||
For examples of what can be done take a look at demos in the _demos directory. You can try them with go run: `go run _demos/keyboard.go` |
||||
|
||||
There are also some interesting projects using termbox-go: |
||||
- [godit](https://github.com/nsf/godit) is an emacsish lightweight text editor written using termbox. |
||||
- [gomatrix](https://github.com/GeertJohan/gomatrix) connects to The Matrix and displays its data streams in your terminal. |
||||
- [gotetris](https://github.com/jjinux/gotetris) is an implementation of Tetris. |
||||
- [sokoban-go](https://github.com/rn2dy/sokoban-go) is an implementation of sokoban game. |
||||
- [hecate](https://github.com/evanmiller/hecate) is a hex editor designed by Satan. |
||||
- [httopd](https://github.com/verdverm/httopd) is top for httpd logs. |
||||
- [mop](https://github.com/michaeldv/mop) is stock market tracker for hackers. |
||||
- [termui](https://github.com/gizak/termui) is a terminal dashboard. |
||||
- [termloop](https://github.com/JoelOtter/termloop) is a terminal game engine. |
||||
- [xterm-color-chart](https://github.com/kutuluk/xterm-color-chart) is a XTerm 256 color chart. |
||||
- [gocui](https://github.com/jroimartin/gocui) is a minimalist Go library aimed at creating console user interfaces. |
||||
- [dry](https://github.com/moncho/dry) is an interactive cli to manage Docker containers. |
||||
- [pxl](https://github.com/ichinaski/pxl) displays images in the terminal. |
||||
- [snake-game](https://github.com/DyegoCosta/snake-game) is an implementation of the Snake game. |
||||
- [gone](https://github.com/guillaumebreton/gone) is a CLI pomodoro® timer. |
||||
- [Spoof.go](https://github.com/sabey/spoofgo) controllable movement spoofing from the cli |
||||
- [lf](https://github.com/gokcehan/lf) is a terminal file manager |
||||
- [rat](https://github.com/ericfreese/rat) lets you compose shell commands to build terminal applications. |
||||
|
||||
### API reference |
||||
[godoc.org/github.com/nsf/termbox-go](http://godoc.org/github.com/nsf/termbox-go) |
||||
@ -1,457 +0,0 @@ |
||||
// +build !windows
|
||||
|
||||
package termbox |
||||
|
||||
import "github.com/mattn/go-runewidth" |
||||
import "fmt" |
||||
import "os" |
||||
import "os/signal" |
||||
import "syscall" |
||||
import "runtime" |
||||
|
||||
// public API
|
||||
|
||||
// Initializes termbox library. This function should be called before any other functions.
|
||||
// After successful initialization, the library must be finalized using 'Close' function.
|
||||
//
|
||||
// Example usage:
|
||||
// err := termbox.Init()
|
||||
// if err != nil {
|
||||
// panic(err)
|
||||
// }
|
||||
// defer termbox.Close()
|
||||
func Init() error { |
||||
var err error |
||||
|
||||
out, err = os.OpenFile("/dev/tty", syscall.O_WRONLY, 0) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
in, err = syscall.Open("/dev/tty", syscall.O_RDONLY, 0) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
|
||||
err = setup_term() |
||||
if err != nil { |
||||
return fmt.Errorf("termbox: error while reading terminfo data: %v", err) |
||||
} |
||||
|
||||
signal.Notify(sigwinch, syscall.SIGWINCH) |
||||
signal.Notify(sigio, syscall.SIGIO) |
||||
|
||||
_, err = fcntl(in, syscall.F_SETFL, syscall.O_ASYNC|syscall.O_NONBLOCK) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
_, err = fcntl(in, syscall.F_SETOWN, syscall.Getpid()) |
||||
if runtime.GOOS != "darwin" && err != nil { |
||||
return err |
||||
} |
||||
err = tcgetattr(out.Fd(), &orig_tios) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
|
||||
tios := orig_tios |
||||
tios.Iflag &^= syscall_IGNBRK | syscall_BRKINT | syscall_PARMRK | |
||||
syscall_ISTRIP | syscall_INLCR | syscall_IGNCR | |
||||
syscall_ICRNL | syscall_IXON |
||||
tios.Lflag &^= syscall_ECHO | syscall_ECHONL | syscall_ICANON | |
||||
syscall_ISIG | syscall_IEXTEN |
||||
tios.Cflag &^= syscall_CSIZE | syscall_PARENB |
||||
tios.Cflag |= syscall_CS8 |
||||
tios.Cc[syscall_VMIN] = 1 |
||||
tios.Cc[syscall_VTIME] = 0 |
||||
|
||||
err = tcsetattr(out.Fd(), &tios) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
|
||||
out.WriteString(funcs[t_enter_ca]) |
||||
out.WriteString(funcs[t_enter_keypad]) |
||||
out.WriteString(funcs[t_hide_cursor]) |
||||
out.WriteString(funcs[t_clear_screen]) |
||||
|
||||
termw, termh = get_term_size(out.Fd()) |
||||
back_buffer.init(termw, termh) |
||||
front_buffer.init(termw, termh) |
||||
back_buffer.clear() |
||||
front_buffer.clear() |
||||
|
||||
go func() { |
||||
buf := make([]byte, 128) |
||||
for { |
||||
select { |
||||
case <-sigio: |
||||
for { |
||||
n, err := syscall.Read(in, buf) |
||||
if err == syscall.EAGAIN || err == syscall.EWOULDBLOCK { |
||||
break |
||||
} |
||||
select { |
||||
case input_comm <- input_event{buf[:n], err}: |
||||
ie := <-input_comm |
||||
buf = ie.data[:128] |
||||
case <-quit: |
||||
return |
||||
} |
||||
} |
||||
case <-quit: |
||||
return |
||||
} |
||||
} |
||||
}() |
||||
|
||||
IsInit = true |
||||
return nil |
||||
} |
||||
|
||||
// Interrupt an in-progress call to PollEvent by causing it to return
|
||||
// EventInterrupt. Note that this function will block until the PollEvent
|
||||
// function has successfully been interrupted.
|
||||
func Interrupt() { |
||||
interrupt_comm <- struct{}{} |
||||
} |
||||
|
||||
// Finalizes termbox library, should be called after successful initialization
|
||||
// when termbox's functionality isn't required anymore.
|
||||
func Close() { |
||||
quit <- 1 |
||||
out.WriteString(funcs[t_show_cursor]) |
||||
out.WriteString(funcs[t_sgr0]) |
||||
out.WriteString(funcs[t_clear_screen]) |
||||
out.WriteString(funcs[t_exit_ca]) |
||||
out.WriteString(funcs[t_exit_keypad]) |
||||
out.WriteString(funcs[t_exit_mouse]) |
||||
tcsetattr(out.Fd(), &orig_tios) |
||||
|
||||
out.Close() |
||||
syscall.Close(in) |
||||
|
||||
// reset the state, so that on next Init() it will work again
|
||||
termw = 0 |
||||
termh = 0 |
||||
input_mode = InputEsc |
||||
out = nil |
||||
in = 0 |
||||
lastfg = attr_invalid |
||||
lastbg = attr_invalid |
||||
lastx = coord_invalid |
||||
lasty = coord_invalid |
||||
cursor_x = cursor_hidden |
||||
cursor_y = cursor_hidden |
||||
foreground = ColorDefault |
||||
background = ColorDefault |
||||
IsInit = false |
||||
} |
||||
|
||||
// Synchronizes the internal back buffer with the terminal.
|
||||
func Flush() error { |
||||
// invalidate cursor position
|
||||
lastx = coord_invalid |
||||
lasty = coord_invalid |
||||
|
||||
update_size_maybe() |
||||
|
||||
for y := 0; y < front_buffer.height; y++ { |
||||
line_offset := y * front_buffer.width |
||||
for x := 0; x < front_buffer.width; { |
||||
cell_offset := line_offset + x |
||||
back := &back_buffer.cells[cell_offset] |
||||
front := &front_buffer.cells[cell_offset] |
||||
if back.Ch < ' ' { |
||||
back.Ch = ' ' |
||||
} |
||||
w := runewidth.RuneWidth(back.Ch) |
||||
if w == 0 || w == 2 && runewidth.IsAmbiguousWidth(back.Ch) { |
||||
w = 1 |
||||
} |
||||
if *back == *front { |
||||
x += w |
||||
continue |
||||
} |
||||
*front = *back |
||||
send_attr(back.Fg, back.Bg) |
||||
|
||||
if w == 2 && x == front_buffer.width-1 { |
||||
// there's not enough space for 2-cells rune,
|
||||
// let's just put a space in there
|
||||
send_char(x, y, ' ') |
||||
} else { |
||||
send_char(x, y, back.Ch) |
||||
if w == 2 { |
||||
next := cell_offset + 1 |
||||
front_buffer.cells[next] = Cell{ |
||||
Ch: 0, |
||||
Fg: back.Fg, |
||||
Bg: back.Bg, |
||||
} |
||||
} |
||||
} |
||||
x += w |
||||
} |
||||
} |
||||
if !is_cursor_hidden(cursor_x, cursor_y) { |
||||
write_cursor(cursor_x, cursor_y) |
||||
} |
||||
return flush() |
||||
} |
||||
|
||||
// Sets the position of the cursor. See also HideCursor().
|
||||
func SetCursor(x, y int) { |
||||
if is_cursor_hidden(cursor_x, cursor_y) && !is_cursor_hidden(x, y) { |
||||
outbuf.WriteString(funcs[t_show_cursor]) |
||||
} |
||||
|
||||
if !is_cursor_hidden(cursor_x, cursor_y) && is_cursor_hidden(x, y) { |
||||
outbuf.WriteString(funcs[t_hide_cursor]) |
||||
} |
||||
|
||||
cursor_x, cursor_y = x, y |
||||
if !is_cursor_hidden(cursor_x, cursor_y) { |
||||
write_cursor(cursor_x, cursor_y) |
||||
} |
||||
} |
||||
|
||||
// The shortcut for SetCursor(-1, -1).
|
||||
func HideCursor() { |
||||
SetCursor(cursor_hidden, cursor_hidden) |
||||
} |
||||
|
||||
// Changes cell's parameters in the internal back buffer at the specified
|
||||
// position.
|
||||
func SetCell(x, y int, ch rune, fg, bg Attribute) { |
||||
if x < 0 || x >= back_buffer.width { |
||||
return |
||||
} |
||||
if y < 0 || y >= back_buffer.height { |
||||
return |
||||
} |
||||
|
||||
back_buffer.cells[y*back_buffer.width+x] = Cell{ch, fg, bg} |
||||
} |
||||
|
||||
// Returns a slice into the termbox's back buffer. You can get its dimensions
|
||||
// using 'Size' function. The slice remains valid as long as no 'Clear' or
|
||||
// 'Flush' function calls were made after call to this function.
|
||||
func CellBuffer() []Cell { |
||||
return back_buffer.cells |
||||
} |
||||
|
||||
// After getting a raw event from PollRawEvent function call, you can parse it
|
||||
// again into an ordinary one using termbox logic. That is parse an event as
|
||||
// termbox would do it. Returned event in addition to usual Event struct fields
|
||||
// sets N field to the amount of bytes used within 'data' slice. If the length
|
||||
// of 'data' slice is zero or event cannot be parsed for some other reason, the
|
||||
// function will return a special event type: EventNone.
|
||||
//
|
||||
// IMPORTANT: EventNone may contain a non-zero N, which means you should skip
|
||||
// these bytes, because termbox cannot recognize them.
|
||||
//
|
||||
// NOTE: This API is experimental and may change in future.
|
||||
func ParseEvent(data []byte) Event { |
||||
event := Event{Type: EventKey} |
||||
ok := extract_event(data, &event) |
||||
if !ok { |
||||
return Event{Type: EventNone, N: event.N} |
||||
} |
||||
return event |
||||
} |
||||
|
||||
// Wait for an event and return it. This is a blocking function call. Instead
|
||||
// of EventKey and EventMouse it returns EventRaw events. Raw event is written
|
||||
// into `data` slice and Event's N field is set to the amount of bytes written.
|
||||
// The minimum required length of the 'data' slice is 1. This requirement may
|
||||
// vary on different platforms.
|
||||
//
|
||||
// NOTE: This API is experimental and may change in future.
|
||||
func PollRawEvent(data []byte) Event { |
||||
if len(data) == 0 { |
||||
panic("len(data) >= 1 is a requirement") |
||||
} |
||||
|
||||
var event Event |
||||
if extract_raw_event(data, &event) { |
||||
return event |
||||
} |
||||
|
||||
for { |
||||
select { |
||||
case ev := <-input_comm: |
||||
if ev.err != nil { |
||||
return Event{Type: EventError, Err: ev.err} |
||||
} |
||||
|
||||
inbuf = append(inbuf, ev.data...) |
||||
input_comm <- ev |
||||
if extract_raw_event(data, &event) { |
||||
return event |
||||
} |
||||
case <-interrupt_comm: |
||||
event.Type = EventInterrupt |
||||
return event |
||||
|
||||
case <-sigwinch: |
||||
event.Type = EventResize |
||||
event.Width, event.Height = get_term_size(out.Fd()) |
||||
return event |
||||
} |
||||
} |
||||
} |
||||
|
||||
// Wait for an event and return it. This is a blocking function call.
|
||||
func PollEvent() Event { |
||||
var event Event |
||||
|
||||
// try to extract event from input buffer, return on success
|
||||
event.Type = EventKey |
||||
ok := extract_event(inbuf, &event) |
||||
if event.N != 0 { |
||||
copy(inbuf, inbuf[event.N:]) |
||||
inbuf = inbuf[:len(inbuf)-event.N] |
||||
} |
||||
if ok { |
||||
return event |
||||
} |
||||
|
||||
for { |
||||
select { |
||||
case ev := <-input_comm: |
||||
if ev.err != nil { |
||||
return Event{Type: EventError, Err: ev.err} |
||||
} |
||||
|
||||
inbuf = append(inbuf, ev.data...) |
||||
input_comm <- ev |
||||
ok := extract_event(inbuf, &event) |
||||
if event.N != 0 { |
||||
copy(inbuf, inbuf[event.N:]) |
||||
inbuf = inbuf[:len(inbuf)-event.N] |
||||
} |
||||
if ok { |
||||
return event |
||||
} |
||||
case <-interrupt_comm: |
||||
event.Type = EventInterrupt |
||||
return event |
||||
|
||||
case <-sigwinch: |
||||
event.Type = EventResize |
||||
event.Width, event.Height = get_term_size(out.Fd()) |
||||
return event |
||||
} |
||||
} |
||||
} |
||||
|
||||
// Returns the size of the internal back buffer (which is mostly the same as
|
||||
// terminal's window size in characters). But it doesn't always match the size
|
||||
// of the terminal window, after the terminal size has changed, the internal
|
||||
// back buffer will get in sync only after Clear or Flush function calls.
|
||||
func Size() (width int, height int) { |
||||
return termw, termh |
||||
} |
||||
|
||||
// Clears the internal back buffer.
|
||||
func Clear(fg, bg Attribute) error { |
||||
foreground, background = fg, bg |
||||
err := update_size_maybe() |
||||
back_buffer.clear() |
||||
return err |
||||
} |
||||
|
||||
// Sets termbox input mode. Termbox has two input modes:
|
||||
//
|
||||
// 1. Esc input mode. When ESC sequence is in the buffer and it doesn't match
|
||||
// any known sequence. ESC means KeyEsc. This is the default input mode.
|
||||
//
|
||||
// 2. Alt input mode. When ESC sequence is in the buffer and it doesn't match
|
||||
// any known sequence. ESC enables ModAlt modifier for the next keyboard event.
|
||||
//
|
||||
// Both input modes can be OR'ed with Mouse mode. Setting Mouse mode bit up will
|
||||
// enable mouse button press/release and drag events.
|
||||
//
|
||||
// If 'mode' is InputCurrent, returns the current input mode. See also Input*
|
||||
// constants.
|
||||
func SetInputMode(mode InputMode) InputMode { |
||||
if mode == InputCurrent { |
||||
return input_mode |
||||
} |
||||
if mode&(InputEsc|InputAlt) == 0 { |
||||
mode |= InputEsc |
||||
} |
||||
if mode&(InputEsc|InputAlt) == InputEsc|InputAlt { |
||||
mode &^= InputAlt |
||||
} |
||||
if mode&InputMouse != 0 { |
||||
out.WriteString(funcs[t_enter_mouse]) |
||||
} else { |
||||
out.WriteString(funcs[t_exit_mouse]) |
||||
} |
||||
|
||||
input_mode = mode |
||||
return input_mode |
||||
} |
||||
|
||||
// Sets the termbox output mode. Termbox has four output options:
|
||||
//
|
||||
// 1. OutputNormal => [1..8]
|
||||
// This mode provides 8 different colors:
|
||||
// black, red, green, yellow, blue, magenta, cyan, white
|
||||
// Shortcut: ColorBlack, ColorRed, ...
|
||||
// Attributes: AttrBold, AttrUnderline, AttrReverse
|
||||
//
|
||||
// Example usage:
|
||||
// SetCell(x, y, '@', ColorBlack | AttrBold, ColorRed);
|
||||
//
|
||||
// 2. Output256 => [1..256]
|
||||
// In this mode you can leverage the 256 terminal mode:
|
||||
// 0x01 - 0x08: the 8 colors as in OutputNormal
|
||||
// 0x09 - 0x10: Color* | AttrBold
|
||||
// 0x11 - 0xe8: 216 different colors
|
||||
// 0xe9 - 0x1ff: 24 different shades of grey
|
||||
//
|
||||
// Example usage:
|
||||
// SetCell(x, y, '@', 184, 240);
|
||||
// SetCell(x, y, '@', 0xb8, 0xf0);
|
||||
//
|
||||
// 3. Output216 => [1..216]
|
||||
// This mode supports the 3rd range of the 256 mode only.
|
||||
// But you dont need to provide an offset.
|
||||
//
|
||||
// 4. OutputGrayscale => [1..26]
|
||||
// This mode supports the 4th range of the 256 mode
|
||||
// and black and white colors from 3th range of the 256 mode
|
||||
// But you dont need to provide an offset.
|
||||
//
|
||||
// In all modes, 0x00 represents the default color.
|
||||
//
|
||||
// `go run _demos/output.go` to see its impact on your terminal.
|
||||
//
|
||||
// If 'mode' is OutputCurrent, it returns the current output mode.
|
||||
//
|
||||
// Note that this may return a different OutputMode than the one requested,
|
||||
// as the requested mode may not be available on the target platform.
|
||||
func SetOutputMode(mode OutputMode) OutputMode { |
||||
if mode == OutputCurrent { |
||||
return output_mode |
||||
} |
||||
|
||||
output_mode = mode |
||||
return output_mode |
||||
} |
||||
|
||||
// Sync comes handy when something causes desync between termbox's understanding
|
||||
// of a terminal buffer and the reality. Such as a third party process. Sync
|
||||
// forces a complete resync between the termbox and a terminal, it may not be
|
||||
// visually pretty though.
|
||||
func Sync() error { |
||||
front_buffer.clear() |
||||
err := send_clear() |
||||
if err != nil { |
||||
return err |
||||
} |
||||
|
||||
return Flush() |
||||
} |
||||
@ -1,187 +0,0 @@ |
||||
// termbox is a library for creating cross-platform text-based interfaces
|
||||
package termbox |
||||
|
||||
// public API, common OS agnostic part
|
||||
|
||||
type ( |
||||
InputMode int |
||||
OutputMode int |
||||
EventType uint8 |
||||
Modifier uint8 |
||||
Key uint16 |
||||
Attribute uint16 |
||||
) |
||||
|
||||
// This type represents a termbox event. The 'Mod', 'Key' and 'Ch' fields are
|
||||
// valid if 'Type' is EventKey. The 'Width' and 'Height' fields are valid if
|
||||
// 'Type' is EventResize. The 'Err' field is valid if 'Type' is EventError.
|
||||
type Event struct { |
||||
Type EventType // one of Event* constants
|
||||
Mod Modifier // one of Mod* constants or 0
|
||||
Key Key // one of Key* constants, invalid if 'Ch' is not 0
|
||||
Ch rune // a unicode character
|
||||
Width int // width of the screen
|
||||
Height int // height of the screen
|
||||
Err error // error in case if input failed
|
||||
MouseX int // x coord of mouse
|
||||
MouseY int // y coord of mouse
|
||||
N int // number of bytes written when getting a raw event
|
||||
} |
||||
|
||||
// A cell, single conceptual entity on the screen. The screen is basically a 2d
|
||||
// array of cells. 'Ch' is a unicode character, 'Fg' and 'Bg' are foreground
|
||||
// and background attributes respectively.
|
||||
type Cell struct { |
||||
Ch rune |
||||
Fg Attribute |
||||
Bg Attribute |
||||
} |
||||
|
||||
// To know if termbox has been initialized or not
|
||||
var ( |
||||
IsInit bool = false |
||||
) |
||||
|
||||
// Key constants, see Event.Key field.
|
||||
const ( |
||||
KeyF1 Key = 0xFFFF - iota |
||||
KeyF2 |
||||
KeyF3 |
||||
KeyF4 |
||||
KeyF5 |
||||
KeyF6 |
||||
KeyF7 |
||||
KeyF8 |
||||
KeyF9 |
||||
KeyF10 |
||||
KeyF11 |
||||
KeyF12 |
||||
KeyInsert |
||||
KeyDelete |
||||
KeyHome |
||||
KeyEnd |
||||
KeyPgup |
||||
KeyPgdn |
||||
KeyArrowUp |
||||
KeyArrowDown |
||||
KeyArrowLeft |
||||
KeyArrowRight |
||||
key_min // see terminfo
|
||||
MouseLeft |
||||
MouseMiddle |
||||
MouseRight |
||||
MouseRelease |
||||
MouseWheelUp |
||||
MouseWheelDown |
||||
) |
||||
|
||||
const ( |
||||
KeyCtrlTilde Key = 0x00 |
||||
KeyCtrl2 Key = 0x00 |
||||
KeyCtrlSpace Key = 0x00 |
||||
KeyCtrlA Key = 0x01 |
||||
KeyCtrlB Key = 0x02 |
||||
KeyCtrlC Key = 0x03 |
||||
KeyCtrlD Key = 0x04 |
||||
KeyCtrlE Key = 0x05 |
||||
KeyCtrlF Key = 0x06 |
||||
KeyCtrlG Key = 0x07 |
||||
KeyBackspace Key = 0x08 |
||||
KeyCtrlH Key = 0x08 |
||||
KeyTab Key = 0x09 |
||||
KeyCtrlI Key = 0x09 |
||||
KeyCtrlJ Key = 0x0A |
||||
KeyCtrlK Key = 0x0B |
||||
KeyCtrlL Key = 0x0C |
||||
KeyEnter Key = 0x0D |
||||
KeyCtrlM Key = 0x0D |
||||
KeyCtrlN Key = 0x0E |
||||
KeyCtrlO Key = 0x0F |
||||
KeyCtrlP Key = 0x10 |
||||
KeyCtrlQ Key = 0x11 |
||||
KeyCtrlR Key = 0x12 |
||||
KeyCtrlS Key = 0x13 |
||||
KeyCtrlT Key = 0x14 |
||||
KeyCtrlU Key = 0x15 |
||||
KeyCtrlV Key = 0x16 |
||||
KeyCtrlW Key = 0x17 |
||||
KeyCtrlX Key = 0x18 |
||||
KeyCtrlY Key = 0x19 |
||||
KeyCtrlZ Key = 0x1A |
||||
KeyEsc Key = 0x1B |
||||
KeyCtrlLsqBracket Key = 0x1B |
||||
KeyCtrl3 Key = 0x1B |
||||
KeyCtrl4 Key = 0x1C |
||||
KeyCtrlBackslash Key = 0x1C |
||||
KeyCtrl5 Key = 0x1D |
||||
KeyCtrlRsqBracket Key = 0x1D |
||||
KeyCtrl6 Key = 0x1E |
||||
KeyCtrl7 Key = 0x1F |
||||
KeyCtrlSlash Key = 0x1F |
||||
KeyCtrlUnderscore Key = 0x1F |
||||
KeySpace Key = 0x20 |
||||
KeyBackspace2 Key = 0x7F |
||||
KeyCtrl8 Key = 0x7F |
||||
) |
||||
|
||||
// Alt modifier constant, see Event.Mod field and SetInputMode function.
|
||||
const ( |
||||
ModAlt Modifier = 1 << iota |
||||
ModMotion |
||||
) |
||||
|
||||
// Cell colors, you can combine a color with multiple attributes using bitwise
|
||||
// OR ('|').
|
||||
const ( |
||||
ColorDefault Attribute = iota |
||||
ColorBlack |
||||
ColorRed |
||||
ColorGreen |
||||
ColorYellow |
||||
ColorBlue |
||||
ColorMagenta |
||||
ColorCyan |
||||
ColorWhite |
||||
) |
||||
|
||||
// Cell attributes, it is possible to use multiple attributes by combining them
|
||||
// using bitwise OR ('|'). Although, colors cannot be combined. But you can
|
||||
// combine attributes and a single color.
|
||||
//
|
||||
// It's worth mentioning that some platforms don't support certain attibutes.
|
||||
// For example windows console doesn't support AttrUnderline. And on some
|
||||
// terminals applying AttrBold to background may result in blinking text. Use
|
||||
// them with caution and test your code on various terminals.
|
||||
const ( |
||||
AttrBold Attribute = 1 << (iota + 9) |
||||
AttrUnderline |
||||
AttrReverse |
||||
) |
||||
|
||||
// Input mode. See SetInputMode function.
|
||||
const ( |
||||
InputEsc InputMode = 1 << iota |
||||
InputAlt |
||||
InputMouse |
||||
InputCurrent InputMode = 0 |
||||
) |
||||
|
||||
// Output mode. See SetOutputMode function.
|
||||
const ( |
||||
OutputCurrent OutputMode = iota |
||||
OutputNormal |
||||
Output256 |
||||
Output216 |
||||
OutputGrayscale |
||||
) |
||||
|
||||
// Event type. See Event.Type field.
|
||||
const ( |
||||
EventKey EventType = iota |
||||
EventResize |
||||
EventMouse |
||||
EventError |
||||
EventInterrupt |
||||
EventRaw |
||||
EventNone |
||||
) |
||||
@ -1,239 +0,0 @@ |
||||
package termbox |
||||
|
||||
import ( |
||||
"syscall" |
||||
) |
||||
|
||||
// public API
|
||||
|
||||
// Initializes termbox library. This function should be called before any other functions.
|
||||
// After successful initialization, the library must be finalized using 'Close' function.
|
||||
//
|
||||
// Example usage:
|
||||
// err := termbox.Init()
|
||||
// if err != nil {
|
||||
// panic(err)
|
||||
// }
|
||||
// defer termbox.Close()
|
||||
func Init() error { |
||||
var err error |
||||
|
||||
interrupt, err = create_event() |
||||
if err != nil { |
||||
return err |
||||
} |
||||
|
||||
in, err = syscall.Open("CONIN$", syscall.O_RDWR, 0) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
out, err = syscall.Open("CONOUT$", syscall.O_RDWR, 0) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
|
||||
err = get_console_mode(in, &orig_mode) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
|
||||
err = set_console_mode(in, enable_window_input) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
|
||||
orig_size = get_term_size(out) |
||||
win_size := get_win_size(out) |
||||
|
||||
err = set_console_screen_buffer_size(out, win_size) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
|
||||
err = get_console_cursor_info(out, &orig_cursor_info) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
|
||||
show_cursor(false) |
||||
term_size = get_term_size(out) |
||||
back_buffer.init(int(term_size.x), int(term_size.y)) |
||||
front_buffer.init(int(term_size.x), int(term_size.y)) |
||||
back_buffer.clear() |
||||
front_buffer.clear() |
||||
clear() |
||||
|
||||
diffbuf = make([]diff_msg, 0, 32) |
||||
|
||||
go input_event_producer() |
||||
IsInit = true |
||||
return nil |
||||
} |
||||
|
||||
// Finalizes termbox library, should be called after successful initialization
|
||||
// when termbox's functionality isn't required anymore.
|
||||
func Close() { |
||||
// we ignore errors here, because we can't really do anything about them
|
||||
Clear(0, 0) |
||||
Flush() |
||||
|
||||
// stop event producer
|
||||
cancel_comm <- true |
||||
set_event(interrupt) |
||||
select { |
||||
case <-input_comm: |
||||
default: |
||||
} |
||||
<-cancel_done_comm |
||||
|
||||
set_console_cursor_info(out, &orig_cursor_info) |
||||
set_console_cursor_position(out, coord{}) |
||||
set_console_screen_buffer_size(out, orig_size) |
||||
set_console_mode(in, orig_mode) |
||||
syscall.Close(in) |
||||
syscall.Close(out) |
||||
syscall.Close(interrupt) |
||||
IsInit = false |
||||
} |
||||
|
||||
// Interrupt an in-progress call to PollEvent by causing it to return
|
||||
// EventInterrupt. Note that this function will block until the PollEvent
|
||||
// function has successfully been interrupted.
|
||||
func Interrupt() { |
||||
interrupt_comm <- struct{}{} |
||||
} |
||||
|
||||
// Synchronizes the internal back buffer with the terminal.
|
||||
func Flush() error { |
||||
update_size_maybe() |
||||
prepare_diff_messages() |
||||
for _, diff := range diffbuf { |
||||
r := small_rect{ |
||||
left: 0, |
||||
top: diff.pos, |
||||
right: term_size.x - 1, |
||||
bottom: diff.pos + diff.lines - 1, |
||||
} |
||||
write_console_output(out, diff.chars, r) |
||||
} |
||||
if !is_cursor_hidden(cursor_x, cursor_y) { |
||||
move_cursor(cursor_x, cursor_y) |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
// Sets the position of the cursor. See also HideCursor().
|
||||
func SetCursor(x, y int) { |
||||
if is_cursor_hidden(cursor_x, cursor_y) && !is_cursor_hidden(x, y) { |
||||
show_cursor(true) |
||||
} |
||||
|
||||
if !is_cursor_hidden(cursor_x, cursor_y) && is_cursor_hidden(x, y) { |
||||
show_cursor(false) |
||||
} |
||||
|
||||
cursor_x, cursor_y = x, y |
||||
if !is_cursor_hidden(cursor_x, cursor_y) { |
||||
move_cursor(cursor_x, cursor_y) |
||||
} |
||||
} |
||||
|
||||
// The shortcut for SetCursor(-1, -1).
|
||||
func HideCursor() { |
||||
SetCursor(cursor_hidden, cursor_hidden) |
||||
} |
||||
|
||||
// Changes cell's parameters in the internal back buffer at the specified
|
||||
// position.
|
||||
func SetCell(x, y int, ch rune, fg, bg Attribute) { |
||||
if x < 0 || x >= back_buffer.width { |
||||
return |
||||
} |
||||
if y < 0 || y >= back_buffer.height { |
||||
return |
||||
} |
||||
|
||||
back_buffer.cells[y*back_buffer.width+x] = Cell{ch, fg, bg} |
||||
} |
||||
|
||||
// Returns a slice into the termbox's back buffer. You can get its dimensions
|
||||
// using 'Size' function. The slice remains valid as long as no 'Clear' or
|
||||
// 'Flush' function calls were made after call to this function.
|
||||
func CellBuffer() []Cell { |
||||
return back_buffer.cells |
||||
} |
||||
|
||||
// Wait for an event and return it. This is a blocking function call.
|
||||
func PollEvent() Event { |
||||
select { |
||||
case ev := <-input_comm: |
||||
return ev |
||||
case <-interrupt_comm: |
||||
return Event{Type: EventInterrupt} |
||||
} |
||||
} |
||||
|
||||
// Returns the size of the internal back buffer (which is mostly the same as
|
||||
// console's window size in characters). But it doesn't always match the size
|
||||
// of the console window, after the console size has changed, the internal back
|
||||
// buffer will get in sync only after Clear or Flush function calls.
|
||||
func Size() (int, int) { |
||||
return int(term_size.x), int(term_size.y) |
||||
} |
||||
|
||||
// Clears the internal back buffer.
|
||||
func Clear(fg, bg Attribute) error { |
||||
foreground, background = fg, bg |
||||
update_size_maybe() |
||||
back_buffer.clear() |
||||
return nil |
||||
} |
||||
|
||||
// Sets termbox input mode. Termbox has two input modes:
|
||||
//
|
||||
// 1. Esc input mode. When ESC sequence is in the buffer and it doesn't match
|
||||
// any known sequence. ESC means KeyEsc. This is the default input mode.
|
||||
//
|
||||
// 2. Alt input mode. When ESC sequence is in the buffer and it doesn't match
|
||||
// any known sequence. ESC enables ModAlt modifier for the next keyboard event.
|
||||
//
|
||||
// Both input modes can be OR'ed with Mouse mode. Setting Mouse mode bit up will
|
||||
// enable mouse button press/release and drag events.
|
||||
//
|
||||
// If 'mode' is InputCurrent, returns the current input mode. See also Input*
|
||||
// constants.
|
||||
func SetInputMode(mode InputMode) InputMode { |
||||
if mode == InputCurrent { |
||||
return input_mode |
||||
} |
||||
if mode&InputMouse != 0 { |
||||
err := set_console_mode(in, enable_window_input|enable_mouse_input|enable_extended_flags) |
||||
if err != nil { |
||||
panic(err) |
||||
} |
||||
} else { |
||||
err := set_console_mode(in, enable_window_input) |
||||
if err != nil { |
||||
panic(err) |
||||
} |
||||
} |
||||
|
||||
input_mode = mode |
||||
return input_mode |
||||
} |
||||
|
||||
// Sets the termbox output mode.
|
||||
//
|
||||
// Windows console does not support extra colour modes,
|
||||
// so this will always set and return OutputNormal.
|
||||
func SetOutputMode(mode OutputMode) OutputMode { |
||||
return OutputNormal |
||||
} |
||||
|
||||
// Sync comes handy when something causes desync between termbox's understanding
|
||||
// of a terminal buffer and the reality. Such as a third party process. Sync
|
||||
// forces a complete resync between the termbox and a terminal, it may not be
|
||||
// visually pretty though. At the moment on Windows it does nothing.
|
||||
func Sync() error { |
||||
return nil |
||||
} |
||||
@ -1,110 +0,0 @@ |
||||
#!/usr/bin/env python |
||||
|
||||
import sys, os, subprocess |
||||
|
||||
def escaped(s): |
||||
return repr(s)[1:-1] |
||||
|
||||
def tput(term, name): |
||||
try: |
||||
return subprocess.check_output(['tput', '-T%s' % term, name]).decode() |
||||
except subprocess.CalledProcessError as e: |
||||
return e.output.decode() |
||||
|
||||
|
||||
def w(s): |
||||
if s == None: |
||||
return |
||||
sys.stdout.write(s) |
||||
|
||||
terminals = { |
||||
'xterm' : 'xterm', |
||||
'rxvt-256color' : 'rxvt_256color', |
||||
'rxvt-unicode' : 'rxvt_unicode', |
||||
'linux' : 'linux', |
||||
'Eterm' : 'eterm', |
||||
'screen' : 'screen' |
||||
} |
||||
|
||||
keys = [ |
||||
"F1", "kf1", |
||||
"F2", "kf2", |
||||
"F3", "kf3", |
||||
"F4", "kf4", |
||||
"F5", "kf5", |
||||
"F6", "kf6", |
||||
"F7", "kf7", |
||||
"F8", "kf8", |
||||
"F9", "kf9", |
||||
"F10", "kf10", |
||||
"F11", "kf11", |
||||
"F12", "kf12", |
||||
"INSERT", "kich1", |
||||
"DELETE", "kdch1", |
||||
"HOME", "khome", |
||||
"END", "kend", |
||||
"PGUP", "kpp", |
||||
"PGDN", "knp", |
||||
"KEY_UP", "kcuu1", |
||||
"KEY_DOWN", "kcud1", |
||||
"KEY_LEFT", "kcub1", |
||||
"KEY_RIGHT", "kcuf1" |
||||
] |
||||
|
||||
funcs = [ |
||||
"T_ENTER_CA", "smcup", |
||||
"T_EXIT_CA", "rmcup", |
||||
"T_SHOW_CURSOR", "cnorm", |
||||
"T_HIDE_CURSOR", "civis", |
||||
"T_CLEAR_SCREEN", "clear", |
||||
"T_SGR0", "sgr0", |
||||
"T_UNDERLINE", "smul", |
||||
"T_BOLD", "bold", |
||||
"T_BLINK", "blink", |
||||
"T_REVERSE", "rev", |
||||
"T_ENTER_KEYPAD", "smkx", |
||||
"T_EXIT_KEYPAD", "rmkx" |
||||
] |
||||
|
||||
def iter_pairs(iterable): |
||||
iterable = iter(iterable) |
||||
while True: |
||||
yield (next(iterable), next(iterable)) |
||||
|
||||
def do_term(term, nick): |
||||
w("// %s\n" % term) |
||||
w("var %s_keys = []string{\n\t" % nick) |
||||
for k, v in iter_pairs(keys): |
||||
w('"') |
||||
w(escaped(tput(term, v))) |
||||
w('",') |
||||
w("\n}\n") |
||||
w("var %s_funcs = []string{\n\t" % nick) |
||||
for k,v in iter_pairs(funcs): |
||||
w('"') |
||||
if v == "sgr": |
||||
w("\\033[3%d;4%dm") |
||||
elif v == "cup": |
||||
w("\\033[%d;%dH") |
||||
else: |
||||
w(escaped(tput(term, v))) |
||||
w('", ') |
||||
w("\n}\n\n") |
||||
|
||||
def do_terms(d): |
||||
w("var terms = []struct {\n") |
||||
w("\tname string\n") |
||||
w("\tkeys []string\n") |
||||
w("\tfuncs []string\n") |
||||
w("}{\n") |
||||
for k, v in d.items(): |
||||
w('\t{"%s", %s_keys, %s_funcs},\n' % (k, v, v)) |
||||
w("}\n\n") |
||||
|
||||
w("// +build !windows\n\npackage termbox\n\n") |
||||
|
||||
for k,v in terminals.items(): |
||||
do_term(k, v) |
||||
|
||||
do_terms(terminals) |
||||
|
||||
@ -1,39 +0,0 @@ |
||||
// +build ignore
|
||||
|
||||
package termbox |
||||
|
||||
/* |
||||
#include <termios.h> |
||||
#include <sys/ioctl.h> |
||||
*/ |
||||
import "C" |
||||
|
||||
type syscall_Termios C.struct_termios |
||||
|
||||
const ( |
||||
syscall_IGNBRK = C.IGNBRK |
||||
syscall_BRKINT = C.BRKINT |
||||
syscall_PARMRK = C.PARMRK |
||||
syscall_ISTRIP = C.ISTRIP |
||||
syscall_INLCR = C.INLCR |
||||
syscall_IGNCR = C.IGNCR |
||||
syscall_ICRNL = C.ICRNL |
||||
syscall_IXON = C.IXON |
||||
syscall_OPOST = C.OPOST |
||||
syscall_ECHO = C.ECHO |
||||
syscall_ECHONL = C.ECHONL |
||||
syscall_ICANON = C.ICANON |
||||
syscall_ISIG = C.ISIG |
||||
syscall_IEXTEN = C.IEXTEN |
||||
syscall_CSIZE = C.CSIZE |
||||
syscall_PARENB = C.PARENB |
||||
syscall_CS8 = C.CS8 |
||||
syscall_VMIN = C.VMIN |
||||
syscall_VTIME = C.VTIME |
||||
|
||||
// on darwin change these to (on *bsd too?):
|
||||
// C.TIOCGETA
|
||||
// C.TIOCSETA
|
||||
syscall_TCGETS = C.TCGETS |
||||
syscall_TCSETS = C.TCSETS |
||||
) |
||||
@ -1,41 +0,0 @@ |
||||
// Created by cgo -godefs - DO NOT EDIT
|
||||
// cgo -godefs syscalls.go
|
||||
|
||||
// +build !amd64
|
||||
|
||||
package termbox |
||||
|
||||
type syscall_Termios struct { |
||||
Iflag uint32 |
||||
Oflag uint32 |
||||
Cflag uint32 |
||||
Lflag uint32 |
||||
Cc [20]uint8 |
||||
Ispeed uint32 |
||||
Ospeed uint32 |
||||
} |
||||
|
||||
const ( |
||||
syscall_IGNBRK = 0x1 |
||||
syscall_BRKINT = 0x2 |
||||
syscall_PARMRK = 0x8 |
||||
syscall_ISTRIP = 0x20 |
||||
syscall_INLCR = 0x40 |
||||
syscall_IGNCR = 0x80 |
||||
syscall_ICRNL = 0x100 |
||||
syscall_IXON = 0x200 |
||||
syscall_OPOST = 0x1 |
||||
syscall_ECHO = 0x8 |
||||
syscall_ECHONL = 0x10 |
||||
syscall_ICANON = 0x100 |
||||
syscall_ISIG = 0x80 |
||||
syscall_IEXTEN = 0x400 |
||||
syscall_CSIZE = 0x300 |
||||
syscall_PARENB = 0x1000 |
||||
syscall_CS8 = 0x300 |
||||
syscall_VMIN = 0x10 |
||||
syscall_VTIME = 0x11 |
||||
|
||||
syscall_TCGETS = 0x402c7413 |
||||
syscall_TCSETS = 0x802c7414 |
||||
) |
||||
@ -1,40 +0,0 @@ |
||||
// Created by cgo -godefs - DO NOT EDIT
|
||||
// cgo -godefs syscalls.go
|
||||
|
||||
package termbox |
||||
|
||||
type syscall_Termios struct { |
||||
Iflag uint64 |
||||
Oflag uint64 |
||||
Cflag uint64 |
||||
Lflag uint64 |
||||
Cc [20]uint8 |
||||
Pad_cgo_0 [4]byte |
||||
Ispeed uint64 |
||||
Ospeed uint64 |
||||
} |
||||
|
||||
const ( |
||||
syscall_IGNBRK = 0x1 |
||||
syscall_BRKINT = 0x2 |
||||
syscall_PARMRK = 0x8 |
||||
syscall_ISTRIP = 0x20 |
||||
syscall_INLCR = 0x40 |
||||
syscall_IGNCR = 0x80 |
||||
syscall_ICRNL = 0x100 |
||||
syscall_IXON = 0x200 |
||||
syscall_OPOST = 0x1 |
||||
syscall_ECHO = 0x8 |
||||
syscall_ECHONL = 0x10 |
||||
syscall_ICANON = 0x100 |
||||
syscall_ISIG = 0x80 |
||||
syscall_IEXTEN = 0x400 |
||||
syscall_CSIZE = 0x300 |
||||
syscall_PARENB = 0x1000 |
||||
syscall_CS8 = 0x300 |
||||
syscall_VMIN = 0x10 |
||||
syscall_VTIME = 0x11 |
||||
|
||||
syscall_TCGETS = 0x40487413 |
||||
syscall_TCSETS = 0x80487414 |
||||
) |
||||
@ -1,39 +0,0 @@ |
||||
// Created by cgo -godefs - DO NOT EDIT
|
||||
// cgo -godefs syscalls.go
|
||||
|
||||
package termbox |
||||
|
||||
type syscall_Termios struct { |
||||
Iflag uint32 |
||||
Oflag uint32 |
||||
Cflag uint32 |
||||
Lflag uint32 |
||||
Cc [20]uint8 |
||||
Ispeed uint32 |
||||
Ospeed uint32 |
||||
} |
||||
|
||||
const ( |
||||
syscall_IGNBRK = 0x1 |
||||
syscall_BRKINT = 0x2 |
||||
syscall_PARMRK = 0x8 |
||||
syscall_ISTRIP = 0x20 |
||||
syscall_INLCR = 0x40 |
||||
syscall_IGNCR = 0x80 |
||||
syscall_ICRNL = 0x100 |
||||
syscall_IXON = 0x200 |
||||
syscall_OPOST = 0x1 |
||||
syscall_ECHO = 0x8 |
||||
syscall_ECHONL = 0x10 |
||||
syscall_ICANON = 0x100 |
||||
syscall_ISIG = 0x80 |
||||
syscall_IEXTEN = 0x400 |
||||
syscall_CSIZE = 0x300 |
||||
syscall_PARENB = 0x1000 |
||||
syscall_CS8 = 0x300 |
||||
syscall_VMIN = 0x10 |
||||
syscall_VTIME = 0x11 |
||||
|
||||
syscall_TCGETS = 0x402c7413 |
||||
syscall_TCSETS = 0x802c7414 |
||||
) |
||||
@ -1,39 +0,0 @@ |
||||
// Created by cgo -godefs - DO NOT EDIT
|
||||
// cgo -godefs syscalls.go
|
||||
|
||||
package termbox |
||||
|
||||
type syscall_Termios struct { |
||||
Iflag uint32 |
||||
Oflag uint32 |
||||
Cflag uint32 |
||||
Lflag uint32 |
||||
Cc [20]uint8 |
||||
Ispeed uint32 |
||||
Ospeed uint32 |
||||
} |
||||
|
||||
const ( |
||||
syscall_IGNBRK = 0x1 |
||||
syscall_BRKINT = 0x2 |
||||
syscall_PARMRK = 0x8 |
||||
syscall_ISTRIP = 0x20 |
||||
syscall_INLCR = 0x40 |
||||
syscall_IGNCR = 0x80 |
||||
syscall_ICRNL = 0x100 |
||||
syscall_IXON = 0x200 |
||||
syscall_OPOST = 0x1 |
||||
syscall_ECHO = 0x8 |
||||
syscall_ECHONL = 0x10 |
||||
syscall_ICANON = 0x100 |
||||
syscall_ISIG = 0x80 |
||||
syscall_IEXTEN = 0x400 |
||||
syscall_CSIZE = 0x300 |
||||
syscall_PARENB = 0x1000 |
||||
syscall_CS8 = 0x300 |
||||
syscall_VMIN = 0x10 |
||||
syscall_VTIME = 0x11 |
||||
|
||||
syscall_TCGETS = 0x402c7413 |
||||
syscall_TCSETS = 0x802c7414 |
||||
) |
||||
@ -1,33 +0,0 @@ |
||||
// Created by cgo -godefs - DO NOT EDIT
|
||||
// cgo -godefs syscalls.go
|
||||
|
||||
package termbox |
||||
|
||||
import "syscall" |
||||
|
||||
type syscall_Termios syscall.Termios |
||||
|
||||
const ( |
||||
syscall_IGNBRK = syscall.IGNBRK |
||||
syscall_BRKINT = syscall.BRKINT |
||||
syscall_PARMRK = syscall.PARMRK |
||||
syscall_ISTRIP = syscall.ISTRIP |
||||
syscall_INLCR = syscall.INLCR |
||||
syscall_IGNCR = syscall.IGNCR |
||||
syscall_ICRNL = syscall.ICRNL |
||||
syscall_IXON = syscall.IXON |
||||
syscall_OPOST = syscall.OPOST |
||||
syscall_ECHO = syscall.ECHO |
||||
syscall_ECHONL = syscall.ECHONL |
||||
syscall_ICANON = syscall.ICANON |
||||
syscall_ISIG = syscall.ISIG |
||||
syscall_IEXTEN = syscall.IEXTEN |
||||
syscall_CSIZE = syscall.CSIZE |
||||
syscall_PARENB = syscall.PARENB |
||||
syscall_CS8 = syscall.CS8 |
||||
syscall_VMIN = syscall.VMIN |
||||
syscall_VTIME = syscall.VTIME |
||||
|
||||
syscall_TCGETS = syscall.TCGETS |
||||
syscall_TCSETS = syscall.TCSETS |
||||
) |
||||
@ -1,39 +0,0 @@ |
||||
// Created by cgo -godefs - DO NOT EDIT
|
||||
// cgo -godefs syscalls.go
|
||||
|
||||
package termbox |
||||
|
||||
type syscall_Termios struct { |
||||
Iflag uint32 |
||||
Oflag uint32 |
||||
Cflag uint32 |
||||
Lflag uint32 |
||||
Cc [20]uint8 |
||||
Ispeed int32 |
||||
Ospeed int32 |
||||
} |
||||
|
||||
const ( |
||||
syscall_IGNBRK = 0x1 |
||||
syscall_BRKINT = 0x2 |
||||
syscall_PARMRK = 0x8 |
||||
syscall_ISTRIP = 0x20 |
||||
syscall_INLCR = 0x40 |
||||
syscall_IGNCR = 0x80 |
||||
syscall_ICRNL = 0x100 |
||||
syscall_IXON = 0x200 |
||||
syscall_OPOST = 0x1 |
||||
syscall_ECHO = 0x8 |
||||
syscall_ECHONL = 0x10 |
||||
syscall_ICANON = 0x100 |
||||
syscall_ISIG = 0x80 |
||||
syscall_IEXTEN = 0x400 |
||||
syscall_CSIZE = 0x300 |
||||
syscall_PARENB = 0x1000 |
||||
syscall_CS8 = 0x300 |
||||
syscall_VMIN = 0x10 |
||||
syscall_VTIME = 0x11 |
||||
|
||||
syscall_TCGETS = 0x402c7413 |
||||
syscall_TCSETS = 0x802c7414 |
||||
) |
||||
@ -1,39 +0,0 @@ |
||||
// Created by cgo -godefs - DO NOT EDIT
|
||||
// cgo -godefs syscalls.go
|
||||
|
||||
package termbox |
||||
|
||||
type syscall_Termios struct { |
||||
Iflag uint32 |
||||
Oflag uint32 |
||||
Cflag uint32 |
||||
Lflag uint32 |
||||
Cc [20]uint8 |
||||
Ispeed int32 |
||||
Ospeed int32 |
||||
} |
||||
|
||||
const ( |
||||
syscall_IGNBRK = 0x1 |
||||
syscall_BRKINT = 0x2 |
||||
syscall_PARMRK = 0x8 |
||||
syscall_ISTRIP = 0x20 |
||||
syscall_INLCR = 0x40 |
||||
syscall_IGNCR = 0x80 |
||||
syscall_ICRNL = 0x100 |
||||
syscall_IXON = 0x200 |
||||
syscall_OPOST = 0x1 |
||||
syscall_ECHO = 0x8 |
||||
syscall_ECHONL = 0x10 |
||||
syscall_ICANON = 0x100 |
||||
syscall_ISIG = 0x80 |
||||
syscall_IEXTEN = 0x400 |
||||
syscall_CSIZE = 0x300 |
||||
syscall_PARENB = 0x1000 |
||||
syscall_CS8 = 0x300 |
||||
syscall_VMIN = 0x10 |
||||
syscall_VTIME = 0x11 |
||||
|
||||
syscall_TCGETS = 0x402c7413 |
||||
syscall_TCSETS = 0x802c7414 |
||||
) |
||||
@ -1,61 +0,0 @@ |
||||
// Created by cgo -godefs - DO NOT EDIT
|
||||
// cgo -godefs -- -DUNICODE syscalls.go
|
||||
|
||||
package termbox |
||||
|
||||
const ( |
||||
foreground_blue = 0x1 |
||||
foreground_green = 0x2 |
||||
foreground_red = 0x4 |
||||
foreground_intensity = 0x8 |
||||
background_blue = 0x10 |
||||
background_green = 0x20 |
||||
background_red = 0x40 |
||||
background_intensity = 0x80 |
||||
std_input_handle = -0xa |
||||
std_output_handle = -0xb |
||||
key_event = 0x1 |
||||
mouse_event = 0x2 |
||||
window_buffer_size_event = 0x4 |
||||
enable_window_input = 0x8 |
||||
enable_mouse_input = 0x10 |
||||
enable_extended_flags = 0x80 |
||||
|
||||
vk_f1 = 0x70 |
||||
vk_f2 = 0x71 |
||||
vk_f3 = 0x72 |
||||
vk_f4 = 0x73 |
||||
vk_f5 = 0x74 |
||||
vk_f6 = 0x75 |
||||
vk_f7 = 0x76 |
||||
vk_f8 = 0x77 |
||||
vk_f9 = 0x78 |
||||
vk_f10 = 0x79 |
||||
vk_f11 = 0x7a |
||||
vk_f12 = 0x7b |
||||
vk_insert = 0x2d |
||||
vk_delete = 0x2e |
||||
vk_home = 0x24 |
||||
vk_end = 0x23 |
||||
vk_pgup = 0x21 |
||||
vk_pgdn = 0x22 |
||||
vk_arrow_up = 0x26 |
||||
vk_arrow_down = 0x28 |
||||
vk_arrow_left = 0x25 |
||||
vk_arrow_right = 0x27 |
||||
vk_backspace = 0x8 |
||||
vk_tab = 0x9 |
||||
vk_enter = 0xd |
||||
vk_esc = 0x1b |
||||
vk_space = 0x20 |
||||
|
||||
left_alt_pressed = 0x2 |
||||
left_ctrl_pressed = 0x8 |
||||
right_alt_pressed = 0x1 |
||||
right_ctrl_pressed = 0x4 |
||||
shift_pressed = 0x10 |
||||
|
||||
generic_read = 0x80000000 |
||||
generic_write = 0x40000000 |
||||
console_textmode_buffer = 0x1 |
||||
) |
||||
@ -1,511 +0,0 @@ |
||||
// +build !windows
|
||||
|
||||
package termbox |
||||
|
||||
import "unicode/utf8" |
||||
import "bytes" |
||||
import "syscall" |
||||
import "unsafe" |
||||
import "strings" |
||||
import "strconv" |
||||
import "os" |
||||
import "io" |
||||
|
||||
// private API
|
||||
|
||||
const ( |
||||
t_enter_ca = iota |
||||
t_exit_ca |
||||
t_show_cursor |
||||
t_hide_cursor |
||||
t_clear_screen |
||||
t_sgr0 |
||||
t_underline |
||||
t_bold |
||||
t_blink |
||||
t_reverse |
||||
t_enter_keypad |
||||
t_exit_keypad |
||||
t_enter_mouse |
||||
t_exit_mouse |
||||
t_max_funcs |
||||
) |
||||
|
||||
const ( |
||||
coord_invalid = -2 |
||||
attr_invalid = Attribute(0xFFFF) |
||||
) |
||||
|
||||
type input_event struct { |
||||
data []byte |
||||
err error |
||||
} |
||||
|
||||
var ( |
||||
// term specific sequences
|
||||
keys []string |
||||
funcs []string |
||||
|
||||
// termbox inner state
|
||||
orig_tios syscall_Termios |
||||
back_buffer cellbuf |
||||
front_buffer cellbuf |
||||
termw int |
||||
termh int |
||||
input_mode = InputEsc |
||||
output_mode = OutputNormal |
||||
out *os.File |
||||
in int |
||||
lastfg = attr_invalid |
||||
lastbg = attr_invalid |
||||
lastx = coord_invalid |
||||
lasty = coord_invalid |
||||
cursor_x = cursor_hidden |
||||
cursor_y = cursor_hidden |
||||
foreground = ColorDefault |
||||
background = ColorDefault |
||||
inbuf = make([]byte, 0, 64) |
||||
outbuf bytes.Buffer |
||||
sigwinch = make(chan os.Signal, 1) |
||||
sigio = make(chan os.Signal, 1) |
||||
quit = make(chan int) |
||||
input_comm = make(chan input_event) |
||||
interrupt_comm = make(chan struct{}) |
||||
intbuf = make([]byte, 0, 16) |
||||
|
||||
// grayscale indexes
|
||||
grayscale = []Attribute{ |
||||
0, 17, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, |
||||
245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 232, |
||||
} |
||||
) |
||||
|
||||
func write_cursor(x, y int) { |
||||
outbuf.WriteString("\033[") |
||||
outbuf.Write(strconv.AppendUint(intbuf, uint64(y+1), 10)) |
||||
outbuf.WriteString(";") |
||||
outbuf.Write(strconv.AppendUint(intbuf, uint64(x+1), 10)) |
||||
outbuf.WriteString("H") |
||||
} |
||||
|
||||
func write_sgr_fg(a Attribute) { |
||||
switch output_mode { |
||||
case Output256, Output216, OutputGrayscale: |
||||
outbuf.WriteString("\033[38;5;") |
||||
outbuf.Write(strconv.AppendUint(intbuf, uint64(a-1), 10)) |
||||
outbuf.WriteString("m") |
||||
default: |
||||
outbuf.WriteString("\033[3") |
||||
outbuf.Write(strconv.AppendUint(intbuf, uint64(a-1), 10)) |
||||
outbuf.WriteString("m") |
||||
} |
||||
} |
||||
|
||||
func write_sgr_bg(a Attribute) { |
||||
switch output_mode { |
||||
case Output256, Output216, OutputGrayscale: |
||||
outbuf.WriteString("\033[48;5;") |
||||
outbuf.Write(strconv.AppendUint(intbuf, uint64(a-1), 10)) |
||||
outbuf.WriteString("m") |
||||
default: |
||||
outbuf.WriteString("\033[4") |
||||
outbuf.Write(strconv.AppendUint(intbuf, uint64(a-1), 10)) |
||||
outbuf.WriteString("m") |
||||
} |
||||
} |
||||
|
||||
func write_sgr(fg, bg Attribute) { |
||||
switch output_mode { |
||||
case Output256, Output216, OutputGrayscale: |
||||
outbuf.WriteString("\033[38;5;") |
||||
outbuf.Write(strconv.AppendUint(intbuf, uint64(fg-1), 10)) |
||||
outbuf.WriteString("m") |
||||
outbuf.WriteString("\033[48;5;") |
||||
outbuf.Write(strconv.AppendUint(intbuf, uint64(bg-1), 10)) |
||||
outbuf.WriteString("m") |
||||
default: |
||||
outbuf.WriteString("\033[3") |
||||
outbuf.Write(strconv.AppendUint(intbuf, uint64(fg-1), 10)) |
||||
outbuf.WriteString(";4") |
||||
outbuf.Write(strconv.AppendUint(intbuf, uint64(bg-1), 10)) |
||||
outbuf.WriteString("m") |
||||
} |
||||
} |
||||
|
||||
type winsize struct { |
||||
rows uint16 |
||||
cols uint16 |
||||
xpixels uint16 |
||||
ypixels uint16 |
||||
} |
||||
|
||||
func get_term_size(fd uintptr) (int, int) { |
||||
var sz winsize |
||||
_, _, _ = syscall.Syscall(syscall.SYS_IOCTL, |
||||
fd, uintptr(syscall.TIOCGWINSZ), uintptr(unsafe.Pointer(&sz))) |
||||
return int(sz.cols), int(sz.rows) |
||||
} |
||||
|
||||
func send_attr(fg, bg Attribute) { |
||||
if fg == lastfg && bg == lastbg { |
||||
return |
||||
} |
||||
|
||||
outbuf.WriteString(funcs[t_sgr0]) |
||||
|
||||
var fgcol, bgcol Attribute |
||||
|
||||
switch output_mode { |
||||
case Output256: |
||||
fgcol = fg & 0x1FF |
||||
bgcol = bg & 0x1FF |
||||
case Output216: |
||||
fgcol = fg & 0xFF |
||||
bgcol = bg & 0xFF |
||||
if fgcol > 216 { |
||||
fgcol = ColorDefault |
||||
} |
||||
if bgcol > 216 { |
||||
bgcol = ColorDefault |
||||
} |
||||
if fgcol != ColorDefault { |
||||
fgcol += 0x10 |
||||
} |
||||
if bgcol != ColorDefault { |
||||
bgcol += 0x10 |
||||
} |
||||
case OutputGrayscale: |
||||
fgcol = fg & 0x1F |
||||
bgcol = bg & 0x1F |
||||
if fgcol > 26 { |
||||
fgcol = ColorDefault |
||||
} |
||||
if bgcol > 26 { |
||||
bgcol = ColorDefault |
||||
} |
||||
if fgcol != ColorDefault { |
||||
fgcol = grayscale[fgcol] |
||||
} |
||||
if bgcol != ColorDefault { |
||||
bgcol = grayscale[bgcol] |
||||
} |
||||
default: |
||||
fgcol = fg & 0x0F |
||||
bgcol = bg & 0x0F |
||||
} |
||||
|
||||
if fgcol != ColorDefault { |
||||
if bgcol != ColorDefault { |
||||
write_sgr(fgcol, bgcol) |
||||
} else { |
||||
write_sgr_fg(fgcol) |
||||
} |
||||
} else if bgcol != ColorDefault { |
||||
write_sgr_bg(bgcol) |
||||
} |
||||
|
||||
if fg&AttrBold != 0 { |
||||
outbuf.WriteString(funcs[t_bold]) |
||||
} |
||||
if bg&AttrBold != 0 { |
||||
outbuf.WriteString(funcs[t_blink]) |
||||
} |
||||
if fg&AttrUnderline != 0 { |
||||
outbuf.WriteString(funcs[t_underline]) |
||||
} |
||||
if fg&AttrReverse|bg&AttrReverse != 0 { |
||||
outbuf.WriteString(funcs[t_reverse]) |
||||
} |
||||
|
||||
lastfg, lastbg = fg, bg |
||||
} |
||||
|
||||
func send_char(x, y int, ch rune) { |
||||
var buf [8]byte |
||||
n := utf8.EncodeRune(buf[:], ch) |
||||
if x-1 != lastx || y != lasty { |
||||
write_cursor(x, y) |
||||
} |
||||
lastx, lasty = x, y |
||||
outbuf.Write(buf[:n]) |
||||
} |
||||
|
||||
func flush() error { |
||||
_, err := io.Copy(out, &outbuf) |
||||
outbuf.Reset() |
||||
return err |
||||
} |
||||
|
||||
func send_clear() error { |
||||
send_attr(foreground, background) |
||||
outbuf.WriteString(funcs[t_clear_screen]) |
||||
if !is_cursor_hidden(cursor_x, cursor_y) { |
||||
write_cursor(cursor_x, cursor_y) |
||||
} |
||||
|
||||
// we need to invalidate cursor position too and these two vars are
|
||||
// used only for simple cursor positioning optimization, cursor
|
||||
// actually may be in the correct place, but we simply discard
|
||||
// optimization once and it gives us simple solution for the case when
|
||||
// cursor moved
|
||||
lastx = coord_invalid |
||||
lasty = coord_invalid |
||||
|
||||
return flush() |
||||
} |
||||
|
||||
func update_size_maybe() error { |
||||
w, h := get_term_size(out.Fd()) |
||||
if w != termw || h != termh { |
||||
termw, termh = w, h |
||||
back_buffer.resize(termw, termh) |
||||
front_buffer.resize(termw, termh) |
||||
front_buffer.clear() |
||||
return send_clear() |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
func tcsetattr(fd uintptr, termios *syscall_Termios) error { |
||||
r, _, e := syscall.Syscall(syscall.SYS_IOCTL, |
||||
fd, uintptr(syscall_TCSETS), uintptr(unsafe.Pointer(termios))) |
||||
if r != 0 { |
||||
return os.NewSyscallError("SYS_IOCTL", e) |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
func tcgetattr(fd uintptr, termios *syscall_Termios) error { |
||||
r, _, e := syscall.Syscall(syscall.SYS_IOCTL, |
||||
fd, uintptr(syscall_TCGETS), uintptr(unsafe.Pointer(termios))) |
||||
if r != 0 { |
||||
return os.NewSyscallError("SYS_IOCTL", e) |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
func parse_mouse_event(event *Event, buf string) (int, bool) { |
||||
if strings.HasPrefix(buf, "\033[M") && len(buf) >= 6 { |
||||
// X10 mouse encoding, the simplest one
|
||||
// \033 [ M Cb Cx Cy
|
||||
b := buf[3] - 32 |
||||
switch b & 3 { |
||||
case 0: |
||||
if b&64 != 0 { |
||||
event.Key = MouseWheelUp |
||||
} else { |
||||
event.Key = MouseLeft |
||||
} |
||||
case 1: |
||||
if b&64 != 0 { |
||||
event.Key = MouseWheelDown |
||||
} else { |
||||
event.Key = MouseMiddle |
||||
} |
||||
case 2: |
||||
event.Key = MouseRight |
||||
case 3: |
||||
event.Key = MouseRelease |
||||
default: |
||||
return 6, false |
||||
} |
||||
event.Type = EventMouse // KeyEvent by default
|
||||
if b&32 != 0 { |
||||
event.Mod |= ModMotion |
||||
} |
||||
|
||||
// the coord is 1,1 for upper left
|
||||
event.MouseX = int(buf[4]) - 1 - 32 |
||||
event.MouseY = int(buf[5]) - 1 - 32 |
||||
return 6, true |
||||
} else if strings.HasPrefix(buf, "\033[<") || strings.HasPrefix(buf, "\033[") { |
||||
// xterm 1006 extended mode or urxvt 1015 extended mode
|
||||
// xterm: \033 [ < Cb ; Cx ; Cy (M or m)
|
||||
// urxvt: \033 [ Cb ; Cx ; Cy M
|
||||
|
||||
// find the first M or m, that's where we stop
|
||||
mi := strings.IndexAny(buf, "Mm") |
||||
if mi == -1 { |
||||
return 0, false |
||||
} |
||||
|
||||
// whether it's a capital M or not
|
||||
isM := buf[mi] == 'M' |
||||
|
||||
// whether it's urxvt or not
|
||||
isU := false |
||||
|
||||
// buf[2] is safe here, because having M or m found means we have at
|
||||
// least 3 bytes in a string
|
||||
if buf[2] == '<' { |
||||
buf = buf[3:mi] |
||||
} else { |
||||
isU = true |
||||
buf = buf[2:mi] |
||||
} |
||||
|
||||
s1 := strings.Index(buf, ";") |
||||
s2 := strings.LastIndex(buf, ";") |
||||
// not found or only one ';'
|
||||
if s1 == -1 || s2 == -1 || s1 == s2 { |
||||
return 0, false |
||||
} |
||||
|
||||
n1, err := strconv.ParseInt(buf[0:s1], 10, 64) |
||||
if err != nil { |
||||
return 0, false |
||||
} |
||||
n2, err := strconv.ParseInt(buf[s1+1:s2], 10, 64) |
||||
if err != nil { |
||||
return 0, false |
||||
} |
||||
n3, err := strconv.ParseInt(buf[s2+1:], 10, 64) |
||||
if err != nil { |
||||
return 0, false |
||||
} |
||||
|
||||
// on urxvt, first number is encoded exactly as in X10, but we need to
|
||||
// make it zero-based, on xterm it is zero-based already
|
||||
if isU { |
||||
n1 -= 32 |
||||
} |
||||
switch n1 & 3 { |
||||
case 0: |
||||
if n1&64 != 0 { |
||||
event.Key = MouseWheelUp |
||||
} else { |
||||
event.Key = MouseLeft |
||||
} |
||||
case 1: |
||||
if n1&64 != 0 { |
||||
event.Key = MouseWheelDown |
||||
} else { |
||||
event.Key = MouseMiddle |
||||
} |
||||
case 2: |
||||
event.Key = MouseRight |
||||
case 3: |
||||
event.Key = MouseRelease |
||||
default: |
||||
return mi + 1, false |
||||
} |
||||
if !isM { |
||||
// on xterm mouse release is signaled by lowercase m
|
||||
event.Key = MouseRelease |
||||
} |
||||
|
||||
event.Type = EventMouse // KeyEvent by default
|
||||
if n1&32 != 0 { |
||||
event.Mod |= ModMotion |
||||
} |
||||
|
||||
event.MouseX = int(n2) - 1 |
||||
event.MouseY = int(n3) - 1 |
||||
return mi + 1, true |
||||
} |
||||
|
||||
return 0, false |
||||
} |
||||
|
||||
func parse_escape_sequence(event *Event, buf []byte) (int, bool) { |
||||
bufstr := string(buf) |
||||
for i, key := range keys { |
||||
if strings.HasPrefix(bufstr, key) { |
||||
event.Ch = 0 |
||||
event.Key = Key(0xFFFF - i) |
||||
return len(key), true |
||||
} |
||||
} |
||||
|
||||
// if none of the keys match, let's try mouse seqences
|
||||
return parse_mouse_event(event, bufstr) |
||||
} |
||||
|
||||
func extract_raw_event(data []byte, event *Event) bool { |
||||
if len(inbuf) == 0 { |
||||
return false |
||||
} |
||||
|
||||
n := len(data) |
||||
if n == 0 { |
||||
return false |
||||
} |
||||
|
||||
n = copy(data, inbuf) |
||||
copy(inbuf, inbuf[n:]) |
||||
inbuf = inbuf[:len(inbuf)-n] |
||||
|
||||
event.N = n |
||||
event.Type = EventRaw |
||||
return true |
||||
} |
||||
|
||||
func extract_event(inbuf []byte, event *Event) bool { |
||||
if len(inbuf) == 0 { |
||||
event.N = 0 |
||||
return false |
||||
} |
||||
|
||||
if inbuf[0] == '\033' { |
||||
// possible escape sequence
|
||||
if n, ok := parse_escape_sequence(event, inbuf); n != 0 { |
||||
event.N = n |
||||
return ok |
||||
} |
||||
|
||||
// it's not escape sequence, then it's Alt or Esc, check input_mode
|
||||
switch { |
||||
case input_mode&InputEsc != 0: |
||||
// if we're in escape mode, fill Esc event, pop buffer, return success
|
||||
event.Ch = 0 |
||||
event.Key = KeyEsc |
||||
event.Mod = 0 |
||||
event.N = 1 |
||||
return true |
||||
case input_mode&InputAlt != 0: |
||||
// if we're in alt mode, set Alt modifier to event and redo parsing
|
||||
event.Mod = ModAlt |
||||
ok := extract_event(inbuf[1:], event) |
||||
if ok { |
||||
event.N++ |
||||
} else { |
||||
event.N = 0 |
||||
} |
||||
return ok |
||||
default: |
||||
panic("unreachable") |
||||
} |
||||
} |
||||
|
||||
// if we're here, this is not an escape sequence and not an alt sequence
|
||||
// so, it's a FUNCTIONAL KEY or a UNICODE character
|
||||
|
||||
// first of all check if it's a functional key
|
||||
if Key(inbuf[0]) <= KeySpace || Key(inbuf[0]) == KeyBackspace2 { |
||||
// fill event, pop buffer, return success
|
||||
event.Ch = 0 |
||||
event.Key = Key(inbuf[0]) |
||||
event.N = 1 |
||||
return true |
||||
} |
||||
|
||||
// the only possible option is utf8 rune
|
||||
if r, n := utf8.DecodeRune(inbuf); r != utf8.RuneError { |
||||
event.Ch = r |
||||
event.Key = 0 |
||||
event.N = n |
||||
return true |
||||
} |
||||
|
||||
return false |
||||
} |
||||
|
||||
func fcntl(fd int, cmd int, arg int) (val int, err error) { |
||||
r, _, e := syscall.Syscall(syscall.SYS_FCNTL, uintptr(fd), uintptr(cmd), |
||||
uintptr(arg)) |
||||
val = int(r) |
||||
if e != 0 { |
||||
err = e |
||||
} |
||||
return |
||||
} |
||||
@ -1,59 +0,0 @@ |
||||
package termbox |
||||
|
||||
// private API, common OS agnostic part
|
||||
|
||||
type cellbuf struct { |
||||
width int |
||||
height int |
||||
cells []Cell |
||||
} |
||||
|
||||
func (this *cellbuf) init(width, height int) { |
||||
this.width = width |
||||
this.height = height |
||||
this.cells = make([]Cell, width*height) |
||||
} |
||||
|
||||
func (this *cellbuf) resize(width, height int) { |
||||
if this.width == width && this.height == height { |
||||
return |
||||
} |
||||
|
||||
oldw := this.width |
||||
oldh := this.height |
||||
oldcells := this.cells |
||||
|
||||
this.init(width, height) |
||||
this.clear() |
||||
|
||||
minw, minh := oldw, oldh |
||||
|
||||
if width < minw { |
||||
minw = width |
||||
} |
||||
if height < minh { |
||||
minh = height |
||||
} |
||||
|
||||
for i := 0; i < minh; i++ { |
||||
srco, dsto := i*oldw, i*width |
||||
src := oldcells[srco : srco+minw] |
||||
dst := this.cells[dsto : dsto+minw] |
||||
copy(dst, src) |
||||
} |
||||
} |
||||
|
||||
func (this *cellbuf) clear() { |
||||
for i := range this.cells { |
||||
c := &this.cells[i] |
||||
c.Ch = ' ' |
||||
c.Fg = foreground |
||||
c.Bg = background |
||||
} |
||||
} |
||||
|
||||
const cursor_hidden = -1 |
||||
|
||||
func is_cursor_hidden(x, y int) bool { |
||||
return x == cursor_hidden || y == cursor_hidden |
||||
} |
||||
@ -1,856 +0,0 @@ |
||||
package termbox |
||||
|
||||
import "syscall" |
||||
import "unsafe" |
||||
import "unicode/utf16" |
||||
import "github.com/mattn/go-runewidth" |
||||
|
||||
type ( |
||||
wchar uint16 |
||||
short int16 |
||||
dword uint32 |
||||
word uint16 |
||||
char_info struct { |
||||
char wchar |
||||
attr word |
||||
} |
||||
coord struct { |
||||
x short |
||||
y short |
||||
} |
||||
small_rect struct { |
||||
left short |
||||
top short |
||||
right short |
||||
bottom short |
||||
} |
||||
console_screen_buffer_info struct { |
||||
size coord |
||||
cursor_position coord |
||||
attributes word |
||||
window small_rect |
||||
maximum_window_size coord |
||||
} |
||||
console_cursor_info struct { |
||||
size dword |
||||
visible int32 |
||||
} |
||||
input_record struct { |
||||
event_type word |
||||
_ [2]byte |
||||
event [16]byte |
||||
} |
||||
key_event_record struct { |
||||
key_down int32 |
||||
repeat_count word |
||||
virtual_key_code word |
||||
virtual_scan_code word |
||||
unicode_char wchar |
||||
control_key_state dword |
||||
} |
||||
window_buffer_size_record struct { |
||||
size coord |
||||
} |
||||
mouse_event_record struct { |
||||
mouse_pos coord |
||||
button_state dword |
||||
control_key_state dword |
||||
event_flags dword |
||||
} |
||||
) |
||||
|
||||
const ( |
||||
mouse_lmb = 0x1 |
||||
mouse_rmb = 0x2 |
||||
mouse_mmb = 0x4 | 0x8 | 0x10 |
||||
) |
||||
|
||||
func (this coord) uintptr() uintptr { |
||||
return uintptr(*(*int32)(unsafe.Pointer(&this))) |
||||
} |
||||
|
||||
var kernel32 = syscall.NewLazyDLL("kernel32.dll") |
||||
var is_cjk = runewidth.IsEastAsian() |
||||
|
||||
var ( |
||||
proc_set_console_active_screen_buffer = kernel32.NewProc("SetConsoleActiveScreenBuffer") |
||||
proc_set_console_screen_buffer_size = kernel32.NewProc("SetConsoleScreenBufferSize") |
||||
proc_create_console_screen_buffer = kernel32.NewProc("CreateConsoleScreenBuffer") |
||||
proc_get_console_screen_buffer_info = kernel32.NewProc("GetConsoleScreenBufferInfo") |
||||
proc_write_console_output = kernel32.NewProc("WriteConsoleOutputW") |
||||
proc_write_console_output_character = kernel32.NewProc("WriteConsoleOutputCharacterW") |
||||
proc_write_console_output_attribute = kernel32.NewProc("WriteConsoleOutputAttribute") |
||||
proc_set_console_cursor_info = kernel32.NewProc("SetConsoleCursorInfo") |
||||
proc_set_console_cursor_position = kernel32.NewProc("SetConsoleCursorPosition") |
||||
proc_get_console_cursor_info = kernel32.NewProc("GetConsoleCursorInfo") |
||||
proc_read_console_input = kernel32.NewProc("ReadConsoleInputW") |
||||
proc_get_console_mode = kernel32.NewProc("GetConsoleMode") |
||||
proc_set_console_mode = kernel32.NewProc("SetConsoleMode") |
||||
proc_fill_console_output_character = kernel32.NewProc("FillConsoleOutputCharacterW") |
||||
proc_fill_console_output_attribute = kernel32.NewProc("FillConsoleOutputAttribute") |
||||
proc_create_event = kernel32.NewProc("CreateEventW") |
||||
proc_wait_for_multiple_objects = kernel32.NewProc("WaitForMultipleObjects") |
||||
proc_set_event = kernel32.NewProc("SetEvent") |
||||
) |
||||
|
||||
func set_console_active_screen_buffer(h syscall.Handle) (err error) { |
||||
r0, _, e1 := syscall.Syscall(proc_set_console_active_screen_buffer.Addr(), |
||||
1, uintptr(h), 0, 0) |
||||
if int(r0) == 0 { |
||||
if e1 != 0 { |
||||
err = error(e1) |
||||
} else { |
||||
err = syscall.EINVAL |
||||
} |
||||
} |
||||
return |
||||
} |
||||
|
||||
func set_console_screen_buffer_size(h syscall.Handle, size coord) (err error) { |
||||
r0, _, e1 := syscall.Syscall(proc_set_console_screen_buffer_size.Addr(), |
||||
2, uintptr(h), size.uintptr(), 0) |
||||
if int(r0) == 0 { |
||||
if e1 != 0 { |
||||
err = error(e1) |
||||
} else { |
||||
err = syscall.EINVAL |
||||
} |
||||
} |
||||
return |
||||
} |
||||
|
||||
func create_console_screen_buffer() (h syscall.Handle, err error) { |
||||
r0, _, e1 := syscall.Syscall6(proc_create_console_screen_buffer.Addr(), |
||||
5, uintptr(generic_read|generic_write), 0, 0, console_textmode_buffer, 0, 0) |
||||
if int(r0) == 0 { |
||||
if e1 != 0 { |
||||
err = error(e1) |
||||
} else { |
||||
err = syscall.EINVAL |
||||
} |
||||
} |
||||
return syscall.Handle(r0), err |
||||
} |
||||
|
||||
func get_console_screen_buffer_info(h syscall.Handle, info *console_screen_buffer_info) (err error) { |
||||
r0, _, e1 := syscall.Syscall(proc_get_console_screen_buffer_info.Addr(), |
||||
2, uintptr(h), uintptr(unsafe.Pointer(info)), 0) |
||||
if int(r0) == 0 { |
||||
if e1 != 0 { |
||||
err = error(e1) |
||||
} else { |
||||
err = syscall.EINVAL |
||||
} |
||||
} |
||||
return |
||||
} |
||||
|
||||
func write_console_output(h syscall.Handle, chars []char_info, dst small_rect) (err error) { |
||||
tmp_coord = coord{dst.right - dst.left + 1, dst.bottom - dst.top + 1} |
||||
tmp_rect = dst |
||||
r0, _, e1 := syscall.Syscall6(proc_write_console_output.Addr(), |
||||
5, uintptr(h), uintptr(unsafe.Pointer(&chars[0])), tmp_coord.uintptr(), |
||||
tmp_coord0.uintptr(), uintptr(unsafe.Pointer(&tmp_rect)), 0) |
||||
if int(r0) == 0 { |
||||
if e1 != 0 { |
||||
err = error(e1) |
||||
} else { |
||||
err = syscall.EINVAL |
||||
} |
||||
} |
||||
return |
||||
} |
||||
|
||||
func write_console_output_character(h syscall.Handle, chars []wchar, pos coord) (err error) { |
||||
r0, _, e1 := syscall.Syscall6(proc_write_console_output_character.Addr(), |
||||
5, uintptr(h), uintptr(unsafe.Pointer(&chars[0])), uintptr(len(chars)), |
||||
pos.uintptr(), uintptr(unsafe.Pointer(&tmp_arg)), 0) |
||||
if int(r0) == 0 { |
||||
if e1 != 0 { |
||||
err = error(e1) |
||||
} else { |
||||
err = syscall.EINVAL |
||||
} |
||||
} |
||||
return |
||||
} |
||||
|
||||
func write_console_output_attribute(h syscall.Handle, attrs []word, pos coord) (err error) { |
||||
r0, _, e1 := syscall.Syscall6(proc_write_console_output_attribute.Addr(), |
||||
5, uintptr(h), uintptr(unsafe.Pointer(&attrs[0])), uintptr(len(attrs)), |
||||
pos.uintptr(), uintptr(unsafe.Pointer(&tmp_arg)), 0) |
||||
if int(r0) == 0 { |
||||
if e1 != 0 { |
||||
err = error(e1) |
||||
} else { |
||||
err = syscall.EINVAL |
||||
} |
||||
} |
||||
return |
||||
} |
||||
|
||||
func set_console_cursor_info(h syscall.Handle, info *console_cursor_info) (err error) { |
||||
r0, _, e1 := syscall.Syscall(proc_set_console_cursor_info.Addr(), |
||||
2, uintptr(h), uintptr(unsafe.Pointer(info)), 0) |
||||
if int(r0) == 0 { |
||||
if e1 != 0 { |
||||
err = error(e1) |
||||
} else { |
||||
err = syscall.EINVAL |
||||
} |
||||
} |
||||
return |
||||
} |
||||
|
||||
func get_console_cursor_info(h syscall.Handle, info *console_cursor_info) (err error) { |
||||
r0, _, e1 := syscall.Syscall(proc_get_console_cursor_info.Addr(), |
||||
2, uintptr(h), uintptr(unsafe.Pointer(info)), 0) |
||||
if int(r0) == 0 { |
||||
if e1 != 0 { |
||||
err = error(e1) |
||||
} else { |
||||
err = syscall.EINVAL |
||||
} |
||||
} |
||||
return |
||||
} |
||||
|
||||
func set_console_cursor_position(h syscall.Handle, pos coord) (err error) { |
||||
r0, _, e1 := syscall.Syscall(proc_set_console_cursor_position.Addr(), |
||||
2, uintptr(h), pos.uintptr(), 0) |
||||
if int(r0) == 0 { |
||||
if e1 != 0 { |
||||
err = error(e1) |
||||
} else { |
||||
err = syscall.EINVAL |
||||
} |
||||
} |
||||
return |
||||
} |
||||
|
||||
func read_console_input(h syscall.Handle, record *input_record) (err error) { |
||||
r0, _, e1 := syscall.Syscall6(proc_read_console_input.Addr(), |
||||
4, uintptr(h), uintptr(unsafe.Pointer(record)), 1, uintptr(unsafe.Pointer(&tmp_arg)), 0, 0) |
||||
if int(r0) == 0 { |
||||
if e1 != 0 { |
||||
err = error(e1) |
||||
} else { |
||||
err = syscall.EINVAL |
||||
} |
||||
} |
||||
return |
||||
} |
||||
|
||||
func get_console_mode(h syscall.Handle, mode *dword) (err error) { |
||||
r0, _, e1 := syscall.Syscall(proc_get_console_mode.Addr(), |
||||
2, uintptr(h), uintptr(unsafe.Pointer(mode)), 0) |
||||
if int(r0) == 0 { |
||||
if e1 != 0 { |
||||
err = error(e1) |
||||
} else { |
||||
err = syscall.EINVAL |
||||
} |
||||
} |
||||
return |
||||
} |
||||
|
||||
func set_console_mode(h syscall.Handle, mode dword) (err error) { |
||||
r0, _, e1 := syscall.Syscall(proc_set_console_mode.Addr(), |
||||
2, uintptr(h), uintptr(mode), 0) |
||||
if int(r0) == 0 { |
||||
if e1 != 0 { |
||||
err = error(e1) |
||||
} else { |
||||
err = syscall.EINVAL |
||||
} |
||||
} |
||||
return |
||||
} |
||||
|
||||
func fill_console_output_character(h syscall.Handle, char wchar, n int) (err error) { |
||||
r0, _, e1 := syscall.Syscall6(proc_fill_console_output_character.Addr(), |
||||
5, uintptr(h), uintptr(char), uintptr(n), tmp_coord.uintptr(), |
||||
uintptr(unsafe.Pointer(&tmp_arg)), 0) |
||||
if int(r0) == 0 { |
||||
if e1 != 0 { |
||||
err = error(e1) |
||||
} else { |
||||
err = syscall.EINVAL |
||||
} |
||||
} |
||||
return |
||||
} |
||||
|
||||
func fill_console_output_attribute(h syscall.Handle, attr word, n int) (err error) { |
||||
r0, _, e1 := syscall.Syscall6(proc_fill_console_output_attribute.Addr(), |
||||
5, uintptr(h), uintptr(attr), uintptr(n), tmp_coord.uintptr(), |
||||
uintptr(unsafe.Pointer(&tmp_arg)), 0) |
||||
if int(r0) == 0 { |
||||
if e1 != 0 { |
||||
err = error(e1) |
||||
} else { |
||||
err = syscall.EINVAL |
||||
} |
||||
} |
||||
return |
||||
} |
||||
|
||||
func create_event() (out syscall.Handle, err error) { |
||||
r0, _, e1 := syscall.Syscall6(proc_create_event.Addr(), |
||||
4, 0, 0, 0, 0, 0, 0) |
||||
if int(r0) == 0 { |
||||
if e1 != 0 { |
||||
err = error(e1) |
||||
} else { |
||||
err = syscall.EINVAL |
||||
} |
||||
} |
||||
return syscall.Handle(r0), err |
||||
} |
||||
|
||||
func wait_for_multiple_objects(objects []syscall.Handle) (err error) { |
||||
r0, _, e1 := syscall.Syscall6(proc_wait_for_multiple_objects.Addr(), |
||||
4, uintptr(len(objects)), uintptr(unsafe.Pointer(&objects[0])), |
||||
0, 0xFFFFFFFF, 0, 0) |
||||
if uint32(r0) == 0xFFFFFFFF { |
||||
if e1 != 0 { |
||||
err = error(e1) |
||||
} else { |
||||
err = syscall.EINVAL |
||||
} |
||||
} |
||||
return |
||||
} |
||||
|
||||
func set_event(ev syscall.Handle) (err error) { |
||||
r0, _, e1 := syscall.Syscall(proc_set_event.Addr(), |
||||
1, uintptr(ev), 0, 0) |
||||
if int(r0) == 0 { |
||||
if e1 != 0 { |
||||
err = error(e1) |
||||
} else { |
||||
err = syscall.EINVAL |
||||
} |
||||
} |
||||
return |
||||
} |
||||
|
||||
type diff_msg struct { |
||||
pos short |
||||
lines short |
||||
chars []char_info |
||||
} |
||||
|
||||
type input_event struct { |
||||
event Event |
||||
err error |
||||
} |
||||
|
||||
var ( |
||||
orig_cursor_info console_cursor_info |
||||
orig_size coord |
||||
orig_mode dword |
||||
orig_screen syscall.Handle |
||||
back_buffer cellbuf |
||||
front_buffer cellbuf |
||||
term_size coord |
||||
input_mode = InputEsc |
||||
cursor_x = cursor_hidden |
||||
cursor_y = cursor_hidden |
||||
foreground = ColorDefault |
||||
background = ColorDefault |
||||
in syscall.Handle |
||||
out syscall.Handle |
||||
interrupt syscall.Handle |
||||
charbuf []char_info |
||||
diffbuf []diff_msg |
||||
beg_x = -1 |
||||
beg_y = -1 |
||||
beg_i = -1 |
||||
input_comm = make(chan Event) |
||||
interrupt_comm = make(chan struct{}) |
||||
cancel_comm = make(chan bool, 1) |
||||
cancel_done_comm = make(chan bool) |
||||
alt_mode_esc = false |
||||
|
||||
// these ones just to prevent heap allocs at all costs
|
||||
tmp_info console_screen_buffer_info |
||||
tmp_arg dword |
||||
tmp_coord0 = coord{0, 0} |
||||
tmp_coord = coord{0, 0} |
||||
tmp_rect = small_rect{0, 0, 0, 0} |
||||
) |
||||
|
||||
func get_cursor_position(out syscall.Handle) coord { |
||||
err := get_console_screen_buffer_info(out, &tmp_info) |
||||
if err != nil { |
||||
panic(err) |
||||
} |
||||
return tmp_info.cursor_position |
||||
} |
||||
|
||||
func get_term_size(out syscall.Handle) coord { |
||||
err := get_console_screen_buffer_info(out, &tmp_info) |
||||
if err != nil { |
||||
panic(err) |
||||
} |
||||
return tmp_info.size |
||||
} |
||||
|
||||
func get_win_size(out syscall.Handle) coord { |
||||
err := get_console_screen_buffer_info(out, &tmp_info) |
||||
if err != nil { |
||||
panic(err) |
||||
} |
||||
return coord{ |
||||
x: tmp_info.window.right - tmp_info.window.left + 1, |
||||
y: tmp_info.window.bottom - tmp_info.window.top + 1, |
||||
} |
||||
} |
||||
|
||||
func update_size_maybe() { |
||||
size := get_term_size(out) |
||||
if size.x != term_size.x || size.y != term_size.y { |
||||
term_size = size |
||||
back_buffer.resize(int(size.x), int(size.y)) |
||||
front_buffer.resize(int(size.x), int(size.y)) |
||||
front_buffer.clear() |
||||
clear() |
||||
|
||||
area := int(size.x) * int(size.y) |
||||
if cap(charbuf) < area { |
||||
charbuf = make([]char_info, 0, area) |
||||
} |
||||
} |
||||
} |
||||
|
||||
var color_table_bg = []word{ |
||||
0, // default (black)
|
||||
0, // black
|
||||
background_red, |
||||
background_green, |
||||
background_red | background_green, // yellow
|
||||
background_blue, |
||||
background_red | background_blue, // magenta
|
||||
background_green | background_blue, // cyan
|
||||
background_red | background_blue | background_green, // white
|
||||
} |
||||
|
||||
var color_table_fg = []word{ |
||||
foreground_red | foreground_blue | foreground_green, // default (white)
|
||||
0, |
||||
foreground_red, |
||||
foreground_green, |
||||
foreground_red | foreground_green, // yellow
|
||||
foreground_blue, |
||||
foreground_red | foreground_blue, // magenta
|
||||
foreground_green | foreground_blue, // cyan
|
||||
foreground_red | foreground_blue | foreground_green, // white
|
||||
} |
||||
|
||||
const ( |
||||
replacement_char = '\uFFFD' |
||||
max_rune = '\U0010FFFF' |
||||
surr1 = 0xd800 |
||||
surr2 = 0xdc00 |
||||
surr3 = 0xe000 |
||||
surr_self = 0x10000 |
||||
) |
||||
|
||||
func append_diff_line(y int) int { |
||||
n := 0 |
||||
for x := 0; x < front_buffer.width; { |
||||
cell_offset := y*front_buffer.width + x |
||||
back := &back_buffer.cells[cell_offset] |
||||
front := &front_buffer.cells[cell_offset] |
||||
attr, char := cell_to_char_info(*back) |
||||
charbuf = append(charbuf, char_info{attr: attr, char: char[0]}) |
||||
*front = *back |
||||
n++ |
||||
w := runewidth.RuneWidth(back.Ch) |
||||
if w == 0 || w == 2 && runewidth.IsAmbiguousWidth(back.Ch) { |
||||
w = 1 |
||||
} |
||||
x += w |
||||
// If not CJK, fill trailing space with whitespace
|
||||
if !is_cjk && w == 2 { |
||||
charbuf = append(charbuf, char_info{attr: attr, char: ' '}) |
||||
} |
||||
} |
||||
return n |
||||
} |
||||
|
||||
// compares 'back_buffer' with 'front_buffer' and prepares all changes in the form of
|
||||
// 'diff_msg's in the 'diff_buf'
|
||||
func prepare_diff_messages() { |
||||
// clear buffers
|
||||
diffbuf = diffbuf[:0] |
||||
charbuf = charbuf[:0] |
||||
|
||||
var diff diff_msg |
||||
gbeg := 0 |
||||
for y := 0; y < front_buffer.height; y++ { |
||||
same := true |
||||
line_offset := y * front_buffer.width |
||||
for x := 0; x < front_buffer.width; x++ { |
||||
cell_offset := line_offset + x |
||||
back := &back_buffer.cells[cell_offset] |
||||
front := &front_buffer.cells[cell_offset] |
||||
if *back != *front { |
||||
same = false |
||||
break |
||||
} |
||||
} |
||||
if same && diff.lines > 0 { |
||||
diffbuf = append(diffbuf, diff) |
||||
diff = diff_msg{} |
||||
} |
||||
if !same { |
||||
beg := len(charbuf) |
||||
end := beg + append_diff_line(y) |
||||
if diff.lines == 0 { |
||||
diff.pos = short(y) |
||||
gbeg = beg |
||||
} |
||||
diff.lines++ |
||||
diff.chars = charbuf[gbeg:end] |
||||
} |
||||
} |
||||
if diff.lines > 0 { |
||||
diffbuf = append(diffbuf, diff) |
||||
diff = diff_msg{} |
||||
} |
||||
} |
||||
|
||||
func get_ct(table []word, idx int) word { |
||||
idx = idx & 0x0F |
||||
if idx >= len(table) { |
||||
idx = len(table) - 1 |
||||
} |
||||
return table[idx] |
||||
} |
||||
|
||||
func cell_to_char_info(c Cell) (attr word, wc [2]wchar) { |
||||
attr = get_ct(color_table_fg, int(c.Fg)) | get_ct(color_table_bg, int(c.Bg)) |
||||
if c.Fg&AttrReverse|c.Bg&AttrReverse != 0 { |
||||
attr = (attr&0xF0)>>4 | (attr&0x0F)<<4 |
||||
} |
||||
if c.Fg&AttrBold != 0 { |
||||
attr |= foreground_intensity |
||||
} |
||||
if c.Bg&AttrBold != 0 { |
||||
attr |= background_intensity |
||||
} |
||||
|
||||
r0, r1 := utf16.EncodeRune(c.Ch) |
||||
if r0 == 0xFFFD { |
||||
wc[0] = wchar(c.Ch) |
||||
wc[1] = ' ' |
||||
} else { |
||||
wc[0] = wchar(r0) |
||||
wc[1] = wchar(r1) |
||||
} |
||||
return |
||||
} |
||||
|
||||
func move_cursor(x, y int) { |
||||
err := set_console_cursor_position(out, coord{short(x), short(y)}) |
||||
if err != nil { |
||||
panic(err) |
||||
} |
||||
} |
||||
|
||||
func show_cursor(visible bool) { |
||||
var v int32 |
||||
if visible { |
||||
v = 1 |
||||
} |
||||
|
||||
var info console_cursor_info |
||||
info.size = 100 |
||||
info.visible = v |
||||
err := set_console_cursor_info(out, &info) |
||||
if err != nil { |
||||
panic(err) |
||||
} |
||||
} |
||||
|
||||
func clear() { |
||||
var err error |
||||
attr, char := cell_to_char_info(Cell{ |
||||
' ', |
||||
foreground, |
||||
background, |
||||
}) |
||||
|
||||
area := int(term_size.x) * int(term_size.y) |
||||
err = fill_console_output_attribute(out, attr, area) |
||||
if err != nil { |
||||
panic(err) |
||||
} |
||||
err = fill_console_output_character(out, char[0], area) |
||||
if err != nil { |
||||
panic(err) |
||||
} |
||||
if !is_cursor_hidden(cursor_x, cursor_y) { |
||||
move_cursor(cursor_x, cursor_y) |
||||
} |
||||
} |
||||
|
||||
func key_event_record_to_event(r *key_event_record) (Event, bool) { |
||||
if r.key_down == 0 { |
||||
return Event{}, false |
||||
} |
||||
|
||||
e := Event{Type: EventKey} |
||||
if input_mode&InputAlt != 0 { |
||||
if alt_mode_esc { |
||||
e.Mod = ModAlt |
||||
alt_mode_esc = false |
||||
} |
||||
if r.control_key_state&(left_alt_pressed|right_alt_pressed) != 0 { |
||||
e.Mod = ModAlt |
||||
} |
||||
} |
||||
|
||||
ctrlpressed := r.control_key_state&(left_ctrl_pressed|right_ctrl_pressed) != 0 |
||||
|
||||
if r.virtual_key_code >= vk_f1 && r.virtual_key_code <= vk_f12 { |
||||
switch r.virtual_key_code { |
||||
case vk_f1: |
||||
e.Key = KeyF1 |
||||
case vk_f2: |
||||
e.Key = KeyF2 |
||||
case vk_f3: |
||||
e.Key = KeyF3 |
||||
case vk_f4: |
||||
e.Key = KeyF4 |
||||
case vk_f5: |
||||
e.Key = KeyF5 |
||||
case vk_f6: |
||||
e.Key = KeyF6 |
||||
case vk_f7: |
||||
e.Key = KeyF7 |
||||
case vk_f8: |
||||
e.Key = KeyF8 |
||||
case vk_f9: |
||||
e.Key = KeyF9 |
||||
case vk_f10: |
||||
e.Key = KeyF10 |
||||
case vk_f11: |
||||
e.Key = KeyF11 |
||||
case vk_f12: |
||||
e.Key = KeyF12 |
||||
default: |
||||
panic("unreachable") |
||||
} |
||||
|
||||
return e, true |
||||
} |
||||
|
||||
if r.virtual_key_code <= vk_delete { |
||||
switch r.virtual_key_code { |
||||
case vk_insert: |
||||
e.Key = KeyInsert |
||||
case vk_delete: |
||||
e.Key = KeyDelete |
||||
case vk_home: |
||||
e.Key = KeyHome |
||||
case vk_end: |
||||
e.Key = KeyEnd |
||||
case vk_pgup: |
||||
e.Key = KeyPgup |
||||
case vk_pgdn: |
||||
e.Key = KeyPgdn |
||||
case vk_arrow_up: |
||||
e.Key = KeyArrowUp |
||||
case vk_arrow_down: |
||||
e.Key = KeyArrowDown |
||||
case vk_arrow_left: |
||||
e.Key = KeyArrowLeft |
||||
case vk_arrow_right: |
||||
e.Key = KeyArrowRight |
||||
case vk_backspace: |
||||
if ctrlpressed { |
||||
e.Key = KeyBackspace2 |
||||
} else { |
||||
e.Key = KeyBackspace |
||||
} |
||||
case vk_tab: |
||||
e.Key = KeyTab |
||||
case vk_enter: |
||||
e.Key = KeyEnter |
||||
case vk_esc: |
||||
switch { |
||||
case input_mode&InputEsc != 0: |
||||
e.Key = KeyEsc |
||||
case input_mode&InputAlt != 0: |
||||
alt_mode_esc = true |
||||
return Event{}, false |
||||
} |
||||
case vk_space: |
||||
if ctrlpressed { |
||||
// manual return here, because KeyCtrlSpace is zero
|
||||
e.Key = KeyCtrlSpace |
||||
return e, true |
||||
} else { |
||||
e.Key = KeySpace |
||||
} |
||||
} |
||||
|
||||
if e.Key != 0 { |
||||
return e, true |
||||
} |
||||
} |
||||
|
||||
if ctrlpressed { |
||||
if Key(r.unicode_char) >= KeyCtrlA && Key(r.unicode_char) <= KeyCtrlRsqBracket { |
||||
e.Key = Key(r.unicode_char) |
||||
if input_mode&InputAlt != 0 && e.Key == KeyEsc { |
||||
alt_mode_esc = true |
||||
return Event{}, false |
||||
} |
||||
return e, true |
||||
} |
||||
switch r.virtual_key_code { |
||||
case 192, 50: |
||||
// manual return here, because KeyCtrl2 is zero
|
||||
e.Key = KeyCtrl2 |
||||
return e, true |
||||
case 51: |
||||
if input_mode&InputAlt != 0 { |
||||
alt_mode_esc = true |
||||
return Event{}, false |
||||
} |
||||
e.Key = KeyCtrl3 |
||||
case 52: |
||||
e.Key = KeyCtrl4 |
||||
case 53: |
||||
e.Key = KeyCtrl5 |
||||
case 54: |
||||
e.Key = KeyCtrl6 |
||||
case 189, 191, 55: |
||||
e.Key = KeyCtrl7 |
||||
case 8, 56: |
||||
e.Key = KeyCtrl8 |
||||
} |
||||
|
||||
if e.Key != 0 { |
||||
return e, true |
||||
} |
||||
} |
||||
|
||||
if r.unicode_char != 0 { |
||||
e.Ch = rune(r.unicode_char) |
||||
return e, true |
||||
} |
||||
|
||||
return Event{}, false |
||||
} |
||||
|
||||
func input_event_producer() { |
||||
var r input_record |
||||
var err error |
||||
var last_button Key |
||||
var last_button_pressed Key |
||||
var last_state = dword(0) |
||||
var last_x, last_y = -1, -1 |
||||
handles := []syscall.Handle{in, interrupt} |
||||
for { |
||||
err = wait_for_multiple_objects(handles) |
||||
if err != nil { |
||||
input_comm <- Event{Type: EventError, Err: err} |
||||
} |
||||
|
||||
select { |
||||
case <-cancel_comm: |
||||
cancel_done_comm <- true |
||||
return |
||||
default: |
||||
} |
||||
|
||||
err = read_console_input(in, &r) |
||||
if err != nil { |
||||
input_comm <- Event{Type: EventError, Err: err} |
||||
} |
||||
|
||||
switch r.event_type { |
||||
case key_event: |
||||
kr := (*key_event_record)(unsafe.Pointer(&r.event)) |
||||
ev, ok := key_event_record_to_event(kr) |
||||
if ok { |
||||
for i := 0; i < int(kr.repeat_count); i++ { |
||||
input_comm <- ev |
||||
} |
||||
} |
||||
case window_buffer_size_event: |
||||
sr := *(*window_buffer_size_record)(unsafe.Pointer(&r.event)) |
||||
input_comm <- Event{ |
||||
Type: EventResize, |
||||
Width: int(sr.size.x), |
||||
Height: int(sr.size.y), |
||||
} |
||||
case mouse_event: |
||||
mr := *(*mouse_event_record)(unsafe.Pointer(&r.event)) |
||||
ev := Event{Type: EventMouse} |
||||
switch mr.event_flags { |
||||
case 0, 2: |
||||
// single or double click
|
||||
cur_state := mr.button_state |
||||
switch { |
||||
case last_state&mouse_lmb == 0 && cur_state&mouse_lmb != 0: |
||||
last_button = MouseLeft |
||||
last_button_pressed = last_button |
||||
case last_state&mouse_rmb == 0 && cur_state&mouse_rmb != 0: |
||||
last_button = MouseRight |
||||
last_button_pressed = last_button |
||||
case last_state&mouse_mmb == 0 && cur_state&mouse_mmb != 0: |
||||
last_button = MouseMiddle |
||||
last_button_pressed = last_button |
||||
case last_state&mouse_lmb != 0 && cur_state&mouse_lmb == 0: |
||||
last_button = MouseRelease |
||||
case last_state&mouse_rmb != 0 && cur_state&mouse_rmb == 0: |
||||
last_button = MouseRelease |
||||
case last_state&mouse_mmb != 0 && cur_state&mouse_mmb == 0: |
||||
last_button = MouseRelease |
||||
default: |
||||
last_state = cur_state |
||||
continue |
||||
} |
||||
last_state = cur_state |
||||
ev.Key = last_button |
||||
last_x, last_y = int(mr.mouse_pos.x), int(mr.mouse_pos.y) |
||||
ev.MouseX = last_x |
||||
ev.MouseY = last_y |
||||
case 1: |
||||
// mouse motion
|
||||
x, y := int(mr.mouse_pos.x), int(mr.mouse_pos.y) |
||||
if last_state != 0 && (last_x != x || last_y != y) { |
||||
ev.Key = last_button_pressed |
||||
ev.Mod = ModMotion |
||||
ev.MouseX = x |
||||
ev.MouseY = y |
||||
last_x, last_y = x, y |
||||
} else { |
||||
ev.Type = EventNone |
||||
} |
||||
case 4: |
||||
// mouse wheel
|
||||
n := int16(mr.button_state >> 16) |
||||
if n > 0 { |
||||
ev.Key = MouseWheelUp |
||||
} else { |
||||
ev.Key = MouseWheelDown |
||||
} |
||||
last_x, last_y = int(mr.mouse_pos.x), int(mr.mouse_pos.y) |
||||
ev.MouseX = last_x |
||||
ev.MouseY = last_y |
||||
default: |
||||
ev.Type = EventNone |
||||
} |
||||
if ev.Type != EventNone { |
||||
input_comm <- ev |
||||
} |
||||
} |
||||
} |
||||
} |
||||
@ -1,221 +0,0 @@ |
||||
// +build !windows
|
||||
// This file contains a simple and incomplete implementation of the terminfo
|
||||
// database. Information was taken from the ncurses manpages term(5) and
|
||||
// terminfo(5). Currently, only the string capabilities for special keys and for
|
||||
// functions without parameters are actually used. Colors are still done with
|
||||
// ANSI escape sequences. Other special features that are not (yet?) supported
|
||||
// are reading from ~/.terminfo, the TERMINFO_DIRS variable, Berkeley database
|
||||
// format and extended capabilities.
|
||||
|
||||
package termbox |
||||
|
||||
import ( |
||||
"bytes" |
||||
"encoding/binary" |
||||
"encoding/hex" |
||||
"errors" |
||||
"fmt" |
||||
"io/ioutil" |
||||
"os" |
||||
"strings" |
||||
) |
||||
|
||||
const ( |
||||
ti_magic = 0432 |
||||
ti_header_length = 12 |
||||
ti_mouse_enter = "\x1b[?1000h\x1b[?1002h\x1b[?1015h\x1b[?1006h" |
||||
ti_mouse_leave = "\x1b[?1006l\x1b[?1015l\x1b[?1002l\x1b[?1000l" |
||||
) |
||||
|
||||
func load_terminfo() ([]byte, error) { |
||||
var data []byte |
||||
var err error |
||||
|
||||
term := os.Getenv("TERM") |
||||
if term == "" { |
||||
return nil, fmt.Errorf("termbox: TERM not set") |
||||
} |
||||
|
||||
// The following behaviour follows the one described in terminfo(5) as
|
||||
// distributed by ncurses.
|
||||
|
||||
terminfo := os.Getenv("TERMINFO") |
||||
if terminfo != "" { |
||||
// if TERMINFO is set, no other directory should be searched
|
||||
return ti_try_path(terminfo) |
||||
} |
||||
|
||||
// next, consider ~/.terminfo
|
||||
home := os.Getenv("HOME") |
||||
if home != "" { |
||||
data, err = ti_try_path(home + "/.terminfo") |
||||
if err == nil { |
||||
return data, nil |
||||
} |
||||
} |
||||
|
||||
// next, TERMINFO_DIRS
|
||||
dirs := os.Getenv("TERMINFO_DIRS") |
||||
if dirs != "" { |
||||
for _, dir := range strings.Split(dirs, ":") { |
||||
if dir == "" { |
||||
// "" -> "/usr/share/terminfo"
|
||||
dir = "/usr/share/terminfo" |
||||
} |
||||
data, err = ti_try_path(dir) |
||||
if err == nil { |
||||
return data, nil |
||||
} |
||||
} |
||||
} |
||||
|
||||
// fall back to /usr/share/terminfo
|
||||
return ti_try_path("/usr/share/terminfo") |
||||
} |
||||
|
||||
func ti_try_path(path string) (data []byte, err error) { |
||||
// load_terminfo already made sure it is set
|
||||
term := os.Getenv("TERM") |
||||
|
||||
// first try, the typical *nix path
|
||||
terminfo := path + "/" + term[0:1] + "/" + term |
||||
data, err = ioutil.ReadFile(terminfo) |
||||
if err == nil { |
||||
return |
||||
} |
||||
|
||||
// fallback to darwin specific dirs structure
|
||||
terminfo = path + "/" + hex.EncodeToString([]byte(term[:1])) + "/" + term |
||||
data, err = ioutil.ReadFile(terminfo) |
||||
return |
||||
} |
||||
|
||||
func setup_term_builtin() error { |
||||
name := os.Getenv("TERM") |
||||
if name == "" { |
||||
return errors.New("termbox: TERM environment variable not set") |
||||
} |
||||
|
||||
for _, t := range terms { |
||||
if t.name == name { |
||||
keys = t.keys |
||||
funcs = t.funcs |
||||
return nil |
||||
} |
||||
} |
||||
|
||||
compat_table := []struct { |
||||
partial string |
||||
keys []string |
||||
funcs []string |
||||
}{ |
||||
{"xterm", xterm_keys, xterm_funcs}, |
||||
{"rxvt", rxvt_unicode_keys, rxvt_unicode_funcs}, |
||||
{"linux", linux_keys, linux_funcs}, |
||||
{"Eterm", eterm_keys, eterm_funcs}, |
||||
{"screen", screen_keys, screen_funcs}, |
||||
// let's assume that 'cygwin' is xterm compatible
|
||||
{"cygwin", xterm_keys, xterm_funcs}, |
||||
{"st", xterm_keys, xterm_funcs}, |
||||
} |
||||
|
||||
// try compatibility variants
|
||||
for _, it := range compat_table { |
||||
if strings.Contains(name, it.partial) { |
||||
keys = it.keys |
||||
funcs = it.funcs |
||||
return nil |
||||
} |
||||
} |
||||
|
||||
return errors.New("termbox: unsupported terminal") |
||||
} |
||||
|
||||
func setup_term() (err error) { |
||||
var data []byte |
||||
var header [6]int16 |
||||
var str_offset, table_offset int16 |
||||
|
||||
data, err = load_terminfo() |
||||
if err != nil { |
||||
return setup_term_builtin() |
||||
} |
||||
|
||||
rd := bytes.NewReader(data) |
||||
// 0: magic number, 1: size of names section, 2: size of boolean section, 3:
|
||||
// size of numbers section (in integers), 4: size of the strings section (in
|
||||
// integers), 5: size of the string table
|
||||
|
||||
err = binary.Read(rd, binary.LittleEndian, header[:]) |
||||
if err != nil { |
||||
return |
||||
} |
||||
|
||||
if (header[1]+header[2])%2 != 0 { |
||||
// old quirk to align everything on word boundaries
|
||||
header[2] += 1 |
||||
} |
||||
str_offset = ti_header_length + header[1] + header[2] + 2*header[3] |
||||
table_offset = str_offset + 2*header[4] |
||||
|
||||
keys = make([]string, 0xFFFF-key_min) |
||||
for i, _ := range keys { |
||||
keys[i], err = ti_read_string(rd, str_offset+2*ti_keys[i], table_offset) |
||||
if err != nil { |
||||
return |
||||
} |
||||
} |
||||
funcs = make([]string, t_max_funcs) |
||||
// the last two entries are reserved for mouse. because the table offset is
|
||||
// not there, the two entries have to fill in manually
|
||||
for i, _ := range funcs[:len(funcs)-2] { |
||||
funcs[i], err = ti_read_string(rd, str_offset+2*ti_funcs[i], table_offset) |
||||
if err != nil { |
||||
return |
||||
} |
||||
} |
||||
funcs[t_max_funcs-2] = ti_mouse_enter |
||||
funcs[t_max_funcs-1] = ti_mouse_leave |
||||
return nil |
||||
} |
||||
|
||||
func ti_read_string(rd *bytes.Reader, str_off, table int16) (string, error) { |
||||
var off int16 |
||||
|
||||
_, err := rd.Seek(int64(str_off), 0) |
||||
if err != nil { |
||||
return "", err |
||||
} |
||||
err = binary.Read(rd, binary.LittleEndian, &off) |
||||
if err != nil { |
||||
return "", err |
||||
} |
||||
_, err = rd.Seek(int64(table+off), 0) |
||||
if err != nil { |
||||
return "", err |
||||
} |
||||
var bs []byte |
||||
for { |
||||
b, err := rd.ReadByte() |
||||
if err != nil { |
||||
return "", err |
||||
} |
||||
if b == byte(0x00) { |
||||
break |
||||
} |
||||
bs = append(bs, b) |
||||
} |
||||
return string(bs), nil |
||||
} |
||||
|
||||
// "Maps" the function constants from termbox.go to the number of the respective
|
||||
// string capability in the terminfo file. Taken from (ncurses) term.h.
|
||||
var ti_funcs = []int16{ |
||||
28, 40, 16, 13, 5, 39, 36, 27, 26, 34, 89, 88, |
||||
} |
||||
|
||||
// Same as above for the special keys.
|
||||
var ti_keys = []int16{ |
||||
66, 68 /* apparently not a typo; 67 is F10 for whatever reason */, 69, 70, |
||||
71, 72, 73, 74, 75, 67, 216, 217, 77, 59, 76, 164, 82, 81, 87, 61, 79, 83, |
||||
} |
||||
@ -1,64 +0,0 @@ |
||||
// +build !windows
|
||||
|
||||
package termbox |
||||
|
||||
// Eterm
|
||||
var eterm_keys = []string{ |
||||
"\x1b[11~", "\x1b[12~", "\x1b[13~", "\x1b[14~", "\x1b[15~", "\x1b[17~", "\x1b[18~", "\x1b[19~", "\x1b[20~", "\x1b[21~", "\x1b[23~", "\x1b[24~", "\x1b[2~", "\x1b[3~", "\x1b[7~", "\x1b[8~", "\x1b[5~", "\x1b[6~", "\x1b[A", "\x1b[B", "\x1b[D", "\x1b[C", |
||||
} |
||||
var eterm_funcs = []string{ |
||||
"\x1b7\x1b[?47h", "\x1b[2J\x1b[?47l\x1b8", "\x1b[?25h", "\x1b[?25l", "\x1b[H\x1b[2J", "\x1b[m\x0f", "\x1b[4m", "\x1b[1m", "\x1b[5m", "\x1b[7m", "", "", "", "", |
||||
} |
||||
|
||||
// screen
|
||||
var screen_keys = []string{ |
||||
"\x1bOP", "\x1bOQ", "\x1bOR", "\x1bOS", "\x1b[15~", "\x1b[17~", "\x1b[18~", "\x1b[19~", "\x1b[20~", "\x1b[21~", "\x1b[23~", "\x1b[24~", "\x1b[2~", "\x1b[3~", "\x1b[1~", "\x1b[4~", "\x1b[5~", "\x1b[6~", "\x1bOA", "\x1bOB", "\x1bOD", "\x1bOC", |
||||
} |
||||
var screen_funcs = []string{ |
||||
"\x1b[?1049h", "\x1b[?1049l", "\x1b[34h\x1b[?25h", "\x1b[?25l", "\x1b[H\x1b[J", "\x1b[m\x0f", "\x1b[4m", "\x1b[1m", "\x1b[5m", "\x1b[7m", "\x1b[?1h\x1b=", "\x1b[?1l\x1b>", ti_mouse_enter, ti_mouse_leave, |
||||
} |
||||
|
||||
// xterm
|
||||
var xterm_keys = []string{ |
||||
"\x1bOP", "\x1bOQ", "\x1bOR", "\x1bOS", "\x1b[15~", "\x1b[17~", "\x1b[18~", "\x1b[19~", "\x1b[20~", "\x1b[21~", "\x1b[23~", "\x1b[24~", "\x1b[2~", "\x1b[3~", "\x1bOH", "\x1bOF", "\x1b[5~", "\x1b[6~", "\x1bOA", "\x1bOB", "\x1bOD", "\x1bOC", |
||||
} |
||||
var xterm_funcs = []string{ |
||||
"\x1b[?1049h", "\x1b[?1049l", "\x1b[?12l\x1b[?25h", "\x1b[?25l", "\x1b[H\x1b[2J", "\x1b(B\x1b[m", "\x1b[4m", "\x1b[1m", "\x1b[5m", "\x1b[7m", "\x1b[?1h\x1b=", "\x1b[?1l\x1b>", ti_mouse_enter, ti_mouse_leave, |
||||
} |
||||
|
||||
// rxvt-unicode
|
||||
var rxvt_unicode_keys = []string{ |
||||
"\x1b[11~", "\x1b[12~", "\x1b[13~", "\x1b[14~", "\x1b[15~", "\x1b[17~", "\x1b[18~", "\x1b[19~", "\x1b[20~", "\x1b[21~", "\x1b[23~", "\x1b[24~", "\x1b[2~", "\x1b[3~", "\x1b[7~", "\x1b[8~", "\x1b[5~", "\x1b[6~", "\x1b[A", "\x1b[B", "\x1b[D", "\x1b[C", |
||||
} |
||||
var rxvt_unicode_funcs = []string{ |
||||
"\x1b[?1049h", "\x1b[r\x1b[?1049l", "\x1b[?25h", "\x1b[?25l", "\x1b[H\x1b[2J", "\x1b[m\x1b(B", "\x1b[4m", "\x1b[1m", "\x1b[5m", "\x1b[7m", "\x1b=", "\x1b>", ti_mouse_enter, ti_mouse_leave, |
||||
} |
||||
|
||||
// linux
|
||||
var linux_keys = []string{ |
||||
"\x1b[[A", "\x1b[[B", "\x1b[[C", "\x1b[[D", "\x1b[[E", "\x1b[17~", "\x1b[18~", "\x1b[19~", "\x1b[20~", "\x1b[21~", "\x1b[23~", "\x1b[24~", "\x1b[2~", "\x1b[3~", "\x1b[1~", "\x1b[4~", "\x1b[5~", "\x1b[6~", "\x1b[A", "\x1b[B", "\x1b[D", "\x1b[C", |
||||
} |
||||
var linux_funcs = []string{ |
||||
"", "", "\x1b[?25h\x1b[?0c", "\x1b[?25l\x1b[?1c", "\x1b[H\x1b[J", "\x1b[0;10m", "\x1b[4m", "\x1b[1m", "\x1b[5m", "\x1b[7m", "", "", "", "", |
||||
} |
||||
|
||||
// rxvt-256color
|
||||
var rxvt_256color_keys = []string{ |
||||
"\x1b[11~", "\x1b[12~", "\x1b[13~", "\x1b[14~", "\x1b[15~", "\x1b[17~", "\x1b[18~", "\x1b[19~", "\x1b[20~", "\x1b[21~", "\x1b[23~", "\x1b[24~", "\x1b[2~", "\x1b[3~", "\x1b[7~", "\x1b[8~", "\x1b[5~", "\x1b[6~", "\x1b[A", "\x1b[B", "\x1b[D", "\x1b[C", |
||||
} |
||||
var rxvt_256color_funcs = []string{ |
||||
"\x1b7\x1b[?47h", "\x1b[2J\x1b[?47l\x1b8", "\x1b[?25h", "\x1b[?25l", "\x1b[H\x1b[2J", "\x1b[m\x0f", "\x1b[4m", "\x1b[1m", "\x1b[5m", "\x1b[7m", "\x1b=", "\x1b>", ti_mouse_enter, ti_mouse_leave, |
||||
} |
||||
|
||||
var terms = []struct { |
||||
name string |
||||
keys []string |
||||
funcs []string |
||||
}{ |
||||
{"Eterm", eterm_keys, eterm_funcs}, |
||||
{"screen", screen_keys, screen_funcs}, |
||||
{"xterm", xterm_keys, xterm_funcs}, |
||||
{"rxvt-unicode", rxvt_unicode_keys, rxvt_unicode_funcs}, |
||||
{"linux", linux_keys, linux_funcs}, |
||||
{"rxvt-256color", rxvt_256color_keys, rxvt_256color_funcs}, |
||||
} |
||||
@ -1,10 +0,0 @@ |
||||
# Treat all files in this repo as binary, with no git magic updating |
||||
# line endings. Windows users contributing to Go will need to use a |
||||
# modern version of git and editors capable of LF line endings. |
||||
# |
||||
# We'll prevent accidental CRLF line endings from entering the repo |
||||
# via the git-review gofmt checks. |
||||
# |
||||
# See golang.org/issue/9281 |
||||
|
||||
* -text |
||||
@ -1,2 +0,0 @@ |
||||
# Add no patterns to .hgignore except for files generated by the build. |
||||
last-change |
||||
@ -1,3 +0,0 @@ |
||||
# This source code refers to The Go Authors for copyright purposes. |
||||
# The master list of authors is in the main Go distribution, |
||||
# visible at http://tip.golang.org/AUTHORS. |
||||
@ -1,31 +0,0 @@ |
||||
# Contributing to Go |
||||
|
||||
Go is an open source project. |
||||
|
||||
It is the work of hundreds of contributors. We appreciate your help! |
||||
|
||||
|
||||
## Filing issues |
||||
|
||||
When [filing an issue](https://golang.org/issue/new), make sure to answer these five questions: |
||||
|
||||
1. What version of Go are you using (`go version`)? |
||||
2. What operating system and processor architecture are you using? |
||||
3. What did you do? |
||||
4. What did you expect to see? |
||||
5. What did you see instead? |
||||
|
||||
General questions should go to the [golang-nuts mailing list](https://groups.google.com/group/golang-nuts) instead of the issue tracker. |
||||
The gophers there will answer or ask you to file an issue if you've tripped over a bug. |
||||
|
||||
## Contributing code |
||||
|
||||
Please read the [Contribution Guidelines](https://golang.org/doc/contribute.html) |
||||
before sending patches. |
||||
|
||||
**We do not accept GitHub pull requests** |
||||
(we use [Gerrit](https://code.google.com/p/gerrit/) instead for code review). |
||||
|
||||
Unless otherwise noted, the Go source files are distributed under |
||||
the BSD-style license found in the LICENSE file. |
||||
|
||||
@ -1,3 +0,0 @@ |
||||
# This source code was written by the Go contributors. |
||||
# The master list of contributors is in the main Go distribution, |
||||
# visible at http://tip.golang.org/CONTRIBUTORS. |
||||
@ -1,3 +0,0 @@ |
||||
This repository holds supplementary Go networking libraries. |
||||
|
||||
To submit changes to this repository, see http://golang.org/doc/contribute.html. |
||||
@ -1 +0,0 @@ |
||||
issuerepo: golang/go |
||||
@ -0,0 +1,20 @@ |
||||
// Copyright 2017 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
// +build go1.9
|
||||
|
||||
package context |
||||
|
||||
import "context" // standard library's context, as of Go 1.7
|
||||
|
||||
// A Context carries a deadline, a cancelation signal, and other values across
|
||||
// API boundaries.
|
||||
//
|
||||
// Context's methods may be called by multiple goroutines simultaneously.
|
||||
type Context = context.Context |
||||
|
||||
// A CancelFunc tells an operation to abandon its work.
|
||||
// A CancelFunc does not wait for the work to stop.
|
||||
// After the first call, subsequent calls to a CancelFunc do nothing.
|
||||
type CancelFunc = context.CancelFunc |
||||
@ -0,0 +1,109 @@ |
||||
// Copyright 2014 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
// +build !go1.9
|
||||
|
||||
package context |
||||
|
||||
import "time" |
||||
|
||||
// A Context carries a deadline, a cancelation signal, and other values across
|
||||
// API boundaries.
|
||||
//
|
||||
// Context's methods may be called by multiple goroutines simultaneously.
|
||||
type Context interface { |
||||
// Deadline returns the time when work done on behalf of this context
|
||||
// should be canceled. Deadline returns ok==false when no deadline is
|
||||
// set. Successive calls to Deadline return the same results.
|
||||
Deadline() (deadline time.Time, ok bool) |
||||
|
||||
// Done returns a channel that's closed when work done on behalf of this
|
||||
// context should be canceled. Done may return nil if this context can
|
||||
// never be canceled. Successive calls to Done return the same value.
|
||||
//
|
||||
// WithCancel arranges for Done to be closed when cancel is called;
|
||||
// WithDeadline arranges for Done to be closed when the deadline
|
||||
// expires; WithTimeout arranges for Done to be closed when the timeout
|
||||
// elapses.
|
||||
//
|
||||
// Done is provided for use in select statements:
|
||||
//
|
||||
// // Stream generates values with DoSomething and sends them to out
|
||||
// // until DoSomething returns an error or ctx.Done is closed.
|
||||
// func Stream(ctx context.Context, out chan<- Value) error {
|
||||
// for {
|
||||
// v, err := DoSomething(ctx)
|
||||
// if err != nil {
|
||||
// return err
|
||||
// }
|
||||
// select {
|
||||
// case <-ctx.Done():
|
||||
// return ctx.Err()
|
||||
// case out <- v:
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// See http://blog.golang.org/pipelines for more examples of how to use
|
||||
// a Done channel for cancelation.
|
||||
Done() <-chan struct{} |
||||
|
||||
// Err returns a non-nil error value after Done is closed. Err returns
|
||||
// Canceled if the context was canceled or DeadlineExceeded if the
|
||||
// context's deadline passed. No other values for Err are defined.
|
||||
// After Done is closed, successive calls to Err return the same value.
|
||||
Err() error |
||||
|
||||
// Value returns the value associated with this context for key, or nil
|
||||
// if no value is associated with key. Successive calls to Value with
|
||||
// the same key returns the same result.
|
||||
//
|
||||
// Use context values only for request-scoped data that transits
|
||||
// processes and API boundaries, not for passing optional parameters to
|
||||
// functions.
|
||||
//
|
||||
// A key identifies a specific value in a Context. Functions that wish
|
||||
// to store values in Context typically allocate a key in a global
|
||||
// variable then use that key as the argument to context.WithValue and
|
||||
// Context.Value. A key can be any type that supports equality;
|
||||
// packages should define keys as an unexported type to avoid
|
||||
// collisions.
|
||||
//
|
||||
// Packages that define a Context key should provide type-safe accessors
|
||||
// for the values stores using that key:
|
||||
//
|
||||
// // Package user defines a User type that's stored in Contexts.
|
||||
// package user
|
||||
//
|
||||
// import "golang.org/x/net/context"
|
||||
//
|
||||
// // User is the type of value stored in the Contexts.
|
||||
// type User struct {...}
|
||||
//
|
||||
// // key is an unexported type for keys defined in this package.
|
||||
// // This prevents collisions with keys defined in other packages.
|
||||
// type key int
|
||||
//
|
||||
// // userKey is the key for user.User values in Contexts. It is
|
||||
// // unexported; clients use user.NewContext and user.FromContext
|
||||
// // instead of using this key directly.
|
||||
// var userKey key = 0
|
||||
//
|
||||
// // NewContext returns a new Context that carries value u.
|
||||
// func NewContext(ctx context.Context, u *User) context.Context {
|
||||
// return context.WithValue(ctx, userKey, u)
|
||||
// }
|
||||
//
|
||||
// // FromContext returns the User value stored in ctx, if any.
|
||||
// func FromContext(ctx context.Context) (*User, bool) {
|
||||
// u, ok := ctx.Value(userKey).(*User)
|
||||
// return u, ok
|
||||
// }
|
||||
Value(key interface{}) interface{} |
||||
} |
||||
|
||||
// A CancelFunc tells an operation to abandon its work.
|
||||
// A CancelFunc does not wait for the work to stop.
|
||||
// After the first call, subsequent calls to a CancelFunc do nothing.
|
||||
type CancelFunc func() |
||||
@ -1,648 +0,0 @@ |
||||
// Copyright 2012 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
// +build ignore
|
||||
|
||||
package main |
||||
|
||||
// This program generates table.go and table_test.go.
|
||||
// Invoke as
|
||||
//
|
||||
// go run gen.go |gofmt >table.go
|
||||
// go run gen.go -test |gofmt >table_test.go
|
||||
|
||||
import ( |
||||
"flag" |
||||
"fmt" |
||||
"math/rand" |
||||
"os" |
||||
"sort" |
||||
"strings" |
||||
) |
||||
|
||||
// identifier converts s to a Go exported identifier.
|
||||
// It converts "div" to "Div" and "accept-charset" to "AcceptCharset".
|
||||
func identifier(s string) string { |
||||
b := make([]byte, 0, len(s)) |
||||
cap := true |
||||
for _, c := range s { |
||||
if c == '-' { |
||||
cap = true |
||||
continue |
||||
} |
||||
if cap && 'a' <= c && c <= 'z' { |
||||
c -= 'a' - 'A' |
||||
} |
||||
cap = false |
||||
b = append(b, byte(c)) |
||||
} |
||||
return string(b) |
||||
} |
||||
|
||||
var test = flag.Bool("test", false, "generate table_test.go") |
||||
|
||||
func main() { |
||||
flag.Parse() |
||||
|
||||
var all []string |
||||
all = append(all, elements...) |
||||
all = append(all, attributes...) |
||||
all = append(all, eventHandlers...) |
||||
all = append(all, extra...) |
||||
sort.Strings(all) |
||||
|
||||
if *test { |
||||
fmt.Printf("// generated by go run gen.go -test; DO NOT EDIT\n\n") |
||||
fmt.Printf("package atom\n\n") |
||||
fmt.Printf("var testAtomList = []string{\n") |
||||
for _, s := range all { |
||||
fmt.Printf("\t%q,\n", s) |
||||
} |
||||
fmt.Printf("}\n") |
||||
return |
||||
} |
||||
|
||||
// uniq - lists have dups
|
||||
// compute max len too
|
||||
maxLen := 0 |
||||
w := 0 |
||||
for _, s := range all { |
||||
if w == 0 || all[w-1] != s { |
||||
if maxLen < len(s) { |
||||
maxLen = len(s) |
||||
} |
||||
all[w] = s |
||||
w++ |
||||
} |
||||
} |
||||
all = all[:w] |
||||
|
||||
// Find hash that minimizes table size.
|
||||
var best *table |
||||
for i := 0; i < 1000000; i++ { |
||||
if best != nil && 1<<(best.k-1) < len(all) { |
||||
break |
||||
} |
||||
h := rand.Uint32() |
||||
for k := uint(0); k <= 16; k++ { |
||||
if best != nil && k >= best.k { |
||||
break |
||||
} |
||||
var t table |
||||
if t.init(h, k, all) { |
||||
best = &t |
||||
break |
||||
} |
||||
} |
||||
} |
||||
if best == nil { |
||||
fmt.Fprintf(os.Stderr, "failed to construct string table\n") |
||||
os.Exit(1) |
||||
} |
||||
|
||||
// Lay out strings, using overlaps when possible.
|
||||
layout := append([]string{}, all...) |
||||
|
||||
// Remove strings that are substrings of other strings
|
||||
for changed := true; changed; { |
||||
changed = false |
||||
for i, s := range layout { |
||||
if s == "" { |
||||
continue |
||||
} |
||||
for j, t := range layout { |
||||
if i != j && t != "" && strings.Contains(s, t) { |
||||
changed = true |
||||
layout[j] = "" |
||||
} |
||||
} |
||||
} |
||||
} |
||||
|
||||
// Join strings where one suffix matches another prefix.
|
||||
for { |
||||
// Find best i, j, k such that layout[i][len-k:] == layout[j][:k],
|
||||
// maximizing overlap length k.
|
||||
besti := -1 |
||||
bestj := -1 |
||||
bestk := 0 |
||||
for i, s := range layout { |
||||
if s == "" { |
||||
continue |
||||
} |
||||
for j, t := range layout { |
||||
if i == j { |
||||
continue |
||||
} |
||||
for k := bestk + 1; k <= len(s) && k <= len(t); k++ { |
||||
if s[len(s)-k:] == t[:k] { |
||||
besti = i |
||||
bestj = j |
||||
bestk = k |
||||
} |
||||
} |
||||
} |
||||
} |
||||
if bestk > 0 { |
||||
layout[besti] += layout[bestj][bestk:] |
||||
layout[bestj] = "" |
||||
continue |
||||
} |
||||
break |
||||
} |
||||
|
||||
text := strings.Join(layout, "") |
||||
|
||||
atom := map[string]uint32{} |
||||
for _, s := range all { |
||||
off := strings.Index(text, s) |
||||
if off < 0 { |
||||
panic("lost string " + s) |
||||
} |
||||
atom[s] = uint32(off<<8 | len(s)) |
||||
} |
||||
|
||||
// Generate the Go code.
|
||||
fmt.Printf("// generated by go run gen.go; DO NOT EDIT\n\n") |
||||
fmt.Printf("package atom\n\nconst (\n") |
||||
for _, s := range all { |
||||
fmt.Printf("\t%s Atom = %#x\n", identifier(s), atom[s]) |
||||
} |
||||
fmt.Printf(")\n\n") |
||||
|
||||
fmt.Printf("const hash0 = %#x\n\n", best.h0) |
||||
fmt.Printf("const maxAtomLen = %d\n\n", maxLen) |
||||
|
||||
fmt.Printf("var table = [1<<%d]Atom{\n", best.k) |
||||
for i, s := range best.tab { |
||||
if s == "" { |
||||
continue |
||||
} |
||||
fmt.Printf("\t%#x: %#x, // %s\n", i, atom[s], s) |
||||
} |
||||
fmt.Printf("}\n") |
||||
datasize := (1 << best.k) * 4 |
||||
|
||||
fmt.Printf("const atomText =\n") |
||||
textsize := len(text) |
||||
for len(text) > 60 { |
||||
fmt.Printf("\t%q +\n", text[:60]) |
||||
text = text[60:] |
||||
} |
||||
fmt.Printf("\t%q\n\n", text) |
||||
|
||||
fmt.Fprintf(os.Stderr, "%d atoms; %d string bytes + %d tables = %d total data\n", len(all), textsize, datasize, textsize+datasize) |
||||
} |
||||
|
||||
type byLen []string |
||||
|
||||
func (x byLen) Less(i, j int) bool { return len(x[i]) > len(x[j]) } |
||||
func (x byLen) Swap(i, j int) { x[i], x[j] = x[j], x[i] } |
||||
func (x byLen) Len() int { return len(x) } |
||||
|
||||
// fnv computes the FNV hash with an arbitrary starting value h.
|
||||
func fnv(h uint32, s string) uint32 { |
||||
for i := 0; i < len(s); i++ { |
||||
h ^= uint32(s[i]) |
||||
h *= 16777619 |
||||
} |
||||
return h |
||||
} |
||||
|
||||
// A table represents an attempt at constructing the lookup table.
|
||||
// The lookup table uses cuckoo hashing, meaning that each string
|
||||
// can be found in one of two positions.
|
||||
type table struct { |
||||
h0 uint32 |
||||
k uint |
||||
mask uint32 |
||||
tab []string |
||||
} |
||||
|
||||
// hash returns the two hashes for s.
|
||||
func (t *table) hash(s string) (h1, h2 uint32) { |
||||
h := fnv(t.h0, s) |
||||
h1 = h & t.mask |
||||
h2 = (h >> 16) & t.mask |
||||
return |
||||
} |
||||
|
||||
// init initializes the table with the given parameters.
|
||||
// h0 is the initial hash value,
|
||||
// k is the number of bits of hash value to use, and
|
||||
// x is the list of strings to store in the table.
|
||||
// init returns false if the table cannot be constructed.
|
||||
func (t *table) init(h0 uint32, k uint, x []string) bool { |
||||
t.h0 = h0 |
||||
t.k = k |
||||
t.tab = make([]string, 1<<k) |
||||
t.mask = 1<<k - 1 |
||||
for _, s := range x { |
||||
if !t.insert(s) { |
||||
return false |
||||
} |
||||
} |
||||
return true |
||||
} |
||||
|
||||
// insert inserts s in the table.
|
||||
func (t *table) insert(s string) bool { |
||||
h1, h2 := t.hash(s) |
||||
if t.tab[h1] == "" { |
||||
t.tab[h1] = s |
||||
return true |
||||
} |
||||
if t.tab[h2] == "" { |
||||
t.tab[h2] = s |
||||
return true |
||||
} |
||||
if t.push(h1, 0) { |
||||
t.tab[h1] = s |
||||
return true |
||||
} |
||||
if t.push(h2, 0) { |
||||
t.tab[h2] = s |
||||
return true |
||||
} |
||||
return false |
||||
} |
||||
|
||||
// push attempts to push aside the entry in slot i.
|
||||
func (t *table) push(i uint32, depth int) bool { |
||||
if depth > len(t.tab) { |
||||
return false |
||||
} |
||||
s := t.tab[i] |
||||
h1, h2 := t.hash(s) |
||||
j := h1 + h2 - i |
||||
if t.tab[j] != "" && !t.push(j, depth+1) { |
||||
return false |
||||
} |
||||
t.tab[j] = s |
||||
return true |
||||
} |
||||
|
||||
// The lists of element names and attribute keys were taken from
|
||||
// https://html.spec.whatwg.org/multipage/indices.html#index
|
||||
// as of the "HTML Living Standard - Last Updated 21 February 2015" version.
|
||||
|
||||
var elements = []string{ |
||||
"a", |
||||
"abbr", |
||||
"address", |
||||
"area", |
||||
"article", |
||||
"aside", |
||||
"audio", |
||||
"b", |
||||
"base", |
||||
"bdi", |
||||
"bdo", |
||||
"blockquote", |
||||
"body", |
||||
"br", |
||||
"button", |
||||
"canvas", |
||||
"caption", |
||||
"cite", |
||||
"code", |
||||
"col", |
||||
"colgroup", |
||||
"command", |
||||
"data", |
||||
"datalist", |
||||
"dd", |
||||
"del", |
||||
"details", |
||||
"dfn", |
||||
"dialog", |
||||
"div", |
||||
"dl", |
||||
"dt", |
||||
"em", |
||||
"embed", |
||||
"fieldset", |
||||
"figcaption", |
||||
"figure", |
||||
"footer", |
||||
"form", |
||||
"h1", |
||||
"h2", |
||||
"h3", |
||||
"h4", |
||||
"h5", |
||||
"h6", |
||||
"head", |
||||
"header", |
||||
"hgroup", |
||||
"hr", |
||||
"html", |
||||
"i", |
||||
"iframe", |
||||
"img", |
||||
"input", |
||||
"ins", |
||||
"kbd", |
||||
"keygen", |
||||
"label", |
||||
"legend", |
||||
"li", |
||||
"link", |
||||
"map", |
||||
"mark", |
||||
"menu", |
||||
"menuitem", |
||||
"meta", |
||||
"meter", |
||||
"nav", |
||||
"noscript", |
||||
"object", |
||||
"ol", |
||||
"optgroup", |
||||
"option", |
||||
"output", |
||||
"p", |
||||
"param", |
||||
"pre", |
||||
"progress", |
||||
"q", |
||||
"rp", |
||||
"rt", |
||||
"ruby", |
||||
"s", |
||||
"samp", |
||||
"script", |
||||
"section", |
||||
"select", |
||||
"small", |
||||
"source", |
||||
"span", |
||||
"strong", |
||||
"style", |
||||
"sub", |
||||
"summary", |
||||
"sup", |
||||
"table", |
||||
"tbody", |
||||
"td", |
||||
"template", |
||||
"textarea", |
||||
"tfoot", |
||||
"th", |
||||
"thead", |
||||
"time", |
||||
"title", |
||||
"tr", |
||||
"track", |
||||
"u", |
||||
"ul", |
||||
"var", |
||||
"video", |
||||
"wbr", |
||||
} |
||||
|
||||
// https://html.spec.whatwg.org/multipage/indices.html#attributes-3
|
||||
|
||||
var attributes = []string{ |
||||
"abbr", |
||||
"accept", |
||||
"accept-charset", |
||||
"accesskey", |
||||
"action", |
||||
"alt", |
||||
"async", |
||||
"autocomplete", |
||||
"autofocus", |
||||
"autoplay", |
||||
"challenge", |
||||
"charset", |
||||
"checked", |
||||
"cite", |
||||
"class", |
||||
"cols", |
||||
"colspan", |
||||
"command", |
||||
"content", |
||||
"contenteditable", |
||||
"contextmenu", |
||||
"controls", |
||||
"coords", |
||||
"crossorigin", |
||||
"data", |
||||
"datetime", |
||||
"default", |
||||
"defer", |
||||
"dir", |
||||
"dirname", |
||||
"disabled", |
||||
"download", |
||||
"draggable", |
||||
"dropzone", |
||||
"enctype", |
||||
"for", |
||||
"form", |
||||
"formaction", |
||||
"formenctype", |
||||
"formmethod", |
||||
"formnovalidate", |
||||
"formtarget", |
||||
"headers", |
||||
"height", |
||||
"hidden", |
||||
"high", |
||||
"href", |
||||
"hreflang", |
||||
"http-equiv", |
||||
"icon", |
||||
"id", |
||||
"inputmode", |
||||
"ismap", |
||||
"itemid", |
||||
"itemprop", |
||||
"itemref", |
||||
"itemscope", |
||||
"itemtype", |
||||
"keytype", |
||||
"kind", |
||||
"label", |
||||
"lang", |
||||
"list", |
||||
"loop", |
||||
"low", |
||||
"manifest", |
||||
"max", |
||||
"maxlength", |
||||
"media", |
||||
"mediagroup", |
||||
"method", |
||||
"min", |
||||
"minlength", |
||||
"multiple", |
||||
"muted", |
||||
"name", |
||||
"novalidate", |
||||
"open", |
||||
"optimum", |
||||
"pattern", |
||||
"ping", |
||||
"placeholder", |
||||
"poster", |
||||
"preload", |
||||
"radiogroup", |
||||
"readonly", |
||||
"rel", |
||||
"required", |
||||
"reversed", |
||||
"rows", |
||||
"rowspan", |
||||
"sandbox", |
||||
"spellcheck", |
||||
"scope", |
||||
"scoped", |
||||
"seamless", |
||||
"selected", |
||||
"shape", |
||||
"size", |
||||
"sizes", |
||||
"sortable", |
||||
"sorted", |
||||
"span", |
||||
"src", |
||||
"srcdoc", |
||||
"srclang", |
||||
"start", |
||||
"step", |
||||
"style", |
||||
"tabindex", |
||||
"target", |
||||
"title", |
||||
"translate", |
||||
"type", |
||||
"typemustmatch", |
||||
"usemap", |
||||
"value", |
||||
"width", |
||||
"wrap", |
||||
} |
||||
|
||||
var eventHandlers = []string{ |
||||
"onabort", |
||||
"onautocomplete", |
||||
"onautocompleteerror", |
||||
"onafterprint", |
||||
"onbeforeprint", |
||||
"onbeforeunload", |
||||
"onblur", |
||||
"oncancel", |
||||
"oncanplay", |
||||
"oncanplaythrough", |
||||
"onchange", |
||||
"onclick", |
||||
"onclose", |
||||
"oncontextmenu", |
||||
"oncuechange", |
||||
"ondblclick", |
||||
"ondrag", |
||||
"ondragend", |
||||
"ondragenter", |
||||
"ondragleave", |
||||
"ondragover", |
||||
"ondragstart", |
||||
"ondrop", |
||||
"ondurationchange", |
||||
"onemptied", |
||||
"onended", |
||||
"onerror", |
||||
"onfocus", |
||||
"onhashchange", |
||||
"oninput", |
||||
"oninvalid", |
||||
"onkeydown", |
||||
"onkeypress", |
||||
"onkeyup", |
||||
"onlanguagechange", |
||||
"onload", |
||||
"onloadeddata", |
||||
"onloadedmetadata", |
||||
"onloadstart", |
||||
"onmessage", |
||||
"onmousedown", |
||||
"onmousemove", |
||||
"onmouseout", |
||||
"onmouseover", |
||||
"onmouseup", |
||||
"onmousewheel", |
||||
"onoffline", |
||||
"ononline", |
||||
"onpagehide", |
||||
"onpageshow", |
||||
"onpause", |
||||
"onplay", |
||||
"onplaying", |
||||
"onpopstate", |
||||
"onprogress", |
||||
"onratechange", |
||||
"onreset", |
||||
"onresize", |
||||
"onscroll", |
||||
"onseeked", |
||||
"onseeking", |
||||
"onselect", |
||||
"onshow", |
||||
"onsort", |
||||
"onstalled", |
||||
"onstorage", |
||||
"onsubmit", |
||||
"onsuspend", |
||||
"ontimeupdate", |
||||
"ontoggle", |
||||
"onunload", |
||||
"onvolumechange", |
||||
"onwaiting", |
||||
} |
||||
|
||||
// extra are ad-hoc values not covered by any of the lists above.
|
||||
var extra = []string{ |
||||
"align", |
||||
"annotation", |
||||
"annotation-xml", |
||||
"applet", |
||||
"basefont", |
||||
"bgsound", |
||||
"big", |
||||
"blink", |
||||
"center", |
||||
"color", |
||||
"desc", |
||||
"face", |
||||
"font", |
||||
"foreignObject", // HTML is case-insensitive, but SVG-embedded-in-HTML is case-sensitive.
|
||||
"foreignobject", |
||||
"frame", |
||||
"frameset", |
||||
"image", |
||||
"isindex", |
||||
"listing", |
||||
"malignmark", |
||||
"marquee", |
||||
"math", |
||||
"mglyph", |
||||
"mi", |
||||
"mn", |
||||
"mo", |
||||
"ms", |
||||
"mtext", |
||||
"nobr", |
||||
"noembed", |
||||
"noframes", |
||||
"plaintext", |
||||
"prompt", |
||||
"public", |
||||
"spacer", |
||||
"strike", |
||||
"svg", |
||||
"system", |
||||
"tt", |
||||
"xmp", |
||||
} |
||||
File diff suppressed because it is too large
Load Diff
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue