Merge pull request #123 from RyanRory/sync-open-group

Sync open group
5 years ago · 1d2b3719f9
parent 76f40197c3 b990420c6f
commit 1d2b3719f9
11 changed files with 361 additions and 23 deletions
--- a/2
+++ b/2
@ -1 +1 @@
-Subproject commit 195f31ff3609b54d858b2d14113b294ca6f7bece
+Subproject commit 08a9b071e6f7fa4dc72f7e50ffc8720642774cf1
--- a/Controllers/DeviceLinkingModal.swift
+++ b/Controllers/DeviceLinkingModal.swift
@ -165,8 +165,9 @@ final class DeviceLinkingModal : Modal, DeviceLinkingSessionDelegate {
        let linkingAuthorizationMessage = DeviceLinkingUtilities.getLinkingAuthorizationMessage(for: deviceLink)
        ThreadUtil.enqueue(linkingAuthorizationMessage)
        SSKEnvironment.shared.messageSender.send(linkingAuthorizationMessage, success: {
-            SSKEnvironment.shared.syncManager.syncAllContacts()
-            SSKEnvironment.shared.syncManager.syncAllGroups()
+            let _ = [SSKEnvironment.shared.syncManager.syncAllContacts(),
+                     SSKEnvironment.shared.syncManager.syncAllGroups(),
+                     SSKEnvironment.shared.syncManager.syncAllOpenGroups()]
        }) { _ in
            print("[Loki] Failed to send device link authorization message.")
        }
--- a/SignalMessaging/contacts/OWSSyncManager.m
+++ b/SignalMessaging/contacts/OWSSyncManager.m
@ -17,6 +17,7 @@
 #import <SignalServiceKit/OWSSyncConfigurationMessage.h>
 #import <SignalServiceKit/OWSSyncContactsMessage.h>
 #import <SignalServiceKit/OWSSyncGroupsMessage.h>
+#import <SignalServiceKit/OWSSyncOpenGroupsMessage.h>
 #import <SignalServiceKit/SSKEnvironment.h>
 #import <SignalServiceKit/SignalAccount.h>
 #import <SignalServiceKit/SignalServiceKit-Swift.h>
@ -366,6 +367,24 @@ NSString *const kSyncManagerLastContactSyncKey = @"kTSStorageManagerOWSSyncManag
    return promise;
 }

+- (AnyPromise *)syncAllOpenGroups
+{
+    OWSSyncOpenGroupsMessage *syncOpenGroupsMessage = [[OWSSyncOpenGroupsMessage alloc] init];
+    AnyPromise *promise = [AnyPromise promiseWithResolverBlock:^(PMKResolver resolve) {
+        [self.messageSender sendMessage:syncOpenGroupsMessage
+            success:^{
+                OWSLogInfo(@"Successfully sent open groups syn message.");
+                resolve(@(1));
+            }
+            failure:^(NSError *error) {
+                OWSLogError(@"Failed to send open group sync message with error: %@.", error);
+                resolve(error);
+            }];
+    }];
+    [promise retainUntilComplete];
+    return promise;
+}
+
@end

 NS_ASSUME_NONNULL_END
--- a/SignalServiceKit/protobuf/SignalService.proto
+++ b/SignalServiceKit/protobuf/SignalService.proto
@ -322,6 +322,12 @@ message SyncMessage {
    optional bytes             data = 101; // Loki
  }
  
