go-packages/iris
1
0
Fork 0
mirror of https://github.com/kataras/iris.git synced 2025-01-23 02:31:04 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

Update to 4.1.0, New: SSH Remote control, READ HISTORY.md

Browse Source 
https://github.com/kataras/iris/blob/master/HISTORY.md
This commit is contained in:
Gerasimos Maropoulos 2016-08-17 12:57:54 +03:00
parent 3beb292f4f
commit bef334868b
5 changed files with 742 additions and 15 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
HISTORY.md
View File

@ -2,6 +2,14 @@
**How to upgrade**: remove your `$GOPATH/src/github.com/kataras/iris` folder, open your command-line and execute this command: `go get -u github.com/kataras/iris/iris`.
## 4.0.0 -> 4.1.0
- **NEW FEATURE**: Basic remote control through SSH, example [here](https://github.com/iris-contrib/examples/blob/master/ssh/main.go)
- **NEW FEATURE**: Optionally `OnError` foreach Party (by prefix, use it with your own risk), example [here](https://github.com/iris-contrib/examples/blob/master/httperrors/main.go#L37)
- **FIX**: Sessions + SetFlash on same handler strange behavior[*](https://github.com/kataras/iris/issues/351)
- **FIX**: Multi websocket servers client-side source route panic[*](https://github.com/kataras/iris/issues/365)
- Better gzip response managment
## 4.0.0-alpha.5 -> 4.0.0

8
README.md
View File

@ -8,7 +8,7 @@
<a href="https://github.com/kataras/iris/blob/master/LICENSE"><img src="https://img.shields.io/badge/%20license-MIT%20%20License%20-E91E63.svg?style=flat-square" alt="License"></a>
<a href="https://github.com/kataras/iris/releases"><img src="https://img.shields.io/badge/%20release%20-%20v4.0.0%20-blue.svg?style=flat-square" alt="Releases"></a>
<a href="https://github.com/kataras/iris/releases"><img src="https://img.shields.io/badge/%20release%20-%20v4.1.0%20-blue.svg?style=flat-square" alt="Releases"></a>
<a href="https://www.gitbook.com/book/kataras/iris/details"><img src="https://img.shields.io/badge/%20docs-reference-5272B4.svg?style=flat-square" alt="Practical Guide/Docs"></a><br/>
@ -70,6 +70,7 @@ Features
- Focus on high performance
- Robust routing, static, wildcard subdomains and routes.
- Websocket API, Sessions support out of the box
- Remote control through [SSH](https://github.com/iris-contrib/examples/blob/master/ssh/main.go)
- View system supporting [6+](https://kataras.gitbooks.io/iris/content/template-engines.html) template engines
- Highly scalable response engines
- Live reload
@ -143,7 +144,7 @@ I recommend writing your API tests using this new library, [httpexpect](https://
Versioning
------------
Current: **v4.0.0**
Current: **v4.1.0**
> Iris is an active project
@ -178,7 +179,7 @@ License can be found [here](LICENSE).
[Travis]: http://travis-ci.org/kataras/iris
[License Widget]: https://img.shields.io/badge/license-MIT%20%20License%20-E91E63.svg?style=flat-square
[License]: https://github.com/kataras/iris/blob/master/LICENSE
[Release Widget]: https://img.shields.io/badge/release-v4.0.0-blue.svg?style=flat-square
[Release Widget]: https://img.shields.io/badge/release-v4.1.0-blue.svg?style=flat-square
[Release]: https://github.com/kataras/iris/releases
[Chat Widget]: https://img.shields.io/badge/community-chat-00BCD4.svg?style=flat-square
[Chat]: https://kataras.rocket.chat/channel/iris
@ -193,4 +194,3 @@ License can be found [here](LICENSE).
[Language Widget]: https://img.shields.io/badge/powered_by-Go-3362c2.svg?style=flat-square
[Language]: http://golang.org
[Platform Widget]: https://img.shields.io/badge/platform-Any--OS-gray.svg?style=flat-square

2
http.go
View File

@ -1440,7 +1440,7 @@ func (mux *serveMux) register(method []byte, subdomain string, path string, midd
// build collects all routes info and adds them to the registry in order to be served from the request handler
// this happens once when server is setting the mux's handler.
func (mux *serveMux) build() {
mux.tree = nil
sort.Sort(bySubdomain(mux.lookups))
for _, r := range mux.lookups {
// add to the registry tree

13
iris.go
View File

@ -85,7 +85,7 @@ import (
const (
// Version of the iris
Version = "4.0.0"
Version = "4.1.0"
banner = ` _____ _
|_ _| (_)
@ -102,6 +102,9 @@ var (
Logger *logger.Logger
Plugins PluginContainer
Websocket WebsocketServer
// Look ssh.go for this field's configuration
// example: https://github.com/iris-contrib/examples/blob/master/ssh/main.go
SSH *SSHServer
Servers *ServerList
// Available is a channel type of bool, fired to true when the server is opened and all plugins ran
// never fires false, if the .Close called then the channel is re-allocating.
@ -121,6 +124,7 @@ func initDefault() {
Logger = Default.Logger
Plugins = Default.Plugins
Websocket = Default.Websocket
SSH = Default.SSH
Servers = Default.Servers
Available = Default.Available
}
@ -180,6 +184,7 @@ type (
Logger *logger.Logger
Plugins PluginContainer
Websocket WebsocketServer
SSH *SSHServer
Available chan bool
// this is setted once when .Tester(t) is called
testFramework *httpexpect.Expect
@ -201,6 +206,7 @@ func New(cfg ...config.Iris) *Framework {
Config: &c,
responses: &responseEngines{},
Available: make(chan bool),
SSH: &SSHServer{},
}
{
///NOTE: set all with s.Config pointer
@ -283,6 +289,11 @@ func (s *Framework) initialize() {
if debugPath := s.Config.ProfilePath; debugPath != "" {
s.Handle(MethodGet, debugPath+"/*action", profileMiddleware(debugPath)...)
}
// ssh
if s.SSH != nil && s.SSH.Enabled() {
s.SSH.bindTo(s)
}
}
func (s *Framework) acquireCtx(reqCtx *fasthttp.RequestCtx) *Context {

708
ssh.go Normal file
View File

@ -0,0 +1,708 @@
package iris
// Minimal managment over SSH for your Iris & Q web server
//
// Declaration:
//
// iris.SSH.Host = "0.0.0.0:22"
// iris.SSH.KeyPath = "./iris_rsa" // it's auto-generated if not exists
// iris.SSH.Users = iris.Users{"kataras", []byte("pass")}
//
//
// Usage:
// via interactive command shell:
//
// $ ssh kataras@localhost
//
// or via standalone command and exit:
//
// $ ssh kataras@localhost stop
//
//
// Commands available:
//
// stop
// start
// restart
// log
// help
// exit
import (
"bytes"
"fmt"
"io"
"io/ioutil"
"net"
"os"
"os/exec"
"path/filepath"
"runtime"
"strconv"
"strings"
"text/template"
"time"
"github.com/iris-contrib/errors"
"github.com/iris-contrib/logger"
"github.com/kardianos/osext"
"github.com/kardianos/service"
"github.com/kataras/iris/utils"
"golang.org/x/crypto/ssh"
"golang.org/x/crypto/ssh/terminal"
)
// -------------------------------------------------------------------------------------
// -------------------------------------------------------------------------------------
// ----------------------------------Iris+SSH-------------------------------------------
// -------------------------------------------------------------------------------------
// -------------------------------------------------------------------------------------
func _output(format string, a ...interface{}) func(io.Writer) {
if format[len(format)-3:] != "\n" {
format += "\n"
}
msgBytes := []byte(fmt.Sprintf(format, a...))
return func(w io.Writer) {
w.Write(msgBytes)
}
}
type systemServiceWrapper struct{}
func (w *systemServiceWrapper) Start(s service.Service) error {
return nil
}
func (w *systemServiceWrapper) Stop(s service.Service) error {
return nil
}
func (s *SSHServer) bindTo(station *Framework) {
if s.Enabled() && !s.IsListening() { // check if not listening because on restart this block will re-executing,but we don't want to start ssh again, ssh will never stops.
if station.Config.IsDevelopment && s.Logger == nil {
s.Logger = station.Logger
}
// cache the messages to be sent to the channel, no need to produce memory allocations here
statusRunningMsg := _output("The HTTP Server is running.")
statusNotRunningMsg := _output("The HTTP Server is NOT running. ")
serverStoppedMsg := _output("The HTTP Server has been stopped.")
errServerNotReadyMsg := _output("Error: HTTP Server is not even builded yet!")
serverStartedMsg := _output("The HTTP Server has been started.")
serverRestartedMsg := _output("The HTTP Server has been restarted.")
loggerStartedMsg := _output("Logger has been registered to the HTTP Server.\nNew Requests will be printed here.\nYou can still type 'exit' to close this SSH Session.\n\n")
//
sshCommands := Commands{
Command{Name: "status", Description: "Prompts the status of the HTTP Server, is listening(started) or not(stopped).", Action: func(conn ssh.Channel) {
if station.Servers.Main() != nil && station.Servers.Main().IsListening() {
statusRunningMsg(conn)
} else {
statusNotRunningMsg(conn)
}
execPath, err := osext.Executable() // this works fine, if the developer builded the go app, if just go run main.go then prints the temporary path which the go tool creates
if err == nil {
conn.Write([]byte("[EXEC] " + execPath + "\n"))
}
}},
// Note for stop If you have opened a tab with Q route:
// in order to see that the http listener has closed you have to close your browser and re-navigate(browsers caches the tcp connection)
Command{Name: "stop", Description: "Stops the HTTP Server.", Action: func(conn ssh.Channel) {
srv := station.Servers.Main()
if srv != nil && srv.IsListening() {
srv.Close()
srv.listener = nil
serverStoppedMsg(conn)
} else {
errServerNotReadyMsg(conn)
}
}},
Command{Name: "start", Description: "Starts the HTTP Server.", Action: func(conn ssh.Channel) {
srv := station.Servers.Main()
if !srv.IsListening() {
go srv.Open(srv.Handler)
}
serverStartedMsg(conn)
}},
Command{Name: "restart", Description: "Restarts the HTTP Server.", Action: func(conn ssh.Channel) {
srv := station.Servers.Main()
if srv != nil && srv.IsListening() {
srv.Close()
srv.listener = nil
}
go srv.Open(srv.Handler)
serverRestartedMsg(conn)
}},
/* not ready yet
Command{Name: "service", Description: "[REQUIRES HTTP SERVER's ADMIN PRIVILEGE] Adds the web server to the system services, use it when you want to make your server to autorun on reboot", Action: func(conn ssh.Channel) {
///TODO:
// 1. Unistall service and change the 'service' to 'install service'
// 2. Fix, this current implementation doesn't works on windows 10 it says that the service is not responding to request and start...
// 2.1 the fix is maybe add these and change the s.Install to s.Run to the $DESKTOP/some/q/main.go I will try this
// as the example shows.
// remember: run command line as administrator > sc delete "Iris Web Server - $DATETIME" to delete the service, do it on each test.
svcConfig := &service.Config{
Name: "Iris Web Server - " + time.Now().Format(q.TimeFormat),
DisplayName: "Iris Web Server - " + time.Now().Format(q.TimeFormat),
Description: "The web server which has been registered by SSH interface.",
}
prg := &systemServiceWrapper{}
s, err := service.New(prg, svcConfig)
if err != nil {
conn.Write([]byte(err.Error() + "\n"))
return
}
err = s.Install()
if err != nil {
conn.Write([]byte(err.Error() + "\n"))
return
}
conn.Write([]byte("Service has been registered.\n"))
}},*/
Command{Name: "log", Description: "Adds a logger to the HTTP Server, waits for requests and prints them here.", Action: func(conn ssh.Channel) {
// the ssh user can still write commands, this is not blocking anything.
loggerMiddleware := NewLoggerHandler(conn, true)
station.UseGlobalFunc(loggerMiddleware)
// register to the errors also
errorLoggerHandler := NewLoggerHandler(conn, false)
for k, v := range station.mux.errorHandlers {
errorH := v
// wrap the error handler with the ssh logger middleware
station.mux.errorHandlers[k] = HandlerFunc(func(ctx *Context) {
errorH.Serve(ctx)
errorLoggerHandler(ctx) // after the error handler because that is setting the status code.
})
}
station.mux.build() // rebuild the mux in order the UseGlobalFunc to work at runtime
loggerStartedMsg(conn)
// the middleware will still to run, we could remove it on exit but exit is general command I dont want to touch that
// we could make a command like 'log stop' or on 'stop' to remove the middleware...I will think about it.
}},
}
for _, cmd := range sshCommands {
if _, found := s.Commands.ByName(cmd.Name); !found { // yes, the user can add custom commands too, I will cover this on docs some day, it's not too hard if you see the code.
s.Commands.Add(cmd)
}
}
go func() {
station.Must(s.Listen())
}()
}
}
// -------------------------------------------------------------------------------------
// -------------------------------------------------------------------------------------
// ----------------------------------SSH implementation---------------------------------
// -------------------------------------------------------------------------------------
// -------------------------------------------------------------------------------------
var (
// SSHBanner is the banner goes on top of the 'ssh help message'
// it can be changed, defaults is the Iris's banner
SSHBanner = banner
helpMessage = SSHBanner + `
COMMANDS:
{{ range $index, $cmd := .Commands }}
{{- $cmd.Name }} - {{ $cmd.Description }}
{{ end }}
USAGE:
ssh myusername@{{ .Hostname}} -p {{ .Port }} {{ first .Commands}}
or just write the command below
VERSION:
{{ .Version }}
`
helpTmpl *template.Template
)
func init() {
var err error
helpTmpl = template.New("help_message").Funcs(template.FuncMap{"first": func(cmds Commands) string {
if len(cmds) > 0 {
return cmds[0].Name
}
return ""
}})
helpTmpl, err = helpTmpl.Parse(helpMessage)
if err != nil {
panic(err.Error())
}
}
//no need of SSH prefix on these types, we don't have other commands
// use of struct and no global variables because we want each Iris instance to have its own SSH interface.
// Action the command's handler
type Action func(ssh.Channel)
// Command contains the registered SSH commands
// contains a Name which is the payload string
// Description which is the description of the command shows to the admin/user
// Action is the particular command's handler
type Command struct {
Name string
Description string
Action Action
}
// Commands the SSH Commands, it's just a type of []Command
type Commands []Command
// Add adds command(s) to the commands list
func (c *Commands) Add(cmd ...Command) {
pCommands := *c
*c = append(pCommands, cmd...)
}
// ByName returns the command by its Name
// if not found returns a zero-value Command and false as the second output parameter.
func (c *Commands) ByName(commandName string) (cmd Command, found bool) {
pCommands := *c
for _, cmd = range pCommands {
if cmd.Name == commandName {
found = true
return
}
}
return
}
// Users SSH.Users field, it's just map[string][]byte (username:password)
type Users map[string][]byte
func (m Users) exists(username string, pass []byte) bool {
for k, v := range m {
if k == username && bytes.Equal(v, pass) {
return true
}
}
return false
}
// DefaultSSHKeyPath used if SSH.KeyPath is empty. Defaults to: "iris_rsa". It can be changed.
var DefaultSSHKeyPath = "iris_rsa"
var errSSHExecutableNotFound = errors.New(`Cannot generate ssh private key: ssh-keygen couldn't be found. Please specify the ssh[.exe] and ssh-keygen[.exe]
path on your operating system's environment's $PATH or set the configuration field 'Bin'.\n For example, on windows, the path is: C:\\Program Files\\Git\usr\\bin. Error Trace: %q`)
func generateSigner(keypath string, sshKeygenBin string) (ssh.Signer, error) {
if keypath == "" {
keypath = DefaultSSHKeyPath
}
if sshKeygenBin != "" {
// if empty then the user should specify the ssh-keygen bin path (if not setted already)
// on the $PATH system environment, otherwise it will panic.
if sshKeygenBin[len(sshKeygenBin)-1] != os.PathSeparator {
sshKeygenBin += string(os.PathSeparator)
}
sshKeygenBin += "ssh-keygen"
if isWindows {
sshKeygenBin += ".exe"
}
} else {
sshKeygenBin = "ssh-keygen"
}
if !utils.DirectoryExists(keypath) {
os.MkdirAll(filepath.Dir(keypath), os.ModePerm)
keygenCmd := exec.Command(sshKeygenBin, "-f", keypath, "-t", "rsa", "-N", "")
_, err := keygenCmd.Output()
if err != nil {
panic(errSSHExecutableNotFound.Format(err.Error()))
}
}
pemBytes, err := ioutil.ReadFile(keypath)
if err != nil {
return nil, err
}
return ssh.ParsePrivateKey(pemBytes)
}
func validChannel(ch ssh.NewChannel) bool {
if typ := ch.ChannelType(); typ != "session" {
ch.Reject(ssh.UnknownChannelType, typ)
return false
}
return true
}
func execCmd(cmd *exec.Cmd, ch ssh.Channel) error {
stdout, err := cmd.StdoutPipe()
if err != nil {
return err
}
stderr, err := cmd.StderrPipe()
if err != nil {
return err
}
input, err := cmd.StdinPipe()
if err != nil {
return err
}
if err = cmd.Start(); err != nil {
return err
}
go io.Copy(input, ch)
io.Copy(ch, stdout)
io.Copy(ch.Stderr(), stderr)
if err = cmd.Wait(); err != nil {
return err
}
return nil
}
func sendExitStatus(ch ssh.Channel) {
ch.SendRequest("exit-status", false, []byte{0, 0, 0, 0})
}
var errInvalidSSHCommand = errors.New("Invalid Command: '%s'")
func parsePayload(payload string, prefix string) (string, error) {
payloadUTF8 := strings.Map(func(r rune) rune {
if r >= 32 && r < 127 {
return r
}
return -1
}, payload)
if prefIdx := strings.Index(payloadUTF8, prefix); prefIdx != -1 {
p := strings.TrimSpace(payloadUTF8[prefIdx+len(prefix):])
return p, nil
}
return "", errInvalidSSHCommand.Format(payload)
}
const (
isWindows = runtime.GOOS == "windows"
isMac = runtime.GOOS == "darwin"
)
// -------------------------------------------------------------------------------------
// -------------------------------------------------------------------------------------
// ----------------------------------SSH Server-----------------------------------------
// -------------------------------------------------------------------------------------
// -------------------------------------------------------------------------------------
// SSHServer : Simple SSH interface for Iris web framework, does not implements the most secure options and code,
// but its should works
// use it at your own risk.
type SSHServer struct {
Bin string // windows: C:/Program Files/Git/usr/bin, it's the ssh[.exe] and ssh-keygen[.exe], we only need the ssh-keygen.
KeyPath string // C:/Users/kataras/.ssh/iris_rsa
Host string // host:port
listener net.Listener
Users Users // map[string][]byte]{ "username":[]byte("password"), "my_second_username" : []byte("my_second_password")}
Commands Commands // Commands{Command{Name: "restart", Description:"restarts & rebuild the server", Action: func(ssh.Channel){}}}
// note for Commands field:
// the default Iris's commands are defined at the end of this file, I tried to make this file as standalone as I can, because it will be used for Iris web framework also.
Shell bool // Set it to true to enable execute terminal's commands(system commands) via ssh if no other command is found from the Commands field. Defaults to false for security reasons
Logger *logger.Logger // log.New(...)/ $qinstance.Logger, fill it when you want to receive debug and info/warnings messages
}
// Enabled returns true if SSH can be started, if Host != ""
func (s *SSHServer) Enabled() bool {
if s == nil {
return false
}
return s.Host != ""
}
// IsListening returns true if ssh server has been started
func (s *SSHServer) IsListening() bool {
return s.Enabled() && s.listener != nil
}
func (s *SSHServer) logf(format string, a ...interface{}) {
if s.Logger != nil {
s.Logger.Printf(format, a...)
}
}
// parseHostname receives an addr of form host[:port] and returns the hostname part of it
// ex: localhost:8080 will return the `localhost`, mydomain.com:22 will return the 'mydomain'
func parseHostname(addr string) string {
idx := strings.IndexByte(addr, ':')
if idx == 0 {
// only port, then return 0.0.0.0
return "0.0.0.0"
} else if idx > 0 {
return addr[0:idx]
}
// it's already hostname
return addr
}
// parsePort receives an addr of form host[:port] and returns the port part of it
// ex: localhost:8080 will return the `8080`, mydomain.com will return the '22'
func parsePort(addr string) int {
if portIdx := strings.IndexByte(addr, ':'); portIdx != -1 {
afP := addr[portIdx+1:]
p, err := strconv.Atoi(afP)
if err == nil {
return p
}
}
return 22
}
// commands that exists on all ssh interfaces, both Q and Iris
var standardCommands = Commands{Command{Name: "help", Description: "Opens up the assistance"},
Command{Name: "exit", Description: "Exits from the terminal (if interactive shell)"}}
func (s *SSHServer) writeHelp(wr io.Writer) {
port := parsePort(s.Host)
hostname := parseHostname(s.Host)
data := map[string]interface{}{
"Hostname": hostname, "Port": port,
"Commands": append(s.Commands, standardCommands...),
"Version": Version,
}
helpTmpl.Execute(wr, data)
}
var (
errUserInvalid = errors.New("Username or Password rejected for: %q")
errServerListen = errors.New("Cannot listen to: %s, Trace: %s")
)
// Listen starts the SSH Server
func (s *SSHServer) Listen() error {
// get the key
privateKey, err := generateSigner(s.KeyPath, s.Bin)
if err != nil {
return err
}
// prepare the server's configuration
cfg := &ssh.ServerConfig{
// NoClientAuth: true to allow anyone to login, nooo
PasswordCallback: func(c ssh.ConnMetadata, pass []byte) (*ssh.Permissions, error) {
username := c.User()
if !s.Users.exists(username, pass) {
return nil, errUserInvalid.Format(username)
}
return nil, nil
}}
cfg.AddHostKey(privateKey)
// start the server with the configuration we just made.
var lerr error
s.listener, lerr = net.Listen("tcp", s.Host)
if lerr != nil {
return errServerListen.Format(s.Host, lerr.Error())
}
// ready to accept incoming requests
s.logf("SSH Server is running")
for {
conn, err := s.listener.Accept()
if err != nil {
s.logf(err.Error())
continue
}
// handshake first
sshConn, chans, reqs, err := ssh.NewServerConn(conn, cfg)
if err != nil {
s.logf(err.Error())
continue
}
s.logf("New SSH Connection has been enstablish from %s (%s)", sshConn.RemoteAddr(), sshConn.ClientVersion())
// discard all global requests
go ssh.DiscardRequests(reqs)
// accept all current chanels
go s.handleChannels(chans)
}
}
func (s *SSHServer) handleChannels(chans <-chan ssh.NewChannel) {
for ch := range chans {
go s.handleChannel(ch)
}
}
var errUnsupportedReqType = errors.New("Unsupported request type: %q")
func (s *SSHServer) handleChannel(newChannel ssh.NewChannel) {
// we working from terminal, so only type of "session" is allowed.
if !validChannel(newChannel) {
return
}
conn, reqs, err := newChannel.Accept()
if err != nil {
s.logf(err.Error())
return
}
go func(in <-chan *ssh.Request) {
defer func() {
conn.Close()
//debug
s.logf("Session closed")
}()
for req := range in {
var err error
defer func() {
if err != nil {
conn.Write([]byte(err.Error()))
}
sendExitStatus(conn)
}()
switch req.Type {
case "pty-req":
{
s.writeHelp(conn)
req.Reply(true, nil)
}
case "shell":
{
// comes after pty-req, this is when the user just use this form: ssh kataras@mydomain.com -p 22
// then we want interactive shell which will execute the commands:
term := terminal.NewTerminal(conn, "> ")
for {
line, lerr := term.ReadLine()
if lerr == io.EOF {
return
}
if lerr != nil {
err = lerr
s.logf(lerr.Error())
continue
}
payload, perr := parsePayload(line, "")
if perr != nil {
err = perr
return
}
if payload == "help" {
s.writeHelp(conn)
continue
} else if payload == "exit" {
return
}
if cmd, found := s.Commands.ByName(payload); found {
cmd.Action(conn)
} else if s.Shell {
// yes every time check that
if isWindows {
execCmd(exec.Command("cmd", "/C", payload), conn)
} else {
execCmd(exec.Command("sh", "-c", payload), conn)
}
} else {
conn.Write([]byte(errInvalidSSHCommand.Format(payload).Error() + "\n"))
}
//s.logf(line)
}
}
case "exec":
{
// this is the place which the user executed something like that: ssh kataras@mydomain.com -p 22 stop
// a direct command, we don' t open the interactive shell, just execute the command and exit.
payload, perr := parsePayload(string(req.Payload), "")
if perr != nil {
err = perr
return
}
if cmd, found := s.Commands.ByName(payload); found {
cmd.Action(conn)
} else if payload == "help" {
s.writeHelp(conn)
} else if s.Shell {
// yes every time check that
if isWindows {
execCmd(exec.Command("cmd", "/C", payload), conn)
} else {
execCmd(exec.Command("sh", "-c", payload), conn)
}
} else {
err = errInvalidSSHCommand.Format(payload)
}
return
}
default:
{
err = errUnsupportedReqType.Format(req.Type)
return
}
}
}
}(reqs)
}
// NewLoggerHandler is a basic Logger middleware/Handler (not an Entry Parser)
func NewLoggerHandler(writer io.Writer, calculateLatency ...bool) HandlerFunc {
shouldNext := false
if len(calculateLatency) > 0 {
shouldNext = calculateLatency[0]
}
return func(ctx *Context) {
var date, status, ip, method, path string
var latency time.Duration
var startTime, endTime time.Time
path = ctx.PathString()
method = ctx.MethodString()
startTime = time.Now()
if shouldNext {
ctx.Next()
}
endTime = time.Now()
latency = endTime.Sub(startTime)
date = endTime.Format("01/02 - 15:04:05")
status = strconv.Itoa(ctx.Response.StatusCode())
ip = ctx.RemoteAddr()
//finally print the logs to the ssh
writer.Write([]byte(fmt.Sprintf("%s %v %4v %s %s %s \n", date, status, latency, ip, method, path)))
}
}