noormohammedb/brain-to-surreal
1
0
Fork 0
forked from ghe0/brain-to-surreal
Code Pull Requests Activity

Compare commits

base: noormohammedb:a5622659393a4a4336abc3592dc171776d3547bc
Branches Tags
noormohammedb:master
noormohammedb:test_setup
noormohammedb:app_data_integration
ghe0:master
...
compare: noormohammedb:ab9ffa8a79313b3f8530b1de4094461be0da0c3b
Branches Tags
noormohammedb:test_setup
noormohammedb:master
noormohammedb:app_data_integration
ghe0:master

6 Commits
a562265939 ... ab9ffa8a79

Author SHA1 Message Date
Noor
ab9ffa8a79
Add app contract migration 
adjust app contract data types in models
yaml formated
app contract yaml data
 2025-04-24 12:28:30 +05:30
ghe0
a8cf515061
added report and airdrop 2025-04-24 02:47:52 +03:00
ghe0
71cc0a8d82
add operator list 2025-04-23 14:16:03 +03:00
ghe0
f51e29fc4b
inspecting and listing contracts with node info 2025-04-23 04:12:35 +03:00
ghe0
751e81ce37
listing contracts 2025-04-22 19:25:23 +03:00
ghe0
1cf091d801
get_balance working 2025-04-22 18:34:21 +03:00
10 changed files with 1120 additions and 654 deletions
Show Stats Expand all files Collapse all files

1
.gitignore vendored
View File

@ -1 +1,2 @@
/target
tmp

123
Cargo.lock generated
View File