+  // Loki
+  message OpenGroupDetails {
+    optional string            url       = 1;
+    optional uint64            channelId = 2;
+  }
+
  message Blocked {
    repeated string numbers = 1;
    repeated bytes groupIds = 2;
@ -363,6 +369,7 @@ message SyncMessage {
  optional Verified         verified      = 7;
  optional Configuration    configuration = 9;
  optional bytes            padding       = 8;
+  repeated OpenGroupDetails openGroups    = 100;
 }

 message AttachmentPointer {
--- a/SignalServiceKit/src/Messages/DeviceSyncing/OWSSyncOpenGroupsMessage.h
+++ b/SignalServiceKit/src/Messages/DeviceSyncing/OWSSyncOpenGroupsMessage.h
@ -0,0 +1,15 @@
+#import "OWSOutgoingSyncMessage.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@class LKPublicChat;
+
+@interface OWSSyncOpenGroupsMessage : OWSOutgoingSyncMessage
+
+- (instancetype)init NS_DESIGNATED_INITIALIZER;
+
+- (nullable instancetype)initWithCoder:(NSCoder *)coder NS_DESIGNATED_INITIALIZER;
+
+@end
+
+NS_ASSUME_NONNULL_END
--- a/SignalServiceKit/src/Messages/DeviceSyncing/OWSSyncOpenGroupsMessage.m
+++ b/SignalServiceKit/src/Messages/DeviceSyncing/OWSSyncOpenGroupsMessage.m
@ -0,0 +1,47 @@
+#import "OWSSyncOpenGroupsMessage.h"
+#import "OWSPrimaryStorage.h"
+#import <SignalServiceKit/SignalServiceKit-Swift.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@implementation OWSSyncOpenGroupsMessage
+
+- (instancetype)init
+{
+    return [super init];
+}
+
+- (nullable instancetype)initWithCoder:(NSCoder *)coder
+{
+    return [super initWithCoder:coder];
+}
+
+- (nullable SSKProtoSyncMessageBuilder *)syncMessageBuilder
+{
+    NSError *error;
+    NSMutableArray<SSKProtoSyncMessageOpenGroups *> *sessionOpenGroups = @[].mutableCopy;
+    __block NSDictionary<NSString *, LKPublicChat *> *publicChats;
+    [OWSPrimaryStorage.sharedManager.dbReadConnection readWithBlock:^(YapDatabaseReadTransaction *transaction) {
+        publicChats = [LKDatabaseUtilities getAllPublicChats:transaction];
+    }];
+    for (LKPublicChat *openGroup in publicChats.allValues) {
+        SSKProtoSyncMessageOpenGroupsBuilder *openGroupBuilder = [SSKProtoSyncMessageOpenGroups builder];
+        [openGroupBuilder setUrl:openGroup.server];
+        [openGroupBuilder setChannel:openGroup.channel];
+        SSKProtoSyncMessageOpenGroups *_Nullable openGroupProto = [openGroupBuilder buildAndReturnError:&error];
+        if (error || !openGroupProto) {
+            OWSFailDebug(@"could not build protobuf: %@", error);
+            return nil;
+        }
+        [sessionOpenGroups addObject:openGroupProto];
+    }
+
+    SSKProtoSyncMessageBuilder *syncMessageBuilder = [SSKProtoSyncMessage builder];
+    [syncMessageBuilder setOpenGroups:sessionOpenGroups];
+
+    return syncMessageBuilder;
+}
+
+@end
+
+NS_ASSUME_NONNULL_END
--- a/SignalServiceKit/src/Messages/OWSMessageManager.m
+++ b/SignalServiceKit/src/Messages/OWSMessageManager.m
@ -1124,6 +1124,13 @@ NS_ASSUME_NONNULL_BEGIN
                }
            }
        }
+    } else if (syncMessage.openGroups != nil) {
+        if (wasSentByMasterDevice && syncMessage.openGroups.count > 0) {
+            OWSLogInfo(@"[Loki] Received open group sync message.");
+            for (SSKProtoSyncMessageOpenGroups* openGroup in syncMessage.openGroups) {
+                [LKPublicChatManager.shared addChatWithServer:openGroup.url channel:openGroup.channel];
+            }
+        }
    } else {
        OWSLogWarn(@"Ignoring unsupported sync message.");
    }
--- a/SignalServiceKit/src/Protos/Generated/SSKProto.swift
+++ b/SignalServiceKit/src/Protos/Generated/SSKProto.swift
@ -5125,6 +5125,110 @@ extension SSKProtoSyncMessageConfiguration.SSKProtoSyncMessageConfigurationBuild

 #endif

