diff --git a/.gitattributes b/.gitattributes index effdf65..a056147 100644 --- a/.gitattributes +++ b/.gitattributes @@ -1 +1,3 @@ -nix/create-dmg/package-lock.json -diff \ No newline at end of file +**/*.pb.swift linguist-generated=true +**/*.grpc.swift linguist-generated=true +Coder-Desktop/VPNLib/FileSync/MutagenSDK/*.proto linguist-generated=true diff --git a/Coder-Desktop/VPNLib/FileSync/MutagenSDK/filesystem_behavior_probe_mode.pb.swift b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/filesystem_behavior_probe_mode.pb.swift new file mode 100644 index 0000000..d82f905 --- /dev/null +++ b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/filesystem_behavior_probe_mode.pb.swift @@ -0,0 +1,109 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: filesystem_behavior_probe_mode.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// +// This file was taken from +// https://github.com/mutagen-io/mutagen/tree/v0.18.1/pkg/filesystem/behavior/probe_mode.proto +// +// MIT License +// +// Copyright (c) 2016-present Docker, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. + +import SwiftProtobuf + +// If the compiler emits an error on this type, it is because this file +// was generated by a version of the `protoc` Swift plug-in that is +// incompatible with the version of SwiftProtobuf to which you are linking. +// Please ensure that you are building against the same version of the API +// that was used to generate this file. +fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAPIVersionCheck { + struct _2: SwiftProtobuf.ProtobufAPIVersion_2 {} + typealias Version = _2 +} + +/// ProbeMode specifies the mode for filesystem probing. +enum Behavior_ProbeMode: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + + /// ProbeMode_ProbeModeDefault represents an unspecified probe mode. It + /// should be converted to one of the following values based on the desired + /// default behavior. + case `default` // = 0 + + /// ProbeMode_ProbeModeProbe specifies that filesystem behavior should be + /// determined using temporary files or, if possible, a "fast-path" mechanism + /// (such as filesystem format detection) that provides quick but certain + /// determination of filesystem behavior. + case probe // = 1 + + /// ProbeMode_ProbeModeAssume specifies that filesystem behavior should be + /// assumed based on the underlying platform. This is not as accurate as + /// ProbeMode_ProbeModeProbe. + case assume // = 2 + case UNRECOGNIZED(Int) + + init() { + self = .default + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .default + case 1: self = .probe + case 2: self = .assume + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .default: return 0 + case .probe: return 1 + case .assume: return 2 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [Behavior_ProbeMode] = [ + .default, + .probe, + .assume, + ] + +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +extension Behavior_ProbeMode: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ + 0: .same(proto: "ProbeModeDefault"), + 1: .same(proto: "ProbeModeProbe"), + 2: .same(proto: "ProbeModeAssume"), + ] +} diff --git a/Coder-Desktop/VPNLib/FileSync/MutagenSDK/filesystem_behavior_probe_mode.proto b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/filesystem_behavior_probe_mode.proto new file mode 100644 index 0000000..c2fb72a --- /dev/null +++ b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/filesystem_behavior_probe_mode.proto @@ -0,0 +1,49 @@ +/* + * This file was taken from + * https://github.com/mutagen-io/mutagen/tree/v0.18.1/pkg/filesystem/behavior/probe_mode.proto + * + * MIT License + * + * Copyright (c) 2016-present Docker, Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +syntax = "proto3"; + +package behavior; + +option go_package = "github.com/mutagen-io/mutagen/pkg/filesystem/behavior"; + +// ProbeMode specifies the mode for filesystem probing. +enum ProbeMode { + // ProbeMode_ProbeModeDefault represents an unspecified probe mode. It + // should be converted to one of the following values based on the desired + // default behavior. + ProbeModeDefault = 0; + // ProbeMode_ProbeModeProbe specifies that filesystem behavior should be + // determined using temporary files or, if possible, a "fast-path" mechanism + // (such as filesystem format detection) that provides quick but certain + // determination of filesystem behavior. + ProbeModeProbe = 1; + // ProbeMode_ProbeModeAssume specifies that filesystem behavior should be + // assumed based on the underlying platform. This is not as accurate as + // ProbeMode_ProbeModeProbe. + ProbeModeAssume = 2; +} diff --git a/Coder-Desktop/VPNLib/FileSync/MutagenSDK/selection_selection.pb.swift b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/selection_selection.pb.swift new file mode 100644 index 0000000..9ea8215 --- /dev/null +++ b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/selection_selection.pb.swift @@ -0,0 +1,119 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: selection_selection.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// +// This file was taken from +// https://github.com/mutagen-io/mutagen/tree/v0.18.1/pkg/selection/selection.proto +// +// MIT License +// +// Copyright (c) 2016-present Docker, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. + +import SwiftProtobuf + +// If the compiler emits an error on this type, it is because this file +// was generated by a version of the `protoc` Swift plug-in that is +// incompatible with the version of SwiftProtobuf to which you are linking. +// Please ensure that you are building against the same version of the API +// that was used to generate this file. +fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAPIVersionCheck { + struct _2: SwiftProtobuf.ProtobufAPIVersion_2 {} + typealias Version = _2 +} + +/// Selection encodes a selection mechanism that can be used to select a +/// collection of sessions. It should have exactly one member set. +struct Selection_Selection: Sendable { + // 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. + + /// All, if true, indicates that all sessions should be selected. + var all: Bool = false + + /// Specifications is a list of session specifications. Each element may be + /// either a session identifier or name (or a prefix thereof). If non-empty, + /// it indicates that these specifications should be used to select sessions. + var specifications: [String] = [] + + /// LabelSelector is a label selector specification. If present (non-empty), + /// it indicates that this selector should be used to select sessions. + var labelSelector: String = String() + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "selection" + +extension Selection_Selection: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".Selection" + static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ + 1: .same(proto: "all"), + 2: .same(proto: "specifications"), + 3: .same(proto: "labelSelector"), + ] + + mutating func decodeMessage(decoder: inout D) throws { + while let fieldNumber = try decoder.nextFieldNumber() { + // The use of inline closures is to circumvent an issue where the compiler + // allocates stack space for every case branch when no optimizations are + // enabled. https://github.com/apple/swift-protobuf/issues/1034 + switch fieldNumber { + case 1: try { try decoder.decodeSingularBoolField(value: &self.all) }() + case 2: try { try decoder.decodeRepeatedStringField(value: &self.specifications) }() + case 3: try { try decoder.decodeSingularStringField(value: &self.labelSelector) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.all != false { + try visitor.visitSingularBoolField(value: self.all, fieldNumber: 1) + } + if !self.specifications.isEmpty { + try visitor.visitRepeatedStringField(value: self.specifications, fieldNumber: 2) + } + if !self.labelSelector.isEmpty { + try visitor.visitSingularStringField(value: self.labelSelector, fieldNumber: 3) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Selection_Selection, rhs: Selection_Selection) -> Bool { + if lhs.all != rhs.all {return false} + if lhs.specifications != rhs.specifications {return false} + if lhs.labelSelector != rhs.labelSelector {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Coder-Desktop/VPNLib/FileSync/MutagenSDK/selection_selection.proto b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/selection_selection.proto new file mode 100644 index 0000000..552a013 --- /dev/null +++ b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/selection_selection.proto @@ -0,0 +1,46 @@ +/* + * This file was taken from + * https://github.com/mutagen-io/mutagen/tree/v0.18.1/pkg/selection/selection.proto + * + * MIT License + * + * Copyright (c) 2016-present Docker, Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +syntax = "proto3"; + +package selection; + +option go_package = "github.com/mutagen-io/mutagen/pkg/selection"; + +// Selection encodes a selection mechanism that can be used to select a +// collection of sessions. It should have exactly one member set. +message Selection { + // All, if true, indicates that all sessions should be selected. + bool all = 1; + // Specifications is a list of session specifications. Each element may be + // either a session identifier or name (or a prefix thereof). If non-empty, + // it indicates that these specifications should be used to select sessions. + repeated string specifications = 2; + // LabelSelector is a label selector specification. If present (non-empty), + // it indicates that this selector should be used to select sessions. + string labelSelector = 3; +} diff --git a/Coder-Desktop/VPNLib/FileSync/daemon.grpc.swift b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/service_daemon_daemon.grpc.swift similarity index 73% rename from Coder-Desktop/VPNLib/FileSync/daemon.grpc.swift rename to Coder-Desktop/VPNLib/FileSync/MutagenSDK/service_daemon_daemon.grpc.swift index 43d25fb..809b5c2 100644 --- a/Coder-Desktop/VPNLib/FileSync/daemon.grpc.swift +++ b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/service_daemon_daemon.grpc.swift @@ -3,7 +3,7 @@ // swift-format-ignore-file // // Generated by the protocol buffer compiler. -// Source: Coder-Desktop/VPNLib/FileSync/daemon.proto +// Source: service_daemon_daemon.proto // import GRPC import NIO @@ -16,6 +16,11 @@ internal protocol Daemon_DaemonClientProtocol: GRPCClient { var serviceName: String { get } var interceptors: Daemon_DaemonClientInterceptorFactoryProtocol? { get } + func version( + _ request: Daemon_VersionRequest, + callOptions: CallOptions? + ) -> UnaryCall + func terminate( _ request: Daemon_TerminateRequest, callOptions: CallOptions? @@ -27,6 +32,24 @@ extension Daemon_DaemonClientProtocol { return "daemon.Daemon" } + /// Unary call to Version + /// + /// - Parameters: + /// - request: Request to send to Version. + /// - callOptions: Call options. + /// - Returns: A `UnaryCall` with futures for the metadata, status and response. + internal func version( + _ request: Daemon_VersionRequest, + callOptions: CallOptions? = nil + ) -> UnaryCall { + return self.makeUnaryCall( + path: Daemon_DaemonClientMetadata.Methods.version.path, + request: request, + callOptions: callOptions ?? self.defaultCallOptions, + interceptors: self.interceptors?.makeVersionInterceptors() ?? [] + ) + } + /// Unary call to Terminate /// /// - Parameters: @@ -108,6 +131,11 @@ internal protocol Daemon_DaemonAsyncClientProtocol: GRPCClient { static var serviceDescriptor: GRPCServiceDescriptor { get } var interceptors: Daemon_DaemonClientInterceptorFactoryProtocol? { get } + func makeVersionCall( + _ request: Daemon_VersionRequest, + callOptions: CallOptions? + ) -> GRPCAsyncUnaryCall + func makeTerminateCall( _ request: Daemon_TerminateRequest, callOptions: CallOptions? @@ -124,6 +152,18 @@ extension Daemon_DaemonAsyncClientProtocol { return nil } + internal func makeVersionCall( + _ request: Daemon_VersionRequest, + callOptions: CallOptions? = nil + ) -> GRPCAsyncUnaryCall { + return self.makeAsyncUnaryCall( + path: Daemon_DaemonClientMetadata.Methods.version.path, + request: request, + callOptions: callOptions ?? self.defaultCallOptions, + interceptors: self.interceptors?.makeVersionInterceptors() ?? [] + ) + } + internal func makeTerminateCall( _ request: Daemon_TerminateRequest, callOptions: CallOptions? = nil @@ -139,6 +179,18 @@ extension Daemon_DaemonAsyncClientProtocol { @available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *) extension Daemon_DaemonAsyncClientProtocol { + internal func version( + _ request: Daemon_VersionRequest, + callOptions: CallOptions? = nil + ) async throws -> Daemon_VersionResponse { + return try await self.performAsyncUnaryCall( + path: Daemon_DaemonClientMetadata.Methods.version.path, + request: request, + callOptions: callOptions ?? self.defaultCallOptions, + interceptors: self.interceptors?.makeVersionInterceptors() ?? [] + ) + } + internal func terminate( _ request: Daemon_TerminateRequest, callOptions: CallOptions? = nil @@ -171,6 +223,9 @@ internal struct Daemon_DaemonAsyncClient: Daemon_DaemonAsyncClientProtocol { internal protocol Daemon_DaemonClientInterceptorFactoryProtocol: Sendable { + /// - Returns: Interceptors to use when invoking 'version'. + func makeVersionInterceptors() -> [ClientInterceptor] + /// - Returns: Interceptors to use when invoking 'terminate'. func makeTerminateInterceptors() -> [ClientInterceptor] } @@ -180,11 +235,18 @@ internal enum Daemon_DaemonClientMetadata { name: "Daemon", fullName: "daemon.Daemon", methods: [ + Daemon_DaemonClientMetadata.Methods.version, Daemon_DaemonClientMetadata.Methods.terminate, ] ) internal enum Methods { + internal static let version = GRPCMethodDescriptor( + name: "Version", + path: "/daemon.Daemon/Version", + type: GRPCCallType.unary + ) + internal static let terminate = GRPCMethodDescriptor( name: "Terminate", path: "/daemon.Daemon/Terminate", @@ -197,6 +259,8 @@ internal enum Daemon_DaemonClientMetadata { internal protocol Daemon_DaemonProvider: CallHandlerProvider { var interceptors: Daemon_DaemonServerInterceptorFactoryProtocol? { get } + func version(request: Daemon_VersionRequest, context: StatusOnlyCallContext) -> EventLoopFuture + func terminate(request: Daemon_TerminateRequest, context: StatusOnlyCallContext) -> EventLoopFuture } @@ -212,6 +276,15 @@ extension Daemon_DaemonProvider { context: CallHandlerContext ) -> GRPCServerHandlerProtocol? { switch name { + case "Version": + return UnaryServerHandler( + context: context, + requestDeserializer: ProtobufDeserializer(), + responseSerializer: ProtobufSerializer(), + interceptors: self.interceptors?.makeVersionInterceptors() ?? [], + userFunction: self.version(request:context:) + ) + case "Terminate": return UnaryServerHandler( context: context, @@ -233,6 +306,11 @@ internal protocol Daemon_DaemonAsyncProvider: CallHandlerProvider, Sendable { static var serviceDescriptor: GRPCServiceDescriptor { get } var interceptors: Daemon_DaemonServerInterceptorFactoryProtocol? { get } + func version( + request: Daemon_VersionRequest, + context: GRPCAsyncServerCallContext + ) async throws -> Daemon_VersionResponse + func terminate( request: Daemon_TerminateRequest, context: GRPCAsyncServerCallContext @@ -258,6 +336,15 @@ extension Daemon_DaemonAsyncProvider { context: CallHandlerContext ) -> GRPCServerHandlerProtocol? { switch name { + case "Version": + return GRPCAsyncServerHandler( + context: context, + requestDeserializer: ProtobufDeserializer(), + responseSerializer: ProtobufSerializer(), + interceptors: self.interceptors?.makeVersionInterceptors() ?? [], + wrapping: { try await self.version(request: $0, context: $1) } + ) + case "Terminate": return GRPCAsyncServerHandler( context: context, @@ -275,6 +362,10 @@ extension Daemon_DaemonAsyncProvider { internal protocol Daemon_DaemonServerInterceptorFactoryProtocol: Sendable { + /// - Returns: Interceptors to use when handling 'version'. + /// Defaults to calling `self.makeInterceptors()`. + func makeVersionInterceptors() -> [ServerInterceptor] + /// - Returns: Interceptors to use when handling 'terminate'. /// Defaults to calling `self.makeInterceptors()`. func makeTerminateInterceptors() -> [ServerInterceptor] @@ -285,11 +376,18 @@ internal enum Daemon_DaemonServerMetadata { name: "Daemon", fullName: "daemon.Daemon", methods: [ + Daemon_DaemonServerMetadata.Methods.version, Daemon_DaemonServerMetadata.Methods.terminate, ] ) internal enum Methods { + internal static let version = GRPCMethodDescriptor( + name: "Version", + path: "/daemon.Daemon/Version", + type: GRPCCallType.unary + ) + internal static let terminate = GRPCMethodDescriptor( name: "Terminate", path: "/daemon.Daemon/Terminate", diff --git a/Coder-Desktop/VPNLib/FileSync/MutagenSDK/service_daemon_daemon.pb.swift b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/service_daemon_daemon.pb.swift new file mode 100644 index 0000000..f00093a --- /dev/null +++ b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/service_daemon_daemon.pb.swift @@ -0,0 +1,208 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: service_daemon_daemon.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// +// This file was taken from +// https://github.com/mutagen-io/mutagen/tree/v0.18.1/pkg/service/daemon/daemon.proto +// +// MIT License +// +// Copyright (c) 2016-present Docker, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. + +import SwiftProtobuf + +// If the compiler emits an error on this type, it is because this file +// was generated by a version of the `protoc` Swift plug-in that is +// incompatible with the version of SwiftProtobuf to which you are linking. +// Please ensure that you are building against the same version of the API +// that was used to generate this file. +fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAPIVersionCheck { + struct _2: SwiftProtobuf.ProtobufAPIVersion_2 {} + typealias Version = _2 +} + +struct Daemon_VersionRequest: Sendable { + // 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 unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +struct Daemon_VersionResponse: Sendable { + // 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. + + /// TODO: Should we encapsulate these inside a Version message type, perhaps + /// in the mutagen package? + var major: UInt64 = 0 + + var minor: UInt64 = 0 + + var patch: UInt64 = 0 + + var tag: String = String() + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +struct Daemon_TerminateRequest: Sendable { + // 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 unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +struct Daemon_TerminateResponse: Sendable { + // 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 unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "daemon" + +extension Daemon_VersionRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".VersionRequest" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Daemon_VersionRequest, rhs: Daemon_VersionRequest) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Daemon_VersionResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".VersionResponse" + static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ + 1: .same(proto: "major"), + 2: .same(proto: "minor"), + 3: .same(proto: "patch"), + 4: .same(proto: "tag"), + ] + + mutating func decodeMessage(decoder: inout D) throws { + while let fieldNumber = try decoder.nextFieldNumber() { + // The use of inline closures is to circumvent an issue where the compiler + // allocates stack space for every case branch when no optimizations are + // enabled. https://github.com/apple/swift-protobuf/issues/1034 + switch fieldNumber { + case 1: try { try decoder.decodeSingularUInt64Field(value: &self.major) }() + case 2: try { try decoder.decodeSingularUInt64Field(value: &self.minor) }() + case 3: try { try decoder.decodeSingularUInt64Field(value: &self.patch) }() + case 4: try { try decoder.decodeSingularStringField(value: &self.tag) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.major != 0 { + try visitor.visitSingularUInt64Field(value: self.major, fieldNumber: 1) + } + if self.minor != 0 { + try visitor.visitSingularUInt64Field(value: self.minor, fieldNumber: 2) + } + if self.patch != 0 { + try visitor.visitSingularUInt64Field(value: self.patch, fieldNumber: 3) + } + if !self.tag.isEmpty { + try visitor.visitSingularStringField(value: self.tag, fieldNumber: 4) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Daemon_VersionResponse, rhs: Daemon_VersionResponse) -> Bool { + if lhs.major != rhs.major {return false} + if lhs.minor != rhs.minor {return false} + if lhs.patch != rhs.patch {return false} + if lhs.tag != rhs.tag {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Daemon_TerminateRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TerminateRequest" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Daemon_TerminateRequest, rhs: Daemon_TerminateRequest) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Daemon_TerminateResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TerminateResponse" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Daemon_TerminateResponse, rhs: Daemon_TerminateResponse) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Coder-Desktop/VPNLib/FileSync/MutagenSDK/service_daemon_daemon.proto b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/service_daemon_daemon.proto new file mode 100644 index 0000000..c6604cf --- /dev/null +++ b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/service_daemon_daemon.proto @@ -0,0 +1,52 @@ +/* + * This file was taken from + * https://github.com/mutagen-io/mutagen/tree/v0.18.1/pkg/service/daemon/daemon.proto + * + * MIT License + * + * Copyright (c) 2016-present Docker, Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +syntax = "proto3"; + +package daemon; + +option go_package = "github.com/mutagen-io/mutagen/pkg/service/daemon"; + +message VersionRequest{} + +message VersionResponse { + // TODO: Should we encapsulate these inside a Version message type, perhaps + // in the mutagen package? + uint64 major = 1; + uint64 minor = 2; + uint64 patch = 3; + string tag = 4; +} + +message TerminateRequest{} + +message TerminateResponse{} + +service Daemon { + rpc Version(VersionRequest) returns (VersionResponse) {} + rpc Terminate(TerminateRequest) returns (TerminateResponse) {} +} diff --git a/Coder-Desktop/VPNLib/FileSync/MutagenSDK/service_synchronization_synchronization.grpc.swift b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/service_synchronization_synchronization.grpc.swift new file mode 100644 index 0000000..aa8abe2 --- /dev/null +++ b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/service_synchronization_synchronization.grpc.swift @@ -0,0 +1,908 @@ +// +// DO NOT EDIT. +// swift-format-ignore-file +// +// Generated by the protocol buffer compiler. +// Source: service_synchronization_synchronization.proto +// +import GRPC +import NIO +import NIOConcurrencyHelpers +import SwiftProtobuf + + +/// Synchronization manages the lifecycle of synchronization sessions. +/// +/// Usage: instantiate `Synchronization_SynchronizationClient`, then call methods of this protocol to make API calls. +internal protocol Synchronization_SynchronizationClientProtocol: GRPCClient { + var serviceName: String { get } + var interceptors: Synchronization_SynchronizationClientInterceptorFactoryProtocol? { get } + + func create( + _ request: Synchronization_CreateRequest, + callOptions: CallOptions? + ) -> UnaryCall + + func list( + _ request: Synchronization_ListRequest, + callOptions: CallOptions? + ) -> UnaryCall + + func flush( + _ request: Synchronization_FlushRequest, + callOptions: CallOptions? + ) -> UnaryCall + + func pause( + _ request: Synchronization_PauseRequest, + callOptions: CallOptions? + ) -> UnaryCall + + func resume( + _ request: Synchronization_ResumeRequest, + callOptions: CallOptions? + ) -> UnaryCall + + func reset( + _ request: Synchronization_ResetRequest, + callOptions: CallOptions? + ) -> UnaryCall + + func terminate( + _ request: Synchronization_TerminateRequest, + callOptions: CallOptions? + ) -> UnaryCall +} + +extension Synchronization_SynchronizationClientProtocol { + internal var serviceName: String { + return "synchronization.Synchronization" + } + + /// Create creates a new session. + /// + /// - Parameters: + /// - request: Request to send to Create. + /// - callOptions: Call options. + /// - Returns: A `UnaryCall` with futures for the metadata, status and response. + internal func create( + _ request: Synchronization_CreateRequest, + callOptions: CallOptions? = nil + ) -> UnaryCall { + return self.makeUnaryCall( + path: Synchronization_SynchronizationClientMetadata.Methods.create.path, + request: request, + callOptions: callOptions ?? self.defaultCallOptions, + interceptors: self.interceptors?.makeCreateInterceptors() ?? [] + ) + } + + /// List returns metadata for existing sessions. + /// + /// - Parameters: + /// - request: Request to send to List. + /// - callOptions: Call options. + /// - Returns: A `UnaryCall` with futures for the metadata, status and response. + internal func list( + _ request: Synchronization_ListRequest, + callOptions: CallOptions? = nil + ) -> UnaryCall { + return self.makeUnaryCall( + path: Synchronization_SynchronizationClientMetadata.Methods.list.path, + request: request, + callOptions: callOptions ?? self.defaultCallOptions, + interceptors: self.interceptors?.makeListInterceptors() ?? [] + ) + } + + /// Flush flushes sessions. + /// + /// - Parameters: + /// - request: Request to send to Flush. + /// - callOptions: Call options. + /// - Returns: A `UnaryCall` with futures for the metadata, status and response. + internal func flush( + _ request: Synchronization_FlushRequest, + callOptions: CallOptions? = nil + ) -> UnaryCall { + return self.makeUnaryCall( + path: Synchronization_SynchronizationClientMetadata.Methods.flush.path, + request: request, + callOptions: callOptions ?? self.defaultCallOptions, + interceptors: self.interceptors?.makeFlushInterceptors() ?? [] + ) + } + + /// Pause pauses sessions. + /// + /// - Parameters: + /// - request: Request to send to Pause. + /// - callOptions: Call options. + /// - Returns: A `UnaryCall` with futures for the metadata, status and response. + internal func pause( + _ request: Synchronization_PauseRequest, + callOptions: CallOptions? = nil + ) -> UnaryCall { + return self.makeUnaryCall( + path: Synchronization_SynchronizationClientMetadata.Methods.pause.path, + request: request, + callOptions: callOptions ?? self.defaultCallOptions, + interceptors: self.interceptors?.makePauseInterceptors() ?? [] + ) + } + + /// Resume resumes paused or disconnected sessions. + /// + /// - Parameters: + /// - request: Request to send to Resume. + /// - callOptions: Call options. + /// - Returns: A `UnaryCall` with futures for the metadata, status and response. + internal func resume( + _ request: Synchronization_ResumeRequest, + callOptions: CallOptions? = nil + ) -> UnaryCall { + return self.makeUnaryCall( + path: Synchronization_SynchronizationClientMetadata.Methods.resume.path, + request: request, + callOptions: callOptions ?? self.defaultCallOptions, + interceptors: self.interceptors?.makeResumeInterceptors() ?? [] + ) + } + + /// Reset resets sessions' histories. + /// + /// - Parameters: + /// - request: Request to send to Reset. + /// - callOptions: Call options. + /// - Returns: A `UnaryCall` with futures for the metadata, status and response. + internal func reset( + _ request: Synchronization_ResetRequest, + callOptions: CallOptions? = nil + ) -> UnaryCall { + return self.makeUnaryCall( + path: Synchronization_SynchronizationClientMetadata.Methods.reset.path, + request: request, + callOptions: callOptions ?? self.defaultCallOptions, + interceptors: self.interceptors?.makeResetInterceptors() ?? [] + ) + } + + /// Terminate terminates sessions. + /// + /// - Parameters: + /// - request: Request to send to Terminate. + /// - callOptions: Call options. + /// - Returns: A `UnaryCall` with futures for the metadata, status and response. + internal func terminate( + _ request: Synchronization_TerminateRequest, + callOptions: CallOptions? = nil + ) -> UnaryCall { + return self.makeUnaryCall( + path: Synchronization_SynchronizationClientMetadata.Methods.terminate.path, + request: request, + callOptions: callOptions ?? self.defaultCallOptions, + interceptors: self.interceptors?.makeTerminateInterceptors() ?? [] + ) + } +} + +@available(*, deprecated) +extension Synchronization_SynchronizationClient: @unchecked Sendable {} + +@available(*, deprecated, renamed: "Synchronization_SynchronizationNIOClient") +internal final class Synchronization_SynchronizationClient: Synchronization_SynchronizationClientProtocol { + private let lock = Lock() + private var _defaultCallOptions: CallOptions + private var _interceptors: Synchronization_SynchronizationClientInterceptorFactoryProtocol? + internal let channel: GRPCChannel + internal var defaultCallOptions: CallOptions { + get { self.lock.withLock { return self._defaultCallOptions } } + set { self.lock.withLockVoid { self._defaultCallOptions = newValue } } + } + internal var interceptors: Synchronization_SynchronizationClientInterceptorFactoryProtocol? { + get { self.lock.withLock { return self._interceptors } } + set { self.lock.withLockVoid { self._interceptors = newValue } } + } + + /// Creates a client for the synchronization.Synchronization service. + /// + /// - Parameters: + /// - channel: `GRPCChannel` to the service host. + /// - defaultCallOptions: Options to use for each service call if the user doesn't provide them. + /// - interceptors: A factory providing interceptors for each RPC. + internal init( + channel: GRPCChannel, + defaultCallOptions: CallOptions = CallOptions(), + interceptors: Synchronization_SynchronizationClientInterceptorFactoryProtocol? = nil + ) { + self.channel = channel + self._defaultCallOptions = defaultCallOptions + self._interceptors = interceptors + } +} + +internal struct Synchronization_SynchronizationNIOClient: Synchronization_SynchronizationClientProtocol { + internal var channel: GRPCChannel + internal var defaultCallOptions: CallOptions + internal var interceptors: Synchronization_SynchronizationClientInterceptorFactoryProtocol? + + /// Creates a client for the synchronization.Synchronization service. + /// + /// - Parameters: + /// - channel: `GRPCChannel` to the service host. + /// - defaultCallOptions: Options to use for each service call if the user doesn't provide them. + /// - interceptors: A factory providing interceptors for each RPC. + internal init( + channel: GRPCChannel, + defaultCallOptions: CallOptions = CallOptions(), + interceptors: Synchronization_SynchronizationClientInterceptorFactoryProtocol? = nil + ) { + self.channel = channel + self.defaultCallOptions = defaultCallOptions + self.interceptors = interceptors + } +} + +/// Synchronization manages the lifecycle of synchronization sessions. +@available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *) +internal protocol Synchronization_SynchronizationAsyncClientProtocol: GRPCClient { + static var serviceDescriptor: GRPCServiceDescriptor { get } + var interceptors: Synchronization_SynchronizationClientInterceptorFactoryProtocol? { get } + + func makeCreateCall( + _ request: Synchronization_CreateRequest, + callOptions: CallOptions? + ) -> GRPCAsyncUnaryCall + + func makeListCall( + _ request: Synchronization_ListRequest, + callOptions: CallOptions? + ) -> GRPCAsyncUnaryCall + + func makeFlushCall( + _ request: Synchronization_FlushRequest, + callOptions: CallOptions? + ) -> GRPCAsyncUnaryCall + + func makePauseCall( + _ request: Synchronization_PauseRequest, + callOptions: CallOptions? + ) -> GRPCAsyncUnaryCall + + func makeResumeCall( + _ request: Synchronization_ResumeRequest, + callOptions: CallOptions? + ) -> GRPCAsyncUnaryCall + + func makeResetCall( + _ request: Synchronization_ResetRequest, + callOptions: CallOptions? + ) -> GRPCAsyncUnaryCall + + func makeTerminateCall( + _ request: Synchronization_TerminateRequest, + callOptions: CallOptions? + ) -> GRPCAsyncUnaryCall +} + +@available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *) +extension Synchronization_SynchronizationAsyncClientProtocol { + internal static var serviceDescriptor: GRPCServiceDescriptor { + return Synchronization_SynchronizationClientMetadata.serviceDescriptor + } + + internal var interceptors: Synchronization_SynchronizationClientInterceptorFactoryProtocol? { + return nil + } + + internal func makeCreateCall( + _ request: Synchronization_CreateRequest, + callOptions: CallOptions? = nil + ) -> GRPCAsyncUnaryCall { + return self.makeAsyncUnaryCall( + path: Synchronization_SynchronizationClientMetadata.Methods.create.path, + request: request, + callOptions: callOptions ?? self.defaultCallOptions, + interceptors: self.interceptors?.makeCreateInterceptors() ?? [] + ) + } + + internal func makeListCall( + _ request: Synchronization_ListRequest, + callOptions: CallOptions? = nil + ) -> GRPCAsyncUnaryCall { + return self.makeAsyncUnaryCall( + path: Synchronization_SynchronizationClientMetadata.Methods.list.path, + request: request, + callOptions: callOptions ?? self.defaultCallOptions, + interceptors: self.interceptors?.makeListInterceptors() ?? [] + ) + } + + internal func makeFlushCall( + _ request: Synchronization_FlushRequest, + callOptions: CallOptions? = nil + ) -> GRPCAsyncUnaryCall { + return self.makeAsyncUnaryCall( + path: Synchronization_SynchronizationClientMetadata.Methods.flush.path, + request: request, + callOptions: callOptions ?? self.defaultCallOptions, + interceptors: self.interceptors?.makeFlushInterceptors() ?? [] + ) + } + + internal func makePauseCall( + _ request: Synchronization_PauseRequest, + callOptions: CallOptions? = nil + ) -> GRPCAsyncUnaryCall { + return self.makeAsyncUnaryCall( + path: Synchronization_SynchronizationClientMetadata.Methods.pause.path, + request: request, + callOptions: callOptions ?? self.defaultCallOptions, + interceptors: self.interceptors?.makePauseInterceptors() ?? [] + ) + } + + internal func makeResumeCall( + _ request: Synchronization_ResumeRequest, + callOptions: CallOptions? = nil + ) -> GRPCAsyncUnaryCall { + return self.makeAsyncUnaryCall( + path: Synchronization_SynchronizationClientMetadata.Methods.resume.path, + request: request, + callOptions: callOptions ?? self.defaultCallOptions, + interceptors: self.interceptors?.makeResumeInterceptors() ?? [] + ) + } + + internal func makeResetCall( + _ request: Synchronization_ResetRequest, + callOptions: CallOptions? = nil + ) -> GRPCAsyncUnaryCall { + return self.makeAsyncUnaryCall( + path: Synchronization_SynchronizationClientMetadata.Methods.reset.path, + request: request, + callOptions: callOptions ?? self.defaultCallOptions, + interceptors: self.interceptors?.makeResetInterceptors() ?? [] + ) + } + + internal func makeTerminateCall( + _ request: Synchronization_TerminateRequest, + callOptions: CallOptions? = nil + ) -> GRPCAsyncUnaryCall { + return self.makeAsyncUnaryCall( + path: Synchronization_SynchronizationClientMetadata.Methods.terminate.path, + request: request, + callOptions: callOptions ?? self.defaultCallOptions, + interceptors: self.interceptors?.makeTerminateInterceptors() ?? [] + ) + } +} + +@available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *) +extension Synchronization_SynchronizationAsyncClientProtocol { + internal func create( + _ request: Synchronization_CreateRequest, + callOptions: CallOptions? = nil + ) async throws -> Synchronization_CreateResponse { + return try await self.performAsyncUnaryCall( + path: Synchronization_SynchronizationClientMetadata.Methods.create.path, + request: request, + callOptions: callOptions ?? self.defaultCallOptions, + interceptors: self.interceptors?.makeCreateInterceptors() ?? [] + ) + } + + internal func list( + _ request: Synchronization_ListRequest, + callOptions: CallOptions? = nil + ) async throws -> Synchronization_ListResponse { + return try await self.performAsyncUnaryCall( + path: Synchronization_SynchronizationClientMetadata.Methods.list.path, + request: request, + callOptions: callOptions ?? self.defaultCallOptions, + interceptors: self.interceptors?.makeListInterceptors() ?? [] + ) + } + + internal func flush( + _ request: Synchronization_FlushRequest, + callOptions: CallOptions? = nil + ) async throws -> Synchronization_FlushResponse { + return try await self.performAsyncUnaryCall( + path: Synchronization_SynchronizationClientMetadata.Methods.flush.path, + request: request, + callOptions: callOptions ?? self.defaultCallOptions, + interceptors: self.interceptors?.makeFlushInterceptors() ?? [] + ) + } + + internal func pause( + _ request: Synchronization_PauseRequest, + callOptions: CallOptions? = nil + ) async throws -> Synchronization_PauseResponse { + return try await self.performAsyncUnaryCall( + path: Synchronization_SynchronizationClientMetadata.Methods.pause.path, + request: request, + callOptions: callOptions ?? self.defaultCallOptions, + interceptors: self.interceptors?.makePauseInterceptors() ?? [] + ) + } + + internal func resume( + _ request: Synchronization_ResumeRequest, + callOptions: CallOptions? = nil + ) async throws -> Synchronization_ResumeResponse { + return try await self.performAsyncUnaryCall( + path: Synchronization_SynchronizationClientMetadata.Methods.resume.path, + request: request, + callOptions: callOptions ?? self.defaultCallOptions, + interceptors: self.interceptors?.makeResumeInterceptors() ?? [] + ) + } + + internal func reset( + _ request: Synchronization_ResetRequest, + callOptions: CallOptions? = nil + ) async throws -> Synchronization_ResetResponse { + return try await self.performAsyncUnaryCall( + path: Synchronization_SynchronizationClientMetadata.Methods.reset.path, + request: request, + callOptions: callOptions ?? self.defaultCallOptions, + interceptors: self.interceptors?.makeResetInterceptors() ?? [] + ) + } + + internal func terminate( + _ request: Synchronization_TerminateRequest, + callOptions: CallOptions? = nil + ) async throws -> Synchronization_TerminateResponse { + return try await self.performAsyncUnaryCall( + path: Synchronization_SynchronizationClientMetadata.Methods.terminate.path, + request: request, + callOptions: callOptions ?? self.defaultCallOptions, + interceptors: self.interceptors?.makeTerminateInterceptors() ?? [] + ) + } +} + +@available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *) +internal struct Synchronization_SynchronizationAsyncClient: Synchronization_SynchronizationAsyncClientProtocol { + internal var channel: GRPCChannel + internal var defaultCallOptions: CallOptions + internal var interceptors: Synchronization_SynchronizationClientInterceptorFactoryProtocol? + + internal init( + channel: GRPCChannel, + defaultCallOptions: CallOptions = CallOptions(), + interceptors: Synchronization_SynchronizationClientInterceptorFactoryProtocol? = nil + ) { + self.channel = channel + self.defaultCallOptions = defaultCallOptions + self.interceptors = interceptors + } +} + +internal protocol Synchronization_SynchronizationClientInterceptorFactoryProtocol: Sendable { + + /// - Returns: Interceptors to use when invoking 'create'. + func makeCreateInterceptors() -> [ClientInterceptor] + + /// - Returns: Interceptors to use when invoking 'list'. + func makeListInterceptors() -> [ClientInterceptor] + + /// - Returns: Interceptors to use when invoking 'flush'. + func makeFlushInterceptors() -> [ClientInterceptor] + + /// - Returns: Interceptors to use when invoking 'pause'. + func makePauseInterceptors() -> [ClientInterceptor] + + /// - Returns: Interceptors to use when invoking 'resume'. + func makeResumeInterceptors() -> [ClientInterceptor] + + /// - Returns: Interceptors to use when invoking 'reset'. + func makeResetInterceptors() -> [ClientInterceptor] + + /// - Returns: Interceptors to use when invoking 'terminate'. + func makeTerminateInterceptors() -> [ClientInterceptor] +} + +internal enum Synchronization_SynchronizationClientMetadata { + internal static let serviceDescriptor = GRPCServiceDescriptor( + name: "Synchronization", + fullName: "synchronization.Synchronization", + methods: [ + Synchronization_SynchronizationClientMetadata.Methods.create, + Synchronization_SynchronizationClientMetadata.Methods.list, + Synchronization_SynchronizationClientMetadata.Methods.flush, + Synchronization_SynchronizationClientMetadata.Methods.pause, + Synchronization_SynchronizationClientMetadata.Methods.resume, + Synchronization_SynchronizationClientMetadata.Methods.reset, + Synchronization_SynchronizationClientMetadata.Methods.terminate, + ] + ) + + internal enum Methods { + internal static let create = GRPCMethodDescriptor( + name: "Create", + path: "/synchronization.Synchronization/Create", + type: GRPCCallType.unary + ) + + internal static let list = GRPCMethodDescriptor( + name: "List", + path: "/synchronization.Synchronization/List", + type: GRPCCallType.unary + ) + + internal static let flush = GRPCMethodDescriptor( + name: "Flush", + path: "/synchronization.Synchronization/Flush", + type: GRPCCallType.unary + ) + + internal static let pause = GRPCMethodDescriptor( + name: "Pause", + path: "/synchronization.Synchronization/Pause", + type: GRPCCallType.unary + ) + + internal static let resume = GRPCMethodDescriptor( + name: "Resume", + path: "/synchronization.Synchronization/Resume", + type: GRPCCallType.unary + ) + + internal static let reset = GRPCMethodDescriptor( + name: "Reset", + path: "/synchronization.Synchronization/Reset", + type: GRPCCallType.unary + ) + + internal static let terminate = GRPCMethodDescriptor( + name: "Terminate", + path: "/synchronization.Synchronization/Terminate", + type: GRPCCallType.unary + ) + } +} + +/// Synchronization manages the lifecycle of synchronization sessions. +/// +/// To build a server, implement a class that conforms to this protocol. +internal protocol Synchronization_SynchronizationProvider: CallHandlerProvider { + var interceptors: Synchronization_SynchronizationServerInterceptorFactoryProtocol? { get } + + /// Create creates a new session. + func create(request: Synchronization_CreateRequest, context: StatusOnlyCallContext) -> EventLoopFuture + + /// List returns metadata for existing sessions. + func list(request: Synchronization_ListRequest, context: StatusOnlyCallContext) -> EventLoopFuture + + /// Flush flushes sessions. + func flush(request: Synchronization_FlushRequest, context: StatusOnlyCallContext) -> EventLoopFuture + + /// Pause pauses sessions. + func pause(request: Synchronization_PauseRequest, context: StatusOnlyCallContext) -> EventLoopFuture + + /// Resume resumes paused or disconnected sessions. + func resume(request: Synchronization_ResumeRequest, context: StatusOnlyCallContext) -> EventLoopFuture + + /// Reset resets sessions' histories. + func reset(request: Synchronization_ResetRequest, context: StatusOnlyCallContext) -> EventLoopFuture + + /// Terminate terminates sessions. + func terminate(request: Synchronization_TerminateRequest, context: StatusOnlyCallContext) -> EventLoopFuture +} + +extension Synchronization_SynchronizationProvider { + internal var serviceName: Substring { + return Synchronization_SynchronizationServerMetadata.serviceDescriptor.fullName[...] + } + + /// Determines, calls and returns the appropriate request handler, depending on the request's method. + /// Returns nil for methods not handled by this service. + internal func handle( + method name: Substring, + context: CallHandlerContext + ) -> GRPCServerHandlerProtocol? { + switch name { + case "Create": + return UnaryServerHandler( + context: context, + requestDeserializer: ProtobufDeserializer(), + responseSerializer: ProtobufSerializer(), + interceptors: self.interceptors?.makeCreateInterceptors() ?? [], + userFunction: self.create(request:context:) + ) + + case "List": + return UnaryServerHandler( + context: context, + requestDeserializer: ProtobufDeserializer(), + responseSerializer: ProtobufSerializer(), + interceptors: self.interceptors?.makeListInterceptors() ?? [], + userFunction: self.list(request:context:) + ) + + case "Flush": + return UnaryServerHandler( + context: context, + requestDeserializer: ProtobufDeserializer(), + responseSerializer: ProtobufSerializer(), + interceptors: self.interceptors?.makeFlushInterceptors() ?? [], + userFunction: self.flush(request:context:) + ) + + case "Pause": + return UnaryServerHandler( + context: context, + requestDeserializer: ProtobufDeserializer(), + responseSerializer: ProtobufSerializer(), + interceptors: self.interceptors?.makePauseInterceptors() ?? [], + userFunction: self.pause(request:context:) + ) + + case "Resume": + return UnaryServerHandler( + context: context, + requestDeserializer: ProtobufDeserializer(), + responseSerializer: ProtobufSerializer(), + interceptors: self.interceptors?.makeResumeInterceptors() ?? [], + userFunction: self.resume(request:context:) + ) + + case "Reset": + return UnaryServerHandler( + context: context, + requestDeserializer: ProtobufDeserializer(), + responseSerializer: ProtobufSerializer(), + interceptors: self.interceptors?.makeResetInterceptors() ?? [], + userFunction: self.reset(request:context:) + ) + + case "Terminate": + return UnaryServerHandler( + context: context, + requestDeserializer: ProtobufDeserializer(), + responseSerializer: ProtobufSerializer(), + interceptors: self.interceptors?.makeTerminateInterceptors() ?? [], + userFunction: self.terminate(request:context:) + ) + + default: + return nil + } + } +} + +/// Synchronization manages the lifecycle of synchronization sessions. +/// +/// To implement a server, implement an object which conforms to this protocol. +@available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *) +internal protocol Synchronization_SynchronizationAsyncProvider: CallHandlerProvider, Sendable { + static var serviceDescriptor: GRPCServiceDescriptor { get } + var interceptors: Synchronization_SynchronizationServerInterceptorFactoryProtocol? { get } + + /// Create creates a new session. + func create( + request: Synchronization_CreateRequest, + context: GRPCAsyncServerCallContext + ) async throws -> Synchronization_CreateResponse + + /// List returns metadata for existing sessions. + func list( + request: Synchronization_ListRequest, + context: GRPCAsyncServerCallContext + ) async throws -> Synchronization_ListResponse + + /// Flush flushes sessions. + func flush( + request: Synchronization_FlushRequest, + context: GRPCAsyncServerCallContext + ) async throws -> Synchronization_FlushResponse + + /// Pause pauses sessions. + func pause( + request: Synchronization_PauseRequest, + context: GRPCAsyncServerCallContext + ) async throws -> Synchronization_PauseResponse + + /// Resume resumes paused or disconnected sessions. + func resume( + request: Synchronization_ResumeRequest, + context: GRPCAsyncServerCallContext + ) async throws -> Synchronization_ResumeResponse + + /// Reset resets sessions' histories. + func reset( + request: Synchronization_ResetRequest, + context: GRPCAsyncServerCallContext + ) async throws -> Synchronization_ResetResponse + + /// Terminate terminates sessions. + func terminate( + request: Synchronization_TerminateRequest, + context: GRPCAsyncServerCallContext + ) async throws -> Synchronization_TerminateResponse +} + +@available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *) +extension Synchronization_SynchronizationAsyncProvider { + internal static var serviceDescriptor: GRPCServiceDescriptor { + return Synchronization_SynchronizationServerMetadata.serviceDescriptor + } + + internal var serviceName: Substring { + return Synchronization_SynchronizationServerMetadata.serviceDescriptor.fullName[...] + } + + internal var interceptors: Synchronization_SynchronizationServerInterceptorFactoryProtocol? { + return nil + } + + internal func handle( + method name: Substring, + context: CallHandlerContext + ) -> GRPCServerHandlerProtocol? { + switch name { + case "Create": + return GRPCAsyncServerHandler( + context: context, + requestDeserializer: ProtobufDeserializer(), + responseSerializer: ProtobufSerializer(), + interceptors: self.interceptors?.makeCreateInterceptors() ?? [], + wrapping: { try await self.create(request: $0, context: $1) } + ) + + case "List": + return GRPCAsyncServerHandler( + context: context, + requestDeserializer: ProtobufDeserializer(), + responseSerializer: ProtobufSerializer(), + interceptors: self.interceptors?.makeListInterceptors() ?? [], + wrapping: { try await self.list(request: $0, context: $1) } + ) + + case "Flush": + return GRPCAsyncServerHandler( + context: context, + requestDeserializer: ProtobufDeserializer(), + responseSerializer: ProtobufSerializer(), + interceptors: self.interceptors?.makeFlushInterceptors() ?? [], + wrapping: { try await self.flush(request: $0, context: $1) } + ) + + case "Pause": + return GRPCAsyncServerHandler( + context: context, + requestDeserializer: ProtobufDeserializer(), + responseSerializer: ProtobufSerializer(), + interceptors: self.interceptors?.makePauseInterceptors() ?? [], + wrapping: { try await self.pause(request: $0, context: $1) } + ) + + case "Resume": + return GRPCAsyncServerHandler( + context: context, + requestDeserializer: ProtobufDeserializer(), + responseSerializer: ProtobufSerializer(), + interceptors: self.interceptors?.makeResumeInterceptors() ?? [], + wrapping: { try await self.resume(request: $0, context: $1) } + ) + + case "Reset": + return GRPCAsyncServerHandler( + context: context, + requestDeserializer: ProtobufDeserializer(), + responseSerializer: ProtobufSerializer(), + interceptors: self.interceptors?.makeResetInterceptors() ?? [], + wrapping: { try await self.reset(request: $0, context: $1) } + ) + + case "Terminate": + return GRPCAsyncServerHandler( + context: context, + requestDeserializer: ProtobufDeserializer(), + responseSerializer: ProtobufSerializer(), + interceptors: self.interceptors?.makeTerminateInterceptors() ?? [], + wrapping: { try await self.terminate(request: $0, context: $1) } + ) + + default: + return nil + } + } +} + +internal protocol Synchronization_SynchronizationServerInterceptorFactoryProtocol: Sendable { + + /// - Returns: Interceptors to use when handling 'create'. + /// Defaults to calling `self.makeInterceptors()`. + func makeCreateInterceptors() -> [ServerInterceptor] + + /// - Returns: Interceptors to use when handling 'list'. + /// Defaults to calling `self.makeInterceptors()`. + func makeListInterceptors() -> [ServerInterceptor] + + /// - Returns: Interceptors to use when handling 'flush'. + /// Defaults to calling `self.makeInterceptors()`. + func makeFlushInterceptors() -> [ServerInterceptor] + + /// - Returns: Interceptors to use when handling 'pause'. + /// Defaults to calling `self.makeInterceptors()`. + func makePauseInterceptors() -> [ServerInterceptor] + + /// - Returns: Interceptors to use when handling 'resume'. + /// Defaults to calling `self.makeInterceptors()`. + func makeResumeInterceptors() -> [ServerInterceptor] + + /// - Returns: Interceptors to use when handling 'reset'. + /// Defaults to calling `self.makeInterceptors()`. + func makeResetInterceptors() -> [ServerInterceptor] + + /// - Returns: Interceptors to use when handling 'terminate'. + /// Defaults to calling `self.makeInterceptors()`. + func makeTerminateInterceptors() -> [ServerInterceptor] +} + +internal enum Synchronization_SynchronizationServerMetadata { + internal static let serviceDescriptor = GRPCServiceDescriptor( + name: "Synchronization", + fullName: "synchronization.Synchronization", + methods: [ + Synchronization_SynchronizationServerMetadata.Methods.create, + Synchronization_SynchronizationServerMetadata.Methods.list, + Synchronization_SynchronizationServerMetadata.Methods.flush, + Synchronization_SynchronizationServerMetadata.Methods.pause, + Synchronization_SynchronizationServerMetadata.Methods.resume, + Synchronization_SynchronizationServerMetadata.Methods.reset, + Synchronization_SynchronizationServerMetadata.Methods.terminate, + ] + ) + + internal enum Methods { + internal static let create = GRPCMethodDescriptor( + name: "Create", + path: "/synchronization.Synchronization/Create", + type: GRPCCallType.unary + ) + + internal static let list = GRPCMethodDescriptor( + name: "List", + path: "/synchronization.Synchronization/List", + type: GRPCCallType.unary + ) + + internal static let flush = GRPCMethodDescriptor( + name: "Flush", + path: "/synchronization.Synchronization/Flush", + type: GRPCCallType.unary + ) + + internal static let pause = GRPCMethodDescriptor( + name: "Pause", + path: "/synchronization.Synchronization/Pause", + type: GRPCCallType.unary + ) + + internal static let resume = GRPCMethodDescriptor( + name: "Resume", + path: "/synchronization.Synchronization/Resume", + type: GRPCCallType.unary + ) + + internal static let reset = GRPCMethodDescriptor( + name: "Reset", + path: "/synchronization.Synchronization/Reset", + type: GRPCCallType.unary + ) + + internal static let terminate = GRPCMethodDescriptor( + name: "Terminate", + path: "/synchronization.Synchronization/Terminate", + type: GRPCCallType.unary + ) + } +} diff --git a/Coder-Desktop/VPNLib/FileSync/MutagenSDK/service_synchronization_synchronization.pb.swift b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/service_synchronization_synchronization.pb.swift new file mode 100644 index 0000000..ccb4100 --- /dev/null +++ b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/service_synchronization_synchronization.pb.swift @@ -0,0 +1,1006 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: service_synchronization_synchronization.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// +// This file was taken from +// https://github.com/mutagen-io/mutagen/tree/v0.18.1/pkg/service/synchronization/synchronization.proto +// +// MIT License +// +// Copyright (c) 2016-present Docker, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. + +import SwiftProtobuf + +// If the compiler emits an error on this type, it is because this file +// was generated by a version of the `protoc` Swift plug-in that is +// incompatible with the version of SwiftProtobuf to which you are linking. +// Please ensure that you are building against the same version of the API +// that was used to generate this file. +fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAPIVersionCheck { + struct _2: SwiftProtobuf.ProtobufAPIVersion_2 {} + typealias Version = _2 +} + +/// CreationSpecification contains the metadata required for a new session. +struct Synchronization_CreationSpecification: @unchecked Sendable { + // 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. + + /// Alpha is the alpha endpoint URL for the session. + var alpha: Url_URL { + get {return _storage._alpha ?? Url_URL()} + set {_uniqueStorage()._alpha = newValue} + } + /// Returns true if `alpha` has been explicitly set. + var hasAlpha: Bool {return _storage._alpha != nil} + /// Clears the value of `alpha`. Subsequent reads from it will return its default value. + mutating func clearAlpha() {_uniqueStorage()._alpha = nil} + + /// Beta is the beta endpoint URL for the session. + var beta: Url_URL { + get {return _storage._beta ?? Url_URL()} + set {_uniqueStorage()._beta = newValue} + } + /// Returns true if `beta` has been explicitly set. + var hasBeta: Bool {return _storage._beta != nil} + /// Clears the value of `beta`. Subsequent reads from it will return its default value. + mutating func clearBeta() {_uniqueStorage()._beta = nil} + + /// Configuration is the base session configuration. It is the result of + /// merging the global configuration (unless disabled), any manually + /// specified configuration file, and any command line configuration + /// parameters. + var configuration: Synchronization_Configuration { + get {return _storage._configuration ?? Synchronization_Configuration()} + set {_uniqueStorage()._configuration = newValue} + } + /// Returns true if `configuration` has been explicitly set. + var hasConfiguration: Bool {return _storage._configuration != nil} + /// Clears the value of `configuration`. Subsequent reads from it will return its default value. + mutating func clearConfiguration() {_uniqueStorage()._configuration = nil} + + /// ConfigurationAlpha is the alpha-specific session configuration. It is + /// determined based on command line configuration parameters. + var configurationAlpha: Synchronization_Configuration { + get {return _storage._configurationAlpha ?? Synchronization_Configuration()} + set {_uniqueStorage()._configurationAlpha = newValue} + } + /// Returns true if `configurationAlpha` has been explicitly set. + var hasConfigurationAlpha: Bool {return _storage._configurationAlpha != nil} + /// Clears the value of `configurationAlpha`. Subsequent reads from it will return its default value. + mutating func clearConfigurationAlpha() {_uniqueStorage()._configurationAlpha = nil} + + /// ConfigurationBeta is the beta-specific session configuration. It is + /// determined based on command line configuration parameters. + var configurationBeta: Synchronization_Configuration { + get {return _storage._configurationBeta ?? Synchronization_Configuration()} + set {_uniqueStorage()._configurationBeta = newValue} + } + /// Returns true if `configurationBeta` has been explicitly set. + var hasConfigurationBeta: Bool {return _storage._configurationBeta != nil} + /// Clears the value of `configurationBeta`. Subsequent reads from it will return its default value. + mutating func clearConfigurationBeta() {_uniqueStorage()._configurationBeta = nil} + + /// Name is the name for the session object. + var name: String { + get {return _storage._name} + set {_uniqueStorage()._name = newValue} + } + + /// Labels are the labels for the session object. + var labels: Dictionary { + get {return _storage._labels} + set {_uniqueStorage()._labels = newValue} + } + + /// Paused indicates whether or not to create the session pre-paused. + var paused: Bool { + get {return _storage._paused} + set {_uniqueStorage()._paused = newValue} + } + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +/// CreateRequest encodes a request for session creation. +struct Synchronization_CreateRequest: Sendable { + // 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. + + /// Prompter is the prompter identifier to use for creating sessions. + var prompter: String = String() + + /// Specification is the creation specification. + var specification: Synchronization_CreationSpecification { + get {return _specification ?? Synchronization_CreationSpecification()} + set {_specification = newValue} + } + /// Returns true if `specification` has been explicitly set. + var hasSpecification: Bool {return self._specification != nil} + /// Clears the value of `specification`. Subsequent reads from it will return its default value. + mutating func clearSpecification() {self._specification = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _specification: Synchronization_CreationSpecification? = nil +} + +/// CreateResponse encodes a session creation response. +struct Synchronization_CreateResponse: Sendable { + // 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. + + /// Session is the resulting session identifier. + var session: String = String() + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +/// ListRequest encodes a request for session metadata. +struct Synchronization_ListRequest: Sendable { + // 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. + + /// Selection is the session selection criteria. + var selection: Selection_Selection { + get {return _selection ?? Selection_Selection()} + set {_selection = newValue} + } + /// Returns true if `selection` has been explicitly set. + var hasSelection: Bool {return self._selection != nil} + /// Clears the value of `selection`. Subsequent reads from it will return its default value. + mutating func clearSelection() {self._selection = nil} + + /// PreviousStateIndex is the previously seen state index. 0 may be provided + /// to force an immediate state listing. + var previousStateIndex: UInt64 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _selection: Selection_Selection? = nil +} + +/// ListResponse encodes session metadata. +struct Synchronization_ListResponse: Sendable { + // 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. + + /// StateIndex is the state index associated with the session metadata. + var stateIndex: UInt64 = 0 + + /// SessionStates are the session metadata states. + var sessionStates: [Synchronization_State] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +/// FlushRequest encodes a request to flush sessions. +struct Synchronization_FlushRequest: Sendable { + // 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. + + /// Prompter is the prompter to use for status message updates. + var prompter: String = String() + + /// Selection is the session selection criteria. + var selection: Selection_Selection { + get {return _selection ?? Selection_Selection()} + set {_selection = newValue} + } + /// Returns true if `selection` has been explicitly set. + var hasSelection: Bool {return self._selection != nil} + /// Clears the value of `selection`. Subsequent reads from it will return its default value. + mutating func clearSelection() {self._selection = nil} + + /// SkipWait indicates whether or not the operation should avoid blocking. + var skipWait: Bool = false + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _selection: Selection_Selection? = nil +} + +/// FlushResponse indicates completion of flush operation(s). +struct Synchronization_FlushResponse: Sendable { + // 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 unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +/// PauseRequest encodes a request to pause sessions. +struct Synchronization_PauseRequest: Sendable { + // 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. + + /// Prompter is the prompter to use for status message updates. + var prompter: String = String() + + /// Selection is the session selection criteria. + var selection: Selection_Selection { + get {return _selection ?? Selection_Selection()} + set {_selection = newValue} + } + /// Returns true if `selection` has been explicitly set. + var hasSelection: Bool {return self._selection != nil} + /// Clears the value of `selection`. Subsequent reads from it will return its default value. + mutating func clearSelection() {self._selection = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _selection: Selection_Selection? = nil +} + +/// PauseResponse indicates completion of pause operation(s). +struct Synchronization_PauseResponse: Sendable { + // 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 unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +/// ResumeRequest encodes a request to resume sessions. +struct Synchronization_ResumeRequest: Sendable { + // 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. + + /// Prompter is the prompter identifier to use for resuming sessions. + var prompter: String = String() + + /// Selection is the session selection criteria. + var selection: Selection_Selection { + get {return _selection ?? Selection_Selection()} + set {_selection = newValue} + } + /// Returns true if `selection` has been explicitly set. + var hasSelection: Bool {return self._selection != nil} + /// Clears the value of `selection`. Subsequent reads from it will return its default value. + mutating func clearSelection() {self._selection = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _selection: Selection_Selection? = nil +} + +/// ResumeResponse indicates completion of resume operation(s). +struct Synchronization_ResumeResponse: Sendable { + // 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 unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +/// ResetRequest encodes a request to reset sessions. +struct Synchronization_ResetRequest: Sendable { + // 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. + + /// Prompter is the prompter identifier to use for resetting sessions. + var prompter: String = String() + + /// Selection is the session selection criteria. + var selection: Selection_Selection { + get {return _selection ?? Selection_Selection()} + set {_selection = newValue} + } + /// Returns true if `selection` has been explicitly set. + var hasSelection: Bool {return self._selection != nil} + /// Clears the value of `selection`. Subsequent reads from it will return its default value. + mutating func clearSelection() {self._selection = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _selection: Selection_Selection? = nil +} + +/// ResetResponse indicates completion of reset operation(s). +struct Synchronization_ResetResponse: Sendable { + // 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 unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +/// TerminateRequest encodes a request to terminate sessions. +struct Synchronization_TerminateRequest: Sendable { + // 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. + + /// Prompter is the prompter to use for status message updates. + var prompter: String = String() + + /// Selection is the session selection criteria. + var selection: Selection_Selection { + get {return _selection ?? Selection_Selection()} + set {_selection = newValue} + } + /// Returns true if `selection` has been explicitly set. + var hasSelection: Bool {return self._selection != nil} + /// Clears the value of `selection`. Subsequent reads from it will return its default value. + mutating func clearSelection() {self._selection = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _selection: Selection_Selection? = nil +} + +/// TerminateResponse indicates completion of termination operation(s). +struct Synchronization_TerminateResponse: Sendable { + // 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 unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "synchronization" + +extension Synchronization_CreationSpecification: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".CreationSpecification" + static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ + 1: .same(proto: "alpha"), + 2: .same(proto: "beta"), + 3: .same(proto: "configuration"), + 4: .same(proto: "configurationAlpha"), + 5: .same(proto: "configurationBeta"), + 6: .same(proto: "name"), + 7: .same(proto: "labels"), + 8: .same(proto: "paused"), + ] + + fileprivate class _StorageClass { + var _alpha: Url_URL? = nil + var _beta: Url_URL? = nil + var _configuration: Synchronization_Configuration? = nil + var _configurationAlpha: Synchronization_Configuration? = nil + var _configurationBeta: Synchronization_Configuration? = nil + var _name: String = String() + var _labels: Dictionary = [:] + var _paused: Bool = false + + #if swift(>=5.10) + // This property is used as the initial default value for new instances of the type. + // The type itself is protecting the reference to its storage via CoW semantics. + // This will force a copy to be made of this reference when the first mutation occurs; + // hence, it is safe to mark this as `nonisolated(unsafe)`. + static nonisolated(unsafe) let defaultInstance = _StorageClass() + #else + static let defaultInstance = _StorageClass() + #endif + + private init() {} + + init(copying source: _StorageClass) { + _alpha = source._alpha + _beta = source._beta + _configuration = source._configuration + _configurationAlpha = source._configurationAlpha + _configurationBeta = source._configurationBeta + _name = source._name + _labels = source._labels + _paused = source._paused + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(decoder: inout D) throws { + _ = _uniqueStorage() + try withExtendedLifetime(_storage) { (_storage: _StorageClass) in + while let fieldNumber = try decoder.nextFieldNumber() { + // The use of inline closures is to circumvent an issue where the compiler + // allocates stack space for every case branch when no optimizations are + // enabled. https://github.com/apple/swift-protobuf/issues/1034 + switch fieldNumber { + case 1: try { try decoder.decodeSingularMessageField(value: &_storage._alpha) }() + case 2: try { try decoder.decodeSingularMessageField(value: &_storage._beta) }() + case 3: try { try decoder.decodeSingularMessageField(value: &_storage._configuration) }() + case 4: try { try decoder.decodeSingularMessageField(value: &_storage._configurationAlpha) }() + case 5: try { try decoder.decodeSingularMessageField(value: &_storage._configurationBeta) }() + case 6: try { try decoder.decodeSingularStringField(value: &_storage._name) }() + case 7: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._labels) }() + case 8: try { try decoder.decodeSingularBoolField(value: &_storage._paused) }() + default: break + } + } + } + } + + func traverse(visitor: inout V) throws { + try withExtendedLifetime(_storage) { (_storage: _StorageClass) in + // The use of inline closures is to circumvent an issue where the compiler + // allocates stack space for every if/case branch local when no optimizations + // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and + // https://github.com/apple/swift-protobuf/issues/1182 + try { if let v = _storage._alpha { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._beta { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._configuration { + try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + } }() + try { if let v = _storage._configurationAlpha { + try visitor.visitSingularMessageField(value: v, fieldNumber: 4) + } }() + try { if let v = _storage._configurationBeta { + try visitor.visitSingularMessageField(value: v, fieldNumber: 5) + } }() + if !_storage._name.isEmpty { + try visitor.visitSingularStringField(value: _storage._name, fieldNumber: 6) + } + if !_storage._labels.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._labels, fieldNumber: 7) + } + if _storage._paused != false { + try visitor.visitSingularBoolField(value: _storage._paused, fieldNumber: 8) + } + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Synchronization_CreationSpecification, rhs: Synchronization_CreationSpecification) -> 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._alpha != rhs_storage._alpha {return false} + if _storage._beta != rhs_storage._beta {return false} + if _storage._configuration != rhs_storage._configuration {return false} + if _storage._configurationAlpha != rhs_storage._configurationAlpha {return false} + if _storage._configurationBeta != rhs_storage._configurationBeta {return false} + if _storage._name != rhs_storage._name {return false} + if _storage._labels != rhs_storage._labels {return false} + if _storage._paused != rhs_storage._paused {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Synchronization_CreateRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".CreateRequest" + static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ + 1: .same(proto: "prompter"), + 2: .same(proto: "specification"), + ] + + mutating func decodeMessage(decoder: inout D) throws { + while let fieldNumber = try decoder.nextFieldNumber() { + // The use of inline closures is to circumvent an issue where the compiler + // allocates stack space for every case branch when no optimizations are + // enabled. https://github.com/apple/swift-protobuf/issues/1034 + switch fieldNumber { + case 1: try { try decoder.decodeSingularStringField(value: &self.prompter) }() + case 2: try { try decoder.decodeSingularMessageField(value: &self._specification) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + // The use of inline closures is to circumvent an issue where the compiler + // allocates stack space for every if/case branch local when no optimizations + // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and + // https://github.com/apple/swift-protobuf/issues/1182 + if !self.prompter.isEmpty { + try visitor.visitSingularStringField(value: self.prompter, fieldNumber: 1) + } + try { if let v = self._specification { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Synchronization_CreateRequest, rhs: Synchronization_CreateRequest) -> Bool { + if lhs.prompter != rhs.prompter {return false} + if lhs._specification != rhs._specification {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Synchronization_CreateResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".CreateResponse" + static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ + 1: .same(proto: "session"), + ] + + mutating func decodeMessage(decoder: inout D) throws { + while let fieldNumber = try decoder.nextFieldNumber() { + // The use of inline closures is to circumvent an issue where the compiler + // allocates stack space for every case branch when no optimizations are + // enabled. https://github.com/apple/swift-protobuf/issues/1034 + switch fieldNumber { + case 1: try { try decoder.decodeSingularStringField(value: &self.session) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.session.isEmpty { + try visitor.visitSingularStringField(value: self.session, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Synchronization_CreateResponse, rhs: Synchronization_CreateResponse) -> Bool { + if lhs.session != rhs.session {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Synchronization_ListRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".ListRequest" + static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ + 1: .same(proto: "selection"), + 2: .same(proto: "previousStateIndex"), + ] + + mutating func decodeMessage(decoder: inout D) throws { + while let fieldNumber = try decoder.nextFieldNumber() { + // The use of inline closures is to circumvent an issue where the compiler + // allocates stack space for every case branch when no optimizations are + // enabled. https://github.com/apple/swift-protobuf/issues/1034 + switch fieldNumber { + case 1: try { try decoder.decodeSingularMessageField(value: &self._selection) }() + case 2: try { try decoder.decodeSingularUInt64Field(value: &self.previousStateIndex) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + // The use of inline closures is to circumvent an issue where the compiler + // allocates stack space for every if/case branch local when no optimizations + // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and + // https://github.com/apple/swift-protobuf/issues/1182 + try { if let v = self._selection { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + if self.previousStateIndex != 0 { + try visitor.visitSingularUInt64Field(value: self.previousStateIndex, fieldNumber: 2) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Synchronization_ListRequest, rhs: Synchronization_ListRequest) -> Bool { + if lhs._selection != rhs._selection {return false} + if lhs.previousStateIndex != rhs.previousStateIndex {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Synchronization_ListResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".ListResponse" + static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ + 1: .same(proto: "stateIndex"), + 2: .same(proto: "sessionStates"), + ] + + mutating func decodeMessage(decoder: inout D) throws { + while let fieldNumber = try decoder.nextFieldNumber() { + // The use of inline closures is to circumvent an issue where the compiler + // allocates stack space for every case branch when no optimizations are + // enabled. https://github.com/apple/swift-protobuf/issues/1034 + switch fieldNumber { + case 1: try { try decoder.decodeSingularUInt64Field(value: &self.stateIndex) }() + case 2: try { try decoder.decodeRepeatedMessageField(value: &self.sessionStates) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.stateIndex != 0 { + try visitor.visitSingularUInt64Field(value: self.stateIndex, fieldNumber: 1) + } + if !self.sessionStates.isEmpty { + try visitor.visitRepeatedMessageField(value: self.sessionStates, fieldNumber: 2) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Synchronization_ListResponse, rhs: Synchronization_ListResponse) -> Bool { + if lhs.stateIndex != rhs.stateIndex {return false} + if lhs.sessionStates != rhs.sessionStates {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Synchronization_FlushRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".FlushRequest" + static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ + 1: .same(proto: "prompter"), + 2: .same(proto: "selection"), + 3: .same(proto: "skipWait"), + ] + + mutating func decodeMessage(decoder: inout D) throws { + while let fieldNumber = try decoder.nextFieldNumber() { + // The use of inline closures is to circumvent an issue where the compiler + // allocates stack space for every case branch when no optimizations are + // enabled. https://github.com/apple/swift-protobuf/issues/1034 + switch fieldNumber { + case 1: try { try decoder.decodeSingularStringField(value: &self.prompter) }() + case 2: try { try decoder.decodeSingularMessageField(value: &self._selection) }() + case 3: try { try decoder.decodeSingularBoolField(value: &self.skipWait) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + // The use of inline closures is to circumvent an issue where the compiler + // allocates stack space for every if/case branch local when no optimizations + // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and + // https://github.com/apple/swift-protobuf/issues/1182 + if !self.prompter.isEmpty { + try visitor.visitSingularStringField(value: self.prompter, fieldNumber: 1) + } + try { if let v = self._selection { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + if self.skipWait != false { + try visitor.visitSingularBoolField(value: self.skipWait, fieldNumber: 3) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Synchronization_FlushRequest, rhs: Synchronization_FlushRequest) -> Bool { + if lhs.prompter != rhs.prompter {return false} + if lhs._selection != rhs._selection {return false} + if lhs.skipWait != rhs.skipWait {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Synchronization_FlushResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".FlushResponse" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Synchronization_FlushResponse, rhs: Synchronization_FlushResponse) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Synchronization_PauseRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".PauseRequest" + static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ + 1: .same(proto: "prompter"), + 2: .same(proto: "selection"), + ] + + mutating func decodeMessage(decoder: inout D) throws { + while let fieldNumber = try decoder.nextFieldNumber() { + // The use of inline closures is to circumvent an issue where the compiler + // allocates stack space for every case branch when no optimizations are + // enabled. https://github.com/apple/swift-protobuf/issues/1034 + switch fieldNumber { + case 1: try { try decoder.decodeSingularStringField(value: &self.prompter) }() + case 2: try { try decoder.decodeSingularMessageField(value: &self._selection) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + // The use of inline closures is to circumvent an issue where the compiler + // allocates stack space for every if/case branch local when no optimizations + // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and + // https://github.com/apple/swift-protobuf/issues/1182 + if !self.prompter.isEmpty { + try visitor.visitSingularStringField(value: self.prompter, fieldNumber: 1) + } + try { if let v = self._selection { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Synchronization_PauseRequest, rhs: Synchronization_PauseRequest) -> Bool { + if lhs.prompter != rhs.prompter {return false} + if lhs._selection != rhs._selection {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Synchronization_PauseResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".PauseResponse" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Synchronization_PauseResponse, rhs: Synchronization_PauseResponse) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Synchronization_ResumeRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".ResumeRequest" + static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ + 1: .same(proto: "prompter"), + 2: .same(proto: "selection"), + ] + + mutating func decodeMessage(decoder: inout D) throws { + while let fieldNumber = try decoder.nextFieldNumber() { + // The use of inline closures is to circumvent an issue where the compiler + // allocates stack space for every case branch when no optimizations are + // enabled. https://github.com/apple/swift-protobuf/issues/1034 + switch fieldNumber { + case 1: try { try decoder.decodeSingularStringField(value: &self.prompter) }() + case 2: try { try decoder.decodeSingularMessageField(value: &self._selection) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + // The use of inline closures is to circumvent an issue where the compiler + // allocates stack space for every if/case branch local when no optimizations + // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and + // https://github.com/apple/swift-protobuf/issues/1182 + if !self.prompter.isEmpty { + try visitor.visitSingularStringField(value: self.prompter, fieldNumber: 1) + } + try { if let v = self._selection { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Synchronization_ResumeRequest, rhs: Synchronization_ResumeRequest) -> Bool { + if lhs.prompter != rhs.prompter {return false} + if lhs._selection != rhs._selection {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Synchronization_ResumeResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".ResumeResponse" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Synchronization_ResumeResponse, rhs: Synchronization_ResumeResponse) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Synchronization_ResetRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".ResetRequest" + static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ + 1: .same(proto: "prompter"), + 2: .same(proto: "selection"), + ] + + mutating func decodeMessage(decoder: inout D) throws { + while let fieldNumber = try decoder.nextFieldNumber() { + // The use of inline closures is to circumvent an issue where the compiler + // allocates stack space for every case branch when no optimizations are + // enabled. https://github.com/apple/swift-protobuf/issues/1034 + switch fieldNumber { + case 1: try { try decoder.decodeSingularStringField(value: &self.prompter) }() + case 2: try { try decoder.decodeSingularMessageField(value: &self._selection) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + // The use of inline closures is to circumvent an issue where the compiler + // allocates stack space for every if/case branch local when no optimizations + // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and + // https://github.com/apple/swift-protobuf/issues/1182 + if !self.prompter.isEmpty { + try visitor.visitSingularStringField(value: self.prompter, fieldNumber: 1) + } + try { if let v = self._selection { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Synchronization_ResetRequest, rhs: Synchronization_ResetRequest) -> Bool { + if lhs.prompter != rhs.prompter {return false} + if lhs._selection != rhs._selection {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Synchronization_ResetResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".ResetResponse" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Synchronization_ResetResponse, rhs: Synchronization_ResetResponse) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Synchronization_TerminateRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TerminateRequest" + static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ + 1: .same(proto: "prompter"), + 2: .same(proto: "selection"), + ] + + mutating func decodeMessage(decoder: inout D) throws { + while let fieldNumber = try decoder.nextFieldNumber() { + // The use of inline closures is to circumvent an issue where the compiler + // allocates stack space for every case branch when no optimizations are + // enabled. https://github.com/apple/swift-protobuf/issues/1034 + switch fieldNumber { + case 1: try { try decoder.decodeSingularStringField(value: &self.prompter) }() + case 2: try { try decoder.decodeSingularMessageField(value: &self._selection) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + // The use of inline closures is to circumvent an issue where the compiler + // allocates stack space for every if/case branch local when no optimizations + // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and + // https://github.com/apple/swift-protobuf/issues/1182 + if !self.prompter.isEmpty { + try visitor.visitSingularStringField(value: self.prompter, fieldNumber: 1) + } + try { if let v = self._selection { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Synchronization_TerminateRequest, rhs: Synchronization_TerminateRequest) -> Bool { + if lhs.prompter != rhs.prompter {return false} + if lhs._selection != rhs._selection {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Synchronization_TerminateResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TerminateResponse" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Synchronization_TerminateResponse, rhs: Synchronization_TerminateResponse) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Coder-Desktop/VPNLib/FileSync/MutagenSDK/service_synchronization_synchronization.proto b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/service_synchronization_synchronization.proto new file mode 100644 index 0000000..cb1ab73 --- /dev/null +++ b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/service_synchronization_synchronization.proto @@ -0,0 +1,168 @@ +/* + * This file was taken from + * https://github.com/mutagen-io/mutagen/tree/v0.18.1/pkg/service/synchronization/synchronization.proto + * + * MIT License + * + * Copyright (c) 2016-present Docker, Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +syntax = "proto3"; + +package synchronization; + +option go_package = "github.com/mutagen-io/mutagen/pkg/service/synchronization"; + +import "selection_selection.proto"; +import "synchronization_configuration.proto"; +import "synchronization_state.proto"; +import "url_url.proto"; + +// CreationSpecification contains the metadata required for a new session. +message CreationSpecification { + // Alpha is the alpha endpoint URL for the session. + url.URL alpha = 1; + // Beta is the beta endpoint URL for the session. + url.URL beta = 2; + // Configuration is the base session configuration. It is the result of + // merging the global configuration (unless disabled), any manually + // specified configuration file, and any command line configuration + // parameters. + synchronization.Configuration configuration = 3; + // ConfigurationAlpha is the alpha-specific session configuration. It is + // determined based on command line configuration parameters. + synchronization.Configuration configurationAlpha = 4; + // ConfigurationBeta is the beta-specific session configuration. It is + // determined based on command line configuration parameters. + synchronization.Configuration configurationBeta = 5; + // Name is the name for the session object. + string name = 6; + // Labels are the labels for the session object. + map labels = 7; + // Paused indicates whether or not to create the session pre-paused. + bool paused = 8; +} + +// CreateRequest encodes a request for session creation. +message CreateRequest { + // Prompter is the prompter identifier to use for creating sessions. + string prompter = 1; + // Specification is the creation specification. + CreationSpecification specification = 2; +} + +// CreateResponse encodes a session creation response. +message CreateResponse { + // Session is the resulting session identifier. + string session = 1; +} + +// ListRequest encodes a request for session metadata. +message ListRequest { + // Selection is the session selection criteria. + selection.Selection selection = 1; + // PreviousStateIndex is the previously seen state index. 0 may be provided + // to force an immediate state listing. + uint64 previousStateIndex = 2; +} + +// ListResponse encodes session metadata. +message ListResponse { + // StateIndex is the state index associated with the session metadata. + uint64 stateIndex = 1; + // SessionStates are the session metadata states. + repeated synchronization.State sessionStates = 2; +} + +// FlushRequest encodes a request to flush sessions. +message FlushRequest { + // Prompter is the prompter to use for status message updates. + string prompter = 1; + // Selection is the session selection criteria. + selection.Selection selection = 2; + // SkipWait indicates whether or not the operation should avoid blocking. + bool skipWait = 3; +} + +// FlushResponse indicates completion of flush operation(s). +message FlushResponse{} + +// PauseRequest encodes a request to pause sessions. +message PauseRequest { + // Prompter is the prompter to use for status message updates. + string prompter = 1; + // Selection is the session selection criteria. + selection.Selection selection = 2; +} + +// PauseResponse indicates completion of pause operation(s). +message PauseResponse{} + +// ResumeRequest encodes a request to resume sessions. +message ResumeRequest { + // Prompter is the prompter identifier to use for resuming sessions. + string prompter = 1; + // Selection is the session selection criteria. + selection.Selection selection = 2; +} + +// ResumeResponse indicates completion of resume operation(s). +message ResumeResponse{} + +// ResetRequest encodes a request to reset sessions. +message ResetRequest { + // Prompter is the prompter identifier to use for resetting sessions. + string prompter = 1; + // Selection is the session selection criteria. + selection.Selection selection = 2; +} + +// ResetResponse indicates completion of reset operation(s). +message ResetResponse{} + +// TerminateRequest encodes a request to terminate sessions. +message TerminateRequest { + // Prompter is the prompter to use for status message updates. + string prompter = 1; + // Selection is the session selection criteria. + selection.Selection selection = 2; +} + +// TerminateResponse indicates completion of termination operation(s). +message TerminateResponse{} + +// Synchronization manages the lifecycle of synchronization sessions. +service Synchronization { + // Create creates a new session. + rpc Create(CreateRequest) returns (CreateResponse) {} + // List returns metadata for existing sessions. + rpc List(ListRequest) returns (ListResponse) {} + // Flush flushes sessions. + rpc Flush(FlushRequest) returns (FlushResponse) {} + // Pause pauses sessions. + rpc Pause(PauseRequest) returns (PauseResponse) {} + // Resume resumes paused or disconnected sessions. + rpc Resume(ResumeRequest) returns (ResumeResponse) {} + // Reset resets sessions' histories. + rpc Reset(ResetRequest) returns (ResetResponse) {} + // Terminate terminates sessions. + rpc Terminate(TerminateRequest) returns (TerminateResponse) {} +} diff --git a/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_compression_algorithm.pb.swift b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_compression_algorithm.pb.swift new file mode 100644 index 0000000..af5a42d --- /dev/null +++ b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_compression_algorithm.pb.swift @@ -0,0 +1,113 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: synchronization_compression_algorithm.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// +// This file was taken from +// https://github.com/mutagen-io/mutagen/tree/v0.18.1/pkg/synchronization/compression/algorithm.proto +// +// MIT License +// +// Copyright (c) 2016-present Docker, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. + +import SwiftProtobuf + +// If the compiler emits an error on this type, it is because this file +// was generated by a version of the `protoc` Swift plug-in that is +// incompatible with the version of SwiftProtobuf to which you are linking. +// Please ensure that you are building against the same version of the API +// that was used to generate this file. +fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAPIVersionCheck { + struct _2: SwiftProtobuf.ProtobufAPIVersion_2 {} + typealias Version = _2 +} + +/// Algorithm specifies a compression algorithm. +enum Compression_Algorithm: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + + /// Algorithm_AlgorithmDefault represents an unspecified compression + /// algorithm. It should be converted to one of the following values based on + /// the desired default behavior. + case `default` // = 0 + + /// Algorithm_AlgorithmNone specifies that no compression should be used. + case none // = 1 + + /// Algorithm_AlgorithmDeflate specifies that DEFLATE compression should be + /// used. + case deflate // = 2 + + /// Algorithm_AlgorithmZstandard specifies that Zstandard compression should + /// be used. + case zstandard // = 3 + case UNRECOGNIZED(Int) + + init() { + self = .default + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .default + case 1: self = .none + case 2: self = .deflate + case 3: self = .zstandard + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .default: return 0 + case .none: return 1 + case .deflate: return 2 + case .zstandard: return 3 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [Compression_Algorithm] = [ + .default, + .none, + .deflate, + .zstandard, + ] + +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +extension Compression_Algorithm: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ + 0: .same(proto: "AlgorithmDefault"), + 1: .same(proto: "AlgorithmNone"), + 2: .same(proto: "AlgorithmDeflate"), + 3: .same(proto: "AlgorithmZstandard"), + ] +} diff --git a/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_compression_algorithm.proto b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_compression_algorithm.proto new file mode 100644 index 0000000..ac6745e --- /dev/null +++ b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_compression_algorithm.proto @@ -0,0 +1,48 @@ +/* + * This file was taken from + * https://github.com/mutagen-io/mutagen/tree/v0.18.1/pkg/synchronization/compression/algorithm.proto + * + * MIT License + * + * Copyright (c) 2016-present Docker, Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +syntax = "proto3"; + +package compression; + +option go_package = "github.com/mutagen-io/mutagen/pkg/synchronization/compression"; + +// Algorithm specifies a compression algorithm. +enum Algorithm { + // Algorithm_AlgorithmDefault represents an unspecified compression + // algorithm. It should be converted to one of the following values based on + // the desired default behavior. + AlgorithmDefault = 0; + // Algorithm_AlgorithmNone specifies that no compression should be used. + AlgorithmNone = 1; + // Algorithm_AlgorithmDeflate specifies that DEFLATE compression should be + // used. + AlgorithmDeflate = 2; + // Algorithm_AlgorithmZstandard specifies that Zstandard compression should + // be used. + AlgorithmZstandard = 3; +} diff --git a/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_configuration.pb.swift b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_configuration.pb.swift new file mode 100644 index 0000000..8ce62c7 --- /dev/null +++ b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_configuration.pb.swift @@ -0,0 +1,433 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: synchronization_configuration.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// +// This file was taken from +// https://github.com/mutagen-io/mutagen/tree/v0.18.1/pkg/synchronization/configuration.proto +// +// MIT License +// +// Copyright (c) 2016-present Docker, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. + +import SwiftProtobuf + +// If the compiler emits an error on this type, it is because this file +// was generated by a version of the `protoc` Swift plug-in that is +// incompatible with the version of SwiftProtobuf to which you are linking. +// Please ensure that you are building against the same version of the API +// that was used to generate this file. +fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAPIVersionCheck { + struct _2: SwiftProtobuf.ProtobufAPIVersion_2 {} + typealias Version = _2 +} + +/// Configuration encodes session configuration parameters. It is used for create +/// commands to specify configuration options, for loading global configuration +/// options, and for storing a merged configuration inside sessions. It should be +/// considered immutable. +struct Synchronization_Configuration: @unchecked Sendable { + // 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. + + /// SynchronizationMode specifies the synchronization mode that should be + /// used in synchronization. + var synchronizationMode: Core_SynchronizationMode { + get {return _storage._synchronizationMode} + set {_uniqueStorage()._synchronizationMode = newValue} + } + + /// HashingAlgorithm specifies the content hashing algorithm used to track + /// content and perform differential transfers. + var hashingAlgorithm: Hashing_Algorithm { + get {return _storage._hashingAlgorithm} + set {_uniqueStorage()._hashingAlgorithm = newValue} + } + + /// MaximumEntryCount specifies the maximum number of filesystem entries that + /// endpoints will tolerate managing. A zero value indicates no limit. + var maximumEntryCount: UInt64 { + get {return _storage._maximumEntryCount} + set {_uniqueStorage()._maximumEntryCount = newValue} + } + + /// MaximumStagingFileSize is the maximum (individual) file size that + /// endpoints will stage. A zero value indicates no limit. + var maximumStagingFileSize: UInt64 { + get {return _storage._maximumStagingFileSize} + set {_uniqueStorage()._maximumStagingFileSize = newValue} + } + + /// ProbeMode specifies the filesystem probing mode. + var probeMode: Behavior_ProbeMode { + get {return _storage._probeMode} + set {_uniqueStorage()._probeMode = newValue} + } + + /// ScanMode specifies the synchronization root scanning mode. + var scanMode: Synchronization_ScanMode { + get {return _storage._scanMode} + set {_uniqueStorage()._scanMode = newValue} + } + + /// StageMode specifies the file staging mode. + var stageMode: Synchronization_StageMode { + get {return _storage._stageMode} + set {_uniqueStorage()._stageMode = newValue} + } + + /// SymbolicLinkMode specifies the symbolic link mode. + var symbolicLinkMode: Core_SymbolicLinkMode { + get {return _storage._symbolicLinkMode} + set {_uniqueStorage()._symbolicLinkMode = newValue} + } + + /// WatchMode specifies the filesystem watching mode. + var watchMode: Synchronization_WatchMode { + get {return _storage._watchMode} + set {_uniqueStorage()._watchMode = newValue} + } + + /// WatchPollingInterval specifies the interval (in seconds) for poll-based + /// file monitoring. A value of 0 specifies that the default interval should + /// be used. + var watchPollingInterval: UInt32 { + get {return _storage._watchPollingInterval} + set {_uniqueStorage()._watchPollingInterval = newValue} + } + + /// IgnoreSyntax specifies the syntax and semantics to use for ignores. + /// NOTE: This field is out of order due to the historical order in which it + /// was added. + var ignoreSyntax: Ignore_Syntax { + get {return _storage._ignoreSyntax} + set {_uniqueStorage()._ignoreSyntax = newValue} + } + + /// DefaultIgnores specifies the ignore patterns brought in from the global + /// configuration. + /// DEPRECATED: This field is no longer used when loading from global + /// configuration. Instead, ignores provided by global configuration are + /// simply merged into the ignore list of the main configuration. However, + /// older sessions still use this field. + var defaultIgnores: [String] { + get {return _storage._defaultIgnores} + set {_uniqueStorage()._defaultIgnores = newValue} + } + + /// Ignores specifies the ignore patterns brought in from the create request. + var ignores: [String] { + get {return _storage._ignores} + set {_uniqueStorage()._ignores = newValue} + } + + /// IgnoreVCSMode specifies the VCS ignore mode that should be used in + /// synchronization. + var ignoreVcsmode: Ignore_IgnoreVCSMode { + get {return _storage._ignoreVcsmode} + set {_uniqueStorage()._ignoreVcsmode = newValue} + } + + /// PermissionsMode species the manner in which permissions should be + /// propagated between endpoints. + var permissionsMode: Core_PermissionsMode { + get {return _storage._permissionsMode} + set {_uniqueStorage()._permissionsMode = newValue} + } + + /// DefaultFileMode specifies the default permission mode to use for new + /// files in "portable" permission propagation mode. + var defaultFileMode: UInt32 { + get {return _storage._defaultFileMode} + set {_uniqueStorage()._defaultFileMode = newValue} + } + + /// DefaultDirectoryMode specifies the default permission mode to use for new + /// files in "portable" permission propagation mode. + var defaultDirectoryMode: UInt32 { + get {return _storage._defaultDirectoryMode} + set {_uniqueStorage()._defaultDirectoryMode = newValue} + } + + /// DefaultOwner specifies the default owner identifier to use when setting + /// ownership of new files and directories in "portable" permission + /// propagation mode. + var defaultOwner: String { + get {return _storage._defaultOwner} + set {_uniqueStorage()._defaultOwner = newValue} + } + + /// DefaultGroup specifies the default group identifier to use when setting + /// ownership of new files and directories in "portable" permission + /// propagation mode. + var defaultGroup: String { + get {return _storage._defaultGroup} + set {_uniqueStorage()._defaultGroup = newValue} + } + + /// CompressionAlgorithm specifies the compression algorithm to use when + /// communicating with the endpoint. This only applies to remote endpoints. + var compressionAlgorithm: Compression_Algorithm { + get {return _storage._compressionAlgorithm} + set {_uniqueStorage()._compressionAlgorithm = newValue} + } + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "synchronization" + +extension Synchronization_Configuration: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".Configuration" + static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ + 11: .same(proto: "synchronizationMode"), + 17: .same(proto: "hashingAlgorithm"), + 12: .same(proto: "maximumEntryCount"), + 13: .same(proto: "maximumStagingFileSize"), + 14: .same(proto: "probeMode"), + 15: .same(proto: "scanMode"), + 16: .same(proto: "stageMode"), + 1: .same(proto: "symbolicLinkMode"), + 21: .same(proto: "watchMode"), + 22: .same(proto: "watchPollingInterval"), + 34: .same(proto: "ignoreSyntax"), + 31: .same(proto: "defaultIgnores"), + 32: .same(proto: "ignores"), + 33: .same(proto: "ignoreVCSMode"), + 61: .same(proto: "permissionsMode"), + 63: .same(proto: "defaultFileMode"), + 64: .same(proto: "defaultDirectoryMode"), + 65: .same(proto: "defaultOwner"), + 66: .same(proto: "defaultGroup"), + 81: .same(proto: "compressionAlgorithm"), + ] + + fileprivate class _StorageClass { + var _synchronizationMode: Core_SynchronizationMode = .default + var _hashingAlgorithm: Hashing_Algorithm = .default + var _maximumEntryCount: UInt64 = 0 + var _maximumStagingFileSize: UInt64 = 0 + var _probeMode: Behavior_ProbeMode = .default + var _scanMode: Synchronization_ScanMode = .default + var _stageMode: Synchronization_StageMode = .default + var _symbolicLinkMode: Core_SymbolicLinkMode = .default + var _watchMode: Synchronization_WatchMode = .default + var _watchPollingInterval: UInt32 = 0 + var _ignoreSyntax: Ignore_Syntax = .default + var _defaultIgnores: [String] = [] + var _ignores: [String] = [] + var _ignoreVcsmode: Ignore_IgnoreVCSMode = .default + var _permissionsMode: Core_PermissionsMode = .default + var _defaultFileMode: UInt32 = 0 + var _defaultDirectoryMode: UInt32 = 0 + var _defaultOwner: String = String() + var _defaultGroup: String = String() + var _compressionAlgorithm: Compression_Algorithm = .default + + #if swift(>=5.10) + // This property is used as the initial default value for new instances of the type. + // The type itself is protecting the reference to its storage via CoW semantics. + // This will force a copy to be made of this reference when the first mutation occurs; + // hence, it is safe to mark this as `nonisolated(unsafe)`. + static nonisolated(unsafe) let defaultInstance = _StorageClass() + #else + static let defaultInstance = _StorageClass() + #endif + + private init() {} + + init(copying source: _StorageClass) { + _synchronizationMode = source._synchronizationMode + _hashingAlgorithm = source._hashingAlgorithm + _maximumEntryCount = source._maximumEntryCount + _maximumStagingFileSize = source._maximumStagingFileSize + _probeMode = source._probeMode + _scanMode = source._scanMode + _stageMode = source._stageMode + _symbolicLinkMode = source._symbolicLinkMode + _watchMode = source._watchMode + _watchPollingInterval = source._watchPollingInterval + _ignoreSyntax = source._ignoreSyntax + _defaultIgnores = source._defaultIgnores + _ignores = source._ignores + _ignoreVcsmode = source._ignoreVcsmode + _permissionsMode = source._permissionsMode + _defaultFileMode = source._defaultFileMode + _defaultDirectoryMode = source._defaultDirectoryMode + _defaultOwner = source._defaultOwner + _defaultGroup = source._defaultGroup + _compressionAlgorithm = source._compressionAlgorithm + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(decoder: inout D) throws { + _ = _uniqueStorage() + try withExtendedLifetime(_storage) { (_storage: _StorageClass) in + while let fieldNumber = try decoder.nextFieldNumber() { + // The use of inline closures is to circumvent an issue where the compiler + // allocates stack space for every case branch when no optimizations are + // enabled. https://github.com/apple/swift-protobuf/issues/1034 + switch fieldNumber { + case 1: try { try decoder.decodeSingularEnumField(value: &_storage._symbolicLinkMode) }() + case 11: try { try decoder.decodeSingularEnumField(value: &_storage._synchronizationMode) }() + case 12: try { try decoder.decodeSingularUInt64Field(value: &_storage._maximumEntryCount) }() + case 13: try { try decoder.decodeSingularUInt64Field(value: &_storage._maximumStagingFileSize) }() + case 14: try { try decoder.decodeSingularEnumField(value: &_storage._probeMode) }() + case 15: try { try decoder.decodeSingularEnumField(value: &_storage._scanMode) }() + case 16: try { try decoder.decodeSingularEnumField(value: &_storage._stageMode) }() + case 17: try { try decoder.decodeSingularEnumField(value: &_storage._hashingAlgorithm) }() + case 21: try { try decoder.decodeSingularEnumField(value: &_storage._watchMode) }() + case 22: try { try decoder.decodeSingularUInt32Field(value: &_storage._watchPollingInterval) }() + case 31: try { try decoder.decodeRepeatedStringField(value: &_storage._defaultIgnores) }() + case 32: try { try decoder.decodeRepeatedStringField(value: &_storage._ignores) }() + case 33: try { try decoder.decodeSingularEnumField(value: &_storage._ignoreVcsmode) }() + case 34: try { try decoder.decodeSingularEnumField(value: &_storage._ignoreSyntax) }() + case 61: try { try decoder.decodeSingularEnumField(value: &_storage._permissionsMode) }() + case 63: try { try decoder.decodeSingularUInt32Field(value: &_storage._defaultFileMode) }() + case 64: try { try decoder.decodeSingularUInt32Field(value: &_storage._defaultDirectoryMode) }() + case 65: try { try decoder.decodeSingularStringField(value: &_storage._defaultOwner) }() + case 66: try { try decoder.decodeSingularStringField(value: &_storage._defaultGroup) }() + case 81: try { try decoder.decodeSingularEnumField(value: &_storage._compressionAlgorithm) }() + default: break + } + } + } + } + + func traverse(visitor: inout V) throws { + try withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if _storage._symbolicLinkMode != .default { + try visitor.visitSingularEnumField(value: _storage._symbolicLinkMode, fieldNumber: 1) + } + if _storage._synchronizationMode != .default { + try visitor.visitSingularEnumField(value: _storage._synchronizationMode, fieldNumber: 11) + } + if _storage._maximumEntryCount != 0 { + try visitor.visitSingularUInt64Field(value: _storage._maximumEntryCount, fieldNumber: 12) + } + if _storage._maximumStagingFileSize != 0 { + try visitor.visitSingularUInt64Field(value: _storage._maximumStagingFileSize, fieldNumber: 13) + } + if _storage._probeMode != .default { + try visitor.visitSingularEnumField(value: _storage._probeMode, fieldNumber: 14) + } + if _storage._scanMode != .default { + try visitor.visitSingularEnumField(value: _storage._scanMode, fieldNumber: 15) + } + if _storage._stageMode != .default { + try visitor.visitSingularEnumField(value: _storage._stageMode, fieldNumber: 16) + } + if _storage._hashingAlgorithm != .default { + try visitor.visitSingularEnumField(value: _storage._hashingAlgorithm, fieldNumber: 17) + } + if _storage._watchMode != .default { + try visitor.visitSingularEnumField(value: _storage._watchMode, fieldNumber: 21) + } + if _storage._watchPollingInterval != 0 { + try visitor.visitSingularUInt32Field(value: _storage._watchPollingInterval, fieldNumber: 22) + } + if !_storage._defaultIgnores.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._defaultIgnores, fieldNumber: 31) + } + if !_storage._ignores.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._ignores, fieldNumber: 32) + } + if _storage._ignoreVcsmode != .default { + try visitor.visitSingularEnumField(value: _storage._ignoreVcsmode, fieldNumber: 33) + } + if _storage._ignoreSyntax != .default { + try visitor.visitSingularEnumField(value: _storage._ignoreSyntax, fieldNumber: 34) + } + if _storage._permissionsMode != .default { + try visitor.visitSingularEnumField(value: _storage._permissionsMode, fieldNumber: 61) + } + if _storage._defaultFileMode != 0 { + try visitor.visitSingularUInt32Field(value: _storage._defaultFileMode, fieldNumber: 63) + } + if _storage._defaultDirectoryMode != 0 { + try visitor.visitSingularUInt32Field(value: _storage._defaultDirectoryMode, fieldNumber: 64) + } + if !_storage._defaultOwner.isEmpty { + try visitor.visitSingularStringField(value: _storage._defaultOwner, fieldNumber: 65) + } + if !_storage._defaultGroup.isEmpty { + try visitor.visitSingularStringField(value: _storage._defaultGroup, fieldNumber: 66) + } + if _storage._compressionAlgorithm != .default { + try visitor.visitSingularEnumField(value: _storage._compressionAlgorithm, fieldNumber: 81) + } + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Synchronization_Configuration, rhs: Synchronization_Configuration) -> 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._synchronizationMode != rhs_storage._synchronizationMode {return false} + if _storage._hashingAlgorithm != rhs_storage._hashingAlgorithm {return false} + if _storage._maximumEntryCount != rhs_storage._maximumEntryCount {return false} + if _storage._maximumStagingFileSize != rhs_storage._maximumStagingFileSize {return false} + if _storage._probeMode != rhs_storage._probeMode {return false} + if _storage._scanMode != rhs_storage._scanMode {return false} + if _storage._stageMode != rhs_storage._stageMode {return false} + if _storage._symbolicLinkMode != rhs_storage._symbolicLinkMode {return false} + if _storage._watchMode != rhs_storage._watchMode {return false} + if _storage._watchPollingInterval != rhs_storage._watchPollingInterval {return false} + if _storage._ignoreSyntax != rhs_storage._ignoreSyntax {return false} + if _storage._defaultIgnores != rhs_storage._defaultIgnores {return false} + if _storage._ignores != rhs_storage._ignores {return false} + if _storage._ignoreVcsmode != rhs_storage._ignoreVcsmode {return false} + if _storage._permissionsMode != rhs_storage._permissionsMode {return false} + if _storage._defaultFileMode != rhs_storage._defaultFileMode {return false} + if _storage._defaultDirectoryMode != rhs_storage._defaultDirectoryMode {return false} + if _storage._defaultOwner != rhs_storage._defaultOwner {return false} + if _storage._defaultGroup != rhs_storage._defaultGroup {return false} + if _storage._compressionAlgorithm != rhs_storage._compressionAlgorithm {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_configuration.proto b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_configuration.proto new file mode 100644 index 0000000..ed613bc --- /dev/null +++ b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_configuration.proto @@ -0,0 +1,174 @@ +/* + * This file was taken from + * https://github.com/mutagen-io/mutagen/tree/v0.18.1/pkg/synchronization/configuration.proto + * + * MIT License + * + * Copyright (c) 2016-present Docker, Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +syntax = "proto3"; + +package synchronization; + +option go_package = "github.com/mutagen-io/mutagen/pkg/synchronization"; + +import "filesystem_behavior_probe_mode.proto"; +import "synchronization_scan_mode.proto"; +import "synchronization_stage_mode.proto"; +import "synchronization_watch_mode.proto"; +import "synchronization_compression_algorithm.proto"; +import "synchronization_core_mode.proto"; +import "synchronization_core_permissions_mode.proto"; +import "synchronization_core_symbolic_link_mode.proto"; +import "synchronization_core_ignore_syntax.proto"; +import "synchronization_core_ignore_ignore_vcs_mode.proto"; +import "synchronization_hashing_algorithm.proto"; + +// Configuration encodes session configuration parameters. It is used for create +// commands to specify configuration options, for loading global configuration +// options, and for storing a merged configuration inside sessions. It should be +// considered immutable. +message Configuration { + // Synchronization parameters (fields 11-20). + // NOTE: These run from field indices 11-20 (rather than 1-10, which are + // reserved for symbolic link configuration parameters) due to the + // historical order in which these fields were added. Field 17 (the digest + // algorithm) is also listed out of its chronological order of addition due + // to its relative importance in the configuration. + + // SynchronizationMode specifies the synchronization mode that should be + // used in synchronization. + core.SynchronizationMode synchronizationMode = 11; + + // HashingAlgorithm specifies the content hashing algorithm used to track + // content and perform differential transfers. + hashing.Algorithm hashingAlgorithm = 17; + + // MaximumEntryCount specifies the maximum number of filesystem entries that + // endpoints will tolerate managing. A zero value indicates no limit. + uint64 maximumEntryCount = 12; + + // MaximumStagingFileSize is the maximum (individual) file size that + // endpoints will stage. A zero value indicates no limit. + uint64 maximumStagingFileSize = 13; + + // ProbeMode specifies the filesystem probing mode. + behavior.ProbeMode probeMode = 14; + + // ScanMode specifies the synchronization root scanning mode. + ScanMode scanMode = 15; + + // StageMode specifies the file staging mode. + StageMode stageMode = 16; + + // Fields 18-20 are reserved for future synchronization configuration + // parameters. + + + // Symbolic link configuration parameters (fields 1-10). + // NOTE: These run from field indices 1-10. The reason for this is that + // symbolic link configuration parameters is due to the historical order in + // which configuration fields were added. + + // SymbolicLinkMode specifies the symbolic link mode. + core.SymbolicLinkMode symbolicLinkMode = 1; + + // Fields 2-10 are reserved for future symbolic link configuration + // parameters. + + + // Watch configuration parameters (fields 21-30). + + // WatchMode specifies the filesystem watching mode. + WatchMode watchMode = 21; + + // WatchPollingInterval specifies the interval (in seconds) for poll-based + // file monitoring. A value of 0 specifies that the default interval should + // be used. + uint32 watchPollingInterval = 22; + + // Fields 23-30 are reserved for future watch configuration parameters. + + + // Ignore configuration parameters (fields 31-60). + + // IgnoreSyntax specifies the syntax and semantics to use for ignores. + // NOTE: This field is out of order due to the historical order in which it + // was added. + ignore.Syntax ignoreSyntax = 34; + + // DefaultIgnores specifies the ignore patterns brought in from the global + // configuration. + // DEPRECATED: This field is no longer used when loading from global + // configuration. Instead, ignores provided by global configuration are + // simply merged into the ignore list of the main configuration. However, + // older sessions still use this field. + repeated string defaultIgnores = 31; + + // Ignores specifies the ignore patterns brought in from the create request. + repeated string ignores = 32; + + // IgnoreVCSMode specifies the VCS ignore mode that should be used in + // synchronization. + ignore.IgnoreVCSMode ignoreVCSMode = 33; + + // Fields 35-60 are reserved for future ignore configuration parameters. + + + // Permissions configuration parameters (fields 61-80). + + // PermissionsMode species the manner in which permissions should be + // propagated between endpoints. + core.PermissionsMode permissionsMode = 61; + + // Field 62 is reserved for PermissionsPreservationMode. + + // DefaultFileMode specifies the default permission mode to use for new + // files in "portable" permission propagation mode. + uint32 defaultFileMode = 63; + + // DefaultDirectoryMode specifies the default permission mode to use for new + // files in "portable" permission propagation mode. + uint32 defaultDirectoryMode = 64; + + // DefaultOwner specifies the default owner identifier to use when setting + // ownership of new files and directories in "portable" permission + // propagation mode. + string defaultOwner = 65; + + // DefaultGroup specifies the default group identifier to use when setting + // ownership of new files and directories in "portable" permission + // propagation mode. + string defaultGroup = 66; + + // Fields 67-80 are reserved for future permission configuration parameters. + + + // Compression configuration parameters (fields 81-90). + + // CompressionAlgorithm specifies the compression algorithm to use when + // communicating with the endpoint. This only applies to remote endpoints. + compression.Algorithm compressionAlgorithm = 81; + + // Fields 82-90 are reserved for future compression configuration + // parameters. +} diff --git a/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_core_change.pb.swift b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_core_change.pb.swift new file mode 100644 index 0000000..5e53a58 --- /dev/null +++ b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_core_change.pb.swift @@ -0,0 +1,140 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: synchronization_core_change.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// +// This file was taken from +// https://github.com/mutagen-io/mutagen/tree/v0.18.1/pkg/synchronization/core/change.proto +// +// MIT License +// +// Copyright (c) 2016-present Docker, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. + +import SwiftProtobuf + +// If the compiler emits an error on this type, it is because this file +// was generated by a version of the `protoc` Swift plug-in that is +// incompatible with the version of SwiftProtobuf to which you are linking. +// Please ensure that you are building against the same version of the API +// that was used to generate this file. +fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAPIVersionCheck { + struct _2: SwiftProtobuf.ProtobufAPIVersion_2 {} + typealias Version = _2 +} + +/// Change encodes a change to an entry hierarchy. Change objects should be +/// considered immutable and must not be modified. +struct Core_Change: Sendable { + // 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. + + /// Path is the path of the root of the change (relative to the + /// synchronization root). + var path: String = String() + + /// Old represents the old filesystem hierarchy at the change path. It may be + /// nil if no content previously existed. + var old: Core_Entry { + get {return _old ?? Core_Entry()} + set {_old = newValue} + } + /// Returns true if `old` has been explicitly set. + var hasOld: Bool {return self._old != nil} + /// Clears the value of `old`. Subsequent reads from it will return its default value. + mutating func clearOld() {self._old = nil} + + /// New represents the new filesystem hierarchy at the change path. It may be + /// nil if content has been deleted. + var new: Core_Entry { + get {return _new ?? Core_Entry()} + set {_new = newValue} + } + /// Returns true if `new` has been explicitly set. + var hasNew: Bool {return self._new != nil} + /// Clears the value of `new`. Subsequent reads from it will return its default value. + mutating func clearNew() {self._new = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _old: Core_Entry? = nil + fileprivate var _new: Core_Entry? = nil +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "core" + +extension Core_Change: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".Change" + static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ + 1: .same(proto: "path"), + 2: .same(proto: "old"), + 3: .same(proto: "new"), + ] + + mutating func decodeMessage(decoder: inout D) throws { + while let fieldNumber = try decoder.nextFieldNumber() { + // The use of inline closures is to circumvent an issue where the compiler + // allocates stack space for every case branch when no optimizations are + // enabled. https://github.com/apple/swift-protobuf/issues/1034 + switch fieldNumber { + case 1: try { try decoder.decodeSingularStringField(value: &self.path) }() + case 2: try { try decoder.decodeSingularMessageField(value: &self._old) }() + case 3: try { try decoder.decodeSingularMessageField(value: &self._new) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + // The use of inline closures is to circumvent an issue where the compiler + // allocates stack space for every if/case branch local when no optimizations + // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and + // https://github.com/apple/swift-protobuf/issues/1182 + if !self.path.isEmpty { + try visitor.visitSingularStringField(value: self.path, fieldNumber: 1) + } + try { if let v = self._old { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + try { if let v = self._new { + try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Core_Change, rhs: Core_Change) -> Bool { + if lhs.path != rhs.path {return false} + if lhs._old != rhs._old {return false} + if lhs._new != rhs._new {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_core_change.proto b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_core_change.proto new file mode 100644 index 0000000..9fc24db --- /dev/null +++ b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_core_change.proto @@ -0,0 +1,48 @@ +/* + * This file was taken from + * https://github.com/mutagen-io/mutagen/tree/v0.18.1/pkg/synchronization/core/change.proto + * + * MIT License + * + * Copyright (c) 2016-present Docker, Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +syntax = "proto3"; + +package core; + +option go_package = "github.com/mutagen-io/mutagen/pkg/synchronization/core"; + +import "synchronization_core_entry.proto"; + +// Change encodes a change to an entry hierarchy. Change objects should be +// considered immutable and must not be modified. +message Change { + // Path is the path of the root of the change (relative to the + // synchronization root). + string path = 1; + // Old represents the old filesystem hierarchy at the change path. It may be + // nil if no content previously existed. + Entry old = 2; + // New represents the new filesystem hierarchy at the change path. It may be + // nil if content has been deleted. + Entry new = 3; +} diff --git a/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_core_conflict.pb.swift b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_core_conflict.pb.swift new file mode 100644 index 0000000..3607a6c --- /dev/null +++ b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_core_conflict.pb.swift @@ -0,0 +1,123 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: synchronization_core_conflict.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// +// This file was taken from +// https://github.com/mutagen-io/mutagen/tree/v0.18.1/pkg/synchronization/core/conflict.proto +// +// MIT License +// +// Copyright (c) 2016-present Docker, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. + +import SwiftProtobuf + +// If the compiler emits an error on this type, it is because this file +// was generated by a version of the `protoc` Swift plug-in that is +// incompatible with the version of SwiftProtobuf to which you are linking. +// Please ensure that you are building against the same version of the API +// that was used to generate this file. +fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAPIVersionCheck { + struct _2: SwiftProtobuf.ProtobufAPIVersion_2 {} + typealias Version = _2 +} + +/// Conflict encodes conflicting changes on alpha and beta that prevent +/// synchronization of a particular path. Conflict objects should be considered +/// immutable and must not be modified. +struct Core_Conflict: Sendable { + // 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. + + /// Root is the root path for the conflict (relative to the synchronization + /// root). While this can (in theory) be computed based on the change lists + /// contained within the conflict, doing so relies on those change lists + /// being constructed and ordered in a particular manner that's not possible + /// to enforce. Additionally, conflicts are often sorted by their root path, + /// and dynamically computing it on every sort comparison operation would be + /// prohibitively expensive. + var root: String = String() + + /// AlphaChanges are the relevant changes on alpha. + var alphaChanges: [Core_Change] = [] + + /// BetaChanges are the relevant changes on beta. + var betaChanges: [Core_Change] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "core" + +extension Core_Conflict: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".Conflict" + static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ + 1: .same(proto: "root"), + 2: .same(proto: "alphaChanges"), + 3: .same(proto: "betaChanges"), + ] + + mutating func decodeMessage(decoder: inout D) throws { + while let fieldNumber = try decoder.nextFieldNumber() { + // The use of inline closures is to circumvent an issue where the compiler + // allocates stack space for every case branch when no optimizations are + // enabled. https://github.com/apple/swift-protobuf/issues/1034 + switch fieldNumber { + case 1: try { try decoder.decodeSingularStringField(value: &self.root) }() + case 2: try { try decoder.decodeRepeatedMessageField(value: &self.alphaChanges) }() + case 3: try { try decoder.decodeRepeatedMessageField(value: &self.betaChanges) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.root.isEmpty { + try visitor.visitSingularStringField(value: self.root, fieldNumber: 1) + } + if !self.alphaChanges.isEmpty { + try visitor.visitRepeatedMessageField(value: self.alphaChanges, fieldNumber: 2) + } + if !self.betaChanges.isEmpty { + try visitor.visitRepeatedMessageField(value: self.betaChanges, fieldNumber: 3) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Core_Conflict, rhs: Core_Conflict) -> Bool { + if lhs.root != rhs.root {return false} + if lhs.alphaChanges != rhs.alphaChanges {return false} + if lhs.betaChanges != rhs.betaChanges {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_core_conflict.proto b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_core_conflict.proto new file mode 100644 index 0000000..185f665 --- /dev/null +++ b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_core_conflict.proto @@ -0,0 +1,52 @@ +/* + * This file was taken from + * https://github.com/mutagen-io/mutagen/tree/v0.18.1/pkg/synchronization/core/conflict.proto + * + * MIT License + * + * Copyright (c) 2016-present Docker, Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +syntax = "proto3"; + +package core; + +option go_package = "github.com/mutagen-io/mutagen/pkg/synchronization/core"; + +import "synchronization_core_change.proto"; + +// Conflict encodes conflicting changes on alpha and beta that prevent +// synchronization of a particular path. Conflict objects should be considered +// immutable and must not be modified. +message Conflict { + // Root is the root path for the conflict (relative to the synchronization + // root). While this can (in theory) be computed based on the change lists + // contained within the conflict, doing so relies on those change lists + // being constructed and ordered in a particular manner that's not possible + // to enforce. Additionally, conflicts are often sorted by their root path, + // and dynamically computing it on every sort comparison operation would be + // prohibitively expensive. + string root = 1; + // AlphaChanges are the relevant changes on alpha. + repeated Change alphaChanges = 2; + // BetaChanges are the relevant changes on beta. + repeated Change betaChanges = 3; +} diff --git a/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_core_entry.pb.swift b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_core_entry.pb.swift new file mode 100644 index 0000000..d3cb6c5 --- /dev/null +++ b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_core_entry.pb.swift @@ -0,0 +1,245 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: synchronization_core_entry.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// +// This file was taken from +// https://github.com/mutagen-io/mutagen/tree/v0.18.1/pkg/synchronization/core/entry.proto +// +// MIT License +// +// Copyright (c) 2016-present Docker, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. + +import Foundation +import SwiftProtobuf + +// If the compiler emits an error on this type, it is because this file +// was generated by a version of the `protoc` Swift plug-in that is +// incompatible with the version of SwiftProtobuf to which you are linking. +// Please ensure that you are building against the same version of the API +// that was used to generate this file. +fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAPIVersionCheck { + struct _2: SwiftProtobuf.ProtobufAPIVersion_2 {} + typealias Version = _2 +} + +/// EntryKind encodes the type of entry represented by an Entry object. +enum Core_EntryKind: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + + /// EntryKind_Directory indicates a directory. + case directory // = 0 + + /// EntryKind_File indicates a regular file. + case file // = 1 + + /// EntryKind_SymbolicLink indicates a symbolic link. + case symbolicLink // = 2 + + /// EntryKind_Untracked indicates content (or the root of content) that is + /// intentionally excluded from synchronization by Mutagen. This includes + /// explicitly ignored content, content that is ignored due to settings (such + /// as symbolic links in the "ignore" symbolic link mode), as well as content + /// types that Mutagen doesn't understand and/or have a way to propagate + /// (such as FIFOs and Unix domain sockets). This type of entry is not + /// synchronizable. + case untracked // = 100 + + /// EntryKind_Problematic indicates content (or the root of content) that + /// would normally be synchronized, but which is currently inaccessible to + /// scanning. This includes (but is not limited to) content that is modified + /// concurrently with scanning, content that is inaccessible due to + /// permissions, content that can't be read due to filesystem errors, content + /// that cannot be properly encoded given the current settings (such as + /// absolute symbolic links found when using the "portable" symbolic link + /// mode), and content that Mutagen cannot scan or watch reliably (such as + /// directories that are also mount points). This type of entry is not + /// synchronizable. + case problematic // = 101 + + /// EntryKind_PhantomDirectory indicates a directory that was recorded with + /// an ignore mask. This type is used to support Docker-style ignore syntax + /// and semantics, which allow directories to be unignored by child content + /// that is explicitly unignored. This type is pseudo-synchronizable; entries + /// containing phantom contents must have those contents reified (to tracked + /// or ignored directories) using ReifyPhantomDirectories before Reconcile. + case phantomDirectory // = 102 + case UNRECOGNIZED(Int) + + init() { + self = .directory + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .directory + case 1: self = .file + case 2: self = .symbolicLink + case 100: self = .untracked + case 101: self = .problematic + case 102: self = .phantomDirectory + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .directory: return 0 + case .file: return 1 + case .symbolicLink: return 2 + case .untracked: return 100 + case .problematic: return 101 + case .phantomDirectory: return 102 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [Core_EntryKind] = [ + .directory, + .file, + .symbolicLink, + .untracked, + .problematic, + .phantomDirectory, + ] + +} + +/// Entry encodes a filesystem entry (e.g. a directory, a file, or a symbolic +/// link). A nil Entry represents an absence of content. An zero-value Entry +/// represents an empty Directory. Entry objects should be considered immutable +/// and must not be modified. +struct Core_Entry: @unchecked Sendable { + // 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. + + /// Kind encodes the type of filesystem entry being represented. + var kind: Core_EntryKind = .directory + + /// Contents represents a directory entry's contents. It must only be non-nil + /// for directory entries. + var contents: Dictionary = [:] + + /// Digest represents the hash of a file entry's contents. It must only be + /// non-nil for file entries. + var digest: Data = Data() + + /// Executable indicates whether or not a file entry is marked as executable. + /// It must only be set (if appropriate) for file entries. + var executable: Bool = false + + /// Target is the symbolic link target for symbolic link entries. It must be + /// non-empty if and only if the entry is a symbolic link. + var target: String = String() + + /// Problem indicates the relevant error for problematic content. It must be + /// non-empty if and only if the entry represents problematic content. + var problem: String = String() + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "core" + +extension Core_EntryKind: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ + 0: .same(proto: "Directory"), + 1: .same(proto: "File"), + 2: .same(proto: "SymbolicLink"), + 100: .same(proto: "Untracked"), + 101: .same(proto: "Problematic"), + 102: .same(proto: "PhantomDirectory"), + ] +} + +extension Core_Entry: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".Entry" + static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ + 1: .same(proto: "kind"), + 5: .same(proto: "contents"), + 8: .same(proto: "digest"), + 9: .same(proto: "executable"), + 12: .same(proto: "target"), + 15: .same(proto: "problem"), + ] + + mutating func decodeMessage(decoder: inout D) throws { + while let fieldNumber = try decoder.nextFieldNumber() { + // The use of inline closures is to circumvent an issue where the compiler + // allocates stack space for every case branch when no optimizations are + // enabled. https://github.com/apple/swift-protobuf/issues/1034 + switch fieldNumber { + case 1: try { try decoder.decodeSingularEnumField(value: &self.kind) }() + case 5: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.contents) }() + case 8: try { try decoder.decodeSingularBytesField(value: &self.digest) }() + case 9: try { try decoder.decodeSingularBoolField(value: &self.executable) }() + case 12: try { try decoder.decodeSingularStringField(value: &self.target) }() + case 15: try { try decoder.decodeSingularStringField(value: &self.problem) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.kind != .directory { + try visitor.visitSingularEnumField(value: self.kind, fieldNumber: 1) + } + if !self.contents.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.contents, fieldNumber: 5) + } + if !self.digest.isEmpty { + try visitor.visitSingularBytesField(value: self.digest, fieldNumber: 8) + } + if self.executable != false { + try visitor.visitSingularBoolField(value: self.executable, fieldNumber: 9) + } + if !self.target.isEmpty { + try visitor.visitSingularStringField(value: self.target, fieldNumber: 12) + } + if !self.problem.isEmpty { + try visitor.visitSingularStringField(value: self.problem, fieldNumber: 15) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Core_Entry, rhs: Core_Entry) -> Bool { + if lhs.kind != rhs.kind {return false} + if lhs.contents != rhs.contents {return false} + if lhs.digest != rhs.digest {return false} + if lhs.executable != rhs.executable {return false} + if lhs.target != rhs.target {return false} + if lhs.problem != rhs.problem {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_core_entry.proto b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_core_entry.proto new file mode 100644 index 0000000..88e2cad --- /dev/null +++ b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_core_entry.proto @@ -0,0 +1,109 @@ +/* + * This file was taken from + * https://github.com/mutagen-io/mutagen/tree/v0.18.1/pkg/synchronization/core/entry.proto + * + * MIT License + * + * Copyright (c) 2016-present Docker, Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +syntax = "proto3"; + +package core; + +option go_package = "github.com/mutagen-io/mutagen/pkg/synchronization/core"; + +// EntryKind encodes the type of entry represented by an Entry object. +enum EntryKind { + // EntryKind_Directory indicates a directory. + Directory = 0; + // EntryKind_File indicates a regular file. + File = 1; + // EntryKind_SymbolicLink indicates a symbolic link. + SymbolicLink = 2; + + // Values 3-99 are reserved for future synchronizable entry types. + + // EntryKind_Untracked indicates content (or the root of content) that is + // intentionally excluded from synchronization by Mutagen. This includes + // explicitly ignored content, content that is ignored due to settings (such + // as symbolic links in the "ignore" symbolic link mode), as well as content + // types that Mutagen doesn't understand and/or have a way to propagate + // (such as FIFOs and Unix domain sockets). This type of entry is not + // synchronizable. + Untracked = 100; + // EntryKind_Problematic indicates content (or the root of content) that + // would normally be synchronized, but which is currently inaccessible to + // scanning. This includes (but is not limited to) content that is modified + // concurrently with scanning, content that is inaccessible due to + // permissions, content that can't be read due to filesystem errors, content + // that cannot be properly encoded given the current settings (such as + // absolute symbolic links found when using the "portable" symbolic link + // mode), and content that Mutagen cannot scan or watch reliably (such as + // directories that are also mount points). This type of entry is not + // synchronizable. + Problematic = 101; + // EntryKind_PhantomDirectory indicates a directory that was recorded with + // an ignore mask. This type is used to support Docker-style ignore syntax + // and semantics, which allow directories to be unignored by child content + // that is explicitly unignored. This type is pseudo-synchronizable; entries + // containing phantom contents must have those contents reified (to tracked + // or ignored directories) using ReifyPhantomDirectories before Reconcile. + PhantomDirectory = 102; + + // Values 102 - 199 are reserved for future unsynchronizable entry types. +} + +// Entry encodes a filesystem entry (e.g. a directory, a file, or a symbolic +// link). A nil Entry represents an absence of content. An zero-value Entry +// represents an empty Directory. Entry objects should be considered immutable +// and must not be modified. +message Entry { + // Kind encodes the type of filesystem entry being represented. + EntryKind kind = 1; + + // Fields 2-4 are reserved for future common entry data. + + // Contents represents a directory entry's contents. It must only be non-nil + // for directory entries. + map contents = 5; + + // Fields 6-7 are reserved for future directory entry data. + + // Digest represents the hash of a file entry's contents. It must only be + // non-nil for file entries. + bytes digest = 8; + // Executable indicates whether or not a file entry is marked as executable. + // It must only be set (if appropriate) for file entries. + bool executable = 9; + + // Fields 10-11 are reserved for future file entry data. + + // Target is the symbolic link target for symbolic link entries. It must be + // non-empty if and only if the entry is a symbolic link. + string target = 12; + + // Fields 13-14 are reserved for future symbolic link entry data. + + // Problem indicates the relevant error for problematic content. It must be + // non-empty if and only if the entry represents problematic content. + string problem = 15; +} diff --git a/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_core_ignore_ignore_vcs_mode.pb.swift b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_core_ignore_ignore_vcs_mode.pb.swift new file mode 100644 index 0000000..396bbc5 --- /dev/null +++ b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_core_ignore_ignore_vcs_mode.pb.swift @@ -0,0 +1,106 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: synchronization_core_ignore_ignore_vcs_mode.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// +// This file was taken from +// https://github.com/mutagen-io/mutagen/tree/v0.18.1/pkg/synchronization/core/ignore/ignore_vcs_mode.proto +// +// MIT License +// +// Copyright (c) 2016-present Docker, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. + +import SwiftProtobuf + +// If the compiler emits an error on this type, it is because this file +// was generated by a version of the `protoc` Swift plug-in that is +// incompatible with the version of SwiftProtobuf to which you are linking. +// Please ensure that you are building against the same version of the API +// that was used to generate this file. +fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAPIVersionCheck { + struct _2: SwiftProtobuf.ProtobufAPIVersion_2 {} + typealias Version = _2 +} + +/// IgnoreVCSMode specifies the mode for ignoring VCS directories. +enum Ignore_IgnoreVCSMode: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + + /// IgnoreVCSMode_IgnoreVCSModeDefault represents an unspecified VCS ignore + /// mode. It is not valid for use with Scan. It should be converted to one of + /// the following values based on the desired default behavior. + case `default` // = 0 + + /// IgnoreVCSMode_IgnoreVCSModeIgnore indicates that VCS directories should + /// be ignored. + case ignore // = 1 + + /// IgnoreVCSMode_IgnoreVCSModePropagate indicates that VCS directories + /// should be propagated. + case propagate // = 2 + case UNRECOGNIZED(Int) + + init() { + self = .default + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .default + case 1: self = .ignore + case 2: self = .propagate + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .default: return 0 + case .ignore: return 1 + case .propagate: return 2 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [Ignore_IgnoreVCSMode] = [ + .default, + .ignore, + .propagate, + ] + +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +extension Ignore_IgnoreVCSMode: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ + 0: .same(proto: "IgnoreVCSModeDefault"), + 1: .same(proto: "IgnoreVCSModeIgnore"), + 2: .same(proto: "IgnoreVCSModePropagate"), + ] +} diff --git a/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_core_ignore_ignore_vcs_mode.proto b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_core_ignore_ignore_vcs_mode.proto new file mode 100644 index 0000000..6714c0c --- /dev/null +++ b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_core_ignore_ignore_vcs_mode.proto @@ -0,0 +1,46 @@ +/* + * This file was taken from + * https://github.com/mutagen-io/mutagen/tree/v0.18.1/pkg/synchronization/core/ignore/ignore_vcs_mode.proto + * + * MIT License + * + * Copyright (c) 2016-present Docker, Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +syntax = "proto3"; + +package ignore; + +option go_package = "github.com/mutagen-io/mutagen/pkg/synchronization/core/ignore"; + +// IgnoreVCSMode specifies the mode for ignoring VCS directories. +enum IgnoreVCSMode { + // IgnoreVCSMode_IgnoreVCSModeDefault represents an unspecified VCS ignore + // mode. It is not valid for use with Scan. It should be converted to one of + // the following values based on the desired default behavior. + IgnoreVCSModeDefault = 0; + // IgnoreVCSMode_IgnoreVCSModeIgnore indicates that VCS directories should + // be ignored. + IgnoreVCSModeIgnore = 1; + // IgnoreVCSMode_IgnoreVCSModePropagate indicates that VCS directories + // should be propagated. + IgnoreVCSModePropagate = 2; +} diff --git a/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_core_ignore_syntax.pb.swift b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_core_ignore_syntax.pb.swift new file mode 100644 index 0000000..aa516b6 --- /dev/null +++ b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_core_ignore_syntax.pb.swift @@ -0,0 +1,106 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: synchronization_core_ignore_syntax.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// +// This file was taken from +// https://github.com/mutagen-io/mutagen/tree/v0.18.1/pkg/synchronization/core/ignore/syntax.proto +// +// MIT License +// +// Copyright (c) 2016-present Docker, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. + +import SwiftProtobuf + +// If the compiler emits an error on this type, it is because this file +// was generated by a version of the `protoc` Swift plug-in that is +// incompatible with the version of SwiftProtobuf to which you are linking. +// Please ensure that you are building against the same version of the API +// that was used to generate this file. +fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAPIVersionCheck { + struct _2: SwiftProtobuf.ProtobufAPIVersion_2 {} + typealias Version = _2 +} + +/// Syntax specifies the syntax and semantics for ignore specifications. +enum Ignore_Syntax: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + + /// Syntax_SyntaxDefault represents an unspecified ignore syntax. It is not + /// valid for use with core synchronization functions. It should be converted + /// to one of the following values based on the desired default behavior. + case `default` // = 0 + + /// Syntax_SyntaxMutagen specifies that Mutagen-style ignore syntax and + /// semantics should be used. + case mutagen // = 1 + + /// Syntax_SyntaxDocker specifies that Docker-style ignore syntax and + /// semantics should be used. + case docker // = 2 + case UNRECOGNIZED(Int) + + init() { + self = .default + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .default + case 1: self = .mutagen + case 2: self = .docker + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .default: return 0 + case .mutagen: return 1 + case .docker: return 2 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [Ignore_Syntax] = [ + .default, + .mutagen, + .docker, + ] + +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +extension Ignore_Syntax: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ + 0: .same(proto: "SyntaxDefault"), + 1: .same(proto: "SyntaxMutagen"), + 2: .same(proto: "SyntaxDocker"), + ] +} diff --git a/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_core_ignore_syntax.proto b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_core_ignore_syntax.proto new file mode 100644 index 0000000..9346897 --- /dev/null +++ b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_core_ignore_syntax.proto @@ -0,0 +1,46 @@ +/* + * This file was taken from + * https://github.com/mutagen-io/mutagen/tree/v0.18.1/pkg/synchronization/core/ignore/syntax.proto + * + * MIT License + * + * Copyright (c) 2016-present Docker, Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +syntax = "proto3"; + +package ignore; + +option go_package = "github.com/mutagen-io/mutagen/pkg/synchronization/core/ignore"; + +// Syntax specifies the syntax and semantics for ignore specifications. +enum Syntax { + // Syntax_SyntaxDefault represents an unspecified ignore syntax. It is not + // valid for use with core synchronization functions. It should be converted + // to one of the following values based on the desired default behavior. + SyntaxDefault = 0; + // Syntax_SyntaxMutagen specifies that Mutagen-style ignore syntax and + // semantics should be used. + SyntaxMutagen = 1; + // Syntax_SyntaxDocker specifies that Docker-style ignore syntax and + // semantics should be used. + SyntaxDocker = 2; +} diff --git a/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_core_mode.pb.swift b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_core_mode.pb.swift new file mode 100644 index 0000000..4bca523 --- /dev/null +++ b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_core_mode.pb.swift @@ -0,0 +1,135 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: synchronization_core_mode.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// +// This file was taken from +// https://github.com/mutagen-io/mutagen/tree/v0.18.1/pkg/synchronization/core/mode.proto +// +// MIT License +// +// Copyright (c) 2016-present Docker, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. + +import SwiftProtobuf + +// If the compiler emits an error on this type, it is because this file +// was generated by a version of the `protoc` Swift plug-in that is +// incompatible with the version of SwiftProtobuf to which you are linking. +// Please ensure that you are building against the same version of the API +// that was used to generate this file. +fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAPIVersionCheck { + struct _2: SwiftProtobuf.ProtobufAPIVersion_2 {} + typealias Version = _2 +} + +/// SynchronizationMode specifies the mode for synchronization, encoding both +/// directionality and conflict resolution behavior. +enum Core_SynchronizationMode: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + + /// SynchronizationMode_SynchronizationModeDefault represents an unspecified + /// synchronization mode. It is not valid for use with Reconcile. It should + /// be converted to one of the following values based on the desired default + /// behavior. + case `default` // = 0 + + /// SynchronizationMode_SynchronizationModeTwoWaySafe represents a + /// bidirectional synchronization mode where automatic conflict resolution is + /// performed only in cases where no data would be lost. Specifically, this + /// means that modified contents are allowed to propagate to the opposite + /// endpoint if the corresponding contents on the opposite endpoint are + /// unmodified or deleted. All other conflicts are left unresolved. + case twoWaySafe // = 1 + + /// SynchronizationMode_SynchronizationModeTwoWayResolved is the same as + /// SynchronizationMode_SynchronizationModeTwoWaySafe, but specifies that the + /// alpha endpoint should win automatically in any conflict between alpha and + /// beta, including cases where alpha has deleted contents that beta has + /// modified. + case twoWayResolved // = 2 + + /// SynchronizationMode_SynchronizationModeOneWaySafe represents a + /// unidirectional synchronization mode where contents and changes propagate + /// from alpha to beta, but won't overwrite any creations or modifications on + /// beta. + case oneWaySafe // = 3 + + /// SynchronizationMode_SynchronizationModeOneWayReplica represents a + /// unidirectional synchronization mode where contents on alpha are mirrored + /// (verbatim) to beta, overwriting any conflicting contents on beta and + /// deleting any extraneous contents on beta. + case oneWayReplica // = 4 + case UNRECOGNIZED(Int) + + init() { + self = .default + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .default + case 1: self = .twoWaySafe + case 2: self = .twoWayResolved + case 3: self = .oneWaySafe + case 4: self = .oneWayReplica + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .default: return 0 + case .twoWaySafe: return 1 + case .twoWayResolved: return 2 + case .oneWaySafe: return 3 + case .oneWayReplica: return 4 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [Core_SynchronizationMode] = [ + .default, + .twoWaySafe, + .twoWayResolved, + .oneWaySafe, + .oneWayReplica, + ] + +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +extension Core_SynchronizationMode: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ + 0: .same(proto: "SynchronizationModeDefault"), + 1: .same(proto: "SynchronizationModeTwoWaySafe"), + 2: .same(proto: "SynchronizationModeTwoWayResolved"), + 3: .same(proto: "SynchronizationModeOneWaySafe"), + 4: .same(proto: "SynchronizationModeOneWayReplica"), + ] +} diff --git a/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_core_mode.proto b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_core_mode.proto new file mode 100644 index 0000000..212daf7 --- /dev/null +++ b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_core_mode.proto @@ -0,0 +1,69 @@ +/* + * This file was taken from + * https://github.com/mutagen-io/mutagen/tree/v0.18.1/pkg/synchronization/core/mode.proto + * + * MIT License + * + * Copyright (c) 2016-present Docker, Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +syntax = "proto3"; + +package core; + +option go_package = "github.com/mutagen-io/mutagen/pkg/synchronization/core"; + +// SynchronizationMode specifies the mode for synchronization, encoding both +// directionality and conflict resolution behavior. +enum SynchronizationMode { + // SynchronizationMode_SynchronizationModeDefault represents an unspecified + // synchronization mode. It is not valid for use with Reconcile. It should + // be converted to one of the following values based on the desired default + // behavior. + SynchronizationModeDefault = 0; + + // SynchronizationMode_SynchronizationModeTwoWaySafe represents a + // bidirectional synchronization mode where automatic conflict resolution is + // performed only in cases where no data would be lost. Specifically, this + // means that modified contents are allowed to propagate to the opposite + // endpoint if the corresponding contents on the opposite endpoint are + // unmodified or deleted. All other conflicts are left unresolved. + SynchronizationModeTwoWaySafe = 1; + + // SynchronizationMode_SynchronizationModeTwoWayResolved is the same as + // SynchronizationMode_SynchronizationModeTwoWaySafe, but specifies that the + // alpha endpoint should win automatically in any conflict between alpha and + // beta, including cases where alpha has deleted contents that beta has + // modified. + SynchronizationModeTwoWayResolved = 2; + + // SynchronizationMode_SynchronizationModeOneWaySafe represents a + // unidirectional synchronization mode where contents and changes propagate + // from alpha to beta, but won't overwrite any creations or modifications on + // beta. + SynchronizationModeOneWaySafe = 3; + + // SynchronizationMode_SynchronizationModeOneWayReplica represents a + // unidirectional synchronization mode where contents on alpha are mirrored + // (verbatim) to beta, overwriting any conflicting contents on beta and + // deleting any extraneous contents on beta. + SynchronizationModeOneWayReplica = 4; +} diff --git a/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_core_permissions_mode.pb.swift b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_core_permissions_mode.pb.swift new file mode 100644 index 0000000..e6d9597 --- /dev/null +++ b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_core_permissions_mode.pb.swift @@ -0,0 +1,110 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: synchronization_core_permissions_mode.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// +// This file was taken from +// https://github.com/mutagen-io/mutagen/tree/v0.18.1/pkg/synchronization/core/permissions_mode.proto +// +// MIT License +// +// Copyright (c) 2016-present Docker, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. + +import SwiftProtobuf + +// If the compiler emits an error on this type, it is because this file +// was generated by a version of the `protoc` Swift plug-in that is +// incompatible with the version of SwiftProtobuf to which you are linking. +// Please ensure that you are building against the same version of the API +// that was used to generate this file. +fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAPIVersionCheck { + struct _2: SwiftProtobuf.ProtobufAPIVersion_2 {} + typealias Version = _2 +} + +/// PermissionsMode specifies the mode for handling permission propagation. +enum Core_PermissionsMode: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + + /// PermissionsMode_PermissionsModeDefault represents an unspecified + /// permissions mode. It is not valid for use with Scan. It should be + /// converted to one of the following values based on the desired default + /// behavior. + case `default` // = 0 + + /// PermissionsMode_PermissionsModePortable specifies that permissions should + /// be propagated in a portable fashion. This means that only executability + /// bits are managed by Mutagen and that manual specifications for ownership + /// and base file permissions are used. + case portable // = 1 + + /// PermissionsMode_PermissionsModeManual specifies that only manual + /// permission specifications should be used. In this case, Mutagen does not + /// perform any propagation of permissions. + case manual // = 2 + case UNRECOGNIZED(Int) + + init() { + self = .default + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .default + case 1: self = .portable + case 2: self = .manual + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .default: return 0 + case .portable: return 1 + case .manual: return 2 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [Core_PermissionsMode] = [ + .default, + .portable, + .manual, + ] + +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +extension Core_PermissionsMode: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ + 0: .same(proto: "PermissionsModeDefault"), + 1: .same(proto: "PermissionsModePortable"), + 2: .same(proto: "PermissionsModeManual"), + ] +} diff --git a/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_core_permissions_mode.proto b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_core_permissions_mode.proto new file mode 100644 index 0000000..98caa32 --- /dev/null +++ b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_core_permissions_mode.proto @@ -0,0 +1,50 @@ +/* + * This file was taken from + * https://github.com/mutagen-io/mutagen/tree/v0.18.1/pkg/synchronization/core/permissions_mode.proto + * + * MIT License + * + * Copyright (c) 2016-present Docker, Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +syntax = "proto3"; + +package core; + +option go_package = "github.com/mutagen-io/mutagen/pkg/synchronization/core"; + +// PermissionsMode specifies the mode for handling permission propagation. +enum PermissionsMode { + // PermissionsMode_PermissionsModeDefault represents an unspecified + // permissions mode. It is not valid for use with Scan. It should be + // converted to one of the following values based on the desired default + // behavior. + PermissionsModeDefault = 0; + // PermissionsMode_PermissionsModePortable specifies that permissions should + // be propagated in a portable fashion. This means that only executability + // bits are managed by Mutagen and that manual specifications for ownership + // and base file permissions are used. + PermissionsModePortable = 1; + // PermissionsMode_PermissionsModeManual specifies that only manual + // permission specifications should be used. In this case, Mutagen does not + // perform any propagation of permissions. + PermissionsModeManual = 2; +} diff --git a/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_core_problem.pb.swift b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_core_problem.pb.swift new file mode 100644 index 0000000..8c2ba6b --- /dev/null +++ b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_core_problem.pb.swift @@ -0,0 +1,109 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: synchronization_core_problem.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// +// This file was taken from +// https://github.com/mutagen-io/mutagen/tree/v0.18.1/pkg/synchronization/core/problem.proto +// +// MIT License +// +// Copyright (c) 2016-present Docker, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. + +import SwiftProtobuf + +// If the compiler emits an error on this type, it is because this file +// was generated by a version of the `protoc` Swift plug-in that is +// incompatible with the version of SwiftProtobuf to which you are linking. +// Please ensure that you are building against the same version of the API +// that was used to generate this file. +fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAPIVersionCheck { + struct _2: SwiftProtobuf.ProtobufAPIVersion_2 {} + typealias Version = _2 +} + +/// Problem indicates an issue or error encountered at some stage of a +/// synchronization cycle. Problem objects should be considered immutable and +/// must not be modified. +struct Core_Problem: Sendable { + // 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. + + /// Path is the path at which the problem occurred (relative to the + /// synchronization root). + var path: String = String() + + /// Error is a human-readable summary of the problem. + var error: String = String() + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "core" + +extension Core_Problem: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".Problem" + static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ + 1: .same(proto: "path"), + 2: .same(proto: "error"), + ] + + mutating func decodeMessage(decoder: inout D) throws { + while let fieldNumber = try decoder.nextFieldNumber() { + // The use of inline closures is to circumvent an issue where the compiler + // allocates stack space for every case branch when no optimizations are + // enabled. https://github.com/apple/swift-protobuf/issues/1034 + switch fieldNumber { + case 1: try { try decoder.decodeSingularStringField(value: &self.path) }() + case 2: try { try decoder.decodeSingularStringField(value: &self.error) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.path.isEmpty { + try visitor.visitSingularStringField(value: self.path, fieldNumber: 1) + } + if !self.error.isEmpty { + try visitor.visitSingularStringField(value: self.error, fieldNumber: 2) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Core_Problem, rhs: Core_Problem) -> Bool { + if lhs.path != rhs.path {return false} + if lhs.error != rhs.error {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_core_problem.proto b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_core_problem.proto new file mode 100644 index 0000000..2ff6610 --- /dev/null +++ b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_core_problem.proto @@ -0,0 +1,43 @@ +/* + * This file was taken from + * https://github.com/mutagen-io/mutagen/tree/v0.18.1/pkg/synchronization/core/problem.proto + * + * MIT License + * + * Copyright (c) 2016-present Docker, Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +syntax = "proto3"; + +package core; + +option go_package = "github.com/mutagen-io/mutagen/pkg/synchronization/core"; + +// Problem indicates an issue or error encountered at some stage of a +// synchronization cycle. Problem objects should be considered immutable and +// must not be modified. +message Problem { + // Path is the path at which the problem occurred (relative to the + // synchronization root). + string path = 1; + // Error is a human-readable summary of the problem. + string error = 2; +} diff --git a/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_core_symbolic_link_mode.pb.swift b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_core_symbolic_link_mode.pb.swift new file mode 100644 index 0000000..d379c68 --- /dev/null +++ b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_core_symbolic_link_mode.pb.swift @@ -0,0 +1,118 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: synchronization_core_symbolic_link_mode.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// +// This file was taken from +// https://github.com/mutagen-io/mutagen/tree/v0.18.1/pkg/synchronization/core/symbolic_link_mode.proto +// +// MIT License +// +// Copyright (c) 2016-present Docker, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. + +import SwiftProtobuf + +// If the compiler emits an error on this type, it is because this file +// was generated by a version of the `protoc` Swift plug-in that is +// incompatible with the version of SwiftProtobuf to which you are linking. +// Please ensure that you are building against the same version of the API +// that was used to generate this file. +fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAPIVersionCheck { + struct _2: SwiftProtobuf.ProtobufAPIVersion_2 {} + typealias Version = _2 +} + +/// SymbolicLinkMode specifies the mode for handling symbolic links. +enum Core_SymbolicLinkMode: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + + /// SymbolicLinkMode_SymbolicLinkModeDefault represents an unspecified + /// symbolic link mode. It is not valid for use with Scan or Transition. It + /// should be converted to one of the following values based on the desired + /// default behavior. + case `default` // = 0 + + /// SymbolicLinkMode_SymbolicLinkModeIgnore specifies that all symbolic links + /// should be ignored. + case ignore // = 1 + + /// SymbolicLinkMode_SymbolicLinkModePortable specifies that only portable + /// symbolic links should be synchronized. Any absolute symbolic links or + /// symbolic links which are otherwise non-portable will be treate as + /// problematic content. + case portable // = 2 + + /// SymbolicLinkMode_SymbolicLinkModePOSIXRaw specifies that symbolic links + /// should be propagated in their raw form. It is only valid on POSIX systems + /// and only makes sense in the context of POSIX-to-POSIX synchronization. + case posixraw // = 3 + case UNRECOGNIZED(Int) + + init() { + self = .default + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .default + case 1: self = .ignore + case 2: self = .portable + case 3: self = .posixraw + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .default: return 0 + case .ignore: return 1 + case .portable: return 2 + case .posixraw: return 3 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [Core_SymbolicLinkMode] = [ + .default, + .ignore, + .portable, + .posixraw, + ] + +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +extension Core_SymbolicLinkMode: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ + 0: .same(proto: "SymbolicLinkModeDefault"), + 1: .same(proto: "SymbolicLinkModeIgnore"), + 2: .same(proto: "SymbolicLinkModePortable"), + 3: .same(proto: "SymbolicLinkModePOSIXRaw"), + ] +} diff --git a/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_core_symbolic_link_mode.proto b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_core_symbolic_link_mode.proto new file mode 100644 index 0000000..0229296 --- /dev/null +++ b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_core_symbolic_link_mode.proto @@ -0,0 +1,53 @@ +/* + * This file was taken from + * https://github.com/mutagen-io/mutagen/tree/v0.18.1/pkg/synchronization/core/symbolic_link_mode.proto + * + * MIT License + * + * Copyright (c) 2016-present Docker, Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +syntax = "proto3"; + +package core; + +option go_package = "github.com/mutagen-io/mutagen/pkg/synchronization/core"; + +// SymbolicLinkMode specifies the mode for handling symbolic links. +enum SymbolicLinkMode { + // SymbolicLinkMode_SymbolicLinkModeDefault represents an unspecified + // symbolic link mode. It is not valid for use with Scan or Transition. It + // should be converted to one of the following values based on the desired + // default behavior. + SymbolicLinkModeDefault = 0; + // SymbolicLinkMode_SymbolicLinkModeIgnore specifies that all symbolic links + // should be ignored. + SymbolicLinkModeIgnore = 1; + // SymbolicLinkMode_SymbolicLinkModePortable specifies that only portable + // symbolic links should be synchronized. Any absolute symbolic links or + // symbolic links which are otherwise non-portable will be treate as + // problematic content. + SymbolicLinkModePortable = 2; + // SymbolicLinkMode_SymbolicLinkModePOSIXRaw specifies that symbolic links + // should be propagated in their raw form. It is only valid on POSIX systems + // and only makes sense in the context of POSIX-to-POSIX synchronization. + SymbolicLinkModePOSIXRaw = 3; +} diff --git a/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_hashing_algorithm.pb.swift b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_hashing_algorithm.pb.swift new file mode 100644 index 0000000..5a9c295 --- /dev/null +++ b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_hashing_algorithm.pb.swift @@ -0,0 +1,111 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: synchronization_hashing_algorithm.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// +// This file was taken from +// https://github.com/mutagen-io/mutagen/tree/v0.18.1/pkg/synchronization/hashing/algorithm.proto +// +// MIT License +// +// Copyright (c) 2016-present Docker, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. + +import SwiftProtobuf + +// If the compiler emits an error on this type, it is because this file +// was generated by a version of the `protoc` Swift plug-in that is +// incompatible with the version of SwiftProtobuf to which you are linking. +// Please ensure that you are building against the same version of the API +// that was used to generate this file. +fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAPIVersionCheck { + struct _2: SwiftProtobuf.ProtobufAPIVersion_2 {} + typealias Version = _2 +} + +/// Algorithm specifies a hashing algorithm. +enum Hashing_Algorithm: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + + /// Algorithm_AlgorithmDefault represents an unspecified hashing algorithm. + /// It should be converted to one of the following values based on the + /// desired default behavior. + case `default` // = 0 + + /// Algorithm_AlgorithmSHA1 specifies that SHA-1 hashing should be used. + case sha1 // = 1 + + /// Algorithm_AlgorithmSHA256 specifies that SHA-256 hashing should be used. + case sha256 // = 2 + + /// Algorithm_AlgorithmXXH128 specifies that XXH128 hashing should be used. + case xxh128 // = 3 + case UNRECOGNIZED(Int) + + init() { + self = .default + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .default + case 1: self = .sha1 + case 2: self = .sha256 + case 3: self = .xxh128 + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .default: return 0 + case .sha1: return 1 + case .sha256: return 2 + case .xxh128: return 3 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [Hashing_Algorithm] = [ + .default, + .sha1, + .sha256, + .xxh128, + ] + +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +extension Hashing_Algorithm: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ + 0: .same(proto: "AlgorithmDefault"), + 1: .same(proto: "AlgorithmSHA1"), + 2: .same(proto: "AlgorithmSHA256"), + 3: .same(proto: "AlgorithmXXH128"), + ] +} diff --git a/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_hashing_algorithm.proto b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_hashing_algorithm.proto new file mode 100644 index 0000000..a4837bc --- /dev/null +++ b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_hashing_algorithm.proto @@ -0,0 +1,46 @@ +/* + * This file was taken from + * https://github.com/mutagen-io/mutagen/tree/v0.18.1/pkg/synchronization/hashing/algorithm.proto + * + * MIT License + * + * Copyright (c) 2016-present Docker, Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +syntax = "proto3"; + +package hashing; + +option go_package = "github.com/mutagen-io/mutagen/pkg/synchronization/hashing"; + +// Algorithm specifies a hashing algorithm. +enum Algorithm { + // Algorithm_AlgorithmDefault represents an unspecified hashing algorithm. + // It should be converted to one of the following values based on the + // desired default behavior. + AlgorithmDefault = 0; + // Algorithm_AlgorithmSHA1 specifies that SHA-1 hashing should be used. + AlgorithmSHA1 = 1; + // Algorithm_AlgorithmSHA256 specifies that SHA-256 hashing should be used. + AlgorithmSHA256 = 2; + // Algorithm_AlgorithmXXH128 specifies that XXH128 hashing should be used. + AlgorithmXXH128 = 3; +} diff --git a/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_rsync_receive.pb.swift b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_rsync_receive.pb.swift new file mode 100644 index 0000000..324659c --- /dev/null +++ b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_rsync_receive.pb.swift @@ -0,0 +1,145 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: synchronization_rsync_receive.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// +// This file was taken from +// https://github.com/mutagen-io/mutagen/tree/v0.18.1/pkg/synchronization/rsync/receive.proto +// +// MIT License +// +// Copyright (c) 2016-present Docker, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. + +import SwiftProtobuf + +// If the compiler emits an error on this type, it is because this file +// was generated by a version of the `protoc` Swift plug-in that is +// incompatible with the version of SwiftProtobuf to which you are linking. +// Please ensure that you are building against the same version of the API +// that was used to generate this file. +fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAPIVersionCheck { + struct _2: SwiftProtobuf.ProtobufAPIVersion_2 {} + typealias Version = _2 +} + +/// ReceiverState encodes that status of an rsync receiver. It should be +/// considered immutable. +struct Rsync_ReceiverState: Sendable { + // 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. + + /// Path is the path currently being received. + var path: String = String() + + /// ReceivedSize is the number of bytes that have been received for the + /// current path from both block and data operations. + var receivedSize: UInt64 = 0 + + /// ExpectedSize is the number of bytes expected for the current path. + var expectedSize: UInt64 = 0 + + /// ReceivedFiles is the number of files that have already been received. + var receivedFiles: UInt64 = 0 + + /// ExpectedFiles is the total number of files expected. + var expectedFiles: UInt64 = 0 + + /// TotalReceivedSize is the total number of bytes that have been received + /// for all files from both block and data operations. + var totalReceivedSize: UInt64 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "rsync" + +extension Rsync_ReceiverState: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".ReceiverState" + static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ + 1: .same(proto: "path"), + 2: .same(proto: "receivedSize"), + 3: .same(proto: "expectedSize"), + 4: .same(proto: "receivedFiles"), + 5: .same(proto: "expectedFiles"), + 6: .same(proto: "totalReceivedSize"), + ] + + mutating func decodeMessage(decoder: inout D) throws { + while let fieldNumber = try decoder.nextFieldNumber() { + // The use of inline closures is to circumvent an issue where the compiler + // allocates stack space for every case branch when no optimizations are + // enabled. https://github.com/apple/swift-protobuf/issues/1034 + switch fieldNumber { + case 1: try { try decoder.decodeSingularStringField(value: &self.path) }() + case 2: try { try decoder.decodeSingularUInt64Field(value: &self.receivedSize) }() + case 3: try { try decoder.decodeSingularUInt64Field(value: &self.expectedSize) }() + case 4: try { try decoder.decodeSingularUInt64Field(value: &self.receivedFiles) }() + case 5: try { try decoder.decodeSingularUInt64Field(value: &self.expectedFiles) }() + case 6: try { try decoder.decodeSingularUInt64Field(value: &self.totalReceivedSize) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.path.isEmpty { + try visitor.visitSingularStringField(value: self.path, fieldNumber: 1) + } + if self.receivedSize != 0 { + try visitor.visitSingularUInt64Field(value: self.receivedSize, fieldNumber: 2) + } + if self.expectedSize != 0 { + try visitor.visitSingularUInt64Field(value: self.expectedSize, fieldNumber: 3) + } + if self.receivedFiles != 0 { + try visitor.visitSingularUInt64Field(value: self.receivedFiles, fieldNumber: 4) + } + if self.expectedFiles != 0 { + try visitor.visitSingularUInt64Field(value: self.expectedFiles, fieldNumber: 5) + } + if self.totalReceivedSize != 0 { + try visitor.visitSingularUInt64Field(value: self.totalReceivedSize, fieldNumber: 6) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Rsync_ReceiverState, rhs: Rsync_ReceiverState) -> Bool { + if lhs.path != rhs.path {return false} + if lhs.receivedSize != rhs.receivedSize {return false} + if lhs.expectedSize != rhs.expectedSize {return false} + if lhs.receivedFiles != rhs.receivedFiles {return false} + if lhs.expectedFiles != rhs.expectedFiles {return false} + if lhs.totalReceivedSize != rhs.totalReceivedSize {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_rsync_receive.proto b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_rsync_receive.proto new file mode 100644 index 0000000..43bad22 --- /dev/null +++ b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_rsync_receive.proto @@ -0,0 +1,56 @@ +/* + * This file was taken from + * https://github.com/mutagen-io/mutagen/tree/v0.18.1/pkg/synchronization/rsync/receive.proto + * + * MIT License + * + * Copyright (c) 2016-present Docker, Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +syntax = "proto3"; + +package rsync; + +option go_package = "github.com/mutagen-io/mutagen/pkg/synchronization/rsync"; + +// ReceiverState encodes that status of an rsync receiver. It should be +// considered immutable. +message ReceiverState { + // Path is the path currently being received. + string path = 1; + // ReceivedSize is the number of bytes that have been received for the + // current path from both block and data operations. + uint64 receivedSize = 2; + // ExpectedSize is the number of bytes expected for the current path. + uint64 expectedSize = 3; + // ReceivedFiles is the number of files that have already been received. + uint64 receivedFiles = 4; + // ExpectedFiles is the total number of files expected. + uint64 expectedFiles = 5; + // TotalReceivedSize is the total number of bytes that have been received + // for all files from both block and data operations. + uint64 totalReceivedSize = 6; + // TODO: We may want to add statistics on the speedup offered by the rsync + // algorithm in terms of data volume, though obviously this can't account + // for any savings that might come from compression at the transport layer. + // It would also be really nice to have TotalExpectedSize, but this is + // prohibitively difficult and expensive to compute. +} diff --git a/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_scan_mode.pb.swift b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_scan_mode.pb.swift new file mode 100644 index 0000000..4d0ad6f --- /dev/null +++ b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_scan_mode.pb.swift @@ -0,0 +1,106 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: synchronization_scan_mode.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// +// This file was taken from +// https://github.com/mutagen-io/mutagen/tree/v0.18.1/pkg/synchronization/scan_mode.proto +// +// MIT License +// +// Copyright (c) 2016-present Docker, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. + +import SwiftProtobuf + +// If the compiler emits an error on this type, it is because this file +// was generated by a version of the `protoc` Swift plug-in that is +// incompatible with the version of SwiftProtobuf to which you are linking. +// Please ensure that you are building against the same version of the API +// that was used to generate this file. +fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAPIVersionCheck { + struct _2: SwiftProtobuf.ProtobufAPIVersion_2 {} + typealias Version = _2 +} + +/// ScanMode specifies the mode for synchronization root scanning. +enum Synchronization_ScanMode: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + + /// ScanMode_ScanModeDefault represents an unspecified scan mode. It should + /// be converted to one of the following values based on the desired default + /// behavior. + case `default` // = 0 + + /// ScanMode_ScanModeFull specifies that full scans should be performed on + /// each synchronization cycle. + case full // = 1 + + /// ScanMode_ScanModeAccelerated specifies that scans should attempt to use + /// watch-based acceleration. + case accelerated // = 2 + case UNRECOGNIZED(Int) + + init() { + self = .default + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .default + case 1: self = .full + case 2: self = .accelerated + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .default: return 0 + case .full: return 1 + case .accelerated: return 2 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [Synchronization_ScanMode] = [ + .default, + .full, + .accelerated, + ] + +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +extension Synchronization_ScanMode: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ + 0: .same(proto: "ScanModeDefault"), + 1: .same(proto: "ScanModeFull"), + 2: .same(proto: "ScanModeAccelerated"), + ] +} diff --git a/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_scan_mode.proto b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_scan_mode.proto new file mode 100644 index 0000000..c95f0e3 --- /dev/null +++ b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_scan_mode.proto @@ -0,0 +1,46 @@ +/* + * This file was taken from + * https://github.com/mutagen-io/mutagen/tree/v0.18.1/pkg/synchronization/scan_mode.proto + * + * MIT License + * + * Copyright (c) 2016-present Docker, Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +syntax = "proto3"; + +package synchronization; + +option go_package = "github.com/mutagen-io/mutagen/pkg/synchronization"; + +// ScanMode specifies the mode for synchronization root scanning. +enum ScanMode { + // ScanMode_ScanModeDefault represents an unspecified scan mode. It should + // be converted to one of the following values based on the desired default + // behavior. + ScanModeDefault = 0; + // ScanMode_ScanModeFull specifies that full scans should be performed on + // each synchronization cycle. + ScanModeFull = 1; + // ScanMode_ScanModeAccelerated specifies that scans should attempt to use + // watch-based acceleration. + ScanModeAccelerated = 2; +} diff --git a/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_session.pb.swift b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_session.pb.swift new file mode 100644 index 0000000..652166f --- /dev/null +++ b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_session.pb.swift @@ -0,0 +1,370 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: synchronization_session.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// +// This file was taken from +// https://github.com/mutagen-io/mutagen/tree/v0.18.1/pkg/synchronization/session.proto +// +// MIT License +// +// Copyright (c) 2016-present Docker, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. + +import SwiftProtobuf + +// If the compiler emits an error on this type, it is because this file +// was generated by a version of the `protoc` Swift plug-in that is +// incompatible with the version of SwiftProtobuf to which you are linking. +// Please ensure that you are building against the same version of the API +// that was used to generate this file. +fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAPIVersionCheck { + struct _2: SwiftProtobuf.ProtobufAPIVersion_2 {} + typealias Version = _2 +} + +/// Session represents a synchronization session configuration and persistent +/// state. It is mutable within the context of the daemon, so it should be +/// accessed and modified in a synchronized fashion. Outside of the daemon (e.g. +/// when returned via the API), it should be considered immutable. +struct Synchronization_Session: @unchecked Sendable { + // 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. + + /// Identifier is the (unique) session identifier. It is static. It cannot be + /// empty. + var identifier: String { + get {return _storage._identifier} + set {_uniqueStorage()._identifier = newValue} + } + + /// Version is the session version. It is static. + var version: Synchronization_Version { + get {return _storage._version} + set {_uniqueStorage()._version = newValue} + } + + /// CreationTime is the creation time of the session. It is static. It cannot + /// be nil. + var creationTime: SwiftProtobuf.Google_Protobuf_Timestamp { + get {return _storage._creationTime ?? SwiftProtobuf.Google_Protobuf_Timestamp()} + set {_uniqueStorage()._creationTime = newValue} + } + /// Returns true if `creationTime` has been explicitly set. + var hasCreationTime: Bool {return _storage._creationTime != nil} + /// Clears the value of `creationTime`. Subsequent reads from it will return its default value. + mutating func clearCreationTime() {_uniqueStorage()._creationTime = nil} + + /// CreatingVersionMajor is the major version component of the version of + /// Mutagen which created the session. It is static. + var creatingVersionMajor: UInt32 { + get {return _storage._creatingVersionMajor} + set {_uniqueStorage()._creatingVersionMajor = newValue} + } + + /// CreatingVersionMinor is the minor version component of the version of + /// Mutagen which created the session. It is static. + var creatingVersionMinor: UInt32 { + get {return _storage._creatingVersionMinor} + set {_uniqueStorage()._creatingVersionMinor = newValue} + } + + /// CreatingVersionPatch is the patch version component of the version of + /// Mutagen which created the session. It is static. + var creatingVersionPatch: UInt32 { + get {return _storage._creatingVersionPatch} + set {_uniqueStorage()._creatingVersionPatch = newValue} + } + + /// Alpha is the alpha endpoint URL. It is static. It cannot be nil. + var alpha: Url_URL { + get {return _storage._alpha ?? Url_URL()} + set {_uniqueStorage()._alpha = newValue} + } + /// Returns true if `alpha` has been explicitly set. + var hasAlpha: Bool {return _storage._alpha != nil} + /// Clears the value of `alpha`. Subsequent reads from it will return its default value. + mutating func clearAlpha() {_uniqueStorage()._alpha = nil} + + /// Beta is the beta endpoint URL. It is static. It cannot be nil. + var beta: Url_URL { + get {return _storage._beta ?? Url_URL()} + set {_uniqueStorage()._beta = newValue} + } + /// Returns true if `beta` has been explicitly set. + var hasBeta: Bool {return _storage._beta != nil} + /// Clears the value of `beta`. Subsequent reads from it will return its default value. + mutating func clearBeta() {_uniqueStorage()._beta = nil} + + /// Configuration is the flattened session configuration. It is static. It + /// cannot be nil. + var configuration: Synchronization_Configuration { + get {return _storage._configuration ?? Synchronization_Configuration()} + set {_uniqueStorage()._configuration = newValue} + } + /// Returns true if `configuration` has been explicitly set. + var hasConfiguration: Bool {return _storage._configuration != nil} + /// Clears the value of `configuration`. Subsequent reads from it will return its default value. + mutating func clearConfiguration() {_uniqueStorage()._configuration = nil} + + /// ConfigurationAlpha are the alpha-specific session configuration + /// overrides. It is static. It may be nil for existing sessions loaded from + /// disk, but it is not considered valid unless non-nil, so it should be + /// replaced with an empty default value in-memory if a nil on-disk value is + /// detected. + var configurationAlpha: Synchronization_Configuration { + get {return _storage._configurationAlpha ?? Synchronization_Configuration()} + set {_uniqueStorage()._configurationAlpha = newValue} + } + /// Returns true if `configurationAlpha` has been explicitly set. + var hasConfigurationAlpha: Bool {return _storage._configurationAlpha != nil} + /// Clears the value of `configurationAlpha`. Subsequent reads from it will return its default value. + mutating func clearConfigurationAlpha() {_uniqueStorage()._configurationAlpha = nil} + + /// ConfigurationBeta are the beta-specific session configuration overrides. + /// It is static. It may be nil for existing sessions loaded from disk, but + /// it is not considered valid unless non-nil, so it should be replaced with + /// an empty default value in-memory if a nil on-disk value is detected. + var configurationBeta: Synchronization_Configuration { + get {return _storage._configurationBeta ?? Synchronization_Configuration()} + set {_uniqueStorage()._configurationBeta = newValue} + } + /// Returns true if `configurationBeta` has been explicitly set. + var hasConfigurationBeta: Bool {return _storage._configurationBeta != nil} + /// Clears the value of `configurationBeta`. Subsequent reads from it will return its default value. + mutating func clearConfigurationBeta() {_uniqueStorage()._configurationBeta = nil} + + /// Name is a user-friendly name for the session. It may be empty and is not + /// guaranteed to be unique across all sessions. It is only used as a simpler + /// handle for specifying sessions. It is static. + var name: String { + get {return _storage._name} + set {_uniqueStorage()._name = newValue} + } + + /// Labels are the session labels. They are static. + var labels: Dictionary { + get {return _storage._labels} + set {_uniqueStorage()._labels = newValue} + } + + /// Paused indicates whether or not the session is marked as paused. + var paused: Bool { + get {return _storage._paused} + set {_uniqueStorage()._paused = newValue} + } + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "synchronization" + +extension Synchronization_Session: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".Session" + static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ + 1: .same(proto: "identifier"), + 2: .same(proto: "version"), + 3: .same(proto: "creationTime"), + 4: .same(proto: "creatingVersionMajor"), + 5: .same(proto: "creatingVersionMinor"), + 6: .same(proto: "creatingVersionPatch"), + 7: .same(proto: "alpha"), + 8: .same(proto: "beta"), + 9: .same(proto: "configuration"), + 11: .same(proto: "configurationAlpha"), + 12: .same(proto: "configurationBeta"), + 14: .same(proto: "name"), + 13: .same(proto: "labels"), + 10: .same(proto: "paused"), + ] + + fileprivate class _StorageClass { + var _identifier: String = String() + var _version: Synchronization_Version = .invalid + var _creationTime: SwiftProtobuf.Google_Protobuf_Timestamp? = nil + var _creatingVersionMajor: UInt32 = 0 + var _creatingVersionMinor: UInt32 = 0 + var _creatingVersionPatch: UInt32 = 0 + var _alpha: Url_URL? = nil + var _beta: Url_URL? = nil + var _configuration: Synchronization_Configuration? = nil + var _configurationAlpha: Synchronization_Configuration? = nil + var _configurationBeta: Synchronization_Configuration? = nil + var _name: String = String() + var _labels: Dictionary = [:] + var _paused: Bool = false + + #if swift(>=5.10) + // This property is used as the initial default value for new instances of the type. + // The type itself is protecting the reference to its storage via CoW semantics. + // This will force a copy to be made of this reference when the first mutation occurs; + // hence, it is safe to mark this as `nonisolated(unsafe)`. + static nonisolated(unsafe) let defaultInstance = _StorageClass() + #else + static let defaultInstance = _StorageClass() + #endif + + private init() {} + + init(copying source: _StorageClass) { + _identifier = source._identifier + _version = source._version + _creationTime = source._creationTime + _creatingVersionMajor = source._creatingVersionMajor + _creatingVersionMinor = source._creatingVersionMinor + _creatingVersionPatch = source._creatingVersionPatch + _alpha = source._alpha + _beta = source._beta + _configuration = source._configuration + _configurationAlpha = source._configurationAlpha + _configurationBeta = source._configurationBeta + _name = source._name + _labels = source._labels + _paused = source._paused + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(decoder: inout D) throws { + _ = _uniqueStorage() + try withExtendedLifetime(_storage) { (_storage: _StorageClass) in + while let fieldNumber = try decoder.nextFieldNumber() { + // The use of inline closures is to circumvent an issue where the compiler + // allocates stack space for every case branch when no optimizations are + // enabled. https://github.com/apple/swift-protobuf/issues/1034 + switch fieldNumber { + case 1: try { try decoder.decodeSingularStringField(value: &_storage._identifier) }() + case 2: try { try decoder.decodeSingularEnumField(value: &_storage._version) }() + case 3: try { try decoder.decodeSingularMessageField(value: &_storage._creationTime) }() + case 4: try { try decoder.decodeSingularUInt32Field(value: &_storage._creatingVersionMajor) }() + case 5: try { try decoder.decodeSingularUInt32Field(value: &_storage._creatingVersionMinor) }() + case 6: try { try decoder.decodeSingularUInt32Field(value: &_storage._creatingVersionPatch) }() + case 7: try { try decoder.decodeSingularMessageField(value: &_storage._alpha) }() + case 8: try { try decoder.decodeSingularMessageField(value: &_storage._beta) }() + case 9: try { try decoder.decodeSingularMessageField(value: &_storage._configuration) }() + case 10: try { try decoder.decodeSingularBoolField(value: &_storage._paused) }() + case 11: try { try decoder.decodeSingularMessageField(value: &_storage._configurationAlpha) }() + case 12: try { try decoder.decodeSingularMessageField(value: &_storage._configurationBeta) }() + case 13: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._labels) }() + case 14: try { try decoder.decodeSingularStringField(value: &_storage._name) }() + default: break + } + } + } + } + + func traverse(visitor: inout V) throws { + try withExtendedLifetime(_storage) { (_storage: _StorageClass) in + // The use of inline closures is to circumvent an issue where the compiler + // allocates stack space for every if/case branch local when no optimizations + // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and + // https://github.com/apple/swift-protobuf/issues/1182 + if !_storage._identifier.isEmpty { + try visitor.visitSingularStringField(value: _storage._identifier, fieldNumber: 1) + } + if _storage._version != .invalid { + try visitor.visitSingularEnumField(value: _storage._version, fieldNumber: 2) + } + try { if let v = _storage._creationTime { + try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + } }() + if _storage._creatingVersionMajor != 0 { + try visitor.visitSingularUInt32Field(value: _storage._creatingVersionMajor, fieldNumber: 4) + } + if _storage._creatingVersionMinor != 0 { + try visitor.visitSingularUInt32Field(value: _storage._creatingVersionMinor, fieldNumber: 5) + } + if _storage._creatingVersionPatch != 0 { + try visitor.visitSingularUInt32Field(value: _storage._creatingVersionPatch, fieldNumber: 6) + } + try { if let v = _storage._alpha { + try visitor.visitSingularMessageField(value: v, fieldNumber: 7) + } }() + try { if let v = _storage._beta { + try visitor.visitSingularMessageField(value: v, fieldNumber: 8) + } }() + try { if let v = _storage._configuration { + try visitor.visitSingularMessageField(value: v, fieldNumber: 9) + } }() + if _storage._paused != false { + try visitor.visitSingularBoolField(value: _storage._paused, fieldNumber: 10) + } + try { if let v = _storage._configurationAlpha { + try visitor.visitSingularMessageField(value: v, fieldNumber: 11) + } }() + try { if let v = _storage._configurationBeta { + try visitor.visitSingularMessageField(value: v, fieldNumber: 12) + } }() + if !_storage._labels.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._labels, fieldNumber: 13) + } + if !_storage._name.isEmpty { + try visitor.visitSingularStringField(value: _storage._name, fieldNumber: 14) + } + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Synchronization_Session, rhs: Synchronization_Session) -> 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._identifier != rhs_storage._identifier {return false} + if _storage._version != rhs_storage._version {return false} + if _storage._creationTime != rhs_storage._creationTime {return false} + if _storage._creatingVersionMajor != rhs_storage._creatingVersionMajor {return false} + if _storage._creatingVersionMinor != rhs_storage._creatingVersionMinor {return false} + if _storage._creatingVersionPatch != rhs_storage._creatingVersionPatch {return false} + if _storage._alpha != rhs_storage._alpha {return false} + if _storage._beta != rhs_storage._beta {return false} + if _storage._configuration != rhs_storage._configuration {return false} + if _storage._configurationAlpha != rhs_storage._configurationAlpha {return false} + if _storage._configurationBeta != rhs_storage._configurationBeta {return false} + if _storage._name != rhs_storage._name {return false} + if _storage._labels != rhs_storage._labels {return false} + if _storage._paused != rhs_storage._paused {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_session.proto b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_session.proto new file mode 100644 index 0000000..9f3f165 --- /dev/null +++ b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_session.proto @@ -0,0 +1,100 @@ +/* + * This file was taken from + * https://github.com/mutagen-io/mutagen/tree/v0.18.1/pkg/synchronization/session.proto + * + * MIT License + * + * Copyright (c) 2016-present Docker, Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +syntax = "proto3"; + +package synchronization; + +option go_package = "github.com/mutagen-io/mutagen/pkg/synchronization"; + +import "google/protobuf/timestamp.proto"; + +import "synchronization_configuration.proto"; +import "synchronization_version.proto"; +import "url_url.proto"; + +// Session represents a synchronization session configuration and persistent +// state. It is mutable within the context of the daemon, so it should be +// accessed and modified in a synchronized fashion. Outside of the daemon (e.g. +// when returned via the API), it should be considered immutable. +message Session { + // The identifier, version, creationTime, and creatingVersion* fields are + // considered the "header" fields for all session versions. A message + // composed purely of these fields is guaranteed to be compatible with all + // future session versions. This can be used to dispatch session decoding to + // more specific message structures once multiple session version formats + // are implemented. + + // Identifier is the (unique) session identifier. It is static. It cannot be + // empty. + string identifier = 1; + // Version is the session version. It is static. + Version version = 2; + // CreationTime is the creation time of the session. It is static. It cannot + // be nil. + google.protobuf.Timestamp creationTime = 3; + // CreatingVersionMajor is the major version component of the version of + // Mutagen which created the session. It is static. + uint32 creatingVersionMajor = 4; + // CreatingVersionMinor is the minor version component of the version of + // Mutagen which created the session. It is static. + uint32 creatingVersionMinor = 5; + // CreatingVersionPatch is the patch version component of the version of + // Mutagen which created the session. It is static. + uint32 creatingVersionPatch = 6; + + // The remaining fields are those currently used by session version 1. + + // Alpha is the alpha endpoint URL. It is static. It cannot be nil. + url.URL alpha = 7; + // Beta is the beta endpoint URL. It is static. It cannot be nil. + url.URL beta = 8; + // Configuration is the flattened session configuration. It is static. It + // cannot be nil. + Configuration configuration = 9; + // ConfigurationAlpha are the alpha-specific session configuration + // overrides. It is static. It may be nil for existing sessions loaded from + // disk, but it is not considered valid unless non-nil, so it should be + // replaced with an empty default value in-memory if a nil on-disk value is + // detected. + Configuration configurationAlpha = 11; + // ConfigurationBeta are the beta-specific session configuration overrides. + // It is static. It may be nil for existing sessions loaded from disk, but + // it is not considered valid unless non-nil, so it should be replaced with + // an empty default value in-memory if a nil on-disk value is detected. + Configuration configurationBeta = 12; + // Name is a user-friendly name for the session. It may be empty and is not + // guaranteed to be unique across all sessions. It is only used as a simpler + // handle for specifying sessions. It is static. + string name = 14; + // Labels are the session labels. They are static. + map labels = 13; + // Paused indicates whether or not the session is marked as paused. + bool paused = 10; + // NOTE: Fields 11, 12, 13, and 14 are used above. They are out of order for + // historical reasons. +} diff --git a/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_stage_mode.pb.swift b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_stage_mode.pb.swift new file mode 100644 index 0000000..61769ac --- /dev/null +++ b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_stage_mode.pb.swift @@ -0,0 +1,115 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: synchronization_stage_mode.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// +// This file was taken from +// https://github.com/mutagen-io/mutagen/tree/v0.18.1/pkg/synchronization/stage_mode.proto +// +// MIT License +// +// Copyright (c) 2016-present Docker, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. + +import SwiftProtobuf + +// If the compiler emits an error on this type, it is because this file +// was generated by a version of the `protoc` Swift plug-in that is +// incompatible with the version of SwiftProtobuf to which you are linking. +// Please ensure that you are building against the same version of the API +// that was used to generate this file. +fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAPIVersionCheck { + struct _2: SwiftProtobuf.ProtobufAPIVersion_2 {} + typealias Version = _2 +} + +/// StageMode specifies the mode for file staging. +enum Synchronization_StageMode: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + + /// StageMode_StageModeDefault represents an unspecified staging mode. It + /// should be converted to one of the following values based on the desired + /// default behavior. + case `default` // = 0 + + /// StageMode_StageModeMutagen specifies that files should be staged in the + /// Mutagen data directory. + case mutagen // = 1 + + /// StageMode_StageModeNeighboring specifies that files should be staged in a + /// directory which neighbors the synchronization root. + case neighboring // = 2 + + /// StageMode_StageModeInternal specified that files should be staged in a + /// directory contained within a synchronization root. This mode will only + /// function if the synchronization root already exists. + case `internal` // = 3 + case UNRECOGNIZED(Int) + + init() { + self = .default + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .default + case 1: self = .mutagen + case 2: self = .neighboring + case 3: self = .internal + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .default: return 0 + case .mutagen: return 1 + case .neighboring: return 2 + case .internal: return 3 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [Synchronization_StageMode] = [ + .default, + .mutagen, + .neighboring, + .internal, + ] + +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +extension Synchronization_StageMode: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ + 0: .same(proto: "StageModeDefault"), + 1: .same(proto: "StageModeMutagen"), + 2: .same(proto: "StageModeNeighboring"), + 3: .same(proto: "StageModeInternal"), + ] +} diff --git a/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_stage_mode.proto b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_stage_mode.proto new file mode 100644 index 0000000..f049b9a --- /dev/null +++ b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_stage_mode.proto @@ -0,0 +1,50 @@ +/* + * This file was taken from + * https://github.com/mutagen-io/mutagen/tree/v0.18.1/pkg/synchronization/stage_mode.proto + * + * MIT License + * + * Copyright (c) 2016-present Docker, Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +syntax = "proto3"; + +package synchronization; + +option go_package = "github.com/mutagen-io/mutagen/pkg/synchronization"; + +// StageMode specifies the mode for file staging. +enum StageMode { + // StageMode_StageModeDefault represents an unspecified staging mode. It + // should be converted to one of the following values based on the desired + // default behavior. + StageModeDefault = 0; + // StageMode_StageModeMutagen specifies that files should be staged in the + // Mutagen data directory. + StageModeMutagen = 1; + // StageMode_StageModeNeighboring specifies that files should be staged in a + // directory which neighbors the synchronization root. + StageModeNeighboring = 2; + // StageMode_StageModeInternal specified that files should be staged in a + // directory contained within a synchronization root. This mode will only + // function if the synchronization root already exists. + StageModeInternal = 3; +} diff --git a/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_state.pb.swift b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_state.pb.swift new file mode 100644 index 0000000..0d7ef6c --- /dev/null +++ b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_state.pb.swift @@ -0,0 +1,579 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: synchronization_state.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// +// This file was taken from +// https://github.com/mutagen-io/mutagen/tree/v0.18.1/pkg/synchronization/state.proto +// +// MIT License +// +// Copyright (c) 2016-present Docker, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. + +import SwiftProtobuf + +// If the compiler emits an error on this type, it is because this file +// was generated by a version of the `protoc` Swift plug-in that is +// incompatible with the version of SwiftProtobuf to which you are linking. +// Please ensure that you are building against the same version of the API +// that was used to generate this file. +fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAPIVersionCheck { + struct _2: SwiftProtobuf.ProtobufAPIVersion_2 {} + typealias Version = _2 +} + +/// Status encodes the status of a synchronization session. +enum Synchronization_Status: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + + /// Status_Disconnected indicates that the session is unpaused but not + /// currently connected or connecting to either endpoint. + case disconnected // = 0 + + /// Status_HaltedOnRootEmptied indicates that the session is halted due to + /// the root emptying safety check. + case haltedOnRootEmptied // = 1 + + /// Status_HaltedOnRootDeletion indicates that the session is halted due to + /// the root deletion safety check. + case haltedOnRootDeletion // = 2 + + /// Status_HaltedOnRootTypeChange indicates that the session is halted due to + /// the root type change safety check. + case haltedOnRootTypeChange // = 3 + + /// Status_ConnectingAlpha indicates that the session is attempting to + /// connect to the alpha endpoint. + case connectingAlpha // = 4 + + /// Status_ConnectingBeta indicates that the session is attempting to connect + /// to the beta endpoint. + case connectingBeta // = 5 + + /// Status_Watching indicates that the session is watching for filesystem + /// changes. + case watching // = 6 + + /// Status_Scanning indicates that the session is scanning the filesystem on + /// each endpoint. + case scanning // = 7 + + /// Status_WaitingForRescan indicates that the session is waiting to retry + /// scanning after an error during the previous scanning operation. + case waitingForRescan // = 8 + + /// Status_Reconciling indicates that the session is performing + /// reconciliation. + case reconciling // = 9 + + /// Status_StagingAlpha indicates that the session is staging files on alpha. + case stagingAlpha // = 10 + + /// Status_StagingBeta indicates that the session is staging files on beta. + case stagingBeta // = 11 + + /// Status_Transitioning indicates that the session is performing transition + /// operations on each endpoint. + case transitioning // = 12 + + /// Status_Saving indicates that the session is recording synchronization + /// history to disk. + case saving // = 13 + case UNRECOGNIZED(Int) + + init() { + self = .disconnected + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .disconnected + case 1: self = .haltedOnRootEmptied + case 2: self = .haltedOnRootDeletion + case 3: self = .haltedOnRootTypeChange + case 4: self = .connectingAlpha + case 5: self = .connectingBeta + case 6: self = .watching + case 7: self = .scanning + case 8: self = .waitingForRescan + case 9: self = .reconciling + case 10: self = .stagingAlpha + case 11: self = .stagingBeta + case 12: self = .transitioning + case 13: self = .saving + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .disconnected: return 0 + case .haltedOnRootEmptied: return 1 + case .haltedOnRootDeletion: return 2 + case .haltedOnRootTypeChange: return 3 + case .connectingAlpha: return 4 + case .connectingBeta: return 5 + case .watching: return 6 + case .scanning: return 7 + case .waitingForRescan: return 8 + case .reconciling: return 9 + case .stagingAlpha: return 10 + case .stagingBeta: return 11 + case .transitioning: return 12 + case .saving: return 13 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [Synchronization_Status] = [ + .disconnected, + .haltedOnRootEmptied, + .haltedOnRootDeletion, + .haltedOnRootTypeChange, + .connectingAlpha, + .connectingBeta, + .watching, + .scanning, + .waitingForRescan, + .reconciling, + .stagingAlpha, + .stagingBeta, + .transitioning, + .saving, + ] + +} + +/// EndpointState encodes the current state of a synchronization endpoint. It is +/// mutable within the context of the daemon, so it should be accessed and +/// modified in a synchronized fashion. Outside of the daemon (e.g. when returned +/// via the API), it should be considered immutable. +struct Synchronization_EndpointState: Sendable { + // 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. + + /// Connected indicates whether or not the controller is currently connected + /// to the endpoint. + var connected: Bool = false + + /// Scanned indicates whether or not at least one scan has been performed on + /// the endpoint. + var scanned: Bool = false + + /// Directories is the number of synchronizable directory entries contained + /// in the last snapshot from the endpoint. + var directories: UInt64 = 0 + + /// Files is the number of synchronizable file entries contained in the last + /// snapshot from the endpoint. + var files: UInt64 = 0 + + /// SymbolicLinks is the number of synchronizable symbolic link entries + /// contained in the last snapshot from the endpoint. + var symbolicLinks: UInt64 = 0 + + /// TotalFileSize is the total size of all synchronizable files referenced by + /// the last snapshot from the endpoint. + var totalFileSize: UInt64 = 0 + + /// ScanProblems is the list of non-terminal problems encountered during the + /// last scanning operation on the endpoint. This list may be a truncated + /// version of the full list if too many problems are encountered to report + /// via the API, in which case ExcludedScanProblems will be non-zero. + var scanProblems: [Core_Problem] = [] + + /// ExcludedScanProblems is the number of problems that have been excluded + /// from ScanProblems due to truncation. This value can be non-zero only if + /// ScanProblems is non-empty. + var excludedScanProblems: UInt64 = 0 + + /// TransitionProblems is the list of non-terminal problems encountered + /// during the last transition operation on the endpoint. This list may be a + /// truncated version of the full list if too many problems are encountered + /// to report via the API, in which case ExcludedTransitionProblems will be + /// non-zero. + var transitionProblems: [Core_Problem] = [] + + /// ExcludedTransitionProblems is the number of problems that have been + /// excluded from TransitionProblems due to truncation. This value can be + /// non-zero only if TransitionProblems is non-empty. + var excludedTransitionProblems: UInt64 = 0 + + /// StagingProgress is the rsync staging progress. It is non-nil if and only + /// if the endpoint is currently staging files. + var stagingProgress: Rsync_ReceiverState { + get {return _stagingProgress ?? Rsync_ReceiverState()} + set {_stagingProgress = newValue} + } + /// Returns true if `stagingProgress` has been explicitly set. + var hasStagingProgress: Bool {return self._stagingProgress != nil} + /// Clears the value of `stagingProgress`. Subsequent reads from it will return its default value. + mutating func clearStagingProgress() {self._stagingProgress = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _stagingProgress: Rsync_ReceiverState? = nil +} + +/// State encodes the current state of a synchronization session. It is mutable +/// within the context of the daemon, so it should be accessed and modified in a +/// synchronized fashion. Outside of the daemon (e.g. when returned via the API), +/// it should be considered immutable. +struct Synchronization_State: @unchecked Sendable { + // 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. + + /// Session is the session metadata. If the session is paused, then the + /// remainder of the fields in this structure should be ignored. + var session: Synchronization_Session { + get {return _storage._session ?? Synchronization_Session()} + set {_uniqueStorage()._session = newValue} + } + /// Returns true if `session` has been explicitly set. + var hasSession: Bool {return _storage._session != nil} + /// Clears the value of `session`. Subsequent reads from it will return its default value. + mutating func clearSession() {_uniqueStorage()._session = nil} + + /// Status is the session status. + var status: Synchronization_Status { + get {return _storage._status} + set {_uniqueStorage()._status = newValue} + } + + /// LastError is the last error to occur during synchronization. It is + /// cleared after a successful synchronization cycle. + var lastError: String { + get {return _storage._lastError} + set {_uniqueStorage()._lastError = newValue} + } + + /// SuccessfulCycles is the number of successful synchronization cycles to + /// occur since successfully connecting to the endpoints. + var successfulCycles: UInt64 { + get {return _storage._successfulCycles} + set {_uniqueStorage()._successfulCycles = newValue} + } + + /// Conflicts are the content conflicts identified during reconciliation. + /// This list may be a truncated version of the full list if too many + /// conflicts are encountered to report via the API, in which case + /// ExcludedConflicts will be non-zero. + var conflicts: [Core_Conflict] { + get {return _storage._conflicts} + set {_uniqueStorage()._conflicts = newValue} + } + + /// ExcludedConflicts is the number of conflicts that have been excluded from + /// Conflicts due to truncation. This value can be non-zero only if conflicts + /// is non-empty. + var excludedConflicts: UInt64 { + get {return _storage._excludedConflicts} + set {_uniqueStorage()._excludedConflicts = newValue} + } + + /// AlphaState encodes the state of the alpha endpoint. It is always non-nil. + var alphaState: Synchronization_EndpointState { + get {return _storage._alphaState ?? Synchronization_EndpointState()} + set {_uniqueStorage()._alphaState = newValue} + } + /// Returns true if `alphaState` has been explicitly set. + var hasAlphaState: Bool {return _storage._alphaState != nil} + /// Clears the value of `alphaState`. Subsequent reads from it will return its default value. + mutating func clearAlphaState() {_uniqueStorage()._alphaState = nil} + + /// BetaState encodes the state of the beta endpoint. It is always non-nil. + var betaState: Synchronization_EndpointState { + get {return _storage._betaState ?? Synchronization_EndpointState()} + set {_uniqueStorage()._betaState = newValue} + } + /// Returns true if `betaState` has been explicitly set. + var hasBetaState: Bool {return _storage._betaState != nil} + /// Clears the value of `betaState`. Subsequent reads from it will return its default value. + mutating func clearBetaState() {_uniqueStorage()._betaState = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "synchronization" + +extension Synchronization_Status: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ + 0: .same(proto: "Disconnected"), + 1: .same(proto: "HaltedOnRootEmptied"), + 2: .same(proto: "HaltedOnRootDeletion"), + 3: .same(proto: "HaltedOnRootTypeChange"), + 4: .same(proto: "ConnectingAlpha"), + 5: .same(proto: "ConnectingBeta"), + 6: .same(proto: "Watching"), + 7: .same(proto: "Scanning"), + 8: .same(proto: "WaitingForRescan"), + 9: .same(proto: "Reconciling"), + 10: .same(proto: "StagingAlpha"), + 11: .same(proto: "StagingBeta"), + 12: .same(proto: "Transitioning"), + 13: .same(proto: "Saving"), + ] +} + +extension Synchronization_EndpointState: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".EndpointState" + static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ + 1: .same(proto: "connected"), + 2: .same(proto: "scanned"), + 3: .same(proto: "directories"), + 4: .same(proto: "files"), + 5: .same(proto: "symbolicLinks"), + 6: .same(proto: "totalFileSize"), + 7: .same(proto: "scanProblems"), + 8: .same(proto: "excludedScanProblems"), + 9: .same(proto: "transitionProblems"), + 10: .same(proto: "excludedTransitionProblems"), + 11: .same(proto: "stagingProgress"), + ] + + mutating func decodeMessage(decoder: inout D) throws { + while let fieldNumber = try decoder.nextFieldNumber() { + // The use of inline closures is to circumvent an issue where the compiler + // allocates stack space for every case branch when no optimizations are + // enabled. https://github.com/apple/swift-protobuf/issues/1034 + switch fieldNumber { + case 1: try { try decoder.decodeSingularBoolField(value: &self.connected) }() + case 2: try { try decoder.decodeSingularBoolField(value: &self.scanned) }() + case 3: try { try decoder.decodeSingularUInt64Field(value: &self.directories) }() + case 4: try { try decoder.decodeSingularUInt64Field(value: &self.files) }() + case 5: try { try decoder.decodeSingularUInt64Field(value: &self.symbolicLinks) }() + case 6: try { try decoder.decodeSingularUInt64Field(value: &self.totalFileSize) }() + case 7: try { try decoder.decodeRepeatedMessageField(value: &self.scanProblems) }() + case 8: try { try decoder.decodeSingularUInt64Field(value: &self.excludedScanProblems) }() + case 9: try { try decoder.decodeRepeatedMessageField(value: &self.transitionProblems) }() + case 10: try { try decoder.decodeSingularUInt64Field(value: &self.excludedTransitionProblems) }() + case 11: try { try decoder.decodeSingularMessageField(value: &self._stagingProgress) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + // The use of inline closures is to circumvent an issue where the compiler + // allocates stack space for every if/case branch local when no optimizations + // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and + // https://github.com/apple/swift-protobuf/issues/1182 + if self.connected != false { + try visitor.visitSingularBoolField(value: self.connected, fieldNumber: 1) + } + if self.scanned != false { + try visitor.visitSingularBoolField(value: self.scanned, fieldNumber: 2) + } + if self.directories != 0 { + try visitor.visitSingularUInt64Field(value: self.directories, fieldNumber: 3) + } + if self.files != 0 { + try visitor.visitSingularUInt64Field(value: self.files, fieldNumber: 4) + } + if self.symbolicLinks != 0 { + try visitor.visitSingularUInt64Field(value: self.symbolicLinks, fieldNumber: 5) + } + if self.totalFileSize != 0 { + try visitor.visitSingularUInt64Field(value: self.totalFileSize, fieldNumber: 6) + } + if !self.scanProblems.isEmpty { + try visitor.visitRepeatedMessageField(value: self.scanProblems, fieldNumber: 7) + } + if self.excludedScanProblems != 0 { + try visitor.visitSingularUInt64Field(value: self.excludedScanProblems, fieldNumber: 8) + } + if !self.transitionProblems.isEmpty { + try visitor.visitRepeatedMessageField(value: self.transitionProblems, fieldNumber: 9) + } + if self.excludedTransitionProblems != 0 { + try visitor.visitSingularUInt64Field(value: self.excludedTransitionProblems, fieldNumber: 10) + } + try { if let v = self._stagingProgress { + try visitor.visitSingularMessageField(value: v, fieldNumber: 11) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Synchronization_EndpointState, rhs: Synchronization_EndpointState) -> Bool { + if lhs.connected != rhs.connected {return false} + if lhs.scanned != rhs.scanned {return false} + if lhs.directories != rhs.directories {return false} + if lhs.files != rhs.files {return false} + if lhs.symbolicLinks != rhs.symbolicLinks {return false} + if lhs.totalFileSize != rhs.totalFileSize {return false} + if lhs.scanProblems != rhs.scanProblems {return false} + if lhs.excludedScanProblems != rhs.excludedScanProblems {return false} + if lhs.transitionProblems != rhs.transitionProblems {return false} + if lhs.excludedTransitionProblems != rhs.excludedTransitionProblems {return false} + if lhs._stagingProgress != rhs._stagingProgress {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Synchronization_State: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".State" + static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ + 1: .same(proto: "session"), + 2: .same(proto: "status"), + 3: .same(proto: "lastError"), + 4: .same(proto: "successfulCycles"), + 5: .same(proto: "conflicts"), + 6: .same(proto: "excludedConflicts"), + 7: .same(proto: "alphaState"), + 8: .same(proto: "betaState"), + ] + + fileprivate class _StorageClass { + var _session: Synchronization_Session? = nil + var _status: Synchronization_Status = .disconnected + var _lastError: String = String() + var _successfulCycles: UInt64 = 0 + var _conflicts: [Core_Conflict] = [] + var _excludedConflicts: UInt64 = 0 + var _alphaState: Synchronization_EndpointState? = nil + var _betaState: Synchronization_EndpointState? = nil + + #if swift(>=5.10) + // This property is used as the initial default value for new instances of the type. + // The type itself is protecting the reference to its storage via CoW semantics. + // This will force a copy to be made of this reference when the first mutation occurs; + // hence, it is safe to mark this as `nonisolated(unsafe)`. + static nonisolated(unsafe) let defaultInstance = _StorageClass() + #else + static let defaultInstance = _StorageClass() + #endif + + private init() {} + + init(copying source: _StorageClass) { + _session = source._session + _status = source._status + _lastError = source._lastError + _successfulCycles = source._successfulCycles + _conflicts = source._conflicts + _excludedConflicts = source._excludedConflicts + _alphaState = source._alphaState + _betaState = source._betaState + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(decoder: inout D) throws { + _ = _uniqueStorage() + try withExtendedLifetime(_storage) { (_storage: _StorageClass) in + while let fieldNumber = try decoder.nextFieldNumber() { + // The use of inline closures is to circumvent an issue where the compiler + // allocates stack space for every case branch when no optimizations are + // enabled. https://github.com/apple/swift-protobuf/issues/1034 + switch fieldNumber { + case 1: try { try decoder.decodeSingularMessageField(value: &_storage._session) }() + case 2: try { try decoder.decodeSingularEnumField(value: &_storage._status) }() + case 3: try { try decoder.decodeSingularStringField(value: &_storage._lastError) }() + case 4: try { try decoder.decodeSingularUInt64Field(value: &_storage._successfulCycles) }() + case 5: try { try decoder.decodeRepeatedMessageField(value: &_storage._conflicts) }() + case 6: try { try decoder.decodeSingularUInt64Field(value: &_storage._excludedConflicts) }() + case 7: try { try decoder.decodeSingularMessageField(value: &_storage._alphaState) }() + case 8: try { try decoder.decodeSingularMessageField(value: &_storage._betaState) }() + default: break + } + } + } + } + + func traverse(visitor: inout V) throws { + try withExtendedLifetime(_storage) { (_storage: _StorageClass) in + // The use of inline closures is to circumvent an issue where the compiler + // allocates stack space for every if/case branch local when no optimizations + // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and + // https://github.com/apple/swift-protobuf/issues/1182 + try { if let v = _storage._session { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + if _storage._status != .disconnected { + try visitor.visitSingularEnumField(value: _storage._status, fieldNumber: 2) + } + if !_storage._lastError.isEmpty { + try visitor.visitSingularStringField(value: _storage._lastError, fieldNumber: 3) + } + if _storage._successfulCycles != 0 { + try visitor.visitSingularUInt64Field(value: _storage._successfulCycles, fieldNumber: 4) + } + if !_storage._conflicts.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._conflicts, fieldNumber: 5) + } + if _storage._excludedConflicts != 0 { + try visitor.visitSingularUInt64Field(value: _storage._excludedConflicts, fieldNumber: 6) + } + try { if let v = _storage._alphaState { + try visitor.visitSingularMessageField(value: v, fieldNumber: 7) + } }() + try { if let v = _storage._betaState { + try visitor.visitSingularMessageField(value: v, fieldNumber: 8) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Synchronization_State, rhs: Synchronization_State) -> 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._session != rhs_storage._session {return false} + if _storage._status != rhs_storage._status {return false} + if _storage._lastError != rhs_storage._lastError {return false} + if _storage._successfulCycles != rhs_storage._successfulCycles {return false} + if _storage._conflicts != rhs_storage._conflicts {return false} + if _storage._excludedConflicts != rhs_storage._excludedConflicts {return false} + if _storage._alphaState != rhs_storage._alphaState {return false} + if _storage._betaState != rhs_storage._betaState {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_state.proto b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_state.proto new file mode 100644 index 0000000..78c918d --- /dev/null +++ b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_state.proto @@ -0,0 +1,159 @@ +/* + * This file was taken from + * https://github.com/mutagen-io/mutagen/tree/v0.18.1/pkg/synchronization/state.proto + * + * MIT License + * + * Copyright (c) 2016-present Docker, Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +syntax = "proto3"; + +package synchronization; + +option go_package = "github.com/mutagen-io/mutagen/pkg/synchronization"; + +import "synchronization_rsync_receive.proto"; +import "synchronization_session.proto"; +import "synchronization_core_conflict.proto"; +import "synchronization_core_problem.proto"; + +// Status encodes the status of a synchronization session. +enum Status { + // Status_Disconnected indicates that the session is unpaused but not + // currently connected or connecting to either endpoint. + Disconnected = 0; + // Status_HaltedOnRootEmptied indicates that the session is halted due to + // the root emptying safety check. + HaltedOnRootEmptied = 1; + // Status_HaltedOnRootDeletion indicates that the session is halted due to + // the root deletion safety check. + HaltedOnRootDeletion = 2; + // Status_HaltedOnRootTypeChange indicates that the session is halted due to + // the root type change safety check. + HaltedOnRootTypeChange = 3; + // Status_ConnectingAlpha indicates that the session is attempting to + // connect to the alpha endpoint. + ConnectingAlpha = 4; + // Status_ConnectingBeta indicates that the session is attempting to connect + // to the beta endpoint. + ConnectingBeta = 5; + // Status_Watching indicates that the session is watching for filesystem + // changes. + Watching = 6; + // Status_Scanning indicates that the session is scanning the filesystem on + // each endpoint. + Scanning = 7; + // Status_WaitingForRescan indicates that the session is waiting to retry + // scanning after an error during the previous scanning operation. + WaitingForRescan = 8; + // Status_Reconciling indicates that the session is performing + // reconciliation. + Reconciling = 9; + // Status_StagingAlpha indicates that the session is staging files on alpha. + StagingAlpha = 10; + // Status_StagingBeta indicates that the session is staging files on beta. + StagingBeta = 11; + // Status_Transitioning indicates that the session is performing transition + // operations on each endpoint. + Transitioning = 12; + // Status_Saving indicates that the session is recording synchronization + // history to disk. + Saving = 13; +} + +// EndpointState encodes the current state of a synchronization endpoint. It is +// mutable within the context of the daemon, so it should be accessed and +// modified in a synchronized fashion. Outside of the daemon (e.g. when returned +// via the API), it should be considered immutable. +message EndpointState { + // Connected indicates whether or not the controller is currently connected + // to the endpoint. + bool connected = 1; + // Scanned indicates whether or not at least one scan has been performed on + // the endpoint. + bool scanned = 2; + // Directories is the number of synchronizable directory entries contained + // in the last snapshot from the endpoint. + uint64 directories = 3; + // Files is the number of synchronizable file entries contained in the last + // snapshot from the endpoint. + uint64 files = 4; + // SymbolicLinks is the number of synchronizable symbolic link entries + // contained in the last snapshot from the endpoint. + uint64 symbolicLinks = 5; + // TotalFileSize is the total size of all synchronizable files referenced by + // the last snapshot from the endpoint. + uint64 totalFileSize = 6; + // ScanProblems is the list of non-terminal problems encountered during the + // last scanning operation on the endpoint. This list may be a truncated + // version of the full list if too many problems are encountered to report + // via the API, in which case ExcludedScanProblems will be non-zero. + repeated core.Problem scanProblems = 7; + // ExcludedScanProblems is the number of problems that have been excluded + // from ScanProblems due to truncation. This value can be non-zero only if + // ScanProblems is non-empty. + uint64 excludedScanProblems = 8; + // TransitionProblems is the list of non-terminal problems encountered + // during the last transition operation on the endpoint. This list may be a + // truncated version of the full list if too many problems are encountered + // to report via the API, in which case ExcludedTransitionProblems will be + // non-zero. + repeated core.Problem transitionProblems = 9; + // ExcludedTransitionProblems is the number of problems that have been + // excluded from TransitionProblems due to truncation. This value can be + // non-zero only if TransitionProblems is non-empty. + uint64 excludedTransitionProblems = 10; + // StagingProgress is the rsync staging progress. It is non-nil if and only + // if the endpoint is currently staging files. + rsync.ReceiverState stagingProgress = 11; +} + +// State encodes the current state of a synchronization session. It is mutable +// within the context of the daemon, so it should be accessed and modified in a +// synchronized fashion. Outside of the daemon (e.g. when returned via the API), +// it should be considered immutable. +message State { + // Session is the session metadata. If the session is paused, then the + // remainder of the fields in this structure should be ignored. + Session session = 1; + // Status is the session status. + Status status = 2; + // LastError is the last error to occur during synchronization. It is + // cleared after a successful synchronization cycle. + string lastError = 3; + // SuccessfulCycles is the number of successful synchronization cycles to + // occur since successfully connecting to the endpoints. + uint64 successfulCycles = 4; + // Conflicts are the content conflicts identified during reconciliation. + // This list may be a truncated version of the full list if too many + // conflicts are encountered to report via the API, in which case + // ExcludedConflicts will be non-zero. + repeated core.Conflict conflicts = 5; + // ExcludedConflicts is the number of conflicts that have been excluded from + // Conflicts due to truncation. This value can be non-zero only if conflicts + // is non-empty. + uint64 excludedConflicts = 6; + // AlphaState encodes the state of the alpha endpoint. It is always non-nil. + EndpointState alphaState = 7; + // BetaState encodes the state of the beta endpoint. It is always non-nil. + EndpointState betaState = 8; +} diff --git a/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_version.pb.swift b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_version.pb.swift new file mode 100644 index 0000000..d62b116 --- /dev/null +++ b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_version.pb.swift @@ -0,0 +1,98 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: synchronization_version.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// +// This file was taken from +// https://github.com/mutagen-io/mutagen/tree/v0.18.1/pkg/synchronization/version.proto +// +// MIT License +// +// Copyright (c) 2016-present Docker, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. + +import SwiftProtobuf + +// If the compiler emits an error on this type, it is because this file +// was generated by a version of the `protoc` Swift plug-in that is +// incompatible with the version of SwiftProtobuf to which you are linking. +// Please ensure that you are building against the same version of the API +// that was used to generate this file. +fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAPIVersionCheck { + struct _2: SwiftProtobuf.ProtobufAPIVersion_2 {} + typealias Version = _2 +} + +/// Version specifies a session version, providing default behavior that can vary +/// without affecting existing sessions. +enum Synchronization_Version: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + + /// Invalid is the default session version and represents an unspecfied and + /// invalid version. It is used as a sanity check to ensure that version is + /// set for a session. + case invalid // = 0 + + /// Version1 represents session version 1. + case version1 // = 1 + case UNRECOGNIZED(Int) + + init() { + self = .invalid + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .invalid + case 1: self = .version1 + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .invalid: return 0 + case .version1: return 1 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [Synchronization_Version] = [ + .invalid, + .version1, + ] + +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +extension Synchronization_Version: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ + 0: .same(proto: "Invalid"), + 1: .same(proto: "Version1"), + ] +} diff --git a/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_version.proto b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_version.proto new file mode 100644 index 0000000..9c5c296 --- /dev/null +++ b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_version.proto @@ -0,0 +1,43 @@ +/* + * This file was taken from + * https://github.com/mutagen-io/mutagen/tree/v0.18.1/pkg/synchronization/version.proto + * + * MIT License + * + * Copyright (c) 2016-present Docker, Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +syntax = "proto3"; + +package synchronization; + +option go_package = "github.com/mutagen-io/mutagen/pkg/synchronization"; + +// Version specifies a session version, providing default behavior that can vary +// without affecting existing sessions. +enum Version { + // Invalid is the default session version and represents an unspecfied and + // invalid version. It is used as a sanity check to ensure that version is + // set for a session. + Invalid = 0; + // Version1 represents session version 1. + Version1 = 1; +} diff --git a/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_watch_mode.pb.swift b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_watch_mode.pb.swift new file mode 100644 index 0000000..7836b35 --- /dev/null +++ b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_watch_mode.pb.swift @@ -0,0 +1,118 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: synchronization_watch_mode.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// +// This file was taken from +// https://github.com/mutagen-io/mutagen/tree/v0.18.1/pkg/synchronization/watch_mode.proto +// +// MIT License +// +// Copyright (c) 2016-present Docker, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. + +import SwiftProtobuf + +// If the compiler emits an error on this type, it is because this file +// was generated by a version of the `protoc` Swift plug-in that is +// incompatible with the version of SwiftProtobuf to which you are linking. +// Please ensure that you are building against the same version of the API +// that was used to generate this file. +fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAPIVersionCheck { + struct _2: SwiftProtobuf.ProtobufAPIVersion_2 {} + typealias Version = _2 +} + +/// WatchMode specifies the mode for filesystem watching. +enum Synchronization_WatchMode: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + + /// WatchMode_WatchModeDefault represents an unspecified watch mode. It + /// should be converted to one of the following values based on the desired + /// default behavior. + case `default` // = 0 + + /// WatchMode_WatchModePortable specifies that native recursive watching + /// should be used to monitor paths on systems that support it if those paths + /// fall under the home directory. In these cases, a watch on the entire home + /// directory is established and filtered for events pertaining to the + /// specified path. On all other systems and for all other paths, poll-based + /// watching is used. + case portable // = 1 + + /// WatchMode_WatchModeForcePoll specifies that only poll-based watching + /// should be used. + case forcePoll // = 2 + + /// WatchMode_WatchModeNoWatch specifies that no watching should be used + /// (i.e. no events should be generated). + case noWatch // = 3 + case UNRECOGNIZED(Int) + + init() { + self = .default + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .default + case 1: self = .portable + case 2: self = .forcePoll + case 3: self = .noWatch + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .default: return 0 + case .portable: return 1 + case .forcePoll: return 2 + case .noWatch: return 3 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [Synchronization_WatchMode] = [ + .default, + .portable, + .forcePoll, + .noWatch, + ] + +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +extension Synchronization_WatchMode: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ + 0: .same(proto: "WatchModeDefault"), + 1: .same(proto: "WatchModePortable"), + 2: .same(proto: "WatchModeForcePoll"), + 3: .same(proto: "WatchModeNoWatch"), + ] +} diff --git a/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_watch_mode.proto b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_watch_mode.proto new file mode 100644 index 0000000..1fedd86 --- /dev/null +++ b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/synchronization_watch_mode.proto @@ -0,0 +1,53 @@ +/* + * This file was taken from + * https://github.com/mutagen-io/mutagen/tree/v0.18.1/pkg/synchronization/watch_mode.proto + * + * MIT License + * + * Copyright (c) 2016-present Docker, Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +syntax = "proto3"; + +package synchronization; + +option go_package = "github.com/mutagen-io/mutagen/pkg/synchronization"; + +// WatchMode specifies the mode for filesystem watching. +enum WatchMode { + // WatchMode_WatchModeDefault represents an unspecified watch mode. It + // should be converted to one of the following values based on the desired + // default behavior. + WatchModeDefault = 0; + // WatchMode_WatchModePortable specifies that native recursive watching + // should be used to monitor paths on systems that support it if those paths + // fall under the home directory. In these cases, a watch on the entire home + // directory is established and filtered for events pertaining to the + // specified path. On all other systems and for all other paths, poll-based + // watching is used. + WatchModePortable = 1; + // WatchMode_WatchModeForcePoll specifies that only poll-based watching + // should be used. + WatchModeForcePoll = 2; + // WatchMode_WatchModeNoWatch specifies that no watching should be used + // (i.e. no events should be generated). + WatchModeNoWatch = 3; +} diff --git a/Coder-Desktop/VPNLib/FileSync/MutagenSDK/url_url.pb.swift b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/url_url.pb.swift new file mode 100644 index 0000000..32a305e --- /dev/null +++ b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/url_url.pb.swift @@ -0,0 +1,266 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: url_url.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// +// This file was taken from +// https://github.com/mutagen-io/mutagen/tree/v0.18.1/pkg/url/url.proto +// +// MIT License +// +// Copyright (c) 2016-present Docker, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. + +import SwiftProtobuf + +// If the compiler emits an error on this type, it is because this file +// was generated by a version of the `protoc` Swift plug-in that is +// incompatible with the version of SwiftProtobuf to which you are linking. +// Please ensure that you are building against the same version of the API +// that was used to generate this file. +fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAPIVersionCheck { + struct _2: SwiftProtobuf.ProtobufAPIVersion_2 {} + typealias Version = _2 +} + +/// Kind indicates the kind of a URL. +enum Url_Kind: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + + /// Synchronization indicates a synchronization URL. + case synchronization // = 0 + + /// Forwarding indicates a forwarding URL. + case forwarding // = 1 + case UNRECOGNIZED(Int) + + init() { + self = .synchronization + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .synchronization + case 1: self = .forwarding + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .synchronization: return 0 + case .forwarding: return 1 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [Url_Kind] = [ + .synchronization, + .forwarding, + ] + +} + +/// Protocol indicates a location type. +enum Url_Protocol: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + + /// Local indicates that the resource is on the local system. + case local // = 0 + + /// SSH indicates that the resource is accessible via SSH. + case ssh // = 1 + + /// Docker indicates that the resource is inside a Docker container. + case docker // = 11 + case UNRECOGNIZED(Int) + + init() { + self = .local + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .local + case 1: self = .ssh + case 11: self = .docker + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .local: return 0 + case .ssh: return 1 + case .docker: return 11 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [Url_Protocol] = [ + .local, + .ssh, + .docker, + ] + +} + +/// URL represents a pointer to a resource. It should be considered immutable. +struct Url_URL: Sendable { + // 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. + + /// Kind indicates the URL kind. + /// NOTE: This field number is out of order for historical reasons. + var kind: Url_Kind = .synchronization + + /// Protocol indicates a location type. + var `protocol`: Url_Protocol = .local + + /// User is the user under which a resource should be accessed. + var user: String = String() + + /// Host is protocol-specific, but generally indicates the location of the + /// remote. + var host: String = String() + + /// Port indicates a TCP port via which to access the remote location, if + /// applicable. + var port: UInt32 = 0 + + /// Path indicates the path of a resource. + var path: String = String() + + /// Environment contains captured environment variable information. It is not + /// a required component and its contents and their behavior depend on the + /// transport implementation. + var environment: Dictionary = [:] + + /// Parameters are internal transport parameters. These are set for URLs + /// generated internally that require additional metadata. Parameters are not + /// required and their behavior is dependent on the transport implementation. + var parameters: Dictionary = [:] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "url" + +extension Url_Kind: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ + 0: .same(proto: "Synchronization"), + 1: .same(proto: "Forwarding"), + ] +} + +extension Url_Protocol: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ + 0: .same(proto: "Local"), + 1: .same(proto: "SSH"), + 11: .same(proto: "Docker"), + ] +} + +extension Url_URL: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".URL" + static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ + 7: .same(proto: "kind"), + 1: .same(proto: "protocol"), + 2: .same(proto: "user"), + 3: .same(proto: "host"), + 4: .same(proto: "port"), + 5: .same(proto: "path"), + 6: .same(proto: "environment"), + 8: .same(proto: "parameters"), + ] + + mutating func decodeMessage(decoder: inout D) throws { + while let fieldNumber = try decoder.nextFieldNumber() { + // The use of inline closures is to circumvent an issue where the compiler + // allocates stack space for every case branch when no optimizations are + // enabled. https://github.com/apple/swift-protobuf/issues/1034 + switch fieldNumber { + case 1: try { try decoder.decodeSingularEnumField(value: &self.`protocol`) }() + case 2: try { try decoder.decodeSingularStringField(value: &self.user) }() + case 3: try { try decoder.decodeSingularStringField(value: &self.host) }() + case 4: try { try decoder.decodeSingularUInt32Field(value: &self.port) }() + case 5: try { try decoder.decodeSingularStringField(value: &self.path) }() + case 6: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &self.environment) }() + case 7: try { try decoder.decodeSingularEnumField(value: &self.kind) }() + case 8: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &self.parameters) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.`protocol` != .local { + try visitor.visitSingularEnumField(value: self.`protocol`, fieldNumber: 1) + } + if !self.user.isEmpty { + try visitor.visitSingularStringField(value: self.user, fieldNumber: 2) + } + if !self.host.isEmpty { + try visitor.visitSingularStringField(value: self.host, fieldNumber: 3) + } + if self.port != 0 { + try visitor.visitSingularUInt32Field(value: self.port, fieldNumber: 4) + } + if !self.path.isEmpty { + try visitor.visitSingularStringField(value: self.path, fieldNumber: 5) + } + if !self.environment.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: self.environment, fieldNumber: 6) + } + if self.kind != .synchronization { + try visitor.visitSingularEnumField(value: self.kind, fieldNumber: 7) + } + if !self.parameters.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: self.parameters, fieldNumber: 8) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Url_URL, rhs: Url_URL) -> Bool { + if lhs.kind != rhs.kind {return false} + if lhs.`protocol` != rhs.`protocol` {return false} + if lhs.user != rhs.user {return false} + if lhs.host != rhs.host {return false} + if lhs.port != rhs.port {return false} + if lhs.path != rhs.path {return false} + if lhs.environment != rhs.environment {return false} + if lhs.parameters != rhs.parameters {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Coder-Desktop/VPNLib/FileSync/MutagenSDK/url_url.proto b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/url_url.proto new file mode 100644 index 0000000..27cc4c0 --- /dev/null +++ b/Coder-Desktop/VPNLib/FileSync/MutagenSDK/url_url.proto @@ -0,0 +1,90 @@ +/* + * This file was taken from + * https://github.com/mutagen-io/mutagen/tree/v0.18.1/pkg/url/url.proto + * + * MIT License + * + * Copyright (c) 2016-present Docker, Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +syntax = "proto3"; + +package url; + +option go_package = "github.com/mutagen-io/mutagen/pkg/url"; + +// Kind indicates the kind of a URL. +enum Kind { + // Synchronization indicates a synchronization URL. + Synchronization = 0; + // Forwarding indicates a forwarding URL. + Forwarding = 1; +} + +// Protocol indicates a location type. +enum Protocol { + // Local indicates that the resource is on the local system. + Local = 0; + // SSH indicates that the resource is accessible via SSH. + SSH = 1; + + // Enumeration value 2 is reserved for custom protocols. + + // Enumeration value 3 was previously used for the mutagen.io-based tunnel + // protocol. This protocol was experimental and only available as part of + // the v0.11.x release series. It should not be re-used. + + // Enumeration values 4-10 are reserved for core protocols. + + // Docker indicates that the resource is inside a Docker container. + Docker = 11; +} + +// URL represents a pointer to a resource. It should be considered immutable. +message URL { + // Kind indicates the URL kind. + // NOTE: This field number is out of order for historical reasons. + Kind kind = 7; + // Protocol indicates a location type. + Protocol protocol = 1; + // User is the user under which a resource should be accessed. + string user = 2; + // Host is protocol-specific, but generally indicates the location of the + // remote. + string host = 3; + // Port indicates a TCP port via which to access the remote location, if + // applicable. + uint32 port = 4; + // Path indicates the path of a resource. + string path = 5; + // Environment contains captured environment variable information. It is not + // a required component and its contents and their behavior depend on the + // transport implementation. + map environment = 6; + + // Field 7 is already used above for the kind field. It is out of order for + // historical reasons. + + // Parameters are internal transport parameters. These are set for URLs + // generated internally that require additional metadata. Parameters are not + // required and their behavior is dependent on the transport implementation. + map parameters = 8; +} diff --git a/Coder-Desktop/VPNLib/FileSync/daemon.pb.swift b/Coder-Desktop/VPNLib/FileSync/daemon.pb.swift deleted file mode 100644 index 047ca50..0000000 --- a/Coder-Desktop/VPNLib/FileSync/daemon.pb.swift +++ /dev/null @@ -1,83 +0,0 @@ -// DO NOT EDIT. -// swift-format-ignore-file -// swiftlint:disable all -// -// Generated by the Swift generator plugin for the protocol buffer compiler. -// Source: Coder-Desktop/VPNLib/FileSync/daemon.proto -// -// For information on using the generated types, please see the documentation: -// https://github.com/apple/swift-protobuf/ - -import SwiftProtobuf - -// If the compiler emits an error on this type, it is because this file -// was generated by a version of the `protoc` Swift plug-in that is -// incompatible with the version of SwiftProtobuf to which you are linking. -// Please ensure that you are building against the same version of the API -// that was used to generate this file. -fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAPIVersionCheck { - struct _2: SwiftProtobuf.ProtobufAPIVersion_2 {} - typealias Version = _2 -} - -struct Daemon_TerminateRequest: Sendable { - // 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 unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} -} - -struct Daemon_TerminateResponse: Sendable { - // 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 unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} -} - -// MARK: - Code below here is support for the SwiftProtobuf runtime. - -fileprivate let _protobuf_package = "daemon" - -extension Daemon_TerminateRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TerminateRequest" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - // Load everything into unknown fields - while try decoder.nextFieldNumber() != nil {} - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: Daemon_TerminateRequest, rhs: Daemon_TerminateRequest) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension Daemon_TerminateResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TerminateResponse" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - // Load everything into unknown fields - while try decoder.nextFieldNumber() != nil {} - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: Daemon_TerminateResponse, rhs: Daemon_TerminateResponse) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} diff --git a/Coder-Desktop/VPNLib/FileSync/daemon.proto b/Coder-Desktop/VPNLib/FileSync/daemon.proto deleted file mode 100644 index 4431b35..0000000 --- a/Coder-Desktop/VPNLib/FileSync/daemon.proto +++ /dev/null @@ -1,11 +0,0 @@ -syntax = "proto3"; - -package daemon; - -message TerminateRequest{} - -message TerminateResponse{} - -service Daemon { - rpc Terminate(TerminateRequest) returns (TerminateResponse) {} -} diff --git a/Makefile b/Makefile index 14faf6d..ebb8e38 100644 --- a/Makefile +++ b/Makefile @@ -20,6 +20,9 @@ SCHEME := Coder\ Desktop TEST_PLAN := Coder-Desktop SWIFT_VERSION := 6.0 +MUTAGEN_PROTO_DEFS := $(shell find $(PROJECT)/VPNLib/FileSync/MutagenSDK -type f -name '*.proto' -print) +MUTAGEN_PROTO_SWIFTS := $(patsubst %.proto,%.pb.swift,$(MUTAGEN_PROTO_DEFS)) + MUTAGEN_RESOURCES := mutagen-agents.tar.gz mutagen-darwin-arm64 mutagen-darwin-amd64 ifndef MUTAGEN_VERSION MUTAGEN_VERSION:=$(shell grep -E '^v[0-9]+\.[0-9]+\.[0-9]+$$' $(PROJECT)/Resources/.mutagenversion) @@ -52,7 +55,7 @@ setup: \ $(addprefix $(PROJECT)/Resources/,$(MUTAGEN_RESOURCES)) \ $(XCPROJECT) \ $(PROJECT)/VPNLib/vpn.pb.swift \ - $(PROJECT)/VPNLib/FileSync/daemon.pb.swift + $(MUTAGEN_PROTO_SWIFTS) # Mutagen resources $(addprefix $(PROJECT)/Resources/,$(MUTAGEN_RESOURCES)): $(PROJECT)/Resources/.mutagenversion @@ -72,11 +75,12 @@ $(XCPROJECT): $(PROJECT)/project.yml $(PROJECT)/VPNLib/vpn.pb.swift: $(PROJECT)/VPNLib/vpn.proto protoc --swift_opt=Visibility=public --swift_out=. 'Coder-Desktop/VPNLib/vpn.proto' -$(PROJECT)/VPNLib/FileSync/daemon.pb.swift: $(PROJECT)/VPNLib/FileSync/daemon.proto +$(MUTAGEN_PROTO_SWIFTS): protoc \ - --swift_out=.\ - --grpc-swift_out=. \ - 'Coder-Desktop/VPNLib/FileSync/daemon.proto' + -I=$(PROJECT)/VPNLib/FileSync/MutagenSDK \ + --swift_out=$(PROJECT)/VPNLib/FileSync/MutagenSDK \ + --grpc-swift_out=$(PROJECT)/VPNLib/FileSync/MutagenSDK \ + $(patsubst %.pb.swift,%.proto,$@) $(KEYCHAIN_FILE): security create-keychain -p "" "$(APP_SIGNING_KEYCHAIN)" @@ -164,7 +168,7 @@ clean/mutagen: find $(PROJECT)/Resources -name 'mutagen-*' -delete .PHONY: proto -proto: $(PROJECT)/VPNLib/vpn.pb.swift $(PROJECT)/VPNLib/FileSync/daemon.pb.swift ## Generate Swift files from protobufs +proto: $(PROJECT)/VPNLib/vpn.pb.swift $(MUTAGEN_PROTO_SWIFTS) ## Generate Swift files from protobufs .PHONY: help help: ## Show this help diff --git a/scripts/mutagen-proto.sh b/scripts/mutagen-proto.sh new file mode 100755 index 0000000..4fc6cf6 --- /dev/null +++ b/scripts/mutagen-proto.sh @@ -0,0 +1,142 @@ +#!/usr/bin/env bash + +# This script vendors the Mutagen proto files from a tag on a Mutagen GitHub repo. +# It is very similar to `Update-Proto.ps1` on `coder/coder-desktop-windows`. +# It's very unlikely that we'll use this script regularly. +# +# Unlike the Go compiler, the Swift compiler does not support multiple files +# with the same name in different directories. +# To handle this, this script flattens the directory structure of the proto +# files into the filename, i.e. `service/synchronization/synchronization.proto` +# becomes `service_synchronization_synchronization.proto`. +# It also updates the proto imports to use these paths. + +set -euo pipefail + +if [ $# -ne 1 ]; then + echo "Usage: $0 " + exit 1 +fi + +mutagen_tag="$1" + +# TODO: Change this to `coder/mutagen` once we add a version tag there +repo="mutagen-io/mutagen" +proto_prefix="pkg" +# Right now, we only care about the synchronization and daemon management gRPC +entry_files=("service/synchronization/synchronization.proto" "service/daemon/daemon.proto") + +out_folder="Coder-Desktop/VPNLib/FileSync/MutagenSDK" + +clone_dir="/tmp/coder-desktop-mutagen-proto" +if [ -d "$clone_dir" ]; then + echo "Found existing mutagen repo at $clone_dir, checking out $mutagen_tag..." + pushd "$clone_dir" > /dev/null + git clean -fdx + + current_tag=$(git name-rev --name-only HEAD) + if [ "$current_tag" != "tags/$mutagen_tag" ]; then + git fetch --all + git checkout "$mutagen_tag" + fi + popd > /dev/null +else + mkdir -p "$clone_dir" + echo "Cloning mutagen repo to $clone_dir..." + git clone --depth 1 --branch "$mutagen_tag" "https://github.com/$repo.git" "$clone_dir" +fi + +# Extract MIT License header +mit_start_line=$(grep -n "^MIT License" "$clone_dir/LICENSE" | cut -d ":" -f 1) +if [ -z "$mit_start_line" ]; then + echo "Error: Failed to find MIT License header in Mutagen LICENSE file" + exit 1 +fi +license_header=$(sed -n "${mit_start_line},\$p" "$clone_dir/LICENSE" | sed 's/^/ * /') + +declare -A file_map=() +file_paths=() + +add_file() { + local filepath="$1" + local proto_path="${filepath#"$clone_dir"/"$proto_prefix"/}" + local flat_name + flat_name=$(echo "$proto_path" | sed 's/\//_/g') + + # Skip if already processed + if [[ -n "${file_map[$proto_path]:-}" ]]; then + return + fi + + echo "Adding $proto_path -> $flat_name" + file_map[$proto_path]=$flat_name + file_paths+=("$filepath") + + # Process imports + while IFS= read -r line; do + if [[ $line =~ ^import\ \"(.+)\" ]]; then + import_path="${BASH_REMATCH[1]}" + + # Ignore google imports, as they're not vendored + if [[ $import_path =~ ^google/ ]]; then + echo "Skipping $import_path" + continue + fi + + import_file_path="$clone_dir/$proto_prefix/$import_path" + if [ -f "$import_file_path" ]; then + add_file "$import_file_path" + else + echo "Error: Import $import_path not found" + exit 1 + fi + fi + done < "$filepath" +} + +for entry_file in "${entry_files[@]}"; do + entry_file_path="$clone_dir/$proto_prefix/$entry_file" + if [ ! -f "$entry_file_path" ]; then + echo "Error: Failed to find $entry_file_path in mutagen repo" + exit 1 + fi + add_file "$entry_file_path" +done + +mkdir -p "$out_folder" + +for file_path in "${file_paths[@]}"; do + proto_path="${file_path#"$clone_dir"/"$proto_prefix"/}" + flat_name="${file_map[$proto_path]}" + dst_path="$out_folder/$flat_name" + + cp -f "$file_path" "$dst_path" + + file_header="/*\n * This file was taken from\n * https://github.com/$repo/tree/$mutagen_tag/$proto_prefix/$proto_path\n *\n$license_header\n */\n\n" + content=$(cat "$dst_path") + echo -e "$file_header$content" > "$dst_path" + + tmp_file=$(mktemp) + while IFS= read -r line; do + if [[ $line =~ ^import\ \"(.+)\" ]]; then + import_path="${BASH_REMATCH[1]}" + + # Retain google imports + if [[ $import_path =~ ^google/ ]]; then + echo "$line" >> "$tmp_file" + continue + fi + + # Convert import path to flattened format + flat_import=$(echo "$import_path" | sed 's/\//_/g') + echo "import \"$flat_import\";" >> "$tmp_file" + else + echo "$line" >> "$tmp_file" + fi + done < "$dst_path" + mv "$tmp_file" "$dst_path" + + echo "Processed $proto_path -> $flat_name" +done + +echo "Successfully downloaded proto files from $mutagen_tag to $out_folder" \ No newline at end of file