2016-11-03 23:16:01 +01: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 04:23:39 +02:00
"context"
2016-11-03 23:16:01 +01:00
"fmt"
"io"
2019-11-10 09:42:51 +01:00
"os"
2016-11-03 23:16:01 +01:00
"os/exec"
"strings"
"time"
2019-06-26 20:15:26 +02:00
"code.gitea.io/gitea/modules/process"
2016-11-03 23:16:01 +01:00
)
2016-12-22 10:30:52 +01:00
var (
// GlobalCommandArgs global command args for external package setting
GlobalCommandArgs [ ] string
2018-01-07 14:10:20 +01:00
// DefaultCommandExecutionTimeout default command execution timeout duration
DefaultCommandExecutionTimeout = 60 * time . Second
2016-12-22 10:30:52 +01:00
)
2019-11-10 09:42:51 +01:00
// DefaultLocale is the default LC_ALL to run git commands in.
const DefaultLocale = "C"
2016-11-03 23:16:01 +01:00
// Command represents a command with its subcommands or arguments.
type Command struct {
2019-11-30 15:40:22 +01:00
name string
args [ ] string
parentContext context . Context
desc string
2016-11-03 23:16:01 +01:00
}
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 08:00:25 +01:00
// Make an explicit copy of GlobalCommandArgs, otherwise append might overwrite it
cargs := make ( [ ] string , len ( GlobalCommandArgs ) )
copy ( cargs , GlobalCommandArgs )
2016-11-03 23:16:01 +01:00
return & Command {
2019-11-30 15:40:22 +01:00
name : GitExecutable ,
args : append ( cargs , args ... ) ,
parentContext : DefaultContext ,
2016-11-03 23:16:01 +01:00
}
}
2019-11-27 01:35:52 +01:00
// NewCommandNoGlobals creates and returns a new Git Command based on given command and arguments only with the specify args and don't care global command args
func NewCommandNoGlobals ( args ... string ) * Command {
return & Command {
2019-11-30 15:40:22 +01:00
name : GitExecutable ,
args : args ,
parentContext : DefaultContext ,
2019-11-27 01:35:52 +01:00
}
}
2019-11-30 15:40:22 +01:00
// SetParentContext sets the parent context for this command
func ( c * Command ) SetParentContext ( ctx context . Context ) * Command {
c . parentContext = ctx
return c
}
// SetDescription sets the description for this command which be returned on
// c.String()
func ( c * Command ) SetDescription ( desc string ) * Command {
c . desc = desc
return c
}
2016-11-03 23:16:01 +01:00
// AddArguments adds new argument(s) to the command.
func ( c * Command ) AddArguments ( args ... string ) * Command {
c . args = append ( c . args , args ... )
return c
}
2019-05-11 17:29:17 +02:00
// RunInDirTimeoutEnvPipeline executes the command in given directory with given timeout,
2016-11-03 23:16:01 +01:00
// it pipes stdout and stderr to given io.Writer.
2019-05-11 17:29:17 +02:00
func ( c * Command ) RunInDirTimeoutEnvPipeline ( env [ ] string , timeout time . Duration , dir string , stdout , stderr io . Writer ) error {
return c . RunInDirTimeoutEnvFullPipeline ( env , timeout , dir , stdout , stderr , nil )
}
// RunInDirTimeoutEnvFullPipeline executes the command in given directory with given timeout,
// it pipes stdout and stderr to given io.Writer and passes in an io.Reader as stdin.
func ( c * Command ) RunInDirTimeoutEnvFullPipeline ( env [ ] string , timeout time . Duration , dir string , stdout , stderr io . Writer , stdin io . Reader ) error {
2019-11-11 12:46:28 +01:00
return c . RunInDirTimeoutEnvFullPipelineFunc ( env , timeout , dir , stdout , stderr , stdin , nil )
}
// RunInDirTimeoutEnvFullPipelineFunc executes the command in given directory with given timeout,
// it pipes stdout and stderr to given io.Writer and passes in an io.Reader as stdin. Between cmd.Start and cmd.Wait the passed in function is run.
2020-01-15 09:32:57 +01:00
func ( c * Command ) RunInDirTimeoutEnvFullPipelineFunc ( env [ ] string , timeout time . Duration , dir string , stdout , stderr io . Writer , stdin io . Reader , fn func ( context . Context , context . CancelFunc ) error ) error {
2019-11-11 12:46:28 +01:00
2016-11-03 23:16:01 +01:00
if timeout == - 1 {
2018-01-07 14:10:20 +01:00
timeout = DefaultCommandExecutionTimeout
2016-11-03 23:16:01 +01:00
}
if len ( dir ) == 0 {
log ( c . String ( ) )
} else {
log ( "%s: %v" , dir , c )
}
2019-11-30 15:40:22 +01:00
ctx , cancel := context . WithTimeout ( c . parentContext , timeout )
2017-04-08 04:23:39 +02:00
defer cancel ( )
cmd := exec . CommandContext ( ctx , c . name , c . args ... )
2019-11-10 09:42:51 +01:00
if env == nil {
cmd . Env = append ( os . Environ ( ) , fmt . Sprintf ( "LC_ALL=%s" , DefaultLocale ) )
} else {
cmd . Env = env
cmd . Env = append ( cmd . Env , fmt . Sprintf ( "LC_ALL=%s" , DefaultLocale ) )
}
2016-11-03 23:16:01 +01:00
cmd . Dir = dir
cmd . Stdout = stdout
cmd . Stderr = stderr
2019-05-11 17:29:17 +02:00
cmd . Stdin = stdin
2016-11-03 23:16:01 +01:00
if err := cmd . Start ( ) ; err != nil {
return err
}
2019-11-30 15:40:22 +01:00
desc := c . desc
if desc == "" {
desc = fmt . Sprintf ( "%s %s %s [repo_path: %s]" , GitExecutable , c . name , strings . Join ( c . args , " " ) , dir )
}
pid := process . GetManager ( ) . Add ( desc , cancel )
2019-06-26 20:15:26 +02:00
defer process . GetManager ( ) . Remove ( pid )
2019-11-11 12:46:28 +01:00
if fn != nil {
2020-01-15 09:32:57 +01:00
err := fn ( ctx , cancel )
if err != nil {
cancel ( )
return err
}
2019-11-11 12:46:28 +01:00
}
2019-12-13 10:03:38 +01:00
if err := cmd . Wait ( ) ; err != nil && ctx . Err ( ) != context . DeadlineExceeded {
2017-05-30 11:32:01 +02:00
return err
}
return ctx . Err ( )
2016-11-03 23:16:01 +01:00
}
2019-05-11 17:29:17 +02:00
// 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 {
return c . RunInDirTimeoutEnvPipeline ( nil , timeout , dir , stdout , stderr )
}
// RunInDirTimeoutFullPipeline executes the command in given directory with given timeout,
// it pipes stdout and stderr to given io.Writer, and stdin from the given io.Reader
func ( c * Command ) RunInDirTimeoutFullPipeline ( timeout time . Duration , dir string , stdout , stderr io . Writer , stdin io . Reader ) error {
return c . RunInDirTimeoutEnvFullPipeline ( nil , timeout , dir , stdout , stderr , stdin )
}
2016-11-03 23:16:01 +01: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 ) {
2019-05-11 17:29:17 +02:00
return c . RunInDirTimeoutEnv ( nil , timeout , dir )
}
// RunInDirTimeoutEnv executes the command in given directory with given timeout,
// and returns stdout in []byte and error (combined with stderr).
func ( c * Command ) RunInDirTimeoutEnv ( env [ ] string , timeout time . Duration , dir string ) ( [ ] byte , error ) {
2016-11-03 23:16:01 +01:00
stdout := new ( bytes . Buffer )
stderr := new ( bytes . Buffer )
2019-05-11 17:29:17 +02:00
if err := c . RunInDirTimeoutEnvPipeline ( env , timeout , dir , stdout , stderr ) ; err != nil {
2016-11-03 23:16:01 +01:00
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 {
2019-05-11 17:29:17 +02:00
return c . RunInDirFullPipeline ( dir , stdout , stderr , nil )
}
// RunInDirFullPipeline executes the command in given directory,
// it pipes stdout and stderr to given io.Writer.
func ( c * Command ) RunInDirFullPipeline ( dir string , stdout , stderr io . Writer , stdin io . Reader ) error {
return c . RunInDirTimeoutFullPipeline ( - 1 , dir , stdout , stderr , stdin )
2016-11-03 23:16:01 +01:00
}
2016-12-22 10:30:52 +01:00
// RunInDirBytes executes the command in given directory
2016-11-03 23:16:01 +01: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 ) {
2019-05-11 17:29:17 +02:00
return c . RunInDirWithEnv ( dir , nil )
}
// RunInDirWithEnv executes the command in given directory
// and returns stdout in string and error (combined with stderr).
func ( c * Command ) RunInDirWithEnv ( dir string , env [ ] string ) ( string , error ) {
stdout , err := c . RunInDirTimeoutEnv ( env , - 1 , dir )
2016-11-03 23:16:01 +01:00
if err != nil {
return "" , err
}
return string ( stdout ) , nil
}
2019-03-27 10:33:00 +01:00
// RunTimeout executes the command in default working directory with given timeout,
2016-11-03 23:16:01 +01: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 10:33:00 +01:00
// Run executes the command in default working directory
2016-11-03 23:16:01 +01:00
// and returns stdout in string and error (combined with stderr).
func ( c * Command ) Run ( ) ( string , error ) {
return c . RunTimeout ( - 1 )
}