+// MARK: - SSKProtoSyncMessageOpenGroups
+@objc public class SSKProtoSyncMessageOpenGroups: NSObject {
+    
+    // MARK: - SSKProtoSyncMessageOpenGroupsBuilder
+
+       @objc public class func builder() -> SSKProtoSyncMessageOpenGroupsBuilder {
+           return SSKProtoSyncMessageOpenGroupsBuilder()
+       }
+
+       // asBuilder() constructs a builder that reflects the proto's contents.
+       @objc public func asBuilder() -> SSKProtoSyncMessageOpenGroupsBuilder {
+           let builder = SSKProtoSyncMessageOpenGroupsBuilder()
+           if hasUrl {
+               builder.setUrl(url)
+           }
+           if hasChannel{
+               builder.setChannel(channel)
+           }
+           return builder
+       }
+
+       @objc public class SSKProtoSyncMessageOpenGroupsBuilder: NSObject {
+
+           private var proto = SignalServiceProtos_SyncMessage.OpenGroups()
+
+           @objc fileprivate override init() {}
+
+           @objc public func setUrl(_ valueParam: String) {
+               proto.url = valueParam
+           }
+
+           @objc public func setChannel(_ valueParam: UInt64) {
+               proto.channel = valueParam
+           }
+
+           @objc public func build() throws -> SSKProtoSyncMessageOpenGroups {
+               return try SSKProtoSyncMessageOpenGroups.parseProto(proto)
+           }
+
+           @objc public func buildSerializedData() throws -> Data {
+               return try SSKProtoSyncMessageOpenGroups.parseProto(proto).serializedData()
+           }
+       }
+
+       fileprivate let proto: SignalServiceProtos_SyncMessage.OpenGroups
+
+       @objc public var url: String {
+           return proto.url
+       }
+       @objc public var hasUrl: Bool {
+           return proto.hasUrl
+       }
+
+       @objc public var channel: UInt64 {
+           return proto.channel
+       }
+       @objc public var hasChannel: Bool {
+           return proto.hasChannel
+       }
+
+       private init(proto: SignalServiceProtos_SyncMessage.OpenGroups) {
+           self.proto = proto
+       }
+
+       @objc
+       public func serializedData() throws -> Data {
+           return try self.proto.serializedData()
+       }
+
+       @objc public class func parseData(_ serializedData: Data) throws -> SSKProtoSyncMessageOpenGroups {
+           let proto = try SignalServiceProtos_SyncMessage.OpenGroups(serializedData: serializedData)
+           return try parseProto(proto)
+       }
+
+       fileprivate class func parseProto(_ proto: SignalServiceProtos_SyncMessage.OpenGroups) throws -> SSKProtoSyncMessageOpenGroups {
+           // MARK: - Begin Validation Logic for SSKProtoSyncMessageOpenGroups -
+
+           // MARK: - End Validation Logic for SSKProtoSyncMessageOpenGroups -
+
+           let result = SSKProtoSyncMessageOpenGroups(proto: proto)
+           return result
+       }
+
+       @objc public override var debugDescription: String {
+           return "\(proto)"
+       }
+}
+
+#if DEBUG
+
+extension SSKProtoSyncMessageOpenGroups {
+    @objc public func serializedDataIgnoringErrors() -> Data? {
+        return try! self.serializedData()
+    }
+}
+
+extension SSKProtoSyncMessageOpenGroups.SSKProtoSyncMessageOpenGroupsBuilder {
+    @objc public func buildIgnoringErrors() -> SSKProtoSyncMessageOpenGroups? {
+        return try! self.build()
+    }
+}
+
+#endif
+
 // MARK: - SSKProtoSyncMessage

@objc public class SSKProtoSyncMessage: NSObject {
@ -5163,6 +5267,7 @@ extension SSKProtoSyncMessageConfiguration.SSKProtoSyncMessageConfigurationBuild
        if let _value = padding {
            builder.setPadding(_value)
        }
+        builder.setOpenGroups(openGroups)
        return builder
    }

@ -5184,6 +5289,16 @@ extension SSKProtoSyncMessageConfiguration.SSKProtoSyncMessageConfigurationBuild
            proto.groups = valueParam.proto
        }
        
+        @objc public func addOpenGroup(_ valueParam: SSKProtoSyncMessageOpenGroups) {
+            var items = proto.openGroups
+            items.append(valueParam.proto)
+            proto.openGroups = items
+        }
+        
+        @objc public func setOpenGroups(_ wrappedItems: [SSKProtoSyncMessageOpenGroups]) {
+            proto.openGroups = wrappedItems.map { $0.proto }
+        }
+
        @objc public func setRequest(_ valueParam: SSKProtoSyncMessageRequest) {
            proto.request = valueParam.proto
        }
@ -5231,6 +5346,8 @@ extension SSKProtoSyncMessageConfiguration.SSKProtoSyncMessageConfigurationBuild

    @objc public let groups: SSKProtoSyncMessageGroups?
    
+    @objc public let openGroups: [SSKProtoSyncMessageOpenGroups]
+
    @objc public let request: SSKProtoSyncMessageRequest?

    @objc public let read: [SSKProtoSyncMessageRead]
@ -5259,7 +5376,8 @@ extension SSKProtoSyncMessageConfiguration.SSKProtoSyncMessageConfigurationBuild
                 read: [SSKProtoSyncMessageRead],
                 blocked: SSKProtoSyncMessageBlocked?,
                 verified: SSKProtoVerified?,
-                 configuration: SSKProtoSyncMessageConfiguration?) {
+                 configuration: SSKProtoSyncMessageConfiguration?,
+                 openGroups: [SSKProtoSyncMessageOpenGroups]) {
        self.proto = proto
        self.sent = sent
        self.contacts = contacts
@ -5269,6 +5387,7 @@ extension SSKProtoSyncMessageConfiguration.SSKProtoSyncMessageConfigurationBuild
        self.blocked = blocked
        self.verified = verified
        self.configuration = configuration
+        self.openGroups = openGroups
    }

    @objc
