go-git.v4: gopkg.in/src-d/go-git.v4/plumbing/transport Index | Files | Directories

package transport

import "gopkg.in/src-d/go-git.v4/plumbing/transport"

Package transport includes the implementation for different transport protocols.

`Client` can be used to fetch and send packfiles to a git server. The `client` package provides higher level functions to instantiate the appropriate `Client` based on the repository URL.

go-git supports HTTP and SSH (see `Protocols`), but you can also install your own protocols (see the `client` package).

Each protocol has its own implementation of `Client`, but you should generally not use them directly, use `client.NewClient` instead.

Index

Package Files

common.go

Constants

const (
    UploadPackServiceName  = "git-upload-pack"
    ReceivePackServiceName = "git-receive-pack"
)

Variables

var (
    ErrRepositoryNotFound     = errors.New("repository not found")
    ErrEmptyRemoteRepository  = errors.New("remote repository is empty")
    ErrAuthenticationRequired = errors.New("authentication required")
    ErrAuthorizationFailed    = errors.New("authorization failed")
    ErrEmptyUploadPackRequest = errors.New("empty git-upload-pack given")
    ErrInvalidAuthMethod      = errors.New("invalid auth method")
    ErrAlreadyConnected       = errors.New("session already established")
)
var UnsupportedCapabilities = []capability.Capability{
    capability.MultiACK,
    capability.MultiACKDetailed,
    capability.ThinPack,
}

UnsupportedCapabilities are the capabilities not supported by any client implementation

func FilterUnsupportedCapabilities Uses

func FilterUnsupportedCapabilities(list *capability.List)

FilterUnsupportedCapabilities it filter out all the UnsupportedCapabilities from a capability.List, the intended usage is on the client implementation to filter the capabilities from an AdvRefs message.

type AuthMethod Uses

type AuthMethod interface {
    fmt.Stringer
    Name() string
}

type Endpoint Uses

type Endpoint struct {
    // Protocol is the protocol of the endpoint (e.g. git, https, file).
    Protocol string
    // User is the user.
    User string
    // Password is the password.
    Password string
    // Host is the host.
    Host string
    // Port is the port to connect, if 0 the default port for the given protocol
    // wil be used.
    Port int
    // Path is the repository path.
    Path string
}

Endpoint represents a Git URL in any supported protocol.

func NewEndpoint Uses

func NewEndpoint(endpoint string) (*Endpoint, error)

func (*Endpoint) String Uses

func (u *Endpoint) String() string

String returns a string representation of the Git URL.

type ReceivePackSession Uses

type ReceivePackSession interface {
    Session
    // ReceivePack sends an update references request and a packfile
    // reader and returns a ReportStatus and error. Don't be confused by
    // terminology, the client side of a git-receive-pack is called
    // git-send-pack, although here the same interface is used to make it
    // RPC-like.
    ReceivePack(context.Context, *packp.ReferenceUpdateRequest) (*packp.ReportStatus, error)
}

ReceivePackSession represents a git-receive-pack session. A git-receive-pack session has two steps: reference discovery (AdvertisedReferences) and receiving pack (ReceivePack). In that order.

type Session Uses

type Session interface {
    // AdvertisedReferences retrieves the advertised references for a
    // repository.
    // If the repository does not exist, returns ErrRepositoryNotFound.
    // If the repository exists, but is empty, returns ErrEmptyRemoteRepository.
    AdvertisedReferences() (*packp.AdvRefs, error)
    io.Closer
}

type Transport Uses

type Transport interface {
    // NewUploadPackSession starts a git-upload-pack session for an endpoint.
    NewUploadPackSession(*Endpoint, AuthMethod) (UploadPackSession, error)
    // NewReceivePackSession starts a git-receive-pack session for an endpoint.
    NewReceivePackSession(*Endpoint, AuthMethod) (ReceivePackSession, error)
}

Transport can initiate git-upload-pack and git-receive-pack processes. It is implemented both by the client and the server, making this a RPC.

type UploadPackSession Uses

type UploadPackSession interface {
    Session
    // UploadPack takes a git-upload-pack request and returns a response,
    // including a packfile. Don't be confused by terminology, the client
    // side of a git-upload-pack is called git-fetch-pack, although here
    // the same interface is used to make it RPC-like.
    UploadPack(context.Context, *packp.UploadPackRequest) (*packp.UploadPackResponse, error)
}

UploadPackSession represents a git-upload-pack session. A git-upload-pack session has two steps: reference discovery (AdvertisedReferences) and uploading pack (UploadPack).

Directories

PathSynopsis
clientPackage client contains helper function to deal with the different client protocols.
filePackage file implements the file transport protocol.
gitPackage git implements the git transport protocol.
httpPackage http implements the HTTP transport protocol.
internal/commonPackage common implements the git pack protocol with a pluggable transport.
serverPackage server implements the git server protocol.
sshPackage ssh implements the SSH transport protocol.
testPackage test implements common test suite for different transport implementations.

Package transport imports 12 packages (graph) and is imported by 94 packages. Updated 2019-08-01. Refresh now. Tools for package owners.