func (s *SendPackSuite) sendPackNoCheck(c *C, ep transport.Endpoint,
req *packp.ReferenceUpdateRequest, fixture *fixtures.Fixture,
callAdvertisedReferences bool) (*packp.ReportStatus, error) {
url := ""
if fixture != nil {
url = fixture.URL
}
comment := Commentf(
"failed with ep=%s fixture=%s callAdvertisedReferences=%s",
ep.String(), url, callAdvertisedReferences,
)
r, err := s.Client.NewSendPackSession(ep)
c.Assert(err, IsNil, comment)
defer func() { c.Assert(r.Close(), IsNil, comment) }()
if callAdvertisedReferences {
info, err := r.AdvertisedReferences()
c.Assert(err, IsNil, comment)
c.Assert(info, NotNil, comment)
}
if fixture != nil {
c.Assert(fixture.Packfile(), NotNil)
req.Packfile = fixture.Packfile()
} else {
req.Packfile = s.emptyPackfile()
}
return r.SendPack(req)
}
func (s *session) SendPack(req *packp.ReferenceUpdateRequest) (*packp.ReportStatus, error) {
if _, err := s.AdvertisedReferences(); err != nil {
return nil, err
}
s.packRun = true
if err := req.Encode(s.Stdin); err != nil {
return nil, err
}
if !req.Capabilities.Supports(capability.ReportStatus) {
// If we have neither report-status or sideband, we can only
// check return value error.
return nil, s.Command.Wait()
}
report := packp.NewReportStatus()
if err := report.Decode(s.Stdout); err != nil {
return nil, err
}
if err := report.Error(); err != nil {
return report, err
}
return report, s.Command.Wait()
}
func pushHashes(sess transport.SendPackSession, sto storer.EncodedObjectStorer,
req *packp.ReferenceUpdateRequest, hs []plumbing.Hash) (*packp.ReportStatus, error) {
rd, wr := io.Pipe()
req.Packfile = rd
done := make(chan error)
go func() {
e := packfile.NewEncoder(wr, sto, false)
if _, err := e.Encode(hs); err != nil {
done <- wr.CloseWithError(err)
return
}
done <- wr.Close()
}()
rs, err := sess.SendPack(req)
if err != nil {
return nil, err
}
if err := <-done; err != nil {
return nil, err
}
return rs, nil
}
func (r *Remote) addReferenceIfRefSpecMatches(rs config.RefSpec,
remoteRefs storer.ReferenceStorer, localRef *plumbing.Reference,
req *packp.ReferenceUpdateRequest) error {
if localRef.Type() != plumbing.HashReference {
return nil
}
if !rs.Match(localRef.Name()) {
return nil
}
dstName := rs.Dst(localRef.Name())
oldHash := plumbing.ZeroHash
newHash := localRef.Hash()
iter, err := remoteRefs.IterReferences()
if err != nil {
return err
}
err = iter.ForEach(func(remoteRef *plumbing.Reference) error {
if remoteRef.Type() != plumbing.HashReference {
return nil
}
if dstName != remoteRef.Name() {
return nil
}
oldHash = remoteRef.Hash()
return nil
})
if oldHash == newHash {
return nil
}
req.Commands = append(req.Commands, &packp.Command{
Name: dstName,
Old: oldHash,
New: newHash,
})
return nil
}