@ -5320,6 +5439,9 @@ extension SSKProtoSyncMessageConfiguration.SSKProtoSyncMessageConfigurationBuild
            configuration = try SSKProtoSyncMessageConfiguration.parseProto(proto.configuration)
        }
        
+        var openGroups: [SSKProtoSyncMessageOpenGroups] = []
+        openGroups = try proto.openGroups.map { try SSKProtoSyncMessageOpenGroups.parseProto($0) }
+
        // MARK: - Begin Validation Logic for SSKProtoSyncMessage -

        // MARK: - End Validation Logic for SSKProtoSyncMessage -
@ -5332,7 +5454,8 @@ extension SSKProtoSyncMessageConfiguration.SSKProtoSyncMessageConfigurationBuild
                                         read: read,
                                         blocked: blocked,
                                         verified: verified,
-                                         configuration: configuration)
+                                         configuration: configuration,
+                                         openGroups: openGroups)
        return result
    }

--- a/SignalServiceKit/src/Protos/Generated/SignalService.pb.swift
+++ b/SignalServiceKit/src/Protos/Generated/SignalService.pb.swift
@ -1746,6 +1746,11 @@ struct SignalServiceProtos_SyncMessage {
  /// Clears the value of `groups`. Subsequent reads from it will return its default value.
  mutating func clearGroups() {_uniqueStorage()._groups = nil}
    
+  var openGroups: [SignalServiceProtos_SyncMessage.OpenGroups] {
+    get {return _storage._openGroups}
+    set {_uniqueStorage()._openGroups = newValue}
+  }
+
  var request: SignalServiceProtos_SyncMessage.Request {
    get {return _storage._request ?? SignalServiceProtos_SyncMessage.Request()}
    set {_uniqueStorage()._request = newValue}
@ -1963,6 +1968,36 @@ struct SignalServiceProtos_SyncMessage {
    fileprivate var _storage = _StorageClass.defaultInstance
  }
    
+  struct OpenGroups {
+    // SwiftProtobuf.Message conformance is added in an extension below. See the
+    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+    // methods supported on all messages.
+    
+    var url: String {
+        get {return _storage._url ?? String()}
+        set {_uniqueStorage()._url = newValue}
+    }
+    /// Returns true if `url` has been explicitly set.
+    var hasUrl: Bool {return _storage._url != nil}
+    /// Clears the value of `url`. Subsequent reads from it will return its default value.
+    mutating func clearUrl() {_uniqueStorage()._url = nil}
+    
+    var channel: UInt64 {
+        get {return _storage._channel ?? 0}
+        set {_uniqueStorage()._channel = newValue}
+    }
+    /// Returns true if `channel` has been explicitly set.
+    var hasChannel: Bool {return _storage._channel != nil}
+    /// Clears the value of `channel`. Subsequent reads from it will return its default value.
+    mutating func clearChannel() {_uniqueStorage()._channel = nil}
+    
+    var unknownFields = SwiftProtobuf.UnknownStorage()
+
+    init() {}
+
+    fileprivate var _storage = _StorageClass.defaultInstance
+  }
+
  struct Blocked {
    // SwiftProtobuf.Message conformance is added in an extension below. See the
    // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
@ -4319,6 +4354,7 @@ extension SignalServiceProtos_SyncMessage: SwiftProtobuf.Message, SwiftProtobuf.
    var _sent: SignalServiceProtos_SyncMessage.Sent? = nil
    var _contacts: SignalServiceProtos_SyncMessage.Contacts? = nil
    var _groups: SignalServiceProtos_SyncMessage.Groups? = nil
+    var _openGroups: [SignalServiceProtos_SyncMessage.OpenGroups] = []
    var _request: SignalServiceProtos_SyncMessage.Request? = nil
    var _read: [SignalServiceProtos_SyncMessage.Read] = []
    var _blocked: SignalServiceProtos_SyncMessage.Blocked? = nil
@ -4334,6 +4370,7 @@ extension SignalServiceProtos_SyncMessage: SwiftProtobuf.Message, SwiftProtobuf.
      _sent = source._sent
      _contacts = source._contacts
      _groups = source._groups
+      _openGroups = source._openGroups
      _request = source._request
      _read = source._read
      _blocked = source._blocked
@ -4364,6 +4401,7 @@ extension SignalServiceProtos_SyncMessage: SwiftProtobuf.Message, SwiftProtobuf.
        case 7:   try decoder.decodeSingularMessageField(value: &_storage._verified)
        case 8:   try decoder.decodeSingularBytesField(value: &_storage._padding)
        case 9:   try decoder.decodeSingularMessageField(value: &_storage._configuration)
+        case 100: try decoder.decodeRepeatedMessageField(value: &_storage._openGroups)
        default: break
        }
      }
@ -4399,6 +4437,9 @@ extension SignalServiceProtos_SyncMessage: SwiftProtobuf.Message, SwiftProtobuf.
      if let v = _storage._configuration {
        try visitor.visitSingularMessageField(value: v, fieldNumber: 9)
      }
+      if !_storage._openGroups.isEmpty {
+        try visitor.visitRepeatedMessageField(value: _storage._openGroups, fieldNumber: 100)
+      }
    }
    try unknownFields.traverse(visitor: &visitor)
  }
