DAG-chain/Program.fs at master · mrLSD/DAG-chain · GitHub

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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
/// DAG chain implementation

open System
open System.Text
open DAG
open DAG.Bootstrap
open DAG.State
open DAG.Storage
open System.Net
open DAG.Log
open Utils

let addr = "127.0.0.1"
let port = 3000

let client() =
    let connect = new Sockets.TcpClient()
    connect.Connect(addr, port)
    connect

let listener() = Sockets.TcpListener(IPAddress.Parse(addr), port)

let rec listen(tcpClient: Sockets.TcpClient) = async {
    if tcpClient.Connected then
        Logger.Debug("listen")
        let stream = tcpClient.GetStream()

        Logger.Debug("listen Read")
        let rec data ()  = async {
            let dataLen = (16 * 1024)
            let buffer = Array.zeroCreate dataLen
            let msg = StringBuilder()
            let! len = stream.ReadAsync(buffer, 0, dataLen) |> Async.AwaitTask
            if stream.DataAvailable && len > 0 then
                return msg.Append(BytesToStringLength(buffer, len)).Append(data())
            else
                return msg.Append(BytesToStringLength(buffer, len))
        }
        let! msgData = data()
        Logger.Debug("[{read}] {msg}", msgData.Length, msgData)
        if msgData.Length = 0 then
            stream.Close()
            tcpClient.Close()

        try
            let msg = StringToBytes (sprintf "Time: %O" DateTime.Now.TimeOfDay)
            do! stream.WriteAsync(msg, 0, msg.Length) |> Async.AwaitTask
            Logger.Debug("listen sent {msg}", BytesToString msg)
        with
            | err ->
                Logger.Debug("Connection closed")
                stream.Close()
                tcpClient.Close()
        return! listen(tcpClient) |> Async.Ignore
}

let listenerFlow() = async {
    try
        let listener = listener()
        listener.Start()
        while true do
            do! listen(listener.AcceptTcpClient())
            Logger.Information("New AcceptTcpClient")
    with
        | err -> Logger.Error(err, "listenerFlow")
}

let Client() =
    let connect = new Sockets.TcpClient()
    connect.Connect(addr, port)
    connect

let rec sendClient(stream: Sockets.NetworkStream) = async {
    Logger.Debug("sendClient")
    let mutable sent = false
    let! _= Async.StartChild(async{
        Logger.Debug("sendClient async")
        let msg = StringToBytes (sprintf "Time: %O" DateTime.Now.TimeOfDay)
        Logger.Debug("sendClient Write {msg}", BytesToString msg)
        do! stream.WriteAsync(msg, 0, msg.Length) |> Async.AwaitTask

        Logger.Debug("sendClient Read")
        let dataLen = (16 * 1024)
        let buffer = Array.zeroCreate dataLen
        let! len = stream.ReadAsync(buffer, 0, dataLen) |> Async.AwaitTask
        Logger.Debug("[{len}] {msg}", len, BytesToString buffer)
        sent <- true
    })

    Logger.Information("Wait")

    do! Async.Sleep 10000
    if sent then
        Logger.Debug("sendClient try send\n")
        return! sendClient(stream) |> Async.Ignore
    else
        Logger.Error("Didn't sent\n")
}

let clientFlow() = async {
    try
        do! sendClient(Client().GetStream()) |> Async.Ignore
    with
        | err -> Logger.Error(err, "listenerFlow")
}

[<EntryPoint>]
let main argv =
//    let listener  = Network.TcpConnectC("127.0.0.1", 3000)
//    let listener  = Network.TcpConnectListener("127.0.0.1", 3000)
//    let client  = Network.TcpConnectClient("127.0.0.1", 3000)
//    [ listener.Listen;  ]
//    |> Async.Parallel
//    |> Async.Ignore
//    |> Async.RunSynchronously

//    let listener  = Network.UdpListener("127.0.0.1", 3001)
//    let appState = {
//        AppState.Storage = Storage("data")
//        Listener = listener
//    }
//    let bs = NodeBootstrap(appState)
//    bs.Discovery
    //[listener.GetLoop]
    //[bs.Run; listener.GetLoop]
    //[client.GetLoop; client.SendLoop; client.GetEnv; bs.Run]
//    [bs.Run]
//    |> Async.Parallel
//    |> Async.Ignore
//    |> Async.RunSynchronously


    if argv.Length > 0 then
        [clientFlow()]
        |> Async.Parallel
        |> Async.Ignore
        |> Async.RunSynchronously
    else
        [listenerFlow()]
        |> Async.Parallel
        |> Async.Ignore
        |> Async.RunSynchronously
    0 // return an integer exit code