Package filesystem is a storage backend base on filesystems



    This section is empty.


    This section is empty.


    func NewPackfileIter

    func NewPackfileIter(
    	fs billy.Filesystem,
    	f billy.File,
    	idxFile billy.File,
    	t plumbing.ObjectType,
    	keepPack bool,
    ) (storer.EncodedObjectIter, error)

      NewPackfileIter returns a new EncodedObjectIter for the provided packfile and object type. Packfile and index file will be closed after they're used. If keepPack is true the packfile won't be closed after the iteration finished.


      type ConfigStorage

      type ConfigStorage struct {
      	// contains filtered or unexported fields

      func (*ConfigStorage) Config

      func (c *ConfigStorage) Config() (conf *config.Config, err error)

      func (*ConfigStorage) SetConfig

      func (c *ConfigStorage) SetConfig(cfg *config.Config) (err error)

      type IndexStorage

      type IndexStorage struct {
      	// contains filtered or unexported fields

      func (*IndexStorage) Index

      func (s *IndexStorage) Index() (i *index.Index, err error)

      func (*IndexStorage) SetIndex

      func (s *IndexStorage) SetIndex(idx *index.Index) (err error)

      type ModuleStorage

      type ModuleStorage struct {
      	// contains filtered or unexported fields

      func (*ModuleStorage) Module

      func (s *ModuleStorage) Module(name string) (storage.Storer, error)

      type ObjectStorage

      type ObjectStorage struct {
      	// contains filtered or unexported fields

      func NewObjectStorage

      func NewObjectStorage(dir *dotgit.DotGit, objectCache cache.Object) *ObjectStorage

        NewObjectStorage creates a new ObjectStorage with the given .git directory and cache.

        func NewObjectStorageWithOptions

        func NewObjectStorageWithOptions(dir *dotgit.DotGit, objectCache cache.Object, ops Options) *ObjectStorage

          NewObjectStorageWithOptions creates a new ObjectStorage with the given .git directory, cache and extra options

          func (*ObjectStorage) Close

          func (s *ObjectStorage) Close() error

            Close closes all opened files.

            func (*ObjectStorage) DeleteLooseObject

            func (s *ObjectStorage) DeleteLooseObject(hash plumbing.Hash) error

            func (*ObjectStorage) DeleteOldObjectPackAndIndex

            func (s *ObjectStorage) DeleteOldObjectPackAndIndex(h plumbing.Hash, t time.Time) error

            func (*ObjectStorage) DeltaObject

              DeltaObject returns the object with the given hash, by searching for it in the packfile and the git object directories.

              func (*ObjectStorage) EncodedObject

                EncodedObject returns the object with the given hash, by searching for it in the packfile and the git object directories.

                func (*ObjectStorage) EncodedObjectSize

                func (s *ObjectStorage) EncodedObjectSize(h plumbing.Hash) (
                	size int64, err error)

                  EncodedObjectSize returns the plaintext size of the given object, without actually reading the full object data from storage.

                  func (*ObjectStorage) ForEachObjectHash

                  func (s *ObjectStorage) ForEachObjectHash(fun func(plumbing.Hash) error) error

                  func (*ObjectStorage) HasEncodedObject

                  func (s *ObjectStorage) HasEncodedObject(h plumbing.Hash) (err error)

                    HasEncodedObject returns nil if the object exists, without actually reading the object data from storage.

                    func (*ObjectStorage) IterEncodedObjects

                    func (s *ObjectStorage) IterEncodedObjects(t plumbing.ObjectType) (storer.EncodedObjectIter, error)

                      IterEncodedObjects returns an iterator for all the objects in the packfile with the given type.

                      func (*ObjectStorage) LooseObjectTime

                      func (s *ObjectStorage) LooseObjectTime(hash plumbing.Hash) (time.Time, error)

                      func (*ObjectStorage) NewEncodedObject

                      func (s *ObjectStorage) NewEncodedObject() plumbing.EncodedObject

                      func (*ObjectStorage) ObjectPacks

                      func (s *ObjectStorage) ObjectPacks() ([]plumbing.Hash, error)

                      func (*ObjectStorage) PackfileWriter

                      func (s *ObjectStorage) PackfileWriter() (io.WriteCloser, error)

                      func (*ObjectStorage) Reindex

                      func (s *ObjectStorage) Reindex()

                        Reindex indexes again all packfiles. Useful if git changed packfiles externally

                        func (*ObjectStorage) SetEncodedObject

                        func (s *ObjectStorage) SetEncodedObject(o plumbing.EncodedObject) (h plumbing.Hash, err error)

                          SetEncodedObject adds a new object to the storage.

                          type Options

                          type Options struct {
                          	// ExclusiveAccess means that the filesystem is not modified externally
                          	// while the repo is open.
                          	ExclusiveAccess bool
                          	// KeepDescriptors makes the file descriptors to be reused but they will
                          	// need to be manually closed calling Close().
                          	KeepDescriptors bool
                          	// MaxOpenDescriptors is the max number of file descriptors to keep
                          	// open. If KeepDescriptors is true, all file descriptors will remain open.
                          	MaxOpenDescriptors int

                            Options holds configuration for the storage.

                            type ReferenceStorage

                            type ReferenceStorage struct {
                            	// contains filtered or unexported fields

                            func (*ReferenceStorage) CheckAndSetReference

                            func (r *ReferenceStorage) CheckAndSetReference(ref, old *plumbing.Reference) error

                            func (*ReferenceStorage) CountLooseRefs

                            func (r *ReferenceStorage) CountLooseRefs() (int, error)

                            func (*ReferenceStorage) IterReferences

                            func (r *ReferenceStorage) IterReferences() (storer.ReferenceIter, error)

                            func (*ReferenceStorage) PackRefs

                            func (r *ReferenceStorage) PackRefs() error

                            func (*ReferenceStorage) Reference

                            func (*ReferenceStorage) RemoveReference

                            func (r *ReferenceStorage) RemoveReference(n plumbing.ReferenceName) error

                            func (*ReferenceStorage) SetReference

                            func (r *ReferenceStorage) SetReference(ref *plumbing.Reference) error

                            type ShallowStorage

                            type ShallowStorage struct {
                            	// contains filtered or unexported fields

                              ShallowStorage where the shallow commits are stored, an internal to manipulate the shallow file

                              func (*ShallowStorage) SetShallow

                              func (s *ShallowStorage) SetShallow(commits []plumbing.Hash) error

                                SetShallow save the shallows in the shallow file in the .git folder as one commit per line represented by 40-byte hexadecimal object terminated by a newline.

                                func (*ShallowStorage) Shallow

                                func (s *ShallowStorage) Shallow() ([]plumbing.Hash, error)

                                  Shallow return the shallow commits reading from shallo file from .git

                                  type Storage

                                  type Storage struct {
                                  	// contains filtered or unexported fields

                                    Storage is an implementation of git.Storer that stores data on disk in the standard git format (this is, the .git directory). Zero values of this type are not safe to use, see the NewStorage function below.

                                    func NewStorage

                                    func NewStorage(fs billy.Filesystem, cache cache.Object) *Storage

                                      NewStorage returns a new Storage backed by a given `fs.Filesystem` and cache.

                                      func NewStorageWithOptions

                                      func NewStorageWithOptions(fs billy.Filesystem, cache cache.Object, ops Options) *Storage

                                        NewStorageWithOptions returns a new Storage with extra options, backed by a given `fs.Filesystem` and cache.

                                        func (*Storage) Filesystem

                                        func (s *Storage) Filesystem() billy.Filesystem

                                          Filesystem returns the underlying filesystem

                                          func (*Storage) Init

                                          func (s *Storage) Init() error

                                            Init initializes .git directory


                                            Path Synopsis