@ -4417,6 +4458,7 @@ extension SignalServiceProtos_SyncMessage: SwiftProtobuf.Message, SwiftProtobuf.
        if _storage._verified != rhs_storage._verified {return false}
        if _storage._configuration != rhs_storage._configuration {return false}
        if _storage._padding != rhs_storage._padding {return false}
+        if _storage._openGroups != rhs_storage._openGroups {return false}
        return true
      }
      if !storagesAreEqual {return false}
@ -4708,6 +4750,75 @@ extension SignalServiceProtos_SyncMessage.Groups: SwiftProtobuf.Message, SwiftPr
  }
 }

+extension SignalServiceProtos_SyncMessage.OpenGroups: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = SignalServiceProtos_SyncMessage.protoMessageName + ".OpenGroups"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "url"),
+    2: .same(proto: "channel"),
+  ]
+
+  fileprivate class _StorageClass {
+    var _url: String? = nil
+    var _channel: UInt64? = nil
+
+    static let defaultInstance = _StorageClass()
+
+    private init() {}
+
+    init(copying source: _StorageClass) {
+      _url = source._url
+      _channel = source._channel
+    }
+  }
+
+  fileprivate mutating func _uniqueStorage() -> _StorageClass {
+    if !isKnownUniquelyReferenced(&_storage) {
+      _storage = _StorageClass(copying: _storage)
+    }
+    return _storage
+  }
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    _ = _uniqueStorage()
+    try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
+      while let fieldNumber = try decoder.nextFieldNumber() {
+        switch fieldNumber {
+        case 1: try decoder.decodeSingularStringField(value: &_storage._url)
+        case 2: try decoder.decodeSingularUInt64Field(value: &_storage._channel)
+        default: break
+        }
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
+      if let v = _storage._url {
+        try visitor.visitSingularStringField(value: v, fieldNumber: 1)
+      }
+      if let v = _storage._channel {
+        try visitor.visitSingularUInt64Field(value: v, fieldNumber: 2)
+      }
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: SignalServiceProtos_SyncMessage.OpenGroups, rhs: SignalServiceProtos_SyncMessage.OpenGroups) -> Bool {
+    if lhs._storage !== rhs._storage {
+      let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in
+        let _storage = _args.0
+        let rhs_storage = _args.1
+        if _storage._url != rhs_storage._url {return false}
+        if _storage._channel != rhs_storage._channel {return false}
+        return true
+      }
+      if !storagesAreEqual {return false}
+    }
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
 extension SignalServiceProtos_SyncMessage.Blocked: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = SignalServiceProtos_SyncMessage.protoMessageName + ".Blocked"
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
--- a/SignalServiceKit/src/TestUtils/OWSMockSyncManager.swift
+++ b/SignalServiceKit/src/TestUtils/OWSMockSyncManager.swift
@ -9,6 +9,12 @@ import PromiseKit

@objc
 public class OWSMockSyncManager: NSObject, OWSSyncManagerProtocol {
+    public func syncAllOpenGroups() -> AnyPromise {
+        Logger.info("")
+
+        return AnyPromise()
+    }
+    
    public func syncAllGroups() -> AnyPromise {
        Logger.info("")

--- a/SignalServiceKit/src/Util/OWSSyncManagerProtocol.h
+++ b/SignalServiceKit/src/Util/OWSSyncManagerProtocol.h
@ -22,6 +22,8 @@ NS_ASSUME_NONNULL_BEGIN

 - (AnyPromise *)syncAllGroups __attribute__((warn_unused_result));

+- (AnyPromise *)syncAllOpenGroups __attribute__((warn_unused_result));
+
@end

 NS_ASSUME_NONNULL_END