Come posso installare un pacchetto con go get?

Voglio installare pacchetti da GitHub al mio gopath, ho provato questo:

go get github.com:capotej/groupcache-db-experiment.git

il repository è qui .

Comanda vai

Scarica e installa pacchetti e dipendenze

Uso:

go get [-d] [-f] [-t] [-u] [-v] [-fix] [-insecure] [build flags] [packages]

Ottieni download i pacchetti denominati dai percorsi di importazione, insieme alle loro dipendenze. Quindi installa i pacchetti denominati, come "go install".

Il flag -d indica a get di fermarsi dopo aver scaricato i pacchetti; cioè, istruisce a non installare i pacchetti.

Il flag -f, valido solo quando è impostato -u, forza get -u a non verificare che ogni pacchetto sia stato estratto dal repository del controllo del codice sorgente implicito nel suo percorso di importazione. Questo può essere utile se la fonte è un fork locale dell'originale.

Il flag -fix indica di eseguire lo strumento di correzione sui pacchetti scaricati prima di risolvere le dipendenze o creare il codice.

Il flag -insecure consente il recupero dai repository e la risoluzione di domini personalizzati utilizzando schemi non sicuri come HTTP. Usare con cautela.

Il flag -t indica a get di scaricare anche i pacchetti richiesti per compilare i test per i pacchetti specificati.

Il flag -u indica a utilizzare la rete per aggiornare i pacchetti denominati e le loro dipendenze. Per impostazione predefinita, get utilizza la rete per controllare i pacchetti mancanti ma non la utilizza per cercare aggiornamenti ai pacchetti esistenti.

Il flag -v abilita l'avanzamento dettagliato e l'output di debug.

Get accetta anche flag di build per controllare l'installazione. Vedi "go help build".

Quando si estrae un nuovo pacchetto, get crea la directory di destinazione GOPATH / src /. Se il GOPATH contiene più voci, get utilizza la prima. Per maggiori dettagli vedi: 'go help gopath'.

Durante il check out o l'aggiornamento di un pacchetto, get cerca un ramo o un tag che corrisponda alla versione di Go installata localmente. La regola più importante è che se l'installazione locale esegue la versione "go1", ottenere ricerche per un ramo o un tag denominato "go1". Se non esiste tale versione, recupera il ramo predefinito del pacchetto.

Quando go get controlla o aggiorna un repository Git, aggiorna anche tutti i sottomoduli git a cui fa riferimento il repository.

Non effettuare mai il check-out o l'aggiornamento del codice memorizzato nelle directory dei fornitori.

Per ulteriori informazioni sulla specifica dei pacchetti, vedere "go help packages".

Per ulteriori informazioni su come "go get" trova il codice sorgente da scaricare, vedere "go help importpath".

Questo testo descrive il comportamento di get quando si utilizza GOPATH per gestire il codice sorgente e le dipendenze. Se invece il comando go è in esecuzione in modalità module-aware, i dettagli dei flag e degli effetti di get cambiano, così come "go help get". Vedi 'go help modules' e 'go help module-get'.

Vedi anche: go build, go install, go clean.

Ad esempio, mostrando un output dettagliato,

$ go get -v github.com/capotej/groupcache-db-experiment/...
github.com/capotej/groupcache-db-experiment (download)
github.com/golang/groupcache (download)
github.com/golang/protobuf (download)
github.com/capotej/groupcache-db-experiment/api
github.com/capotej/groupcache-db-experiment/client
github.com/capotej/groupcache-db-experiment/slowdb
github.com/golang/groupcache/consistenthash
github.com/golang/protobuf/proto
github.com/golang/groupcache/lru
github.com/capotej/groupcache-db-experiment/dbserver
github.com/capotej/groupcache-db-experiment/cli
github.com/golang/groupcache/singleflight
github.com/golang/groupcache/groupcachepb
github.com/golang/groupcache
github.com/capotej/groupcache-db-experiment/frontend
$ 

Per prima cosa, abbiamo bisogno di GOPATH

Il $GOPATHè una cartella (o un insieme di cartelle) specificato dalla sua variabile di ambiente. Dobbiamo notare che questa non è la $GOROOTdirectory in cui è installato Go.

export GOPATH=$HOME/gocode
export PATH=$PATH:$GOPATH/bin

Abbiamo utilizzato ~/gocodepath nel nostro computer per memorizzare l'origine della nostra applicazione e le sue dipendenze. IlGOPATH directory memorizzerà anche i binari dei loro pacchetti.

Quindi seleziona Vai env

Il tuo sistema deve avere $GOPATHe $GOROOT, di seguito è il mio Env:

GOARCH="amd64"
GOBIN=""
GOCHAR="6"
GOEXE=""
GOHOSTARCH="amd64"
GOHOSTOS="linux"
GOOS="linux"
GOPATH="/home/elpsstu/gocode"
GORACE=""
GOROOT="/home/pravin/go"
GOTOOLDIR="/home/pravin/go/pkg/tool/linux_amd64"
CC="gcc"
GOGCCFLAGS="-fPIC -m64 -pthread -fmessage-length=0"
CXX="g++"
CGO_ENABLED="1"

Ora, esegui download go package:

go get [-d] [-f] [-fix] [-t] [-u] [build flags] [packages]

Scarica e installa i pacchetti denominati dai percorsi di importazione, insieme alle loro dipendenze. Per maggiori dettagli puoi guardare qui .