00623425a2
Right now, any time we instantiate a Manifest object, we create an API client, and when we create the API client, if we're using SSH, we try to make a connection to the server. However, we often instantiate a Manifest object when performing various functionality such as smudging data, which means that when a user creates an archive locally, they can be prompted for an SSH password, which is undesirable. Let's take a first step to fixing this by making Manifest an interface. Right now, it has one concrete version, a concreteManifest, which can be used to access the internals, and we provide methods to upgrade it from the interface to the concrete type and determine whether it's upgraded or not. We attempt to upgrade it any time we need to access its internals. In the future, we'll also offer a lazyManifest, which is lazy and will only instantiate the concreteManifest inside when we attempt to upgrade it to the latter. But for now, only implement the concreteManifest to make it clearer what's changing. Similarly, we make our TransferQueue upgradable so that we don't upgrade its Manifest right away. In both cases, we'll want to use the lazyManifest to delay the instantiation of the API client (and hence the starting of the SSH connection) in a future commit.
121 lines
3.0 KiB
Go
121 lines
3.0 KiB
Go
package tq
|
|
|
|
import (
|
|
"time"
|
|
|
|
"github.com/git-lfs/git-lfs/v3/errors"
|
|
"github.com/git-lfs/git-lfs/v3/git"
|
|
"github.com/git-lfs/git-lfs/v3/lfsapi"
|
|
"github.com/git-lfs/git-lfs/v3/lfshttp"
|
|
"github.com/git-lfs/git-lfs/v3/tr"
|
|
"github.com/rubyist/tracerx"
|
|
)
|
|
|
|
type tqClient struct {
|
|
maxRetries int
|
|
*lfsapi.Client
|
|
}
|
|
|
|
type batchRef struct {
|
|
Name string `json:"name,omitempty"`
|
|
}
|
|
|
|
type batchRequest struct {
|
|
Operation string `json:"operation"`
|
|
Objects []*Transfer `json:"objects"`
|
|
TransferAdapterNames []string `json:"transfers,omitempty"`
|
|
Ref *batchRef `json:"ref"`
|
|
HashAlgorithm string `json:"hash_algo"`
|
|
}
|
|
|
|
type BatchResponse struct {
|
|
Objects []*Transfer `json:"objects"`
|
|
TransferAdapterName string `json:"transfer"`
|
|
HashAlgorithm string `json:"hash_algo"`
|
|
endpoint lfshttp.Endpoint
|
|
}
|
|
|
|
func Batch(m Manifest, dir Direction, remote string, remoteRef *git.Ref, objects []*Transfer) (*BatchResponse, error) {
|
|
if len(objects) == 0 {
|
|
return &BatchResponse{}, nil
|
|
}
|
|
|
|
cm := m.Upgrade()
|
|
|
|
return cm.batchClient().Batch(remote, &batchRequest{
|
|
Operation: dir.String(),
|
|
Objects: objects,
|
|
TransferAdapterNames: m.GetAdapterNames(dir),
|
|
Ref: &batchRef{Name: remoteRef.Refspec()},
|
|
HashAlgorithm: "sha256",
|
|
})
|
|
}
|
|
|
|
type BatchClient interface {
|
|
Batch(remote string, bReq *batchRequest) (*BatchResponse, error)
|
|
MaxRetries() int
|
|
SetMaxRetries(n int)
|
|
}
|
|
|
|
func (c *tqClient) MaxRetries() int {
|
|
return c.maxRetries
|
|
}
|
|
|
|
func (c *tqClient) SetMaxRetries(n int) {
|
|
c.maxRetries = n
|
|
}
|
|
|
|
func (c *tqClient) Batch(remote string, bReq *batchRequest) (*BatchResponse, error) {
|
|
bRes := &BatchResponse{}
|
|
if len(bReq.Objects) == 0 {
|
|
return bRes, nil
|
|
}
|
|
|
|
if len(bReq.TransferAdapterNames) == 1 && bReq.TransferAdapterNames[0] == "basic" {
|
|
bReq.TransferAdapterNames = nil
|
|
}
|
|
|
|
missing := make(map[string]bool)
|
|
for _, obj := range bReq.Objects {
|
|
missing[obj.Oid] = obj.Missing
|
|
}
|
|
|
|
bRes.endpoint = c.Endpoints.Endpoint(bReq.Operation, remote)
|
|
requestedAt := time.Now()
|
|
|
|
req, err := c.NewRequest("POST", bRes.endpoint, "objects/batch", bReq)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, tr.Tr.Get("batch request"))
|
|
}
|
|
|
|
tracerx.Printf("api: batch %d files", len(bReq.Objects))
|
|
|
|
req = c.Client.LogRequest(req, "lfs.batch")
|
|
res, err := c.DoAPIRequestWithAuth(remote, lfshttp.WithRetries(req, c.MaxRetries()))
|
|
if err != nil {
|
|
tracerx.Printf("api error: %s", err)
|
|
return nil, errors.Wrap(err, tr.Tr.Get("batch response"))
|
|
}
|
|
|
|
if err := lfshttp.DecodeJSON(res, bRes); err != nil {
|
|
return bRes, errors.Wrap(err, tr.Tr.Get("batch response"))
|
|
}
|
|
|
|
if bRes.HashAlgorithm != "" && bRes.HashAlgorithm != "sha256" {
|
|
return bRes, errors.Wrap(errors.New(tr.Tr.Get("unsupported hash algorithm")), tr.Tr.Get("batch response"))
|
|
}
|
|
|
|
if res.StatusCode != 200 {
|
|
return nil, lfshttp.NewStatusCodeError(res)
|
|
}
|
|
|
|
for _, obj := range bRes.Objects {
|
|
obj.Missing = missing[obj.Oid]
|
|
for _, a := range obj.Actions {
|
|
a.createdAt = requestedAt
|
|
}
|
|
}
|
|
|
|
return bRes, nil
|
|
}
|