@ -482,6 +482,26 @@ dependencies = [
"serde",
]
[[package]]
name = "bincode"
version = "2.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "36eaf5d7b090263e8150820482d5d93cd964a81e4019913c972f4edcc6edb740"
dependencies = [
"bincode_derive",
"serde",
"unty",
]
[[package]]
name = "bincode_derive"
version = "2.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bf95709a440f45e986983918d0e8a1f30a9b1df04918fc828670606804ac3c09"
dependencies = [
"virtue",
]
[[package]]
name = "bit-set"
version = "0.5.3"
@ -652,6 +672,8 @@ version = "1.2.19"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8e3a13707ac958681c13b39b458c073d0d9bc8a22cb1b2f4c8e55eb72c13f362"
dependencies = [
"jobserver",
"libc",
"shlex",
]
@ -978,15 +1000,17 @@ dependencies = [
[[package]]
name = "detee-shared"
version = "0.1.0"
source = "git+ssh://git@gitea.detee.cloud/testnet/proto?branch=main#3024c00b8e1c93e70902793385b92bc0a8d1f26a"
source = "git+ssh://git@gitea.detee.cloud/testnet/proto?branch=surreal_brain#fb38352e1b47837b14f32d8df5ae7f6b17202aae"
dependencies = [
"base64 0.22.1",
"bincode 2.0.1",
"prost",
"serde",
"serde_yaml",
"tar",
"thiserror 2.0.12",
"tonic",
"tonic-build",
"zstd",
]
[[package]]
@ -1190,6 +1214,18 @@ version = "0.2.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "28dea519a9695b9977216879a3ebfddf92f1c08c05d984f8996aecd6ecdc811d"
[[package]]
name = "filetime"
version = "0.2.25"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "35c0522e981e68cbfa8c3f978441a5f34b30b96e146b33cd3359176b50fe8586"
dependencies = [
"cfg-if",
"libc",
"libredox",
"windows-sys 0.59.0",
]
[[package]]
name = "fixedbitset"
version = "0.4.2"
@ -1959,6 +1995,16 @@ dependencies = [
"syn 2.0.100",
]
[[package]]
name = "jobserver"
version = "0.1.33"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "38f262f097c174adebe41eb73d66ae9c06b2844fb0da69969647bbddd9b0538a"
dependencies = [
"getrandom 0.3.2",
"libc",
]
[[package]]
name = "js-sys"
version = "0.3.77"
@ -2050,6 +2096,7 @@ checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d"
dependencies = [
"bitflags",
"libc",
"redox_syscall",
]
[[package]]
@ -2606,6 +2653,12 @@ dependencies = [
"spki",
]
[[package]]
name = "pkg-config"
version = "0.3.32"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7edddbd0b52d732b21ad9a5fab5c704c14cd949e5e9a1ec5929a24fded1b904c"
[[package]]
name = "portable-atomic"
version = "1.11.0"
@ -3730,6 +3783,7 @@ dependencies = [
"serde_json",
"serde_yaml",
"surrealdb",
"thiserror 2.0.12",
"tokio",
"tokio-stream",
"tonic",
@ -3743,7 +3797,7 @@ checksum = "cd369a114a892aa1d0851d743f35c4c48672d6b0fb5aaf2b3e4dcacfac68a070"
dependencies = [
"arrayvec",
"async-channel",
"bincode",
"bincode 1.3.3",
"chrono",
"dmp",
"futures",
@ -3792,7 +3846,7 @@ dependencies = [
"async-graphql",
"base64 0.21.7",
"bcrypt",
"bincode",
"bincode 1.3.3",
"blake3",
"bytes",
"castaway",
@ -3925,6 +3979,17 @@ version = "1.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
[[package]]
name = "tar"
version = "0.4.44"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1d863878d212c87a19c1a610eb53bb01fe12951c0501cf5a0d65f724914a667a"
dependencies = [
"filetime",
"libc",
"xattr",
]
[[package]]
name = "tempfile"
version = "3.19.1"
@ -4416,6 +4481,12 @@ version = "0.9.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
[[package]]
name = "unty"
version = "0.0.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6d49784317cd0d1ee7ec5c716dd598ec5b4483ea832a2dced265471cc0f690ae"
[[package]]
name = "url"
version = "2.5.4"
@ -4481,6 +4552,12 @@ version = "0.9.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
[[package]]
name = "virtue"
version = "0.0.18"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "051eb1abcf10076295e815102942cc58f9d5e3b4560e46e53c21e8ff6f3af7b1"
[[package]]
name = "walkdir"
version = "2.5.0"
@ -5008,6 +5085,16 @@ dependencies = [
"tap",
]
[[package]]
name = "xattr"
version = "1.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0d65cbf2f12c15564212d48f4e3dfb87923d25d611f2aed18f4cb23f0413d89e"
dependencies = [
"libc",
"rustix",
]
[[package]]
name = "yoke"
version = "0.7.5"
@ -5120,3 +5207,31 @@ dependencies = [
"quote",
"syn 2.0.100",
]
[[package]]
name = "zstd"
version = "0.13.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e91ee311a569c327171651566e07972200e76fcfe2242a4fa446149a3881c08a"
dependencies = [
"zstd-safe",
]
[[package]]
name = "zstd-safe"
version = "7.2.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8f49c4d5f0abb602a93fb8736af2a4f4dd9512e36f7f570d66e65ff867ed3b9d"
dependencies = [
"zstd-sys",
]
[[package]]
name = "zstd-sys"
version = "2.0.15+zstd.1.5.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "eb81183ddd97d0c74cedf1d50d85c8d08c1b8b68ee863bdee9e706eedba1a237"
dependencies = [
"cc",
"pkg-config",
]

3
Cargo.toml
View File

@ -13,12 +13,13 @@ serde_yaml = "0.9.34"
surrealdb = "2.2.2"
tokio = { version = "1.44.2", features = ["macros", "rt-multi-thread"] }
tonic = { version = "0.12", features = ["tls"] }
detee-shared = { git = "ssh://git@gitea.detee.cloud/testnet/proto", branch = "main" }
detee-shared = { git = "ssh://git@gitea.detee.cloud/testnet/proto", branch = "surreal_brain" }
ed25519-dalek = "2.1.1"
bs58 = "0.5.1"
tokio-stream = "0.1.17"
log = "0.4.27"
env_logger = "0.11.8"
thiserror = "2.0.12"
[profile.release]
lto = true

567
saved_data.yaml
View File

@ -113,275 +113,328 @@ operators:
email: first_on_detee@proton.me
banned_users: []
vm_nodes:
- HiyMp21zaBVbRCjDsD5hEjQnHeHv4e1gpUR6pVfHTKqv
- 3zRxiGRnf46vd3zAEmpaYBJocTV9oJB6yXf5GZFR1Sq4
- Du3UfPSUUZmA5thQmc9Vrxdy7UimpygcpDsQNnwRQPtu
- 4QbUXDM915RUFnHm3NiysLXFLk1WRGZvABwLNzx4tTEW
- DgkbsrwttkZXvzxY5kDwQQoDd79GLmZ5tc7fYJUFkQQb
- HiyMp21zaBVbRCjDsD5hEjQnHeHv4e1gpUR6pVfHTKqv
- 3zRxiGRnf46vd3zAEmpaYBJocTV9oJB6yXf5GZFR1Sq4
- Du3UfPSUUZmA5thQmc9Vrxdy7UimpygcpDsQNnwRQPtu
- 4QbUXDM915RUFnHm3NiysLXFLk1WRGZvABwLNzx4tTEW
- DgkbsrwttkZXvzxY5kDwQQoDd79GLmZ5tc7fYJUFkQQb
app_nodes: []
x52w7jARC5erhWWK65VZmjdGXzBK6ZDgfv1A283d8XK:
escrow: 5499700480000
email: gheo@detee.ltd
banned_users: []
vm_nodes:
- 2Uf5pxhxKTUm6gRMnpbJHYDuyA6BWUfFsdmPyWfbMV1f
- 7Xw3RxbP5pvfjZ8U6yA3HHVSS9YXjKH5Vkas3JRbQYd9
- 2Uf5pxhxKTUm6gRMnpbJHYDuyA6BWUfFsdmPyWfbMV1f
- 7Xw3RxbP5pvfjZ8U6yA3HHVSS9YXjKH5Vkas3JRbQYd9
app_nodes: []
7V3rEuh6j8VuwMVB5PyGqWKLmjJ4fYSv6WtrTL51NZTB:
escrow: 0
email: ''
email: ""
banned_users: []
vm_nodes: []
app_nodes:
- BiqoPUEoAxYxMRXUmyofoS9H1TBQgQqvLJ6MbWh88AQg
- BiqoPUEoAxYxMRXUmyofoS9H1TBQgQqvLJ6MbWh88AQg
vm_nodes:
- public_key: 7Xw3RxbP5pvfjZ8U6yA3HHVSS9YXjKH5Vkas3JRbQYd9
operator_wallet: x52w7jARC5erhWWK65VZmjdGXzBK6ZDgfv1A283d8XK
country: GB
region: England
city: London
ip: 173.234.17.2
avail_mem_mb: 26000
avail_vcpus: 28
avail_storage_gbs: 680
avail_ipv4: 2
avail_ipv6: 65516
avail_ports: 19999
max_ports_per_vm: 5
price: 20000
reports: {}
offline_minutes: 0
- public_key: Du3UfPSUUZmA5thQmc9Vrxdy7UimpygcpDsQNnwRQPtu
operator_wallet: BFopWmwcZAMF1h2PFECZNdEucdZfnZZ32p6R9ZaBiVsS
country: FR
region: Île-de-France
city: Paris
ip: 156.146.63.215
avail_mem_mb: 123000
avail_vcpus: 46
avail_storage_gbs: 440
avail_ipv4: 2
avail_ipv6: 0
avail_ports: 20000
max_ports_per_vm: 5
price: 20000
reports: {}
offline_minutes: 0
- public_key: 2Uf5pxhxKTUm6gRMnpbJHYDuyA6BWUfFsdmPyWfbMV1f
operator_wallet: x52w7jARC5erhWWK65VZmjdGXzBK6ZDgfv1A283d8XK
country: CA
region: Quebec
city: Montréal
ip: 184.107.169.199
avail_mem_mb: 30000
avail_vcpus: 31
avail_storage_gbs: 700
avail_ipv4: 0
avail_ipv6: 0
avail_ports: 20000
max_ports_per_vm: 5
price: 18000
reports: {}
offline_minutes: 0
- public_key: DgkbsrwttkZXvzxY5kDwQQoDd79GLmZ5tc7fYJUFkQQb
operator_wallet: BFopWmwcZAMF1h2PFECZNdEucdZfnZZ32p6R9ZaBiVsS
country: CA
region: British Columbia
city: Vancouver
ip: 149.22.95.1
avail_mem_mb: 109000
avail_vcpus: 45
avail_storage_gbs: 400
avail_ipv4: 25
avail_ipv6: 0
avail_ports: 20000
max_ports_per_vm: 5
price: 20000
reports: {}
offline_minutes: 0
- public_key: 3zRxiGRnf46vd3zAEmpaYBJocTV9oJB6yXf5GZFR1Sq4
operator_wallet: BFopWmwcZAMF1h2PFECZNdEucdZfnZZ32p6R9ZaBiVsS
country: US
region: California
city: San Jose
ip: 149.36.48.99
avail_mem_mb: 120000
avail_vcpus: 41
avail_storage_gbs: 390
avail_ipv4: 23
avail_ipv6: 0
avail_ports: 19999
max_ports_per_vm: 5
price: 20000
reports: {}
offline_minutes: 0
- public_key: HiyMp21zaBVbRCjDsD5hEjQnHeHv4e1gpUR6pVfHTKqv
operator_wallet: BFopWmwcZAMF1h2PFECZNdEucdZfnZZ32p6R9ZaBiVsS
country: CA
region: British Columbia
city: Vancouver
ip: 149.22.95.28
avail_mem_mb: 125000
avail_vcpus: 46
avail_storage_gbs: 400
avail_ipv4: 26
avail_ipv6: 0
avail_ports: 20000
max_ports_per_vm: 5
price: 20000
reports: {}
offline_minutes: 0
- public_key: 7Xw3RxbP5pvfjZ8U6yA3HHVSS9YXjKH5Vkas3JRbQYd9
operator_wallet: x52w7jARC5erhWWK65VZmjdGXzBK6ZDgfv1A283d8XK
country: GB
region: England
city: London
ip: 173.234.17.2
avail_mem_mb: 26000
avail_vcpus: 28
avail_storage_gbs: 680
avail_ipv4: 2
avail_ipv6: 65516
avail_ports: 19999
max_ports_per_vm: 5
price: 20000
reports: {}
offline_minutes: 0
- public_key: Du3UfPSUUZmA5thQmc9Vrxdy7UimpygcpDsQNnwRQPtu
operator_wallet: BFopWmwcZAMF1h2PFECZNdEucdZfnZZ32p6R9ZaBiVsS
country: FR
region: Île-de-France
city: Paris
ip: 156.146.63.215
avail_mem_mb: 123000
avail_vcpus: 46
avail_storage_gbs: 440
avail_ipv4: 2
avail_ipv6: 0
avail_ports: 20000
max_ports_per_vm: 5
price: 20000
reports: {}
offline_minutes: 0
- public_key: 2Uf5pxhxKTUm6gRMnpbJHYDuyA6BWUfFsdmPyWfbMV1f
operator_wallet: x52w7jARC5erhWWK65VZmjdGXzBK6ZDgfv1A283d8XK
country: CA
region: Quebec
city: Montréal
ip: 184.107.169.199
avail_mem_mb: 30000
avail_vcpus: 31
avail_storage_gbs: 700
avail_ipv4: 0
avail_ipv6: 0
avail_ports: 20000
max_ports_per_vm: 5
price: 18000
reports: {}
offline_minutes: 0
- public_key: DgkbsrwttkZXvzxY5kDwQQoDd79GLmZ5tc7fYJUFkQQb
operator_wallet: BFopWmwcZAMF1h2PFECZNdEucdZfnZZ32p6R9ZaBiVsS
country: CA
region: British Columbia
city: Vancouver
ip: 149.22.95.1
avail_mem_mb: 109000
avail_vcpus: 45
avail_storage_gbs: 400
avail_ipv4: 25
avail_ipv6: 0
avail_ports: 20000
max_ports_per_vm: 5
price: 20000
reports: {}
offline_minutes: 0
- public_key: 3zRxiGRnf46vd3zAEmpaYBJocTV9oJB6yXf5GZFR1Sq4
operator_wallet: BFopWmwcZAMF1h2PFECZNdEucdZfnZZ32p6R9ZaBiVsS
country: US
region: California
city: San Jose
ip: 149.36.48.99
avail_mem_mb: 120000
avail_vcpus: 41
avail_storage_gbs: 390
avail_ipv4: 23
avail_ipv6: 0
avail_ports: 19999
max_ports_per_vm: 5
price: 20000
reports: {}
offline_minutes: 0
- public_key: HiyMp21zaBVbRCjDsD5hEjQnHeHv4e1gpUR6pVfHTKqv
operator_wallet: BFopWmwcZAMF1h2PFECZNdEucdZfnZZ32p6R9ZaBiVsS
country: CA
region: British Columbia
city: Vancouver
ip: 149.22.95.28
avail_mem_mb: 125000
avail_vcpus: 46
avail_storage_gbs: 400
avail_ipv4: 26
avail_ipv6: 0
avail_ports: 20000
max_ports_per_vm: 5
price: 20000
reports: {}
offline_minutes: 0
vm_contracts:
- uuid: 958165e3-dea8-407d-8c42-dd17002ef79c
hostname: detee-landing-fr
admin_pubkey: FHuecMbeC1PfjkW2JKyoicJAuiU7khgQT16QUB3Q1XdL
node_pubkey: Du3UfPSUUZmA5thQmc9Vrxdy7UimpygcpDsQNnwRQPtu
exposed_ports: []
public_ipv4: 156.146.63.216
public_ipv6: ''
disk_size_gb: 10
vcpus: 2
memory_mb: 3000
kernel_sha: 3ec4fc5aa5729f515967ec71be4a851622785c0080f7191b1b07717149840151
dtrfs_sha: 3f6b3e5740f249eedfb2f7248c521a551be8b2676f7fcb040f3f3bc840a5004b
created_at: 2025-02-28T23:19:41.769423466Z
updated_at: 2025-04-12T12:11:58.516768949Z
price_per_unit: 20000
locked_nano: 14875500000
collected_at: 2025-04-20T00:34:15.461165181Z
- uuid: e807a2fd-cf90-4a14-bc3a-89ce6dc59033
hostname: detee-landing-gb
admin_pubkey: FHuecMbeC1PfjkW2JKyoicJAuiU7khgQT16QUB3Q1XdL
node_pubkey: 7Xw3RxbP5pvfjZ8U6yA3HHVSS9YXjKH5Vkas3JRbQYd9
exposed_ports: []
public_ipv4: 173.234.136.154
public_ipv6: ''
disk_size_gb: 10
vcpus: 2
memory_mb: 3000
kernel_sha: 3ec4fc5aa5729f515967ec71be4a851622785c0080f7191b1b07717149840151
dtrfs_sha: 3f6b3e5740f249eedfb2f7248c521a551be8b2676f7fcb040f3f3bc840a5004b
created_at: 2025-03-06T19:51:39.595163157Z
updated_at: 2025-03-06T19:51:39.595163842Z
price_per_unit: 20000
locked_nano: 14875500000
collected_at: 2025-04-20T00:34:15.461181545Z
- uuid: 23094406-2307-4332-a642-acee718d0186
hostname: heroic-door
admin_pubkey: DwfL5iFu32xh2YMCUxg63oEAThLRqehDAumiP9q6zuuX
node_pubkey: 7Xw3RxbP5pvfjZ8U6yA3HHVSS9YXjKH5Vkas3JRbQYd9
exposed_ports:
- 38288
public_ipv4: ''
public_ipv6: ''
disk_size_gb: 10
vcpus: 1
memory_mb: 1000
kernel_sha: 14e225e4aaf84cc2e0b5f64206121186ddebc4b378b886da3b2f7515dfd41692
dtrfs_sha: 03ce24dbbe917fdd4f6347e61036805ddbdded5044c272bab188ef9333093bee
created_at: 2025-03-12T16:28:24.749161605Z
updated_at: 2025-03-12T16:28:24.749162477Z
price_per_unit: 20000
locked_nano: 14134140000
collected_at: 2025-04-20T00:34:15.461191231Z
- uuid: 1f49a71c-f68c-4c64-a82e-f50e0ba0b574
hostname: astromech-wrench
admin_pubkey: FHuecMbeC1PfjkW2JKyoicJAuiU7khgQT16QUB3Q1XdL
node_pubkey: DgkbsrwttkZXvzxY5kDwQQoDd79GLmZ5tc7fYJUFkQQb
exposed_ports: []
public_ipv4: 149.22.95.2
public_ipv6: ''
disk_size_gb: 10
vcpus: 2
memory_mb: 3000
kernel_sha: 3a68709138bed09c16671949cf1f03acee95a08381ba84fc70fb586001fa6767
dtrfs_sha: 0bb93443f65c9f4379ed469f94794f5c1bf14d8905b0b2c56a125df4a9ebe83e
created_at: 2025-03-20T14:40:25.557753393Z
updated_at: 2025-03-20T14:40:25.557754242Z
price_per_unit: 20000
locked_nano: 11865620000
collected_at: 2025-04-20T00:34:15.461201690Z
- uuid: 16577f1c-9867-4a17-80a8-6cf0490f1270
hostname: sofenty
admin_pubkey: FHuecMbeC1PfjkW2JKyoicJAuiU7khgQT16QUB3Q1XdL
node_pubkey: Du3UfPSUUZmA5thQmc9Vrxdy7UimpygcpDsQNnwRQPtu
exposed_ports: []
public_ipv4: 156.146.63.217
public_ipv6: ''
disk_size_gb: 10
vcpus: 2
memory_mb: 3000
kernel_sha: e49c8587287b21df7600c04326fd7393524453918c14d67f73757dc769a13542
dtrfs_sha: b5f408d00e2b93dc594fed3a7f2466a9878802ff1c7ae502247471cd06728a45
created_at: 2025-04-07T22:57:57.646151746Z
updated_at: 2025-04-07T22:57:57.646152630Z
price_per_unit: 20000
locked_nano: 11867500000
collected_at: 2025-04-20T00:34:15.461211040Z
- uuid: 4b6e25ca-87ac-478b-8f16-aa8f5c44c704
hostname: cloaked-mailbox
admin_pubkey: DwfL5iFu32xh2YMCUxg63oEAThLRqehDAumiP9q6zuuX
node_pubkey: DgkbsrwttkZXvzxY5kDwQQoDd79GLmZ5tc7fYJUFkQQb
exposed_ports: []
public_ipv4: 149.22.95.2
public_ipv6: ''
disk_size_gb: 30
vcpus: 1
memory_mb: 1000
kernel_sha: e49c8587287b21df7600c04326fd7393524453918c14d67f73757dc769a13542
dtrfs_sha: b5f408d00e2b93dc594fed3a7f2466a9878802ff1c7ae502247471cd06728a45
created_at: 2025-04-12T13:44:56.957037550Z
updated_at: 2025-04-12T13:44:56.957038546Z
price_per_unit: 20000
locked_nano: 11177760000
collected_at: 2025-04-20T00:34:15.461219779Z
- uuid: eb1a13ed-d782-4b71-8860-73540129cb7d
hostname: twenty
admin_pubkey: FHuecMbeC1PfjkW2JKyoicJAuiU7khgQT16QUB3Q1XdL
node_pubkey: 3zRxiGRnf46vd3zAEmpaYBJocTV9oJB6yXf5GZFR1Sq4
exposed_ports: []
public_ipv4: 149.36.48.100
public_ipv6: ''
disk_size_gb: 10
vcpus: 4
memory_mb: 4000
kernel_sha: e49c8587287b21df7600c04326fd7393524453918c14d67f73757dc769a13542
dtrfs_sha: b5f408d00e2b93dc594fed3a7f2466a9878802ff1c7ae502247471cd06728a45
created_at: 2025-04-15T00:46:35.622165457Z
updated_at: 2025-04-15T00:46:35.622166372Z
price_per_unit: 20000
locked_nano: 15570720000
collected_at: 2025-04-20T00:34:15.461230948Z
- uuid: 1bf36309-3774-4825-b023-b2a0ef0405ed
hostname: shadowy-hobo
admin_pubkey: x52w7jARC5erhWWK65VZmjdGXzBK6ZDgfv1A283d8XK
node_pubkey: 3zRxiGRnf46vd3zAEmpaYBJocTV9oJB6yXf5GZFR1Sq4
exposed_ports:
- 46393
public_ipv4: ''
public_ipv6: ''
disk_size_gb: 10
vcpus: 1
memory_mb: 1000
kernel_sha: e765e56166ef321b53399b9638584d1279821dbe3d46191c1f66bbaa075e7919
dtrfs_sha: d207644ee60d54009b6ecdfb720e2ec251cde31774dd249fcc7435aca0377990
created_at: 2025-04-16T20:37:57.176592933Z
updated_at: 2025-04-16T20:37:57.176594069Z
price_per_unit: 20000
locked_nano: 12730960000
collected_at: 2025-04-20T00:34:15.461240342Z
- uuid: 958165e3-dea8-407d-8c42-dd17002ef79c
hostname: detee-landing-fr
admin_pubkey: FHuecMbeC1PfjkW2JKyoicJAuiU7khgQT16QUB3Q1XdL
node_pubkey: Du3UfPSUUZmA5thQmc9Vrxdy7UimpygcpDsQNnwRQPtu
exposed_ports: []
public_ipv4: 156.146.63.216
public_ipv6: ""
disk_size_gb: 10
vcpus: 2
memory_mb: 3000
kernel_sha: 3ec4fc5aa5729f515967ec71be4a851622785c0080f7191b1b07717149840151
dtrfs_sha: 3f6b3e5740f249eedfb2f7248c521a551be8b2676f7fcb040f3f3bc840a5004b
created_at: 2025-02-28T23:19:41.769423466Z
updated_at: 2025-04-12T12:11:58.516768949Z
price_per_unit: 20000
locked_nano: 14875500000
collected_at: 2025-04-20T00:34:15.461165181Z
- uuid: e807a2fd-cf90-4a14-bc3a-89ce6dc59033
hostname: detee-landing-gb
admin_pubkey: FHuecMbeC1PfjkW2JKyoicJAuiU7khgQT16QUB3Q1XdL
node_pubkey: 7Xw3RxbP5pvfjZ8U6yA3HHVSS9YXjKH5Vkas3JRbQYd9
exposed_ports: []
public_ipv4: 173.234.136.154
public_ipv6: ""
disk_size_gb: 10
vcpus: 2
memory_mb: 3000
kernel_sha: 3ec4fc5aa5729f515967ec71be4a851622785c0080f7191b1b07717149840151
dtrfs_sha: 3f6b3e5740f249eedfb2f7248c521a551be8b2676f7fcb040f3f3bc840a5004b
created_at: 2025-03-06T19:51:39.595163157Z
updated_at: 2025-03-06T19:51:39.595163842Z
price_per_unit: 20000
locked_nano: 14875500000
collected_at: 2025-04-20T00:34:15.461181545Z
- uuid: 23094406-2307-4332-a642-acee718d0186
hostname: heroic-door
admin_pubkey: DwfL5iFu32xh2YMCUxg63oEAThLRqehDAumiP9q6zuuX
node_pubkey: 7Xw3RxbP5pvfjZ8U6yA3HHVSS9YXjKH5Vkas3JRbQYd9
exposed_ports:
- 38288
public_ipv4: ""
public_ipv6: ""
disk_size_gb: 10
vcpus: 1
memory_mb: 1000
kernel_sha: 14e225e4aaf84cc2e0b5f64206121186ddebc4b378b886da3b2f7515dfd41692
dtrfs_sha: 03ce24dbbe917fdd4f6347e61036805ddbdded5044c272bab188ef9333093bee
created_at: 2025-03-12T16:28:24.749161605Z
updated_at: 2025-03-12T16:28:24.749162477Z
price_per_unit: 20000
locked_nano: 14134140000
collected_at: 2025-04-20T00:34:15.461191231Z
- uuid: 1f49a71c-f68c-4c64-a82e-f50e0ba0b574
hostname: astromech-wrench
admin_pubkey: FHuecMbeC1PfjkW2JKyoicJAuiU7khgQT16QUB3Q1XdL
node_pubkey: DgkbsrwttkZXvzxY5kDwQQoDd79GLmZ5tc7fYJUFkQQb
exposed_ports: []
public_ipv4: 149.22.95.2
public_ipv6: ""
disk_size_gb: 10
vcpus: 2
memory_mb: 3000
kernel_sha: 3a68709138bed09c16671949cf1f03acee95a08381ba84fc70fb586001fa6767
dtrfs_sha: 0bb93443f65c9f4379ed469f94794f5c1bf14d8905b0b2c56a125df4a9ebe83e
created_at: 2025-03-20T14:40:25.557753393Z
updated_at: 2025-03-20T14:40:25.557754242Z
price_per_unit: 20000
locked_nano: 11865620000
collected_at: 2025-04-20T00:34:15.461201690Z
- uuid: 16577f1c-9867-4a17-80a8-6cf0490f1270
hostname: sofenty
admin_pubkey: FHuecMbeC1PfjkW2JKyoicJAuiU7khgQT16QUB3Q1XdL
node_pubkey: Du3UfPSUUZmA5thQmc9Vrxdy7UimpygcpDsQNnwRQPtu
exposed_ports: []
public_ipv4: 156.146.63.217
public_ipv6: ""
disk_size_gb: 10
vcpus: 2
memory_mb: 3000
kernel_sha: e49c8587287b21df7600c04326fd7393524453918c14d67f73757dc769a13542
dtrfs_sha: b5f408d00e2b93dc594fed3a7f2466a9878802ff1c7ae502247471cd06728a45
created_at: 2025-04-07T22:57:57.646151746Z
updated_at: 2025-04-07T22:57:57.646152630Z
price_per_unit: 20000
locked_nano: 11867500000
collected_at: 2025-04-20T00:34:15.461211040Z
- uuid: 4b6e25ca-87ac-478b-8f16-aa8f5c44c704
hostname: cloaked-mailbox
admin_pubkey: DwfL5iFu32xh2YMCUxg63oEAThLRqehDAumiP9q6zuuX
node_pubkey: DgkbsrwttkZXvzxY5kDwQQoDd79GLmZ5tc7fYJUFkQQb
exposed_ports: []
public_ipv4: 149.22.95.2
public_ipv6: ""
disk_size_gb: 30
vcpus: 1
memory_mb: 1000
kernel_sha: e49c8587287b21df7600c04326fd7393524453918c14d67f73757dc769a13542
dtrfs_sha: b5f408d00e2b93dc594fed3a7f2466a9878802ff1c7ae502247471cd06728a45
created_at: 2025-04-12T13:44:56.957037550Z
updated_at: 2025-04-12T13:44:56.957038546Z
price_per_unit: 20000
locked_nano: 11177760000
collected_at: 2025-04-20T00:34:15.461219779Z
- uuid: eb1a13ed-d782-4b71-8860-73540129cb7d
hostname: twenty
admin_pubkey: FHuecMbeC1PfjkW2JKyoicJAuiU7khgQT16QUB3Q1XdL
node_pubkey: 3zRxiGRnf46vd3zAEmpaYBJocTV9oJB6yXf5GZFR1Sq4
exposed_ports: []
public_ipv4: 149.36.48.100
public_ipv6: ""
disk_size_gb: 10
vcpus: 4
memory_mb: 4000
kernel_sha: e49c8587287b21df7600c04326fd7393524453918c14d67f73757dc769a13542
dtrfs_sha: b5f408d00e2b93dc594fed3a7f2466a9878802ff1c7ae502247471cd06728a45
created_at: 2025-04-15T00:46:35.622165457Z
updated_at: 2025-04-15T00:46:35.622166372Z
price_per_unit: 20000
locked_nano: 15570720000
collected_at: 2025-04-20T00:34:15.461230948Z
- uuid: 1bf36309-3774-4825-b023-b2a0ef0405ed
hostname: shadowy-hobo
admin_pubkey: x52w7jARC5erhWWK65VZmjdGXzBK6ZDgfv1A283d8XK
node_pubkey: 3zRxiGRnf46vd3zAEmpaYBJocTV9oJB6yXf5GZFR1Sq4
exposed_ports:
- 46393
public_ipv4: ""
public_ipv6: ""
disk_size_gb: 10
vcpus: 1
memory_mb: 1000
kernel_sha: e765e56166ef321b53399b9638584d1279821dbe3d46191c1f66bbaa075e7919
dtrfs_sha: d207644ee60d54009b6ecdfb720e2ec251cde31774dd249fcc7435aca0377990
created_at: 2025-04-16T20:37:57.176592933Z
updated_at: 2025-04-16T20:37:57.176594069Z
price_per_unit: 20000
locked_nano: 12730960000
collected_at: 2025-04-20T00:34:15.461240342Z
app_nodes:
- node_pubkey: BiqoPUEoAxYxMRXUmyofoS9H1TBQgQqvLJ6MbWh88AQg
operator_wallet: 7V3rEuh6j8VuwMVB5PyGqWKLmjJ4fYSv6WtrTL51NZTB
country: DE
region: Hesse
city: Frankfurt am Main
ip: 212.95.45.139
avail_mem_mb: 16000
avail_vcpus: 16
avail_storage_mb: 200000
avail_no_of_port: 20000
max_ports_per_app: 9
price: 20000
offline_minutes: 0
app_contracts: []
- node_pubkey: BiqoPUEoAxYxMRXUmyofoS9H1TBQgQqvLJ6MbWh88AQg
operator_wallet: 7V3rEuh6j8VuwMVB5PyGqWKLmjJ4fYSv6WtrTL51NZTB
country: DE
region: Hesse
city: Frankfurt am Main
ip: 212.95.45.139
avail_mem_mb: 16000
avail_vcpus: 16
avail_storage_mb: 200000
avail_no_of_port: 20000
max_ports_per_app: 9
price: 20000
offline_minutes: 0
app_contracts:
- uuid: e3d01f25-2b2a-410b-80e3-12f44e474334
package_url: https://registry.detee.ltd/sgx/packages/base_package_2025-04-17_11-01-08.tar.gz
admin_pubkey: H21Shi4iE7vgfjWEQNvzmpmBMJSaiZ17PYUcdNoAoKNc
node_pubkey: BiqoPUEoAxYxMRXUmyofoS9H1TBQgQqvLJ6MbWh88AQg
mapped_ports:
- - 27158
- 34500
- - 28667
- 8080
host_ipv4: 212.95.45.139
disk_size_mb: 1000
vcpus: 1
memory_mb: 1000
created_at: 2025-04-21T11:27:28.833236909Z
updated_at: 2025-04-21T11:27:28.833237729Z
price_per_unit: 200000
locked_nano: 121200000
collected_at: 2025-04-21T11:28:24.905665571Z
hratls_pubkey: 7E0F887AA6BB9104EEC1066F454D4C2D9063D676715F55F919D3FBCEDC63240B
public_package_mr_enclave:
- 52
- 183
- 102
- 210
- 251
- 219
- 218
- 140
- 168
- 118
- 10
- 193
- 98
- 240
- 147
- 124
- 240
- 189
- 46
- 95
- 138
- 172
- 15
- 246
- 227
- 114
- 70
- 159
- 232
- 212
- 9
- 234
app_name: diligent-seahorse

6
src/bin/brain.rs
View File

@ -2,18 +2,20 @@ use detee_shared::general_proto::brain_general_cli_server::BrainGeneralCliServer
use detee_shared::vm_proto::brain_vm_cli_server::BrainVmCliServer;
use surreal_brain::grpc::BrainGeneralCliMock;
use surreal_brain::grpc::BrainVmCliMock;
use surreal_brain::db;
use tonic::transport::{Identity, Server, ServerTlsConfig};
#[tokio::main]
async fn main() {
env_logger::builder().filter_level(log::LevelFilter::Debug).init();
db::init().await.unwrap();
let addr = "0.0.0.0:31337".parse().unwrap();
let snp_cli_server = BrainVmCliServer::new(BrainVmCliMock {});
let general_service_server = BrainGeneralCliServer::new(BrainGeneralCliMock {});
let cert = std::fs::read_to_string("./brain-crt.pem").unwrap();
let key = std::fs::read_to_string("./brain-mock/brain-key.pem").unwrap();
let cert = std::fs::read_to_string("./tmp/brain-crt.pem").unwrap();
let key = std::fs::read_to_string("./tmp/brain-key.pem").unwrap();
let identity = Identity::from_pem(cert, key);

4
src/bin/migration0.rs
View File

@ -1,14 +1,14 @@
// After deleting this migration, also delete old_brain structs
// and dangling impls from the model
use std::error::Error;
use surreal_brain::{models, old_brain};
use surreal_brain::{db, old_brain};
#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
let old_brain_data = old_brain::BrainData::load_from_disk()?;
// println!("{}", serde_yaml::to_string(&old_brain_data)?);
let result = models::migrate(&old_brain_data).await?;
let result = db::migration0(&old_brain_data).await?;
println!("{result:?}");

521
src/db.rs Normal file
View File

@ -0,0 +1,521 @@
use crate::old_brain;
use serde::{Deserialize, Serialize};
use std::sync::LazyLock;
use surrealdb::{
engine::remote::ws::{Client, Ws},
opt::auth::Root,
sql::Datetime,
RecordId, Surreal,
};
static DB: LazyLock<Surreal<Client>> = LazyLock::new(Surreal::init);
const ACCOUNT: &str = "account";
const OPERATOR: &str = "operator";
const VM_CONTRACT: &str = "vm_contract";
const VM_NODE: &str = "vm_node";
#[derive(thiserror::Error, Debug)]
pub enum Error {
#[error(transparent)]
DataBase(#[from] surrealdb::Error),
}
pub async fn init() -> surrealdb::Result<()> {
DB.connect::<Ws>("localhost:8000").await?;
// Sign in to the server
DB.signin(Root { username: "root", password: "root" }).await?;
DB.use_ns("brain").use_db("migration").await?;
Ok(())
}
pub async fn migration0(old_data: &old_brain::BrainData) -> surrealdb::Result<()> {
let accounts: Vec<Account> = old_data.into();
let vm_nodes: Vec<VmNode> = old_data.into();
let app_nodes: Vec<AppNode> = old_data.into();
let vm_contracts: Vec<VmContract> = old_data.into();
let operators: Vec<OperatorRelation> = old_data.into();
let app_contracts: Vec<AppContract> = old_data.into();
init().await?;
println!("Inserting accounts...");
let _: Vec<Account> = DB.insert(()).content(accounts).await?;
println!("Inserting vm nodes...");
let _: Vec<VmNode> = DB.insert(()).content(vm_nodes).await?;
println!("Inserting app nodes...");
let _: Vec<AppNode> = DB.insert(()).content(app_nodes).await?;
println!("Inserting vm contracts...");
let _: Vec<VmContract> = DB.insert("vm_contract").relation(vm_contracts).await?;
println!("Inserting app contracts...");
let _: Vec<AppContract> = DB.insert("app_contract").relation(app_contracts).await?;
println!("Inserting operators...");
let _: Vec<OperatorRelation> = DB.insert(OPERATOR).relation(operators).await?;
Ok(())
}
#[derive(Debug, Serialize, Deserialize)]
pub struct Account {
pub id: RecordId,
pub balance: u64,
pub tmp_locked: u64,
pub escrow: u64,
pub email: String,
}
impl Account {
pub async fn get(address: &str) -> Result<Self, Error> {
let id = (ACCOUNT, address);
let account: Option<Self> = DB.select(id).await?;
let account = match account {
Some(account) => account,
None => {
Self { id: id.into(), balance: 0, tmp_locked: 0, escrow: 0, email: String::new() }
}
};
Ok(account)
}
pub async fn airdrop(account: &str, tokens: u64) -> Result<(), Error> {
let tokens = tokens.saturating_mul(1_000_000_000);
let _ = DB
.query(format!("upsert account:{account} SET balance = (balance || 0) + {tokens};"))
.await?;
Ok(())
}
}
#[derive(Debug, Serialize, Deserialize)]
pub struct VmNode {
pub id: RecordId,
pub country: String,
pub region: String,
pub city: String,
pub ip: String,
pub avail_mem_mb: u32,
pub avail_vcpus: u32,
pub avail_storage_gbs: u32,
pub avail_ipv4: u32,
pub avail_ipv6: u32,
pub avail_ports: u32,
pub max_ports_per_vm: u32,
pub price: u64,
pub offline_minutes: u64,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct VmContract {
pub id: RecordId,
#[serde(rename = "in")]
pub admin: RecordId,
#[serde(rename = "out")]
pub vm_node: RecordId,
pub state: String,
pub hostname: String,
pub mapped_ports: Vec<(u32, u32)>,
pub public_ipv4: String,
pub public_ipv6: String,
pub disk_size_gb: u32,
pub vcpus: u32,
pub memory_mb: u32,
pub dtrfs_sha: String,
pub kernel_sha: String,
pub created_at: Datetime,
pub updated_at: Datetime,
pub price_per_unit: u64,
pub locked_nano: u64,
pub collected_at: Datetime,
}
impl VmContract {
/// total hardware units of this VM
fn total_units(&self) -> u64 {
// TODO: Optimize this based on price of hardware.
// I tried, but this can be done better.
// Storage cost should also be based on tier
(self.vcpus as u64 * 10)
+ ((self.memory_mb + 256) as u64 / 200)
+ (self.disk_size_gb as u64 / 10)
+ (!self.public_ipv4.is_empty() as u64 * 10)
}
/// Returns price per minute in nanoLP
pub fn price_per_minute(&self) -> u64 {
self.total_units() * self.price_per_unit
}
}
#[derive(Debug, Serialize, Deserialize)]
pub struct VmContractWithNode {
pub id: RecordId,
#[serde(rename = "in")]
pub admin: RecordId,
#[serde(rename = "out")]
pub vm_node: VmNode,
pub state: String,
pub hostname: String,
pub mapped_ports: Vec<(u32, u32)>,
pub public_ipv4: String,
pub public_ipv6: String,
pub disk_size_gb: u32,
pub vcpus: u32,
pub memory_mb: u32,
pub dtrfs_sha: String,
pub kernel_sha: String,
pub created_at: Datetime,
pub updated_at: Datetime,
pub price_per_unit: u64,
pub locked_nano: u64,
pub collected_at: Datetime,
}
impl VmContractWithNode {
pub async fn get_by_uuid(uuid: &str) -> Result<Option<Self>, Error> {
let contract: Option<Self> =
DB.query(format!("select * from {VM_CONTRACT}:{uuid} fetch out;")).await?.take(0)?;
Ok(contract)
}
pub async fn list_by_admin(admin: &str) -> Result<Vec<Self>, Error> {
let mut result = DB
.query(format!("select * from {VM_CONTRACT} where in = {ACCOUNT}:{admin} fetch out;"))
.await?;
let contracts: Vec<Self> = result.take(0)?;
Ok(contracts)
}
pub async fn list_by_operator(operator: &str) -> Result<Vec<Self>, Error> {
let mut result = DB
.query(format!(
"select
(select * from ->operator->vm_node<-vm_contract fetch out) as contracts
from {ACCOUNT}:{operator};"
))
.await?;
#[derive(Deserialize)]
struct Wrapper {
contracts: Vec<VmContractWithNode>,
}
let c: Option<Wrapper> = result.take(0)?;
match c {
Some(c) => Ok(c.contracts),
None => Ok(Vec::new()),
}
}
/// total hardware units of this VM
fn total_units(&self) -> u64 {
// TODO: Optimize this based on price of hardware.
// I tried, but this can be done better.
// Storage cost should also be based on tier
(self.vcpus as u64 * 10)
+ ((self.memory_mb + 256) as u64 / 200)
+ (self.disk_size_gb as u64 / 10)
+ (!self.public_ipv4.is_empty() as u64 * 10)
}
/// Returns price per minute in nanoLP
pub fn price_per_minute(&self) -> u64 {
self.total_units() * self.price_per_unit
}
}
#[derive(Debug, Serialize, Deserialize)]
pub struct AppNode {
id: RecordId,
country: String,
region: String,
city: String,
ip: String,
avail_mem_mb: u32,
avail_vcpus: u32,
avail_storage_gbs: u32,
avail_ports: u32,
max_ports_per_app: u32,
price: u64,
offline_minutes: u64,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct AppContract {
id: RecordId,
#[serde(rename = "in")]
admin: RecordId,
#[serde(rename = "out")]
app_node: RecordId,
state: String,
app_name: String,
mapped_ports: Vec<(u32, u32)>,
host_ipv4: String,
vcpus: u32,
memory_mb: u32,
disk_size_gb: u32,
created_at: Datetime,
updated_at: Datetime,
price_per_unit: u64,
locked_nano: u64,
collected_at: Datetime,
mr_enclave: String,
package_url: String,
hratls_pubkey: String,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct Ban {
id: RecordId,
#[serde(rename = "in")]
from_account: RecordId,
#[serde(rename = "out")]
to_account: RecordId,
created_at: Datetime,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct Kick {
id: RecordId,
#[serde(rename = "in")]
from_account: RecordId,
#[serde(rename = "out")]
to_account: RecordId,
created_at: Datetime,
reason: String,
contract: RecordId,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct Report {
#[serde(rename = "in")]
from_account: RecordId,
#[serde(rename = "out")]
to_node: RecordId,
created_at: Datetime,
reason: String,
}
impl Report {
// TODO: test this functionality and remove this comment
pub async fn create(
from_account: RecordId,
to_node: RecordId,
reason: String,
) -> Result<(), Error> {
let _: Vec<Self> = DB
.insert("report")
.relation(Report { from_account, to_node, created_at: Datetime::default(), reason })
.await?;
Ok(())
}
}
#[derive(Debug, Serialize, Deserialize)]
pub struct OperatorRelation {
#[serde(rename = "in")]
pub account: RecordId,
#[serde(rename = "out")]
pub node: RecordId,
}
impl OperatorRelation {
fn new(account: &str, vm_node: &str) -> Self {
Self {
account: RecordId::from(("account", account.to_string())),
node: RecordId::from(("vm_node", vm_node.to_string())),
}
}
}
/// This is the operator obtained from the DB,
/// however the relation is defined using OperatorRelation
#[derive(Debug, Serialize, Deserialize)]
pub struct Operator {
pub account: RecordId,
pub app_nodes: u64,
pub vm_nodes: u64,
pub email: String,
pub escrow: u64,
pub reports: u64,
}
impl Operator {
pub async fn list() -> Result<Vec<Self>, Error> {
let mut result = DB
.query(format!(
"select *,
in as account,
<-account.email[0] as email,
<-account.escrow[0] as escrow,
count(->vm_node) as vm_nodes,
count(->app_node) as app_nodes,
(select in from <-account->operator->vm_node<-report).len() +
(select in from <-account->operator->app_node<-report).len()
as reports
from operator group by in;"
))
.await?;
let operators: Vec<Self> = result.take(0)?;
Ok(operators)
}
}
// TODO: delete all of these From implementation after migration 0 gets executed
impl From<&old_brain::BrainData> for Vec<VmNode> {
fn from(old_data: &old_brain::BrainData) -> Self {
let mut nodes = Vec::new();
for old_node in old_data.vm_nodes.iter() {
nodes.push(VmNode {
id: RecordId::from(("vm_node", old_node.public_key.clone())),
country: old_node.country.clone(),
region: old_node.region.clone(),
city: old_node.city.clone(),
ip: old_node.ip.clone(),
avail_mem_mb: old_node.avail_mem_mb,
avail_vcpus: old_node.avail_vcpus,
avail_storage_gbs: old_node.avail_storage_gbs,
avail_ipv4: old_node.avail_ipv4,
avail_ipv6: old_node.avail_ipv6,
avail_ports: old_node.avail_ports,
max_ports_per_vm: old_node.max_ports_per_vm,
price: old_node.price,
offline_minutes: old_node.offline_minutes,
});
}
nodes
}
}
impl From<&old_brain::BrainData> for Vec<VmContract> {
fn from(old_data: &old_brain::BrainData) -> Self {
let mut contracts = Vec::new();
for old_c in old_data.vm_contracts.iter() {
let mut mapped_ports = Vec::new();
for port in old_c.exposed_ports.iter() {
mapped_ports.push((*port, 8080 as u32));
}
contracts.push(VmContract {
id: RecordId::from((VM_CONTRACT, old_c.uuid.replace("-", ""))),
admin: RecordId::from((ACCOUNT, old_c.admin_pubkey.clone())),
vm_node: RecordId::from((VM_NODE, old_c.node_pubkey.clone())),
state: "active".to_string(),
hostname: old_c.hostname.clone(),
mapped_ports,
public_ipv4: old_c.public_ipv4.clone(),
public_ipv6: old_c.public_ipv6.clone(),
disk_size_gb: old_c.disk_size_gb,
vcpus: old_c.vcpus,
memory_mb: old_c.memory_mb,
dtrfs_sha: old_c.dtrfs_sha.clone(),
kernel_sha: old_c.kernel_sha.clone(),
price_per_unit: old_c.price_per_unit,
locked_nano: old_c.locked_nano,
created_at: old_c.created_at.into(),
updated_at: old_c.updated_at.into(),
collected_at: old_c.collected_at.into(),
});
}
contracts
}
}
impl From<&old_brain::BrainData> for Vec<AppNode> {
fn from(old_data: &old_brain::BrainData) -> Self {
let mut nodes = Vec::new();
for old_node in old_data.app_nodes.iter() {
nodes.push(AppNode {
id: RecordId::from(("app_node", old_node.node_pubkey.clone())),
country: old_node.country.clone(),
region: old_node.region.clone(),
city: old_node.city.clone(),
ip: old_node.ip.clone(),
avail_mem_mb: old_node.avail_mem_mb,
avail_vcpus: old_node.avail_vcpus,
avail_storage_gbs: old_node.avail_storage_mb,
avail_ports: old_node.avail_no_of_port,
max_ports_per_app: old_node.max_ports_per_app,
price: old_node.price,
offline_minutes: old_node.offline_minutes,
});
}
nodes
}
}
impl From<&old_brain::BrainData> for Vec<AppContract> {
fn from(old_data: &old_brain::BrainData) -> Self {
let mut contracts = Vec::new();
for old_c in old_data.app_contracts.iter() {
let mut mapped_ports = Vec::new();
for port in old_c.mapped_ports.clone().into_iter().map(|(b, c)| (b as u32, c as u32)) {
mapped_ports.push(port);
}
let mr_enclave_hex = old_c
.public_package_mr_enclave
.clone()
.unwrap_or_default()
.iter()
.map(|byte| format!("{:02X}", byte))
.collect();
contracts.push(AppContract {
id: RecordId::from(("app_contract", old_c.uuid.replace("-", ""))),
admin: RecordId::from(("account", old_c.admin_pubkey.clone())),
app_node: RecordId::from(("app_node", old_c.node_pubkey.clone())),
state: "active".to_string(),
mapped_ports,
host_ipv4: old_c.host_ipv4.clone(),
disk_size_gb: old_c.disk_size_mb * 1024,
vcpus: old_c.vcpus,
memory_mb: old_c.memory_mb,
price_per_unit: old_c.price_per_unit,
locked_nano: old_c.locked_nano,
created_at: old_c.created_at.into(),
updated_at: old_c.updated_at.into(),
collected_at: old_c.collected_at.into(),
app_name: old_c.app_name.clone(),
mr_enclave: mr_enclave_hex,
package_url: old_c.package_url.clone(),
hratls_pubkey: old_c.hratls_pubkey.clone(),
});
}
contracts
}
}
impl From<&old_brain::BrainData> for Vec<Account> {
fn from(old_data: &old_brain::BrainData) -> Self {
let mut accounts = Vec::new();
for old_account in old_data.accounts.iter() {
let mut a = Account {
id: RecordId::from(("account", old_account.key())),
balance: old_account.value().balance,
tmp_locked: old_account.value().tmp_locked,
escrow: 0,
email: String::new(),
};
if let Some(operator) = old_data.operators.get(old_account.key()) {
a.escrow = operator.escrow;
a.email = operator.email.clone();
}
accounts.push(a);
}
accounts
}
}
impl From<&old_brain::BrainData> for Vec<OperatorRelation> {
fn from(old_data: &old_brain::BrainData) -> Self {
let mut operator_entries = Vec::new();
for operator in old_data.operators.clone() {
for vm_node in operator.1.vm_nodes.iter() {
operator_entries.push(OperatorRelation::new(&operator.0, vm_node));
}
for app_node in operator.1.app_nodes.iter() {
operator_entries.push(OperatorRelation::new(&operator.0, app_node));
}
}
operator_entries
}
}

226
src/grpc.rs
View File

@ -1,4 +1,5 @@
#![allow(dead_code)]
use crate::db;
use detee_shared::app_proto::AppContract;
use detee_shared::{
common_proto::{Empty, Pubkey},
@ -12,6 +13,8 @@ use detee_shared::{
use log::info;
use std::pin::Pin;
use tokio::sync::mpsc;
use tokio_stream::wrappers::ReceiverStream;
// use tokio::sync::mpsc;
// use tokio_stream::{wrappers::ReceiverStream, Stream};
use tokio_stream::Stream;
@ -19,6 +22,68 @@ use tonic::{Request, Response, Status};
pub struct BrainGeneralCliMock {}
impl From<db::Account> for AccountBalance {
fn from(account: db::Account) -> Self {
AccountBalance { balance: account.balance, tmp_locked: account.tmp_locked }
}
}
impl From<db::VmContractWithNode> for VmContract {
fn from(db_c: db::VmContractWithNode) -> Self {
let mut exposed_ports = Vec::new();
for port in db_c.mapped_ports.iter() {
exposed_ports.push(port.0);
}
VmContract {
uuid: db_c.id.key().to_string(),
hostname: db_c.hostname.clone(),
admin_pubkey: db_c.admin.key().to_string(),
node_pubkey: db_c.vm_node.id.key().to_string(),
node_ip: db_c.vm_node.ip.clone(),
location: format!(
"{}, {}, {}",
db_c.vm_node.city, db_c.vm_node.region, db_c.vm_node.country
),
memory_mb: db_c.memory_mb,
vcpus: db_c.vcpus,
disk_size_gb: db_c.disk_size_gb,
mapped_ports: db_c
.mapped_ports
.iter()
.map(|(h, g)| MappedPort { host_port: *h, guest_port: *g })
.collect(),
vm_public_ipv6: db_c.public_ipv6.clone(),
vm_public_ipv4: db_c.public_ipv4.clone(),
locked_nano: db_c.locked_nano,
dtrfs_sha: db_c.dtrfs_sha.clone(),
kernel_sha: db_c.kernel_sha.clone(),
nano_per_minute: db_c.price_per_minute(),
created_at: db_c.created_at.to_rfc3339(),
updated_at: db_c.updated_at.to_rfc3339(),
collected_at: db_c.collected_at.to_rfc3339(),
}
}
}
impl From<db::Error> for tonic::Status {
fn from(e: db::Error) -> Self {
Self::internal(format!("Internal error: {e}"))
}
}
impl From<db::Operator> for ListOperatorsResp {
fn from(db_o: db::Operator) -> Self {
ListOperatorsResp {
pubkey: db_o.account.key().to_string(),
escrow: db_o.escrow,
email: db_o.email,
app_nodes: db_o.app_nodes,
vm_nodes: db_o.vm_nodes,
reports: db_o.reports,
}
}
}
#[tonic::async_trait]
impl BrainGeneralCli for BrainGeneralCliMock {
type ListAccountsStream = Pin<Box<dyn Stream<Item = Result<Account, Status>> + Send>>;
@ -29,47 +94,42 @@ impl BrainGeneralCli for BrainGeneralCliMock {
Pin<Box<dyn Stream<Item = Result<ListOperatorsResp, Status>> + Send>>;
async fn get_balance(&self, req: Request<Pubkey>) -> Result<Response<AccountBalance>, Status> {
let _req = check_sig_from_req(req)?;
todo!("Ok(Response::new(self.data.get_balance(&req.pubkey).into()))")
let req = check_sig_from_req(req)?;
Ok(Response::new(db::Account::get(&req.pubkey).await?.into()))
}
async fn report_node(&self, req: Request<ReportNodeReq>) -> Result<Response<Empty>, Status> {
let _req = check_sig_from_req(req)?;
todo!();
// match self.data.find_any_contract_by_uuid(&req.contract) {
// Ok((Some(vm_contract), _))
// if vm_contract.admin_pubkey == req.admin_pubkey
// && vm_contract.node_pubkey == req.node_pubkey =>
// {
// ()
// }
// Ok((_, Some(app_contract)))
// if app_contract.admin_pubkey == req.admin_pubkey
// && app_contract.node_pubkey == req.node_pubkey =>
// {
// ()
// }
// _ => return Err(Status::unauthenticated("No contract found by this ID.")),
// };
// self.data.report_any_node(req.admin_pubkey, &req.node_pubkey, req.reason);
// Ok(Response::new(Empty {}))
let req = check_sig_from_req(req)?;
let (account, node) = match db::VmContractWithNode::get_by_uuid(&req.contract).await? {
Some(vm_contract)
if vm_contract.admin.key().to_string() == req.admin_pubkey
&& vm_contract.vm_node.id.key().to_string() == req.node_pubkey =>
{
(vm_contract.admin, vm_contract.vm_node.id)
}
_ => {
// TODO: Hey, Noor! Please add app contract here.
return Err(Status::unauthenticated("No contract found by this ID."));
}
};
db::Report::create(account, node, req.reason).await?;
Ok(Response::new(Empty {}))
}
async fn list_operators(
&self,
_req: Request<Empty>,
req: Request<Empty>,
) -> Result<Response<Self::ListOperatorsStream>, Status> {
todo!();
// let _ = check_sig_from_req(req)?;
// let operators = self.data.list_operators();
// let (tx, rx) = mpsc::channel(6);
// tokio::spawn(async move {
// for op in operators {
// let _ = tx.send(Ok(op.into())).await;
// }
// });
// let output_stream = ReceiverStream::new(rx);
// Ok(Response::new(Box::pin(output_stream) as Self::ListOperatorsStream))
let _ = check_sig_from_req(req)?;
let operators = db::Operator::list().await?;
let (tx, rx) = mpsc::channel(6);
tokio::spawn(async move {
for op in operators {
let _ = tx.send(Ok(op.into())).await;
}
});
let output_stream = ReceiverStream::new(rx);
Ok(Response::new(Box::pin(output_stream) as Self::ListOperatorsStream))
}
async fn inspect_operator(
@ -114,12 +174,11 @@ impl BrainGeneralCli for BrainGeneralCliMock {
// admin commands
async fn airdrop(&self, _req: Request<AirdropReq>) -> Result<Response<Empty>, Status> {
todo!();
// check_admin_key(&req)?;
// let req = check_sig_from_req(req)?;
// self.data.give_airdrop(&req.pubkey, req.tokens);
// Ok(Response::new(Empty {}))
async fn airdrop(&self, req: Request<AirdropReq>) -> Result<Response<Empty>, Status> {
check_admin_key(&req)?;
let req = check_sig_from_req(req)?;
db::Account::airdrop(&req.pubkey, req.tokens).await?;
Ok(Response::new(Empty {}))
}
async fn slash(&self, _req: Request<SlashReq>) -> Result<Response<Empty>, Status> {
@ -268,32 +327,32 @@ impl BrainVmCli for BrainVmCliMock {
"CLI {} requested ListVMVmContractsStream. As operator: {}",
req.wallet, req.as_operator
);
todo!();
// let mut contracts = Vec::new();
// if !req.uuid.is_empty() {
// if let Ok(specific_contract) = self.data.find_contract_by_uuid(&req.uuid) {
// if specific_contract.admin_pubkey == req.wallet {
// contracts.push(specific_contract);
// }
// // TODO: allow operator to inspect contracts
// }
// } else {
// if req.as_operator {
// contracts.append(&mut self.data.find_vm_contracts_by_operator(&req.wallet));
// } else {
// contracts.append(&mut self.data.find_vm_contracts_by_admin(&req.wallet));
// }
// }
// let (tx, rx) = mpsc::channel(6);
// tokio::spawn(async move {
// for contract in contracts {
// let _ = tx.send(Ok(contract.into())).await;
// }
// });
// let output_stream = ReceiverStream::new(rx);
// Ok(Response::new(
// Box::pin(output_stream) as Self::ListVmContractsStream
// ))
let mut contracts = Vec::new();
if !req.uuid.is_empty() {
if let Some(specific_contract) = db::VmContractWithNode::get_by_uuid(&req.uuid).await? {
if specific_contract.admin.key().to_string() == req.wallet {
contracts.push(specific_contract.into());
}
// TODO: allow operator to inspect contracts
}
} else {
if req.as_operator {
contracts.append(
&mut db::VmContractWithNode::list_by_operator(&req.wallet).await?.into(),
);
} else {
contracts
.append(&mut db::VmContractWithNode::list_by_admin(&req.wallet).await?.into());
}
}
let (tx, rx) = mpsc::channel(6);
tokio::spawn(async move {
for contract in contracts {
let _ = tx.send(Ok(contract.into())).await;
}
});
let output_stream = ReceiverStream::new(rx);
Ok(Response::new(Box::pin(output_stream) as Self::ListVmContractsStream))
}
async fn list_vm_nodes(
@ -356,13 +415,26 @@ macro_rules! impl_pubkey_getter {
impl_pubkey_getter!(Pubkey, pubkey);
impl_pubkey_getter!(NewVmReq, admin_pubkey);
impl_pubkey_getter!(DeleteVmReq, admin_pubkey);
impl_pubkey_getter!(ReportNodeReq, admin_pubkey);
impl_pubkey_getter!(UpdateVmReq, admin_pubkey);
impl_pubkey_getter!(ExtendVmReq, admin_pubkey);
impl_pubkey_getter!(ReportNodeReq, admin_pubkey);
impl_pubkey_getter!(ListVmContractsReq, wallet);
impl_pubkey_getter!(RegisterVmNodeReq, node_pubkey);
impl_pubkey_getter!(RegOperatorReq, pubkey);
impl_pubkey_getter!(KickReq, operator_wallet);
impl_pubkey_getter!(BanUserReq, operator_wallet);
impl_pubkey_getter!(VmNodeFilters);
impl_pubkey_getter!(Empty);
impl_pubkey_getter!(AirdropReq);
impl_pubkey_getter!(SlashReq);
// impl_pubkey_getter!(NewAppReq, admin_pubkey);
// impl_pubkey_getter!(DelAppReq, admin_pubkey);
// impl_pubkey_getter!(ListAppContractsReq, admin_pubkey);
//
// impl_pubkey_getter!(RegisterAppNodeReq);
// impl_pubkey_getter!(AppNodeFilters);
fn check_sig_from_req<T: std::fmt::Debug + PubkeyGetter>(req: Request<T>) -> Result<T, Status> {
let time = match req.metadata().get("timestamp") {
@ -426,3 +498,25 @@ fn check_sig_from_req<T: std::fmt::Debug + PubkeyGetter>(req: Request<T>) -> Res
}
Ok(req)
}
const ADMIN_ACCOUNTS: &[&str] = &[
"x52w7jARC5erhWWK65VZmjdGXzBK6ZDgfv1A283d8XK",
"FHuecMbeC1PfjkW2JKyoicJAuiU7khgQT16QUB3Q1XdL",
"H21Shi4iE7vgfjWEQNvzmpmBMJSaiZ17PYUcdNoAoKNc",
];
fn check_admin_key<T>(req: &Request<T>) -> Result<(), Status> {
let pubkey = match req.metadata().get("pubkey") {
Some(p) => p.clone(),
None => return Err(Status::unauthenticated("pubkey not found in metadata.")),
};
let pubkey = pubkey
.to_str()
.map_err(|_| Status::unauthenticated("could not parse pubkey metadata to str"))?;
if !ADMIN_ACCOUNTS.contains(&pubkey) {
return Err(Status::unauthenticated("This operation is reserved to admin accounts"));
}
Ok(())
}

2
src/lib.rs
View File

@ -1,3 +1,3 @@
pub mod grpc;
pub mod models;
pub mod db;
pub mod old_brain;

321
src/models.rs
View File

@ -1,321 +0,0 @@
use serde::{Deserialize, Serialize};
use std::sync::LazyLock;
use surrealdb::{
engine::remote::ws::{Client, Ws},
opt::auth::Root,
sql::Datetime,
RecordId, Surreal,
};
use crate::old_brain;
static DB: LazyLock<Surreal<Client>> = LazyLock::new(Surreal::init);
async fn init() -> surrealdb::Result<()> {
DB.connect::<Ws>("localhost:8000").await?;
// Sign in to the server
DB.signin(Root { username: "root", password: "root" }).await?;
DB.use_ns("brain").use_db("migration").await?;
Ok(())
}
pub async fn migrate(old_data: &old_brain::BrainData) -> surrealdb::Result<()> {
let accounts: Vec<Account> = old_data.into();
let vm_nodes: Vec<VmNode> = old_data.into();
let app_nodes: Vec<AppNode> = old_data.into();
let vm_contracts: Vec<VmContract> = old_data.into();
let operators: Vec<Operator> = old_data.into();
init().await?;
println!("Inserting accounts...");
let _: Vec<Account> = DB.insert(()).content(accounts).await?;
println!("Inserting vm nodes...");
let _: Vec<VmNode> = DB.insert(()).content(vm_nodes).await?;
println!("Inserting app nodes...");
let _: Vec<AppNode> = DB.insert(()).content(app_nodes).await?;
println!("Inserting vm contracts...");
let _: Vec<VmContract> = DB.insert("vm_contract").relation(vm_contracts).await?;
println!("Inserting operators...");
let _: Vec<Operator> = DB.insert("operator").relation(operators).await?;
Ok(())
}
// I am not deleting this example cause I might need it later.
//
// async fn get_wallet_contracts() -> surrealdb::Result<Vec<Wallet>> {
// let mut result = DB
// .query("select *, ->contract.* from wallet:address1;")
// .await?;
// let wallets: Vec<Wallet> = result.take(0)?;
// Ok(wallets)
// }
//
// #[derive(Debug, Serialize, Deserialize)]
// pub struct Wallet {
// balance: u64,
// id: RecordId,
// #[serde(rename = "->contract", default)]
// contracts: Vec<Contract>,
// }
#[derive(Debug, Serialize, Deserialize)]
pub struct Account {
id: RecordId,
balance: u64,
tmp_locked: u64,
escrow: u64,
email: String,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct VmNode {
id: RecordId,
country: String,
region: String,
city: String,
ip: String,
avail_mem_mb: u32,
avail_vcpus: u32,
avail_storage_gbs: u32,
avail_ipv4: u32,
avail_ipv6: u32,
avail_ports: u32,
max_ports_per_vm: u32,
price: u64,
offline_minutes: u64,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct VmContract {
id: RecordId,
#[serde(rename = "in")]
admin: RecordId,
#[serde(rename = "out")]
vm_node: RecordId,
state: String,
hostname: String,
mapped_ports: Vec<(u32, u32)>,
public_ipv4: String,
public_ipv6: String,
disk_size_gb: u32,
vcpus: u32,
memory_mb: u32,
dtrfs_sha: String,
kernel_sha: String,
created_at: Datetime,
updated_at: Datetime,
price_per_unit: u64,
locked_nano: u64,
collected_at: Datetime,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct AppNode {
id: RecordId,
country: String,
region: String,
city: String,
ip: String,
avail_mem_mb: u32,
avail_vcpus: u32,
avail_storage_gbs: u32,
avail_ports: u32,
max_ports_per_app: u32,
price: u64,
offline_minutes: u64,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct AppContract {
id: RecordId,
#[serde(rename = "in")]
admin: RecordId,
#[serde(rename = "out")]
app_node: RecordId,
state: String,
app_name: String,
mapped_ports: Vec<(u64, u64)>,
host_ipv4: String,
vcpus: u64,
memory_mb: u64,
disk_size_gb: u64,
created_at: Datetime,
updated_at: Datetime,
price_per_unit: u64,
locked_nano: u64,
collected_at: Datetime,
mr_enclave: String,
package_url: String,
hratls_pubkey: String,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct Ban {
id: RecordId,
#[serde(rename = "in")]
from_account: RecordId,
#[serde(rename = "out")]
to_account: RecordId,
created_at: Datetime,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct Kick {
id: RecordId,
#[serde(rename = "in")]
from_account: RecordId,
#[serde(rename = "out")]
to_account: RecordId,
created_at: Datetime,
reason: String,
contract: RecordId,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct Report {
id: RecordId,
#[serde(rename = "in")]
from_account: RecordId,
#[serde(rename = "out")]
to_node: RecordId,
created_at: Datetime,
reason: String,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct Operator {
#[serde(rename = "in")]
account: RecordId,
#[serde(rename = "out")]
node: RecordId,
}
impl Operator {
fn new(account: &str, vm_node: &str) -> Self {
Self {
account: RecordId::from(("account", account.to_string())),
node: RecordId::from(("vm_node", vm_node.to_string())),
}
}
}
// TODO: delete all of these From implementation after migration 0 gets executed
impl From<&old_brain::BrainData> for Vec<VmNode> {
fn from(old_data: &old_brain::BrainData) -> Self {
let mut nodes = Vec::new();
for old_node in old_data.vm_nodes.iter() {
nodes.push(VmNode {
id: RecordId::from(("vm_node", old_node.public_key.clone())),
country: old_node.country.clone(),
region: old_node.region.clone(),
city: old_node.city.clone(),
ip: old_node.ip.clone(),
avail_mem_mb: old_node.avail_mem_mb,
avail_vcpus: old_node.avail_vcpus,
avail_storage_gbs: old_node.avail_storage_gbs,
avail_ipv4: old_node.avail_ipv4,
avail_ipv6: old_node.avail_ipv6,
avail_ports: old_node.avail_ports,
max_ports_per_vm: old_node.max_ports_per_vm,
price: old_node.price,
offline_minutes: old_node.offline_minutes,
});
}
nodes
}
}
impl From<&old_brain::BrainData> for Vec<VmContract> {
fn from(old_data: &old_brain::BrainData) -> Self {
let mut contracts = Vec::new();
for old_c in old_data.vm_contracts.iter() {
let mut mapped_ports = Vec::new();
for port in old_c.exposed_ports.iter() {
mapped_ports.push((*port, 8080 as u32));
}
contracts.push(VmContract {
id: RecordId::from(("vm_contract", old_c.uuid.replace("-", ""))),
admin: RecordId::from(("account", old_c.admin_pubkey.clone())),
vm_node: RecordId::from(("vm_node", old_c.node_pubkey.clone())),
state: "active".to_string(),
hostname: old_c.hostname.clone(),
mapped_ports,
public_ipv4: old_c.public_ipv4.clone(),
public_ipv6: old_c.public_ipv6.clone(),
disk_size_gb: old_c.disk_size_gb,
vcpus: old_c.vcpus,
memory_mb: old_c.memory_mb,
dtrfs_sha: old_c.dtrfs_sha.clone(),
kernel_sha: old_c.kernel_sha.clone(),
price_per_unit: old_c.price_per_unit,
locked_nano: old_c.locked_nano,
created_at: old_c.created_at.into(),
updated_at: old_c.updated_at.into(),
collected_at: old_c.collected_at.into(),
});
}
contracts
}
}
impl From<&old_brain::BrainData> for Vec<AppNode> {
fn from(old_data: &old_brain::BrainData) -> Self {
let mut nodes = Vec::new();
for old_node in old_data.app_nodes.iter() {
nodes.push(AppNode {
id: RecordId::from(("app_node", old_node.node_pubkey.clone())),
country: old_node.country.clone(),
region: old_node.region.clone(),
city: old_node.city.clone(),
ip: old_node.ip.clone(),
avail_mem_mb: old_node.avail_mem_mb,
avail_vcpus: old_node.avail_vcpus,
avail_storage_gbs: old_node.avail_storage_mb,
avail_ports: old_node.avail_no_of_port,
max_ports_per_app: old_node.max_ports_per_app,
price: old_node.price,
offline_minutes: old_node.offline_minutes,
});
}
nodes
}
}
impl From<&old_brain::BrainData> for Vec<Account> {
fn from(old_data: &old_brain::BrainData) -> Self {
let mut accounts = Vec::new();
for old_account in old_data.accounts.iter() {
let mut a = Account {
id: RecordId::from(("account", old_account.key())),
balance: old_account.value().balance,
tmp_locked: old_account.value().tmp_locked,
escrow: 0,
email: String::new(),
};
if let Some(operator) = old_data.operators.get(old_account.key()) {
a.escrow = operator.escrow;
a.email = operator.email.clone();
}
accounts.push(a);
}
accounts
}
}
impl From<&old_brain::BrainData> for Vec<Operator> {
fn from(old_data: &old_brain::BrainData) -> Self {
let mut operator_entries = Vec::new();
for operator in old_data.operators.clone() {
for vm_node in operator.1.vm_nodes.iter() {
operator_entries.push(Operator::new(&operator.0, vm_node));
}
for app_node in operator.1.app_nodes.iter() {
operator_entries.push(Operator::new(&operator.0, app_node));
}
}
operator_entries
}
}