func (r ReferenceStorage) SetReference(ref *plumbing.Reference) error {
if ref != nil {
r[ref.Name()] = ref
}
return nil
}
func (s *Server) buildGitUploadPackInfo(ref *plumbing.Reference) *common.GitUploadPackInfo {
info := common.NewGitUploadPackInfo()
info.Refs.SetReference(ref)
info.Refs.SetReference(plumbing.NewSymbolicReference(plumbing.HEAD, ref.Name()))
info.Capabilities.Set("symref", "HEAD:"+ref.Name().String())
return info
}
func (a *AdvRefs) AddReference(r *plumbing.Reference) error {
switch r.Type() {
case plumbing.SymbolicReference:
v := fmt.Sprintf("%s:%s", r.Name().String(), r.Target().String())
a.Capabilities.Add(capability.SymRef, v)
case plumbing.HashReference:
a.References[r.Name().String()] = r.Hash()
default:
return plumbing.ErrInvalidType
}
return nil
}
func (s *Storage) SetReference(ref *plumbing.Reference) error {
key, err := s.buildReferenceKey(ref.Name())
if err != nil {
return err
}
raw := ref.Strings()
bins := driver.BinMap{
urlField: s.url,
"name": raw[0],
"target": raw[1],
}
return s.client.Put(nil, key, bins)
}
func (f *Fetcher) Fetch(w io.Writer, ref *plumbing.Reference) (written int64, err error) {
if err := f.service.Connect(); err != nil {
return 0, err
}
req := &common.GitUploadPackRequest{}
req.Want(ref.Hash())
r, err := f.service.Fetch(req)
if err != nil {
return 0, err
}
return io.Copy(w, r)
}
func resolveReference(s ReferenceStorer, r *plumbing.Reference, recursion int) (*plumbing.Reference, error) {
if r.Type() != plumbing.SymbolicReference {
return r, nil
}
if recursion > MaxResolveRecursion {
return nil, ErrMaxResolveRecursion
}
t, err := s.Reference(r.Target())
if err != nil {
return nil, err
}
recursion++
return resolveReference(s, t, recursion)
}
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
}
func (d *DotGit) SetRef(r *plumbing.Reference) error {
var content string
switch r.Type() {
case plumbing.SymbolicReference:
content = fmt.Sprintf("ref: %s\n", r.Target())
case plumbing.HashReference:
content = fmt.Sprintln(r.Hash().String())
}
f, err := d.fs.Create(r.Name().String())
if err != nil {
return err
}
if _, err := f.Write([]byte(content)); err != nil {
return err
}
return f.Close()
}
func (r *Repository) createReferences(ref *plumbing.Reference) error {
if !ref.IsBranch() {
// detached HEAD mode
head := plumbing.NewHashReference(plumbing.HEAD, ref.Hash())
return r.s.SetReference(head)
}
if err := r.s.SetReference(ref); err != nil {
return err
}
head := plumbing.NewSymbolicReference(plumbing.HEAD, ref.Name())
return r.s.SetReference(head)
}
// we mutate the tag into a branch to avoid detached branches
func (s *Server) mutateTagToBranch(ref *plumbing.Reference, constraint string) *plumbing.Reference {
branch := plumbing.ReferenceName(fmt.Sprintf("refs/heads/%s", constraint))
return plumbing.NewHashReference(branch, ref.Hash())
}
