2016-11-04 01:16:01 +03:00
// Copyright 2015 The Gogs Authors. All rights reserved.
// Use of this source code is governed by a MIT-style
// license that can be found in the LICENSE file.
package git
import (
"bytes"
2017-04-08 05:23:39 +03:00
"context"
2016-11-04 01:16:01 +03:00
"fmt"
"io"
"os/exec"
"strings"
"time"
)
2016-12-22 12:30:52 +03:00
var (
// GlobalCommandArgs global command args for external package setting
GlobalCommandArgs [ ] string
2018-01-07 16:10:20 +03:00
// DefaultCommandExecutionTimeout default command execution timeout duration
DefaultCommandExecutionTimeout = 60 * time . Second
2016-12-22 12:30:52 +03:00
)
2016-11-04 01:16:01 +03:00
// Command represents a command with its subcommands or arguments.
type Command struct {
name string
args [ ] string
}
func ( c * Command ) String ( ) string {
if len ( c . args ) == 0 {
return c . name
}
return fmt . Sprintf ( "%s %s" , c . name , strings . Join ( c . args , " " ) )
}
// NewCommand creates and returns a new Git Command based on given command and arguments.
func NewCommand ( args ... string ) * Command {
2018-11-28 10:00:25 +03:00
// Make an explicit copy of GlobalCommandArgs, otherwise append might overwrite it
cargs := make ( [ ] string , len ( GlobalCommandArgs ) )
copy ( cargs , GlobalCommandArgs )
2016-11-04 01:16:01 +03:00
return & Command {
2019-04-17 14:11:37 +03:00
name : GitExecutable ,
2018-11-28 10:00:25 +03:00
args : append ( cargs , args ... ) ,
2016-11-04 01:16:01 +03:00
}
}
// AddArguments adds new argument(s) to the command.
func ( c * Command ) AddArguments ( args ... string ) * Command {
c . args = append ( c . args , args ... )
return c
}
// RunInDirTimeoutPipeline executes the command in given directory with given timeout,
// it pipes stdout and stderr to given io.Writer.
func ( c * Command ) RunInDirTimeoutPipeline ( timeout time . Duration , dir string , stdout , stderr io . Writer ) error {
if timeout == - 1 {
2018-01-07 16:10:20 +03:00
timeout = DefaultCommandExecutionTimeout
2016-11-04 01:16:01 +03:00
}
if len ( dir ) == 0 {
log ( c . String ( ) )
} else {
log ( "%s: %v" , dir , c )
}
2017-04-08 05:23:39 +03:00
ctx , cancel := context . WithTimeout ( context . Background ( ) , timeout )
defer cancel ( )
cmd := exec . CommandContext ( ctx , c . name , c . args ... )
2016-11-04 01:16:01 +03:00
cmd . Dir = dir
cmd . Stdout = stdout
cmd . Stderr = stderr
if err := cmd . Start ( ) ; err != nil {
return err
}
2017-05-30 12:32:01 +03:00
if err := cmd . Wait ( ) ; err != nil {
return err
}
return ctx . Err ( )
2016-11-04 01:16:01 +03:00
}
// RunInDirTimeout executes the command in given directory with given timeout,
// and returns stdout in []byte and error (combined with stderr).
func ( c * Command ) RunInDirTimeout ( timeout time . Duration , dir string ) ( [ ] byte , error ) {
stdout := new ( bytes . Buffer )
stderr := new ( bytes . Buffer )
if err := c . RunInDirTimeoutPipeline ( timeout , dir , stdout , stderr ) ; err != nil {
return nil , concatenateError ( err , stderr . String ( ) )
}
if stdout . Len ( ) > 0 {
log ( "stdout:\n%s" , stdout . Bytes ( ) [ : 1024 ] )
}
return stdout . Bytes ( ) , nil
}
// RunInDirPipeline executes the command in given directory,
// it pipes stdout and stderr to given io.Writer.
func ( c * Command ) RunInDirPipeline ( dir string , stdout , stderr io . Writer ) error {
return c . RunInDirTimeoutPipeline ( - 1 , dir , stdout , stderr )
}
2016-12-22 12:30:52 +03:00
// RunInDirBytes executes the command in given directory
2016-11-04 01:16:01 +03:00
// and returns stdout in []byte and error (combined with stderr).
func ( c * Command ) RunInDirBytes ( dir string ) ( [ ] byte , error ) {
return c . RunInDirTimeout ( - 1 , dir )
}
// RunInDir executes the command in given directory
// and returns stdout in string and error (combined with stderr).
func ( c * Command ) RunInDir ( dir string ) ( string , error ) {
stdout , err := c . RunInDirTimeout ( - 1 , dir )
if err != nil {
return "" , err
}
return string ( stdout ) , nil
}
2019-03-27 12:33:00 +03:00
// RunTimeout executes the command in default working directory with given timeout,
2016-11-04 01:16:01 +03:00
// and returns stdout in string and error (combined with stderr).
func ( c * Command ) RunTimeout ( timeout time . Duration ) ( string , error ) {
stdout , err := c . RunInDirTimeout ( timeout , "" )
if err != nil {
return "" , err
}
return string ( stdout ) , nil
}
2019-03-27 12:33:00 +03:00
// Run executes the command in default working directory
2016-11-04 01:16:01 +03:00
// and returns stdout in string and error (combined with stderr).
func ( c * Command ) Run ( ) ( string , error ) {
return c . RunTimeout ( - 1 )
}