exocore 0.1.2

Distributed applications framework
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

import SwiftUI
import Exocore

struct DiscoveryView: View {
    @EnvironmentObject var appState: AppState
    @StateObject var state: DiscoveryState = DiscoveryState()

    var body: some View {
        NavigationView {
            VStack {
                discoView()
                Spacer()
                errorView()
                Spacer()
                Button("Generate new node") {
                    appState.node = try? LocalNode.generate()
                    appState.refreshNodeConfig()
                    state.performJoinCell(appState)
                }
            }
            .navigationBarTitle("Cell discovery")
            .onAppear {
                state.performJoinCell(appState)
            }
        }
    }

    @ViewBuilder
    func discoView() -> some View {
        if let pin = state.pin {
            VStack {
                Text("Discovery PIN:")
                    .padding()
                Text(formatPin(pin))
                    .bold()
                    .font(.system(size: 30))
            }
        } else {
            Text("Joining...")
        }
    }

    func errorView() -> Text? {
        if let err = self.state.error {
            return Text("Error: \(err)").foregroundColor(.red)
        }

        return appState.currentError.map {
            Text("Error: \($0)").foregroundColor(.red)
        }
    }
}

class DiscoveryState: ObservableObject {
    private var discovery: Discovery?
    @Published var pin: UInt32?
    @Published var error: String?

    func performJoinCell(_ appState: AppState) {
        guard let node = appState.node else {
            self.error = "No node configured"
            return
        }

        do {
            let discovery = try Discovery()
            self.discovery = discovery
            self.pin = nil
            self.error = nil

            discovery.joinCell(localNode: node) { [weak self] (stage) in
                DispatchQueue.main.async {
                    switch stage {
                    case .pin(let pin):
                        self?.pin = pin
                    case .success(let newNode):
                        appState.node = newNode
                        appState.forceDiscovery = false
                        appState.refreshNodeConfig()
                    case .error(let err):
                        self?.error = err.localizedDescription
                    }
                }
            }
        } catch {
            self.error = error.localizedDescription
        }
    }
}

private func formatPin(_ pin: UInt32) -> String {
    let strPin = pin.description

    var ret = ""
    for (i, char) in strPin.enumerated() {
        if i == 3 || i == 6 {
            ret += " "
        }
        ret += String(char)
    }
    return ret
}

#if DEBUG
struct BootstrapView_Previews: PreviewProvider {
    static var previews: some View {
        DiscoveryView()
    }
}
#endif