Add ACL exchange logic

pkg/acl/list/list.go

@@ -22,6 +22,7 @@ type ACLList interface {
 	RWLocker
 	ID() string
 	Header() *aclpb.Header
+	Records() []*Record
 	ACLState() *ACLState
 	IsAfter(first string, second string) (bool, error)
 	Head() *Record
@@ -113,6 +114,10 @@ func buildWithACLStateBuilder(builder *aclStateBuilder, storage storage.ListStor
 	}, nil
 }
 
+func (a *aclList) Records() []*Record {
+	return a.records
+}
+
 func (a *aclList) ID() string {
 	return a.id
 }

pkg/acl/storage/inmemory.go

@@ -7,11 +7,64 @@ import (
 	"sync"
 )
 
+type inMemoryACLListStorage struct {
+	header  *aclpb.Header
+	records []*aclpb.RawRecord
+
+	id string
+
+	sync.RWMutex
+}
+
+func NewInMemoryACLListStorage(
+	id string,
+	header *aclpb.Header,
+	records []*aclpb.RawRecord) (ListStorage, error) {
+	return &inMemoryACLListStorage{
+		id:      id,
+		header:  header,
+		records: records,
+		RWMutex: sync.RWMutex{},
+	}, nil
+}
+
+func (i *inMemoryACLListStorage) Header() (*aclpb.Header, error) {
+	i.RLock()
+	defer i.RUnlock()
+	return i.header, nil
+}
+
+func (i *inMemoryACLListStorage) Head() (*aclpb.RawRecord, error) {
+	i.RLock()
+	defer i.RUnlock()
+	return i.records[len(i.records)-1], nil
+}
+
+func (i *inMemoryACLListStorage) GetRawRecord(ctx context.Context, id string) (*aclpb.RawRecord, error) {
+	i.RLock()
+	defer i.RUnlock()
+	for _, rec := range i.records {
+		if rec.Id == id {
+			return rec, nil
+		}
+	}
+	return nil, fmt.Errorf("no such record")
+}
+
+func (i *inMemoryACLListStorage) AddRawRecord(ctx context.Context, rec *aclpb.RawRecord) error {
+	panic("implement me")
+}
+
+func (i *inMemoryACLListStorage) ID() (string, error) {
+	i.RLock()
+	defer i.RUnlock()
+	return i.id, nil
+}
+
 type inMemoryTreeStorage struct {
 	id      string
 	header  *aclpb.Header
 	heads   []string
-	orphans []string
 	changes map[string]*aclpb.RawChange
 
 	sync.RWMutex
@@ -24,17 +77,14 @@ func NewInMemoryTreeStorage(
 	header *aclpb.Header,
 	changes []*aclpb.RawChange) (TreeStorage, error) {
 	allChanges := make(map[string]*aclpb.RawChange)
-	var orphans []string
 	for _, ch := range changes {
 		allChanges[ch.Id] = ch
-		orphans = append(orphans, ch.Id)
 	}
 
 	return &inMemoryTreeStorage{
 		id:      treeId,
 		header:  header,
 		heads:   nil,
-		orphans: orphans,
 		changes: allChanges,
 		RWMutex: sync.RWMutex{},
 	}, nil
@@ -123,6 +173,18 @@ func (i *inMemoryStorageProvider) CreateTreeStorage(treeId string, header *aclpb
 	return res, nil
 }
 
+func (i *inMemoryStorageProvider) CreateACLListStorage(id string, header *aclpb.Header, records []*aclpb.RawRecord) (ListStorage, error) {
+	i.Lock()
+	defer i.Unlock()
+	res, err := NewInMemoryACLListStorage(id, header, records)
+	if err != nil {
+		return nil, err
+	}
+
+	i.objects[id] = res
+	return res, nil
+}
+
 func NewInMemoryTreeStorageProvider() Provider {
 	return &inMemoryStorageProvider{
 		objects: make(map[string]Storage),

pkg/acl/storage/provider.go

@@ -11,4 +11,5 @@ type Provider interface {
 	Storage(id string) (Storage, error)
 	AddStorage(id string, st Storage) error
 	CreateTreeStorage(treeId string, header *aclpb.Header, changes []*aclpb.RawChange) (TreeStorage, error)
+	CreateACLListStorage(id string, header *aclpb.Header, records []*aclpb.RawRecord) (ListStorage, error)
 }

pkg/acl/testutils/acllistbuilder/liststoragebuilder.go

@@ -106,6 +106,10 @@ func (t *ACLListStorageBuilder) ID() (string, error) {
 	return t.id, nil
 }
 
+func (t *ACLListStorageBuilder) GetRawRecords() []*aclpb.RawRecord {
+	return t.rawRecords
+}
+
 func (t *ACLListStorageBuilder) GetKeychain() *Keychain {
 	return t.keychain
 }

service/document/service.go

@@ -58,7 +58,15 @@ func (s *service) Name() (name string) {
 }
 
 func (s *service) Run(ctx context.Context) (err error) {
-	return nil
+	syncData := s.storage.ImportedACLSyncData()
+
+	// we could have added a timeout or some additional logic,
+	// but let's just use the ACL id of the latest started node :-)
+	return s.messageService.SendToSpaceAsync("", syncproto.WrapACLList(
+		&syncproto.SyncACLList{Records: syncData.Records},
+		syncData.Header,
+		syncData.Id,
+	))
 }
 
 func (s *service) Close(ctx context.Context) (err error) {

service/storage/service.go

@@ -18,8 +18,15 @@ var CName = "storage"
 
 var log = logger.NewNamed("storage").Sugar()
 
+type ImportedACLSyncData struct {
+	Id      string
+	Header  *aclpb.Header
+	Records []*aclpb.RawRecord
+}
+
 type Service interface {
 	storage.Provider
+	ImportedACLSyncData() ImportedACLSyncData
 }
 
 func New() app.Component {
@@ -27,7 +34,8 @@ func New() app.Component {
 }
 
 type service struct {
-	storageProvider storage.Provider
+	storageProvider     storage.Provider
+	importedACLSyncData ImportedACLSyncData
 }
 
 func (s *service) Init(ctx context.Context, a *app.App) (err error) {
@@ -48,10 +56,18 @@ func (s *service) CreateTreeStorage(treeId string, header *aclpb.Header, changes
 	return s.storageProvider.CreateTreeStorage(treeId, header, changes)
 }
 
+func (s *service) CreateACLListStorage(id string, header *aclpb.Header, records []*aclpb.RawRecord) (storage.ListStorage, error) {
+	return s.storageProvider.CreateACLListStorage(id, header, records)
+}
+
 func (s *service) Name() (name string) {
 	return CName
 }
 
+func (s *service) ImportedACLSyncData() ImportedACLSyncData {
+	return s.importedACLSyncData
+}
+
 func (s *service) Run(ctx context.Context) (err error) {
 	return nil
 }
@@ -72,12 +88,23 @@ func (s *service) importACLList(a *app.App) (err error) {
 		return err
 	}
 
+	header, err := st.Header()
+	if err != nil {
+		return err
+	}
+
 	// checking that acl list contains all the needed permissions for all our nodes
 	err = s.checkActualNodesPermissions(st, a)
 	if err != nil {
 		return err
 	}
 
+	s.importedACLSyncData = ImportedACLSyncData{
+		Id:      id,
+		Header:  header,
+		Records: st.GetRawRecords(),
+	}
+
 	log.Infof("imported ACLList with id %s", id)
 	return s.storageProvider.AddStorage(id, st)
 }

service/sync/requesthandler/requesthandler.go

@@ -66,6 +66,8 @@ func (r *requestHandler) HandleSyncMessage(ctx context.Context, senderId string,
 		return r.HandleFullSyncResponse(ctx, senderId, msg.GetFullSyncResponse(), content.GetTreeHeader(), content.GetTreeId())
 	case msg.GetHeadUpdate() != nil:
 		return r.HandleHeadUpdate(ctx, senderId, msg.GetHeadUpdate(), content.GetTreeHeader(), content.GetTreeId())
+	case msg.GetAclList() != nil:
+		return r.HandleACLList(ctx, senderId, msg.GetAclList(), content.GetTreeHeader(), content.GetTreeId())
 	}
 	return nil
 }
@@ -267,6 +269,27 @@ func (r *requestHandler) HandleFullSyncResponse(
 	return r.messageService.SendToSpaceAsync("", syncproto.WrapHeadUpdate(newUpdate, header, treeId))
 }
 
+func (r *requestHandler) HandleACLList(
+	ctx context.Context,
+	senderId string,
+	req *syncproto.SyncACLList,
+	header *aclpb.Header,
+	id string) (err error) {
+
+	err = r.treeCache.Do(ctx, id, func(obj interface{}) error {
+		return nil
+	})
+	// do nothing if already added
+	if err == nil {
+		return nil
+	}
+	// if not found then add to storage
+	if err == storage.ErrUnknownTreeId {
+		return r.createACLList(ctx, req, header, id)
+	}
+	return err
+}
+
 func (r *requestHandler) prepareFullSyncRequest(theirPath []string, t tree.CommonTree) (*syncproto.SyncFullRequest, error) {
 	ourChanges, err := t.ChangesAfterCommonSnapshot(theirPath)
 	if err != nil {
@@ -320,9 +343,23 @@ func (r *requestHandler) createTree(
 	return r.treeCache.Add(
 		ctx,
 		treeId,
-		header,
-		response.Changes,
-		func(obj interface{}) error {
-			return nil
+		treecache.TreePayload{
+			Header:  header,
+			Changes: response.Changes,
+		})
+}
+
+func (r *requestHandler) createACLList(
+	ctx context.Context,
+	req *syncproto.SyncACLList,
+	header *aclpb.Header,
+	treeId string) error {
+
+	return r.treeCache.Add(
+		ctx,
+		treeId,
+		treecache.ACLListPayload{
+			Header:  header,
+			Records: req.Records,
 		})
 }

service/treecache/service.go

@@ -17,14 +17,23 @@ import (
 
 const CName = "treecache"
 
-// TODO: add context
 type ObjFunc = func(obj interface{}) error
 
 var log = logger.NewNamed("treecache")
 
+type TreePayload struct {
+	Header  *aclpb.Header
+	Changes []*aclpb.RawChange
+}
+
+type ACLListPayload struct {
+	Header  *aclpb.Header
+	Records []*aclpb.RawRecord
+}
+
 type Service interface {
-	Do(ctx context.Context, treeId string, f ObjFunc) error
-	Add(ctx context.Context, treeId string, header *aclpb.Header, changes []*aclpb.RawChange, f ObjFunc) error
+	Do(ctx context.Context, id string, f ObjFunc) error
+	Add(ctx context.Context, id string, payload interface{}) error
 }
 
 type service struct {
@@ -50,16 +59,29 @@ func (s *service) Do(ctx context.Context, treeId string, f ObjFunc) error {
 	return f(t)
 }
 
-func (s *service) Add(ctx context.Context, treeId string, header *aclpb.Header, changes []*aclpb.RawChange, f ObjFunc) error {
-	log.
-		With(zap.String("treeId", treeId), zap.Int("len(changes)", len(changes))).
-		Debug("adding tree with changes")
+func (s *service) Add(ctx context.Context, treeId string, payload interface{}) error {
+	switch pl := payload.(type) {
+	case TreePayload:
+		log.
+			With(zap.String("treeId", treeId), zap.Int("len(changes)", len(pl.Changes))).
+			Debug("adding Tree with changes")
+
+		_, err := s.storage.CreateTreeStorage(treeId, pl.Header, pl.Changes)
+		if err != nil {
+			return err
+		}
+	case ACLListPayload:
+		log.
+			With(zap.String("treeId", treeId), zap.Int("len(changes)", len(pl.Records))).
+			Debug("adding ACLList with records")
+
+		_, err := s.storage.CreateACLListStorage(treeId, pl.Header, pl.Records)
+		if err != nil {
+			return err
+		}
 
-	_, err := s.storage.CreateTreeStorage(treeId, header, changes)
-	if err != nil {
-		return err
 	}
-	return s.Do(ctx, treeId, f)
+	return nil
 }
 
 func (s *service) Init(ctx context.Context, a *app.App) (err error) {
@@ -92,7 +114,7 @@ func (s *service) loadTree(ctx context.Context, id string) (ocache.Object, error
 		return nil, err
 	}
 
-	switch header.DocType {
+	switch header.DocType { // handler
 	case aclpb.Header_ACL:
 		return list.BuildACLListWithIdentity(s.account.Account(), t.(aclstorage.ListStorage))
 	case aclpb.Header_DocTree:

syncproto/helpers.go

@@ -33,3 +33,13 @@ func WrapFullResponse(response *SyncFullResponse, header *aclpb.Header, treeId s
 		TreeId:     treeId,
 	}
 }
+
+func WrapACLList(aclList *SyncACLList, header *aclpb.Header, id string) *Sync {
+	return &Sync{
+		Message: &SyncContentValue{
+			Value: &SyncContentValueValueOfAclList{AclList: aclList},
+		},
+		TreeHeader: header,
+		TreeId:     id,
+	}
+}

syncproto/proto/sync.proto

@@ -60,9 +60,14 @@ message Sync {
             HeadUpdate headUpdate = 1;
             Full.Request fullSyncRequest = 2;
             Full.Response fullSyncResponse = 3;
+            ACLList aclList = 4;
         }
     }
 
+    message ACLList {
+        repeated acl.RawRecord records = 1;
+    }
+
     message HeadUpdate {
         repeated string heads = 1;
         repeated acl.RawChange changes = 2;

syncproto/sync.pb.go

@@ -661,6 +661,7 @@ type SyncContentValue struct {
 	//	*SyncContentValueValueOfHeadUpdate
 	//	*SyncContentValueValueOfFullSyncRequest
 	//	*SyncContentValueValueOfFullSyncResponse
+	//	*SyncContentValueValueOfAclList
 	Value IsSyncContentValueValue `protobuf_oneof:"value"`
 }
 
@@ -712,10 +713,14 @@ type SyncContentValueValueOfFullSyncRequest struct {
 type SyncContentValueValueOfFullSyncResponse struct {
 	FullSyncResponse *SyncFullResponse `protobuf:"bytes,3,opt,name=fullSyncResponse,proto3,oneof" json:"fullSyncResponse,omitempty"`
 }
+type SyncContentValueValueOfAclList struct {
+	AclList *SyncACLList `protobuf:"bytes,4,opt,name=aclList,proto3,oneof" json:"aclList,omitempty"`
+}
 
 func (*SyncContentValueValueOfHeadUpdate) IsSyncContentValueValue()       {}
 func (*SyncContentValueValueOfFullSyncRequest) IsSyncContentValueValue()  {}
 func (*SyncContentValueValueOfFullSyncResponse) IsSyncContentValueValue() {}
+func (*SyncContentValueValueOfAclList) IsSyncContentValueValue()          {}
 
 func (m *SyncContentValue) GetValue() IsSyncContentValueValue {
 	if m != nil {
@@ -745,15 +750,67 @@ func (m *SyncContentValue) GetFullSyncResponse() *SyncFullResponse {
 	return nil
 }
 
+func (m *SyncContentValue) GetAclList() *SyncACLList {
+	if x, ok := m.GetValue().(*SyncContentValueValueOfAclList); ok {
+		return x.AclList
+	}
+	return nil
+}
+
 // XXX_OneofWrappers is for the internal use of the proto package.
 func (*SyncContentValue) XXX_OneofWrappers() []interface{} {
 	return []interface{}{
 		(*SyncContentValueValueOfHeadUpdate)(nil),
 		(*SyncContentValueValueOfFullSyncRequest)(nil),
 		(*SyncContentValueValueOfFullSyncResponse)(nil),
+		(*SyncContentValueValueOfAclList)(nil),
 	}
 }
 
+type SyncACLList struct {
+	Records []*aclpb.RawRecord `protobuf:"bytes,1,rep,name=records,proto3" json:"records,omitempty"`
+}
+
+func (m *SyncACLList) Reset()         { *m = SyncACLList{} }
+func (m *SyncACLList) String() string { return proto.CompactTextString(m) }
+func (*SyncACLList) ProtoMessage()    {}
+func (*SyncACLList) Descriptor() ([]byte, []int) {
+	return fileDescriptor_4b28dfdd48a89166, []int{4, 1}
+}
+func (m *SyncACLList) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *SyncACLList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_SyncACLList.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *SyncACLList) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_SyncACLList.Merge(m, src)
+}
+func (m *SyncACLList) XXX_Size() int {
+	return m.Size()
+}
+func (m *SyncACLList) XXX_DiscardUnknown() {
+	xxx_messageInfo_SyncACLList.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_SyncACLList proto.InternalMessageInfo
+
+func (m *SyncACLList) GetRecords() []*aclpb.RawRecord {
+	if m != nil {
+		return m.Records
+	}
+	return nil
+}
+
 type SyncHeadUpdate struct {
 	Heads        []string           `protobuf:"bytes,1,rep,name=heads,proto3" json:"heads,omitempty"`
 	Changes      []*aclpb.RawChange `protobuf:"bytes,2,rep,name=changes,proto3" json:"changes,omitempty"`
@@ -764,7 +821,7 @@ func (m *SyncHeadUpdate) Reset()         { *m = SyncHeadUpdate{} }
 func (m *SyncHeadUpdate) String() string { return proto.CompactTextString(m) }
 func (*SyncHeadUpdate) ProtoMessage()    {}
 func (*SyncHeadUpdate) Descriptor() ([]byte, []int) {
-	return fileDescriptor_4b28dfdd48a89166, []int{4, 1}
+	return fileDescriptor_4b28dfdd48a89166, []int{4, 2}
 }
 func (m *SyncHeadUpdate) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -821,7 +878,7 @@ func (m *SyncFull) Reset()         { *m = SyncFull{} }
 func (m *SyncFull) String() string { return proto.CompactTextString(m) }
 func (*SyncFull) ProtoMessage()    {}
 func (*SyncFull) Descriptor() ([]byte, []int) {
-	return fileDescriptor_4b28dfdd48a89166, []int{4, 2}
+	return fileDescriptor_4b28dfdd48a89166, []int{4, 3}
 }
 func (m *SyncFull) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -861,7 +918,7 @@ func (m *SyncFullRequest) Reset()         { *m = SyncFullRequest{} }
 func (m *SyncFullRequest) String() string { return proto.CompactTextString(m) }
 func (*SyncFullRequest) ProtoMessage()    {}
 func (*SyncFullRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_4b28dfdd48a89166, []int{4, 2, 0}
+	return fileDescriptor_4b28dfdd48a89166, []int{4, 3, 0}
 }
 func (m *SyncFullRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -921,7 +978,7 @@ func (m *SyncFullResponse) Reset()         { *m = SyncFullResponse{} }
 func (m *SyncFullResponse) String() string { return proto.CompactTextString(m) }
 func (*SyncFullResponse) ProtoMessage()    {}
 func (*SyncFullResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_4b28dfdd48a89166, []int{4, 2, 1}
+	return fileDescriptor_4b28dfdd48a89166, []int{4, 3, 1}
 }
 func (m *SyncFullResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -986,6 +1043,7 @@ func init() {
 	proto.RegisterType((*SubscriptionUnsubscribeSpace)(nil), "anytype.Subscription.UnsubscribeSpace")
 	proto.RegisterType((*Sync)(nil), "anytype.Sync")
 	proto.RegisterType((*SyncContentValue)(nil), "anytype.Sync.ContentValue")
+	proto.RegisterType((*SyncACLList)(nil), "anytype.Sync.ACLList")
 	proto.RegisterType((*SyncHeadUpdate)(nil), "anytype.Sync.HeadUpdate")
 	proto.RegisterType((*SyncFull)(nil), "anytype.Sync.Full")
 	proto.RegisterType((*SyncFullRequest)(nil), "anytype.Sync.Full.Request")
@@ -995,60 +1053,63 @@ func init() {
 func init() { proto.RegisterFile("syncproto/proto/sync.proto", fileDescriptor_4b28dfdd48a89166) }
 
 var fileDescriptor_4b28dfdd48a89166 = []byte{
-	// 840 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x55, 0xd1, 0x8e, 0xdb, 0x44,
-	0x14, 0x8d, 0x13, 0x27, 0x69, 0x6e, 0xa2, 0xac, 0x99, 0xb6, 0x60, 0xdc, 0x2a, 0xb2, 0xac, 0x02,
-	0x56, 0x8b, 0xbc, 0x28, 0x50, 0x21, 0xf1, 0xd6, 0x2e, 0xbb, 0x4a, 0x44, 0x49, 0xa2, 0xc9, 0x66,
-	0x91, 0x78, 0xa9, 0x26, 0xf6, 0x34, 0x89, 0xe2, 0x1d, 0x1b, 0x8f, 0x0d, 0xe4, 0x17, 0x78, 0xea,
-	0x37, 0xf0, 0x0d, 0x7c, 0x04, 0x8f, 0x7d, 0xe4, 0x09, 0xa1, 0x5d, 0xc1, 0x77, 0xa0, 0x99, 0xb1,
-	0x13, 0xaf, 0xbb, 0x7d, 0xed, 0x43, 0x92, 0xb9, 0xf7, 0x9e, 0x73, 0xe6, 0x5c, 0x8f, 0xef, 0x04,
-	0x2c, 0xbe, 0x63, 0x7e, 0x9c, 0x44, 0x69, 0x74, 0xac, 0xbe, 0x45, 0xec, 0xc9, 0x25, 0x6a, 0x13,
-	0xb6, 0x4b, 0x77, 0x31, 0xb5, 0xbe, 0x88, 0xb7, 0xab, 0x63, 0xe2, 0x87, 0xe2, 0xe3, 0xaf, 0x09,
-	0x5b, 0x51, 0x2e, 0x96, 0xf1, 0x52, 0x71, 0x78, 0x29, 0xaf, 0xa8, 0xce, 0x19, 0xb4, 0xbf, 0xa7,
-	0x9c, 0x93, 0x15, 0x45, 0x9f, 0x41, 0x6b, 0x4d, 0x49, 0x40, 0x13, 0x53, 0xb3, 0x35, 0xb7, 0x3b,
-	0x3c, 0xf2, 0x72, 0x59, 0x6f, 0x24, 0xd3, 0x38, 0x2f, 0x23, 0x04, 0x7a, 0x40, 0x52, 0x62, 0xd6,
-	0x6d, 0xcd, 0xed, 0x61, 0xb9, 0x76, 0x7e, 0xd7, 0xa0, 0xa5, 0x60, 0xc8, 0x84, 0x76, 0x9a, 0x10,
-	0x9f, 0x8e, 0x03, 0x29, 0xd4, 0xc3, 0x45, 0x88, 0x1e, 0x42, 0x27, 0xa1, 0x3f, 0x65, 0x94, 0xa7,
-	0xe3, 0x40, 0xb2, 0x75, 0x7c, 0x48, 0x08, 0x5e, 0x42, 0xe3, 0x70, 0x37, 0x0e, 0xcc, 0x86, 0xac,
-	0x15, 0x21, 0x72, 0x41, 0x17, 0x3e, 0x4c, 0xdd, 0xd6, 0xdc, 0xfe, 0xf0, 0xde, 0xde, 0x57, 0xee,
-	0xfc, 0x7c, 0x17, 0x53, 0x2c, 0x11, 0x62, 0x87, 0x80, 0x2e, 0xb3, 0xd5, 0x98, 0xbd, 0x8a, 0xcc,
-	0xa6, 0xad, 0xb9, 0x1d, 0x7c, 0x48, 0x38, 0x7f, 0x34, 0xa0, 0x35, 0xdf, 0xf1, 0x94, 0x5e, 0xa2,
-	0xaf, 0xa1, 0xb3, 0x26, 0x2c, 0xe0, 0x6b, 0xb2, 0xa5, 0x79, 0xbf, 0x1f, 0xef, 0x75, 0x15, 0xc6,
-	0x1b, 0x15, 0x00, 0x7c, 0xc0, 0x0a, 0x2f, 0xf1, 0x86, 0xad, 0xa4, 0xfd, 0x6e, 0xc9, 0x4b, 0xce,
-	0x99, 0x6d, 0xd8, 0x0a, 0x4b, 0x04, 0xfa, 0x04, 0x1a, 0xc4, 0xdf, 0xca, 0x5e, 0xba, 0xc3, 0xbb,
-	0x55, 0xe0, 0x33, 0x7f, 0x8b, 0x45, 0xdd, 0x7a, 0x0a, 0x9d, 0x51, 0x49, 0xfd, 0x48, 0x9e, 0x8b,
-	0x1f, 0x85, 0x17, 0x34, 0xe1, 0x9b, 0x88, 0x49, 0x73, 0x1d, 0x5c, 0x4d, 0x5b, 0x0e, 0xe8, 0x62,
-	0x2f, 0x64, 0xc1, 0x9d, 0x8c, 0x6d, 0x7e, 0x3d, 0xdf, 0x5c, 0xaa, 0x3e, 0x74, 0xbc, 0x8f, 0xad,
-	0x21, 0x34, 0x9e, 0xf9, 0x5b, 0xf4, 0x04, 0x9a, 0x34, 0x49, 0xa2, 0x24, 0xf7, 0x7c, 0xbf, 0x6a,
-	0xe5, 0x54, 0x14, 0xb1, 0xc2, 0x58, 0xaf, 0x35, 0x68, 0xca, 0x04, 0xf2, 0x40, 0xf7, 0xa3, 0x40,
-	0xa9, 0xf6, 0x87, 0xd6, 0xad, 0x2c, 0xef, 0x24, 0x0a, 0x28, 0x96, 0x38, 0x64, 0x43, 0x37, 0xa0,
-	0xdc, 0x4f, 0x36, 0x71, 0x2a, 0x7c, 0xd7, 0xa5, 0xef, 0x72, 0xca, 0x79, 0x0a, 0xba, 0xc0, 0xa3,
-	0x2e, 0xb4, 0x17, 0x93, 0xef, 0x26, 0xd3, 0x1f, 0x26, 0x46, 0x0d, 0xd9, 0xf0, 0x70, 0x31, 0x99,
-	0x2f, 0x66, 0xb3, 0x29, 0x3e, 0x3f, 0xfd, 0xf6, 0xe5, 0x0c, 0x4f, 0xcf, 0xa7, 0x27, 0xd3, 0x17,
-	0x2f, 0x2f, 0x4e, 0xf1, 0x7c, 0x3c, 0x9d, 0x18, 0xe0, 0xfc, 0x56, 0x87, 0xde, 0x3c, 0x5b, 0xee,
-	0x75, 0xd0, 0x0b, 0xe8, 0x73, 0x15, 0x2f, 0xe9, 0x3c, 0x26, 0x7e, 0x71, 0x82, 0x8f, 0x0e, 0x1e,
-	0x4b, 0xf0, 0x22, 0xc8, 0xb1, 0xb8, 0xc2, 0x45, 0x18, 0x8c, 0x8c, 0x55, 0xf4, 0xd4, 0x93, 0xfa,
-	0xf4, 0x76, 0xbd, 0x45, 0x05, 0x8d, 0xdf, 0xe2, 0x5b, 0x8f, 0xa1, 0x7f, 0x73, 0x57, 0xf1, 0x76,
-	0xf3, 0xf8, 0x30, 0x15, 0x1d, 0x5c, 0x84, 0xd6, 0xe7, 0x60, 0x54, 0x15, 0xdf, 0x8d, 0x76, 0xfe,
-	0x6e, 0x82, 0x3e, 0xdf, 0x31, 0xff, 0xdd, 0x10, 0xf4, 0x15, 0xb4, 0x2f, 0xd5, 0x64, 0xe4, 0x7d,
-	0x94, 0xcf, 0x8e, 0xf9, 0xde, 0x49, 0xc4, 0x52, 0xca, 0xd2, 0x0b, 0x12, 0x66, 0x14, 0x17, 0x50,
-	0xf4, 0x04, 0x20, 0x4d, 0x28, 0x55, 0x43, 0x9c, 0xbf, 0xb5, 0x5d, 0x8f, 0xf8, 0x61, 0x31, 0xfe,
-	0xa5, 0x32, 0xfa, 0x10, 0x5a, 0x22, 0x1a, 0x07, 0x72, 0x26, 0x3b, 0x38, 0x8f, 0xac, 0xff, 0x34,
-	0xe8, 0x95, 0xe5, 0xd1, 0x37, 0x00, 0xe2, 0xd6, 0x58, 0xc4, 0x01, 0x49, 0x8b, 0x63, 0x32, 0x6f,
-	0xda, 0x19, 0xed, 0xeb, 0xa3, 0x1a, 0x2e, 0xa1, 0xd1, 0x19, 0x1c, 0xbd, 0xca, 0xc2, 0x50, 0x80,
-	0xb0, 0xba, 0x25, 0x6e, 0xef, 0xe7, 0x2c, 0x0b, 0x43, 0x2f, 0x47, 0x8c, 0x6a, 0xb8, 0x4a, 0x42,
-	0x63, 0x30, 0x0e, 0x29, 0x1e, 0x47, 0x8c, 0xd3, 0xbc, 0xbf, 0x07, 0xb7, 0x0a, 0x29, 0xc8, 0xa8,
-	0x86, 0xdf, 0xa2, 0x3d, 0x6f, 0x43, 0xf3, 0x67, 0xd1, 0x97, 0x15, 0x03, 0x1c, 0x7c, 0xa3, 0x7b,
-	0xd0, 0x14, 0xbe, 0xb9, 0xa9, 0xd9, 0x0d, 0xb7, 0x83, 0x55, 0x80, 0x5c, 0x68, 0xe7, 0x97, 0xad,
-	0x59, 0xb7, 0x1b, 0x6e, 0x77, 0xd8, 0x97, 0x8f, 0x13, 0x93, 0x5f, 0x4e, 0x64, 0x1a, 0x17, 0x65,
-	0xe4, 0x40, 0x8f, 0x33, 0x12, 0xf3, 0x75, 0x94, 0xce, 0x48, 0xba, 0x36, 0x1b, 0x52, 0xe6, 0x46,
-	0xce, 0xfa, 0x57, 0x03, 0x5d, 0x18, 0xb4, 0x2e, 0xa1, 0x5d, 0x74, 0xf6, 0x3e, 0xf6, 0x65, 0x70,
-	0xa7, 0x68, 0xff, 0x7d, 0xec, 0xf7, 0xf8, 0x02, 0xba, 0xa5, 0x7b, 0x1d, 0xdd, 0x87, 0x0f, 0x4a,
-	0xa1, 0xba, 0x7b, 0x8c, 0x1a, 0x7a, 0x00, 0x1f, 0x95, 0xd3, 0xa5, 0xf1, 0x34, 0x34, 0x74, 0x17,
-	0x8e, 0x6e, 0x70, 0x98, 0x6f, 0xd4, 0x9f, 0x3f, 0xfa, 0xf3, 0x6a, 0xa0, 0xbd, 0xb9, 0x1a, 0x68,
-	0xff, 0x5c, 0x0d, 0xb4, 0xd7, 0xd7, 0x83, 0xda, 0x9b, 0xeb, 0x41, 0xed, 0xaf, 0xeb, 0x41, 0xed,
-	0x47, 0x38, 0xde, 0xff, 0xb7, 0x2e, 0x5b, 0xf2, 0xe7, 0xcb, 0xff, 0x03, 0x00, 0x00, 0xff, 0xff,
-	0x34, 0xaa, 0x76, 0x9b, 0x6f, 0x07, 0x00, 0x00,
+	// 882 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x55, 0x41, 0x8f, 0xda, 0x46,
+	0x14, 0xb6, 0xc1, 0xe0, 0xf0, 0x40, 0x2c, 0x9d, 0x24, 0xad, 0xeb, 0x44, 0x08, 0xa1, 0xb4, 0x45,
+	0x49, 0xe5, 0x6d, 0x49, 0xa3, 0x4a, 0xbd, 0x6d, 0xe8, 0xae, 0x40, 0xdd, 0x02, 0x1a, 0x96, 0xad,
+	0xd4, 0x4b, 0x34, 0x8c, 0x27, 0x80, 0xf0, 0x8e, 0x5d, 0x8f, 0x69, 0xcb, 0x5f, 0xe8, 0x29, 0xd7,
+	0x5e, 0xfb, 0x1b, 0xfa, 0x1b, 0xaa, 0x1e, 0x73, 0xec, 0xb1, 0xda, 0x55, 0xff, 0x47, 0x35, 0x33,
+	0x36, 0x18, 0xb2, 0xb9, 0xee, 0x61, 0x17, 0xbf, 0xf7, 0xbe, 0xef, 0x9b, 0xef, 0xbd, 0xf1, 0x8c,
+	0xc1, 0x15, 0x1b, 0x4e, 0xa3, 0x38, 0x4c, 0xc2, 0x63, 0xfd, 0x5f, 0xc6, 0x9e, 0x7a, 0x44, 0x36,
+	0xe1, 0x9b, 0x64, 0x13, 0x31, 0xf7, 0x8b, 0x68, 0x35, 0x3f, 0x26, 0x34, 0x90, 0x7f, 0x74, 0x41,
+	0xf8, 0x9c, 0x09, 0xf9, 0x18, 0xcd, 0x34, 0x47, 0xe4, 0xf2, 0x9a, 0xda, 0x3e, 0x03, 0xfb, 0x7b,
+	0x26, 0x04, 0x99, 0x33, 0xf4, 0x19, 0x94, 0x17, 0x8c, 0xf8, 0x2c, 0x76, 0xcc, 0x96, 0xd9, 0xa9,
+	0x76, 0x8f, 0xbc, 0x54, 0xd6, 0xeb, 0xab, 0x34, 0x4e, 0xcb, 0x08, 0x81, 0xe5, 0x93, 0x84, 0x38,
+	0x85, 0x96, 0xd9, 0xa9, 0x61, 0xf5, 0xdc, 0xfe, 0xc3, 0x84, 0xb2, 0x86, 0x21, 0x07, 0xec, 0x24,
+	0x26, 0x94, 0x0d, 0x7c, 0x25, 0x54, 0xc3, 0x59, 0x88, 0x1e, 0x43, 0x25, 0x66, 0x3f, 0xad, 0x99,
+	0x48, 0x06, 0xbe, 0x62, 0x5b, 0x78, 0x97, 0x90, 0xbc, 0x98, 0x45, 0xc1, 0x66, 0xe0, 0x3b, 0x45,
+	0x55, 0xcb, 0x42, 0xd4, 0x01, 0x4b, 0xfa, 0x70, 0xac, 0x96, 0xd9, 0xa9, 0x77, 0x1f, 0x6c, 0x7d,
+	0xa5, 0xce, 0x2f, 0x36, 0x11, 0xc3, 0x0a, 0x21, 0x57, 0xf0, 0xd9, 0x6c, 0x3d, 0x1f, 0xf0, 0xd7,
+	0xa1, 0x53, 0x6a, 0x99, 0x9d, 0x0a, 0xde, 0x25, 0xda, 0x7f, 0x16, 0xa1, 0x3c, 0xd9, 0x88, 0x84,
+	0x5d, 0xa1, 0xaf, 0xa1, 0xb2, 0x20, 0xdc, 0x17, 0x0b, 0xb2, 0x62, 0x69, 0xbf, 0x1f, 0x6f, 0x75,
+	0x35, 0xc6, 0xeb, 0x67, 0x00, 0xbc, 0xc3, 0x4a, 0x2f, 0xd1, 0x92, 0xcf, 0x95, 0xfd, 0x6a, 0xce,
+	0x4b, 0xca, 0x19, 0x2f, 0xf9, 0x1c, 0x2b, 0x04, 0xfa, 0x04, 0x8a, 0x84, 0xae, 0x54, 0x2f, 0xd5,
+	0xee, 0xfd, 0x43, 0xe0, 0x09, 0x5d, 0x61, 0x59, 0x77, 0x5f, 0x40, 0xa5, 0x9f, 0x53, 0x3f, 0x52,
+	0xfb, 0x42, 0xc3, 0xe0, 0x92, 0xc5, 0x62, 0x19, 0x72, 0x65, 0xae, 0x82, 0x0f, 0xd3, 0x6e, 0x1b,
+	0x2c, 0xb9, 0x16, 0x72, 0xe1, 0xde, 0x9a, 0x2f, 0x7f, 0xbd, 0x58, 0x5e, 0xe9, 0x3e, 0x2c, 0xbc,
+	0x8d, 0xdd, 0x2e, 0x14, 0x4f, 0xe8, 0x0a, 0x3d, 0x83, 0x12, 0x8b, 0xe3, 0x30, 0x4e, 0x3d, 0x3f,
+	0x3c, 0xb4, 0x72, 0x2a, 0x8b, 0x58, 0x63, 0xdc, 0x37, 0x26, 0x94, 0x54, 0x02, 0x79, 0x60, 0xd1,
+	0xd0, 0xd7, 0xaa, 0xf5, 0xae, 0x7b, 0x2b, 0xcb, 0xeb, 0x85, 0x3e, 0xc3, 0x0a, 0x87, 0x5a, 0x50,
+	0xf5, 0x99, 0xa0, 0xf1, 0x32, 0x4a, 0xa4, 0xef, 0x82, 0xf2, 0x9d, 0x4f, 0xb5, 0x5f, 0x80, 0x25,
+	0xf1, 0xa8, 0x0a, 0xf6, 0x74, 0xf8, 0xdd, 0x70, 0xf4, 0xc3, 0xb0, 0x61, 0xa0, 0x16, 0x3c, 0x9e,
+	0x0e, 0x27, 0xd3, 0xf1, 0x78, 0x84, 0x2f, 0x4e, 0xbf, 0x7d, 0x35, 0xc6, 0xa3, 0x8b, 0x51, 0x6f,
+	0x74, 0xfe, 0xea, 0xf2, 0x14, 0x4f, 0x06, 0xa3, 0x61, 0x03, 0xda, 0xbf, 0x15, 0xa0, 0x36, 0x59,
+	0xcf, 0xb6, 0x3a, 0xe8, 0x1c, 0xea, 0x42, 0xc7, 0x33, 0x36, 0x89, 0x08, 0xcd, 0x76, 0xf0, 0xc9,
+	0xce, 0x63, 0x0e, 0x9e, 0x05, 0x29, 0x16, 0x1f, 0x70, 0x11, 0x86, 0xc6, 0x9a, 0x1f, 0xe8, 0xe9,
+	0x49, 0x7d, 0x7a, 0xbb, 0xde, 0xf4, 0x00, 0x8d, 0xdf, 0xe1, 0xbb, 0x4f, 0xa1, 0xbe, 0xbf, 0xaa,
+	0x7c, 0xbb, 0x45, 0xb4, 0x3b, 0x15, 0x15, 0x9c, 0x85, 0xee, 0xe7, 0xd0, 0x38, 0x54, 0x7c, 0x3f,
+	0xba, 0xfd, 0x57, 0x19, 0xac, 0xc9, 0x86, 0xd3, 0xf7, 0x43, 0xd0, 0x57, 0x60, 0x5f, 0xe9, 0x93,
+	0x91, 0xf6, 0x91, 0xdf, 0x3b, 0x4e, 0xbd, 0x5e, 0xc8, 0x13, 0xc6, 0x93, 0x4b, 0x12, 0xac, 0x19,
+	0xce, 0xa0, 0xe8, 0x19, 0x40, 0x12, 0x33, 0xa6, 0x0f, 0x71, 0xfa, 0xd6, 0x56, 0x3d, 0x42, 0x83,
+	0xec, 0xf8, 0xe7, 0xca, 0xe8, 0x43, 0x28, 0xcb, 0x68, 0xe0, 0xab, 0x33, 0x59, 0xc1, 0x69, 0xe4,
+	0xfe, 0x5e, 0x80, 0x5a, 0x5e, 0x1e, 0x7d, 0x03, 0x20, 0x6f, 0x8d, 0x69, 0xe4, 0x93, 0x24, 0xdb,
+	0x26, 0x67, 0xdf, 0x4e, 0x7f, 0x5b, 0xef, 0x1b, 0x38, 0x87, 0x46, 0x67, 0x70, 0xf4, 0x7a, 0x1d,
+	0x04, 0x12, 0x84, 0xf5, 0x2d, 0x71, 0x7b, 0x3f, 0x67, 0xeb, 0x20, 0xf0, 0x52, 0x44, 0xdf, 0xc0,
+	0x87, 0x24, 0x34, 0x80, 0xc6, 0x2e, 0x25, 0xa2, 0x90, 0x0b, 0x96, 0xf6, 0xf7, 0xe8, 0x56, 0x21,
+	0x0d, 0xe9, 0x1b, 0xf8, 0x1d, 0x1a, 0xfa, 0x12, 0x6c, 0x42, 0x83, 0xf3, 0xa5, 0x48, 0x54, 0xe3,
+	0xfb, 0x87, 0x89, 0x53, 0xef, 0xa4, 0x77, 0x2e, 0x8b, 0x7d, 0x03, 0x67, 0xb8, 0x97, 0x36, 0x94,
+	0x7e, 0x96, 0xa3, 0x70, 0x9f, 0x83, 0x9d, 0x96, 0x51, 0x47, 0x5e, 0x75, 0x34, 0x8c, 0x7d, 0xe1,
+	0x98, 0xad, 0x62, 0xa7, 0xda, 0xad, 0xab, 0x41, 0x63, 0xf2, 0x0b, 0x56, 0x69, 0x9c, 0x95, 0xdd,
+	0x08, 0x60, 0x37, 0x1f, 0xf4, 0x00, 0x4a, 0x72, 0x3e, 0x9a, 0x55, 0xc1, 0x3a, 0x90, 0x6a, 0xe9,
+	0xa5, 0xee, 0x14, 0xf6, 0xd5, 0x7a, 0x2a, 0x8d, 0xb3, 0x32, 0x6a, 0x43, 0x4d, 0x70, 0x12, 0x89,
+	0x45, 0x98, 0x8c, 0x49, 0xb2, 0x70, 0x8a, 0x4a, 0x66, 0x2f, 0xe7, 0xfe, 0x67, 0x82, 0x25, 0x07,
+	0xe1, 0x5e, 0x81, 0x9d, 0x4d, 0xf0, 0x2e, 0xd6, 0xe5, 0x70, 0x6f, 0x3b, 0xe6, 0x3b, 0x58, 0xef,
+	0xe9, 0x25, 0x54, 0x73, 0xdf, 0x0f, 0xf4, 0x10, 0x3e, 0xc8, 0x85, 0xfa, 0x8e, 0x6b, 0x18, 0xe8,
+	0x11, 0x7c, 0x94, 0x4f, 0xe7, 0xae, 0x81, 0x86, 0x89, 0xee, 0xc3, 0xd1, 0x1e, 0x87, 0xd3, 0x46,
+	0xe1, 0xe5, 0x93, 0xbf, 0xaf, 0x9b, 0xe6, 0xdb, 0xeb, 0xa6, 0xf9, 0xef, 0x75, 0xd3, 0x7c, 0x73,
+	0xd3, 0x34, 0xde, 0xde, 0x34, 0x8d, 0x7f, 0x6e, 0x9a, 0xc6, 0x8f, 0x70, 0xbc, 0xfd, 0x86, 0xcf,
+	0xca, 0xea, 0xe7, 0xf9, 0xff, 0x01, 0x00, 0x00, 0xff, 0xff, 0xb1, 0x8e, 0x29, 0x21, 0xd7, 0x07,
+	0x00, 0x00,
 }
 
 func (m *Message) Marshal() (dAtA []byte, err error) {
@@ -1595,6 +1656,64 @@ func (m *SyncContentValueValueOfFullSyncResponse) MarshalToSizedBuffer(dAtA []by
 	}
 	return len(dAtA) - i, nil
 }
+func (m *SyncContentValueValueOfAclList) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *SyncContentValueValueOfAclList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	if m.AclList != nil {
+		{
+			size, err := m.AclList.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintSync(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x22
+	}
+	return len(dAtA) - i, nil
+}
+func (m *SyncACLList) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *SyncACLList) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *SyncACLList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.Records) > 0 {
+		for iNdEx := len(m.Records) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Records[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintSync(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0xa
+		}
+	}
+	return len(dAtA) - i, nil
+}
+
 func (m *SyncHeadUpdate) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
@@ -2028,6 +2147,33 @@ func (m *SyncContentValueValueOfFullSyncResponse) Size() (n int) {
 	}
 	return n
 }
+func (m *SyncContentValueValueOfAclList) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.AclList != nil {
+		l = m.AclList.Size()
+		n += 1 + l + sovSync(uint64(l))
+	}
+	return n
+}
+func (m *SyncACLList) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if len(m.Records) > 0 {
+		for _, e := range m.Records {
+			l = e.Size()
+			n += 1 + l + sovSync(uint64(l))
+		}
+	}
+	return n
+}
+
 func (m *SyncHeadUpdate) Size() (n int) {
 	if m == nil {
 		return 0
@@ -3519,6 +3665,125 @@ func (m *SyncContentValue) Unmarshal(dAtA []byte) error {
 			}
 			m.Value = &SyncContentValueValueOfFullSyncResponse{v}
 			iNdEx = postIndex
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field AclList", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowSync
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthSync
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthSync
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			v := &SyncACLList{}
+			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			m.Value = &SyncContentValueValueOfAclList{v}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipSync(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthSync
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *SyncACLList) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowSync
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: ACLList: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: ACLList: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Records", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowSync
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthSync
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthSync
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Records = append(m.Records, &aclpb.RawRecord{})
+			if err := m.Records[len(m.Records)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipSync(dAtA[iNdEx:])