Implement service ordering.

Cargo.lock

@@ -2,6 +2,41 @@
 # It is not intended for manual editing.
 version = 3
 
+[[package]]
+name = "aead"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c192eb8f11fc081b0fe4259ba5af04217d4e0faddd02417310a927911abd7c8"
+dependencies = [
+ "crypto-common",
+ "generic-array",
+]
+
+[[package]]
+name = "aes"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "433cfd6710c9986c576a25ca913c39d66a6474107b406f34f91d4a8923395241"
+dependencies = [
+ "cfg-if",
+ "cipher",
+ "cpufeatures",
+]
+
+[[package]]
+name = "aes-gcm"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "82e1366e0c69c9f927b1fa5ce2c7bf9eafc8f9268c0b9800729e8b267612447c"
+dependencies = [
+ "aead",
+ "aes",
+ "cipher",
+ "ctr",
+ "ghash",
+ "subtle",
+]
+
 [[package]]
 name = "autocfg"
 version = "1.1.0"
@@ -23,6 +58,21 @@ version = "1.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
+[[package]]
+name = "block-buffer"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4152116fd6e9dadb291ae18fc1ec3575ed6d84c29642d97890f4b4a3417297e4"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "byteorder"
+version = "1.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
+
 [[package]]
 name = "cc"
 version = "1.0.76"
@@ -35,6 +85,103 @@ version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
+[[package]]
+name = "cipher"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d1873270f8f7942c191139cb8a40fd228da6c3fd2fc376d7e92d47aa14aeb59e"
+dependencies = [
+ "crypto-common",
+ "inout",
+]
+
+[[package]]
+name = "cpufeatures"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "28d997bd5e24a5928dd43e46dc529867e207907fe0b239c3477d924f7f2ca320"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crypto-common"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
+dependencies = [
+ "generic-array",
+ "rand_core 0.6.4",
+ "typenum",
+]
+
+[[package]]
+name = "ctr"
+version = "0.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0369ee1ad671834580515889b80f2ea915f23b8be8d0daa4bbaf2ac5c7590835"
+dependencies = [
+ "cipher",
+]
+
+[[package]]
+name = "curve25519-dalek"
+version = "3.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "90f9d052967f590a76e62eb387bd0bbb1b000182c3cefe5364db6b7211651bc0"
+dependencies = [
+ "byteorder",
+ "digest",
+ "rand_core 0.5.1",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "derivative"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c6d883546668a3e2011b6a716a7330b82eabb0151b138217f632c8243e17135"
+dependencies = [
+ "proc-macro2 0.4.30",
+ "quote 0.6.13",
+ "syn 0.15.44",
+]
+
+[[package]]
+name = "digest"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3dd60d1080a57a05ab032377049e0591415d2b31afd7028356dbf3cc6dcb066"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "ed25519"
+version = "1.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e9c280362032ea4203659fc489832d0204ef09f247a0506f170dafcac08c369"
+dependencies = [
+ "serde",
+ "signature",
+]
+
+[[package]]
+name = "ed25519-dalek"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c762bae6dcaf24c4c84667b8579785430908723d5c889f469d76a41d59cc7a9d"
+dependencies = [
+ "curve25519-dalek",
+ "ed25519",
+ "rand 0.7.3",
+ "serde",
+ "serde_bytes",
+ "sha2",
+ "zeroize",
+]
+
 [[package]]
 name = "epoll"
 version = "4.3.1"
@@ -70,13 +217,71 @@ dependencies = [
 name = "fleck"
 version = "0.1.0"
 dependencies = [
+ "aes-gcm",
  "bincode",
+ "ed25519-dalek",
  "epoll",
  "lazy_static",
  "log",
+ "mio",
  "nix",
+ "rand 0.8.5",
+ "rudp",
  "serde",
  "timerfd",
+ "topological-sort",
+ "x25519-dalek",
+]
+
+[[package]]
+name = "generic-array"
+version = "0.14.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bff49e947297f3312447abdca79f45f4738097cc82b06e72054d2223f601f1b9"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.1.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fc3cb4d91f53b50155bdcfd23f6a4c39ae1969c2ae85982b135750cccaf5fce"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi 0.9.0+wasi-snapshot-preview1",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c05aeb6a22b8f62540c194aac980f2115af067bfe15a0734d7277a768d396b31"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi 0.11.0+wasi-snapshot-preview1",
+]
+
+[[package]]
+name = "ghash"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d930750de5717d2dd0b8c0d42c076c0e884c81a73e6cab859bbd2339c71e3e40"
+dependencies = [
+ "opaque-debug",
+ "polyval",
+]
+
+[[package]]
+name = "inout"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a0c10553d664a4d0bcff9f4215d0aac67a639cc68ef660840afe309b807bc9f5"
+dependencies = [
+ "generic-array",
 ]
 
 [[package]]
@@ -128,6 +333,18 @@ dependencies = [
  "fleck",
 ]
 
+[[package]]
+name = "mio"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5d732bc30207a6423068df043e3d02e0735b155ad7ce1a6f76fe2baa5b158de"
+dependencies = [
+ "libc",
+ "log",
+ "wasi 0.11.0+wasi-snapshot-preview1",
+ "windows-sys",
+]
+
 [[package]]
 name = "nix"
 version = "0.25.0"
@@ -141,6 +358,39 @@ dependencies = [
  "memoffset",
 ]
 
+[[package]]
+name = "opaque-debug"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "624a8340c38c1b80fd549087862da4ba43e08858af025b236e509b6649fc13d5"
+
+[[package]]
+name = "polyval"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ef234e08c11dfcb2e56f79fd70f6f2eb7f025c0ce2333e82f4f0518ecad30c6"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "opaque-debug",
+ "universal-hash",
+]
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
+
+[[package]]
+name = "proc-macro2"
+version = "0.4.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf3d2011ab5c909338f7887f4fc896d35932e29146c12c8d01da6b22a80ba759"
+dependencies = [
+ "unicode-xid 0.1.0",
+]
+
 [[package]]
 name = "proc-macro2"
 version = "1.0.47"
@@ -150,13 +400,103 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "quote"
+version = "0.6.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ce23b6b870e8f94f81fb0a363d65d86675884b34a09043c81e5562f11c1f8e1"
+dependencies = [
+ "proc-macro2 0.4.30",
+]
+
 [[package]]
 name = "quote"
 version = "1.0.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bbe448f377a7d6961e30f5955f9b8d106c3f5e449d493ee1b125c1d43c2b5179"
 dependencies = [
- "proc-macro2",
+ "proc-macro2 1.0.47",
+]
+
+[[package]]
+name = "rand"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a6b1679d49b24bbfe0c803429aa1874472f50d9b363131f0e89fc356b544d03"
+dependencies = [
+ "getrandom 0.1.16",
+ "libc",
+ "rand_chacha 0.2.2",
+ "rand_core 0.5.1",
+ "rand_hc",
+]
+
+[[package]]
+name = "rand"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+dependencies = [
+ "libc",
+ "rand_chacha 0.3.1",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f4c8ed856279c9737206bf725bf36935d8666ead7aa69b52be55af369d193402"
+dependencies = [
+ "ppv-lite86",
+ "rand_core 0.5.1",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "90bde5296fc891b0cef12a6d03ddccc162ce7b2aff54160af9338f8d40df6d19"
+dependencies = [
+ "getrandom 0.1.16",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+dependencies = [
+ "getrandom 0.2.8",
+]
+
+[[package]]
+name = "rand_hc"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ca3129af7b92a17112d59ad498c6f81eaf463253766b90396d39ea7a39d6613c"
+dependencies = [
+ "rand_core 0.5.1",
+]
+
+[[package]]
+name = "rudp"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed0c971a826761847f6466cd1153464763c601f78b46fb02cba5418b1e2de023"
+dependencies = [
+ "byteorder",
+ "derivative",
 ]
 
 [[package]]
@@ -182,15 +522,60 @@ dependencies = [
  "serde_derive",
 ]
 
+[[package]]
+name = "serde_bytes"
+version = "0.11.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cfc50e8183eeeb6178dcb167ae34a8051d63535023ae38b5d8d12beae193d37b"
+dependencies = [
+ "serde",
+]
+
 [[package]]
 name = "serde_derive"
 version = "1.0.147"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4f1d362ca8fc9c3e3a7484440752472d68a6caa98f1ab81d99b5dfe517cec852"
 dependencies = [
- "proc-macro2",
- "quote",
- "syn",
+ "proc-macro2 1.0.47",
+ "quote 1.0.21",
+ "syn 1.0.103",
+]
+
+[[package]]
+name = "sha2"
+version = "0.9.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4d58a1e1bf39749807d89cf2d98ac2dfa0ff1cb3faa38fbb64dd88ac8013d800"
+dependencies = [
+ "block-buffer",
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+ "opaque-debug",
+]
+
+[[package]]
+name = "signature"
+version = "1.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "74233d3b3b2f6d4b006dc19dee745e73e2a6bfb6f93607cd3b02bd5b00797d7c"
+
+[[package]]
+name = "subtle"
+version = "2.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6bdef32e8150c2a081110b42772ffe7d7c9032b606bc226c8260fd97e0976601"
+
+[[package]]
+name = "syn"
+version = "0.15.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ca4b3b69a77cbe1ffc9e198781b7acb0c7365a883670e8f1c1bc66fba79a5c5"
+dependencies = [
+ "proc-macro2 0.4.30",
+ "quote 0.6.13",
+ "unicode-xid 0.1.0",
 ]
 
 [[package]]
@@ -199,11 +584,23 @@ version = "1.0.103"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a864042229133ada95abf3b54fdc62ef5ccabe9515b64717bcb9a1919e59445d"
 dependencies = [
- "proc-macro2",
- "quote",
+ "proc-macro2 1.0.47",
+ "quote 1.0.21",
  "unicode-ident",
 ]
 
+[[package]]
+name = "synstructure"
+version = "0.12.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f36bdaa60a83aca3921b5259d5400cbf5e90fc51931376a9bd4a0eb79aa7210f"
+dependencies = [
+ "proc-macro2 1.0.47",
+ "quote 1.0.21",
+ "syn 1.0.103",
+ "unicode-xid 0.2.4",
+]
+
 [[package]]
 name = "timerfd"
 version = "1.3.0"
@@ -213,12 +610,64 @@ dependencies = [
  "rustix",
 ]
 
+[[package]]
+name = "topological-sort"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea68304e134ecd095ac6c3574494fc62b909f416c4fca77e440530221e549d3d"
+
+[[package]]
+name = "typenum"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dcf81ac59edc17cc8697ff311e8f5ef2d99fcbd9817b34cec66f90b6c3dfd987"
+
 [[package]]
 name = "unicode-ident"
 version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6ceab39d59e4c9499d4e5a8ee0e2735b891bb7308ac83dfb4e80cad195c9f6f3"
 
+[[package]]
+name = "unicode-xid"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc72304796d0818e357ead4e000d19c9c174ab23dc11093ac919054d20a6a7fc"
+
+[[package]]
+name = "unicode-xid"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f962df74c8c05a667b5ee8bcf162993134c104e96440b663c8daa176dc772d8c"
+
+[[package]]
+name = "universal-hash"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7d3160b73c9a19f7e2939a2fdad446c57c1bbbbf4d919d3213ff1267a580d8b5"
+dependencies = [
+ "crypto-common",
+ "subtle",
+]
+
+[[package]]
+name = "version_check"
+version = "0.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
+
+[[package]]
+name = "wasi"
+version = "0.9.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cccddf32554fecc6acb585f82a32a72e28b48f8c4c1883ddfeeeaa96f7d8e519"
+
+[[package]]
+name = "wasi"
+version = "0.11.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
+
 [[package]]
 name = "winapi"
 version = "0.3.9"
@@ -240,3 +689,92 @@ name = "winapi-x86_64-pc-windows-gnu"
 version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
+[[package]]
+name = "windows-sys"
+version = "0.42.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a3e1820f08b8513f676f7ab6c1f99ff312fb97b553d30ff4dd86f9f15728aa7"
+dependencies = [
+ "windows_aarch64_gnullvm",
+ "windows_aarch64_msvc",
+ "windows_i686_gnu",
+ "windows_i686_msvc",
+ "windows_x86_64_gnu",
+ "windows_x86_64_gnullvm",
+ "windows_x86_64_msvc",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.42.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41d2aa71f6f0cbe00ae5167d90ef3cfe66527d6f613ca78ac8024c3ccab9a19e"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.42.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd0f252f5a35cac83d6311b2e795981f5ee6e67eb1f9a7f64eb4500fbc4dcdb4"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.42.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fbeae19f6716841636c28d695375df17562ca208b2b7d0dc47635a50ae6c5de7"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.42.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "84c12f65daa39dd2babe6e442988fc329d6243fdce47d7d2d155b8d874862246"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.42.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf7b1b21b5362cbc318f686150e5bcea75ecedc74dd157d874d754a2ca44b0ed"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.42.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09d525d2ba30eeb3297665bd434a54297e4170c7f1a44cad4ef58095b4cd2028"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.42.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f40009d85759725a34da6d89a94e63d7bdc50a862acf0dbc7c8e488f1edcb6f5"
+
+[[package]]
+name = "x25519-dalek"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2392b6b94a576b4e2bf3c5b2757d63f10ada8020a2e4d08ac849ebcf6ea8e077"
+dependencies = [
+ "curve25519-dalek",
+ "rand_core 0.5.1",
+ "zeroize",
+]
+
+[[package]]
+name = "zeroize"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4756f7db3f7b5574938c3eb1c117038b8e07f95ee6718c0efad4ac21508f1efd"
+dependencies = [
+ "zeroize_derive",
+]
+
+[[package]]
+name = "zeroize_derive"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f8f187641dad4f680d25c4bfc4225b418165984179f26ca76ec4fb6441d3a17"
+dependencies = [
+ "proc-macro2 1.0.47",
+ "quote 1.0.21",
+ "syn 1.0.103",
+ "synstructure",
+]

fleck/.gitignore

@@ -1,3 +1,4 @@
 /target
 /Cargo.lock
 /.fleck*
+core

fleck/Cargo.toml

@@ -7,10 +7,22 @@ edition = "2021"
 
 [dependencies]
 
+# core dependencies
 serde = { version = "1.0", features = ["derive"] }
 bincode = "1.3.3"
-epoll = "4.3.1"
 log = "0.4.17"
 lazy_static = "1.4.0"
+mio = "0.8.5"
+rudp = "0.2.1"
+topological-sort = "0.2.2"
+
+# linux dependencies
+epoll = "4.3.1"
 nix = { version = "0.25.0", default-features=false, features = ["socket", "net"] }
 timerfd = "1.3.0"
+
+# crypto dependencies
+aes-gcm = "0.10.1"
+ed25519-dalek = { version = "1.0.1", features = ["serde"] }
+x25519-dalek = { version = "1.2.0" }
+rand = "0.8"

fleck/src/crypto.rs

@@ -0,0 +1,28 @@
+use ed25519_dalek::{Keypair, PublicKey};
+
+pub enum TrustLevel {
+    Unknown,
+    Distrusted,
+    // Future extension
+    // Transitively,
+    Ultimately,
+}
+
+pub struct TrustDB {}
+
+pub struct KeyExchangeInitiate {}
+
+impl crate::msg::MessageParams for KeyExchangeInitiate {
+    const NAME: &'static str = "KeyExchangeInitiate";
+    const ENCRYPTED: bool = false;
+}
+
+pub enum KeyExchange {
+    WaitForResponse(x25519_dalek::PublicKey),
+    Completed(SymmetricKey),
+}
+
+pub struct SymmetricKey {
+    key: [u8; 16],
+    nonce: [u8; 16],
+}

fleck/src/io.rs

@@ -1,4 +1,4 @@
-pub mod linux;
+// pub mod linux;
 
 lazy_static::lazy_static! {
     pub static ref MULTICAST_ADDRESS : std::net::SocketAddrV4 =
@@ -25,18 +25,36 @@ pub(crate) trait IOFeedback {
     fn major_tick(&self);
 }
 
-pub(crate) trait FleckIO {
+/*pub(crate) trait FleckIO {
     fn poll<'a>(&self, f: &dyn IOFeedback);
 
     fn local(&self) -> std::rc::Rc<dyn IOChannel>;
     fn global(&self) -> std::rc::Rc<dyn IOChannel>;
 }
 
-pub(crate) trait IOHandler {
-    fn minor(&self);
-}
-
 pub(crate) fn platform() -> std::rc::Rc<dyn FleckIO> {
     std::rc::Rc::new(linux::LinuxIO::default())
+}*/
+
+pub struct FleckIO {
+    local: Vec<std::rc::Rc<dyn IOChannel>>,
+    global: std::rc::Rc<dyn IOChannel>,
+}
+
+impl FleckIO {
+    pub(crate) fn poll(&self, f: &dyn IOFeedback) {}
+
+    pub(crate) fn local(&self) -> &std::rc::Rc<dyn IOChannel> {
+        todo!()
+    }
+
+    pub(crate) fn global(&self) -> &std::rc::Rc<dyn IOChannel> {
+        &self.global
+    }
 }
 
+impl Default for FleckIO {
+    fn default() -> Self {
+        todo!()
+    }
+}

fleck/src/io/linux.rs

@@ -191,7 +191,7 @@ impl Default for LinuxIO {
         minor.set_state(timerfd::TimerState::Periodic{ current: std::time::Duration::new(1, 0), interval: std::time::Duration::new(1, 0) }, timerfd::SetTimeFlags::Default);
 
         let mut major = timerfd::TimerFd::new().unwrap();
-        major.set_state(timerfd::TimerState::Periodic{ current: std::time::Duration::new(2, 0), interval: std::time::Duration::new(15, 0) }, timerfd::SetTimeFlags::Default);
+        major.set_state(timerfd::TimerState::Periodic{ current: std::time::Duration::new(1, 0), interval: std::time::Duration::new(15, 0) }, timerfd::SetTimeFlags::Default);
 
         poller.register_read(minor.as_raw_fd());
         poller.register_read(major.as_raw_fd());

fleck/src/lib.rs

@@ -1,98 +1,94 @@
+use std::cell::RefCell;
+use std::rc::Rc;
+
 mod msg;
 mod node;
 
+mod crypto;
 mod io;
-mod service;
+pub mod service;
 
 pub mod prelude {
     pub use crate::msg::Message;
+    pub use crate::service::{Service,API as ServiceAPI};
 }
 
-use io::{FleckIO,IOChannel};
+use crate as fleck;
 
-pub trait ServiceInterface {
-    fn send(&self, packet: io::Packet);
-}
+use prelude::*;
 
-pub trait FleckService {
-    fn process_incoming(&self, packet: &mut io::Packet) {}
-    fn process_outgoing(&self, packet: &mut io::Packet) {}
-    fn process_minor_tick(&self, si: &dyn ServiceInterface) {}
-    fn process_major_tick(&self, si: &dyn ServiceInterface) {}
-}
+use io::{FleckIO, IOChannel};
 
 pub struct Fleck {
-    io: std::rc::Rc<dyn FleckIO>,
-    services: Vec<std::rc::Rc<dyn FleckService>>,
+    io: Rc<FleckIO>,
+    services: RefCell<service::ServiceStack>,
+    message_registry: msg::MessageRegistry,
+
+    queued_packets: RefCell<Vec<io::Packet>>,
 }
 
 impl Fleck {
-    pub fn new() -> Self {
-        let mut res = Self {
-            io: io::platform(),
-            services: Vec::new()
-        };
+    pub fn new() -> Rc<Self> {
+        let mut res = Rc::new(Self {
+            io: Rc::new(FleckIO::default()),
+            services: RefCell::new(service::ServiceStack::new()),
+            message_registry: msg::MessageRegistry::new(),
+            queued_packets: RefCell::new(vec![]),
+        });
 
-        res.register_services();
+        res.register_core_services();
 
         res
     }
 
-    /*pub fn new_with_io(io: std::rc::Rc<dyn FleckIO>) -> Self {
-        Self {
-            io,
-            services: Vec::new()
-        }
-    }*/
+    fn register_core_services(&self) {
+        let mut svcs = self.services.borrow_mut();
+        // Inserted in send-processing order
 
-    fn register_services(&mut self) {
-        // Inserted in processing order
         // Local discovery
-        self.services.push(std::rc::Rc::new(service::LocalDiscovery::new(self.io.clone())));
+        svcs.give_service(service::core::LocalDiscovery::new());
 
         // Finally, send the packet
-        self.services.push(std::rc::Rc::new(service::SendPacket::new(self.io.clone())));
-    }
-
-    pub fn register_service(&mut self, srv: std::rc::Rc<dyn FleckService>) {
-        self.services.push(srv);
+        svcs.give_service(service::core::SendPacket::default());
     }
 
     pub fn run(&self) {
         self.io.poll(self);
     }
-}
 
-impl ServiceInterface for Fleck {
-     fn send(&self, mut packet: io::Packet) {
-        // process services in forwards order
-        for svc in self.services.iter() {
-            svc.process_outgoing(&mut packet);
+    fn send_queued_packets(&self) {
+        let mut svcs = self.services.borrow_mut();
+        for mut pkt in self.queued_packets.borrow_mut().drain(..) {
+            svcs.process_outgoing(self, &mut pkt);
         }
-     }
+    }
+}
+
+impl ServiceAPI for Fleck {
+    fn raw_io(&self) -> &FleckIO {
+        &self.io
+    }
+    fn send_packet(&self, pkt: io::Packet) {
+        self.queued_packets.borrow_mut().push(pkt);
+    }
 }
 
 impl io::IOFeedback for Fleck {
     fn packet(&self, mut packet: io::Packet) {
-        println!("received a packet!");
-        // received a packet!
-        // process services in reverse order
-        for svc in self.services.iter().rev() {
-            svc.process_incoming(&mut packet);
-        }
+        let mut svcs = self.services.borrow_mut();
+        svcs.process_incoming(self, &mut packet);
+        self.send_queued_packets();
     }
 
     fn minor_tick(&self) {
-        // process services in forwards order
-        for svc in self.services.iter() {
-            svc.process_minor_tick(self);
-        }
+        let mut svcs = self.services.borrow_mut();
+        svcs.process_minor_tick(self);
+        self.send_queued_packets();
     }
 
     fn major_tick(&self) {
-        // process services in forwards order
-        for svc in self.services.iter() {
-            svc.process_major_tick(self);
-        }
+        let mut svcs = self.services.borrow_mut();
+        svcs.process_major_tick(self);
+        self.send_queued_packets();
     }
 }

fleck/src/msg.rs

@@ -1,13 +1,21 @@
-use serde::{Serialize,Deserialize};
+use std::{
+    any::Any,
+    hash::{Hash, Hasher},
+};
+
+use serde::{de::DeserializeOwned, Deserialize, Serialize};
 
 const MESSAGE_MAGIC: u64 = 0x1234123412341234;
 
-#[derive(Serialize,Deserialize)]
+#[derive(Serialize, Deserialize)]
+#[repr(u16)]
 pub enum HeaderType {
     Hello,
+    KeepAlive,
+    UserType(u8),
 }
 
-#[derive(Serialize,Deserialize)]
+#[derive(Serialize, Deserialize)]
 pub struct Message {
     ht: HeaderType,
     magic: u64,
@@ -15,6 +23,48 @@ pub struct Message {
 
 impl Message {
     pub fn build(ht: HeaderType) -> Self {
-        Self { ht, magic: MESSAGE_MAGIC }
+        Self {
+            ht,
+            magic: MESSAGE_MAGIC,
+        }
+    }
+}
+
+pub(crate) struct MessageRegistry {
+    deser: std::collections::HashMap<u16, Box<dyn Fn(&[u8]) -> Option<Box<dyn std::any::Any>>>>,
+}
+
+pub trait MessageParams {
+    const NAME: &'static str;
+    const ENCRYPTED: bool;
+}
+
+impl MessageRegistry {
+    pub(crate) fn new() -> Self {
+        Self {
+            deser: Default::default(),
+        }
+    }
+
+    pub(crate) fn add_message_type<MT: MessageParams + Serialize + DeserializeOwned>(&mut self) {
+        let mut hasher = std::collections::hash_map::DefaultHasher::new();
+        MT::NAME.hash(&mut hasher);
+        let derived_typeid = (hasher.finish() & 0xffff) as u16;
+        self.deser.insert(
+            derived_typeid,
+            Box::new(|data| {
+                let r = bincode::deserialize(data).ok()?;
+                let boxed: Box<dyn Any> = Box::new(r);
+                Some(boxed)
+            }),
+        );
+    }
+
+    pub(crate) fn deserialize(&self, data: &[u8]) -> Option<Box<dyn std::any::Any>> {
+        let msg_type = u16::from_le_bytes(data[0..1].try_into().unwrap());
+        match self.deser.get(&msg_type) {
+            Some(f) => f(&data[2..]),
+            None => None,
+        }
     }
 }

fleck/src/service.rs

@@ -1,56 +1,172 @@
+use std::{rc::Rc, borrow::BorrowMut};
+use std::cell::RefCell;
+use std::ops::DerefMut;
+
 use crate::io::{FleckIO, Packet};
 
-pub(crate) struct SendPacket {
-    io: std::rc::Rc<dyn FleckIO>,
+mod lowlevel;
+mod priority;
+
+pub use priority::{Never, ServicePriority as Priority};
+
+use self::priority::AbstractServicePriority;
+
+pub mod order {
+    pub use super::priority::Never;
+
+    pub struct FirstTag;
+    pub type First = super::priority::Fixpoint<FirstTag>;
+
+    pub struct PreprocessingTag;
+    pub type Preprocessing = super::priority::Fixpoint<PreprocessingTag>;
+
+    pub struct ProcessingTag;
+    pub type Processing = super::priority::Fixpoint<ProcessingTag>;
+
+    pub struct PostprocessingTag;
+    pub type Postprocessing = super::priority::Fixpoint<PostprocessingTag>;
+
+    pub struct LastTag;
+    pub type Last = super::priority::Fixpoint<FirstTag>;
 }
 
-impl SendPacket {
-    pub(crate) fn new(io: std::rc::Rc<dyn FleckIO>) -> Self {
-        Self { io }
+pub(crate) mod core {
+    pub(crate) use super::lowlevel::{LocalDiscovery, SendPacket};
+}
+
+pub trait API {
+    fn raw_io(&self) -> &FleckIO;
+    fn send_packet(&self, pkt: Packet);
+}
+
+pub trait Service {
+    fn process_incoming(&mut self, _api: &dyn API, _packet: &mut Packet) {}
+    fn process_outgoing(&mut self, _api: &dyn API, _packet: &mut Packet) {}
+    fn process_minor_tick(&mut self, _api: &dyn API) {}
+    fn process_major_tick(&mut self, _api: &dyn API) {}
+}
+
+pub trait IncomingPriority {
+    type Priority: priority::AbstractServicePriority;
+}
+
+pub trait OutgoingPriority {
+    type Priority: priority::AbstractServicePriority;
+}
+
+#[macro_export]
+macro_rules! service_priority {
+    ($what:ty, in: $i:ty, out: $o:ty) => {
+        impl fleck::service::IncomingPriority for $what { type Priority = $i; }
+        impl fleck::service::OutgoingPriority for $what { type Priority = $o; }
+    };
+    ($what:ty, in: $i:ty) => {
+        impl fleck::service::IncomingPriority for $what { type Priority = $i; }
+        impl fleck::service::OutgoingPriority for $what { type Priority = fleck::service::order::Never; }
+    };
+    ($what:ty, out: $o:ty) => {
+        impl fleck::service::IncomingPriority for $what { type Priority = fleck::service::order::Never; }
+        impl fleck::service::OutgoingPriority for $what { type Priority = $o; }
+    };
+    ($what:ty) => {
+        impl fleck::service::IncomingPriority for $what { type Priority = fleck::service::order::Never; }
+        impl fleck::service::OutgoingPriority for $what { type Priority = fleck::service::order::Never; }
+    };
+}
+
+#[derive(Default)]
+pub struct ServiceStack {
+    services: Vec<Rc<RefCell<dyn Service>>>,
+
+    incoming_order: priority::TotalOrder<Rc<RefCell<dyn Service>>>,
+    outgoing_order: priority::TotalOrder<Rc<RefCell<dyn Service>>>,
+
+    incoming_cache: Option<Vec<Rc<RefCell<dyn Service>>>>,
+    outgoing_cache: Option<Vec<Rc<RefCell<dyn Service>>>>,
+}
+
+impl ServiceStack {
+    pub(crate) fn new() -> Self {
+        Self::default()
+        /*Self {
+            api: None,
+            services: Vec::new(),
+
+            incoming_order: Default::default(),
+            outgoing_order: Default::default(),
+        }*/
+    }
+
+    pub fn give_service<S: 'static + Service + IncomingPriority + OutgoingPriority>(
+        &mut self,
+        srv: S,
+    ) {
+        let srv = Rc::new(RefCell::new(srv));
+
+        self.incoming_cache = None;
+        self.outgoing_cache = None;
+
+        self.services.push(srv.clone());
+        if !<<S as IncomingPriority>::Priority as AbstractServicePriority>::NEVER {
+            self.incoming_order.add_priority::<<S as IncomingPriority>::Priority>(srv.clone());
+        }
+        if !<<S as OutgoingPriority>::Priority as AbstractServicePriority>::NEVER {
+            self.incoming_order.add_priority::<<S as OutgoingPriority>::Priority>(srv.clone());
+        }
     }
 }
 
-impl crate::FleckService for SendPacket {
-    fn process_outgoing(&self, packet: &mut crate::io::Packet) {
-        // use default channel if not specified
-        if packet.channel.is_none() {
-            packet.channel = Some(self.io.global());
+
+impl Service for ServiceStack {
+    fn process_incoming(&mut self, api: &dyn API, packet: &mut Packet) {
+        let services = self.incoming_cache.get_or_insert_with(|| {
+            self.incoming_order.clone().order()
+        });
+
+        for srv in services {
+            srv.as_ref().borrow_mut().deref_mut().process_incoming(api, packet);
         }
+    }
+
+    fn process_outgoing(&mut self, api: &dyn API, packet: &mut Packet) {
+        let services = self.outgoing_cache.get_or_insert_with(|| {
+            self.outgoing_order.clone().order()
+        });
 
-        // serialize if needed
-        match (packet.data.as_ref().is_some(), packet.msg.take()) {
-            (false, Some(msg)) => {
-                packet.data = Some(bincode::serialize(&msg).expect("failed to serialize message"));
-            },
-            _ => {},
+        for srv in services {
+            srv.as_ref().borrow_mut().deref_mut().process_incoming(api, packet);
         }
+        
+    }
 
-        match &mut packet.channel {
-            Some(ch) => ch.clone().send_packet(packet),
-            _ => {
-                println!("tried to send packet with no channel?");
-            }
+    fn process_minor_tick(&mut self, api: &dyn API) {
+        for srv in &self.services {
+            srv.as_ref().borrow_mut().deref_mut().process_minor_tick(api);
         }
     }
-}
 
-pub(crate) struct LocalDiscovery {
-    io: std::rc::Rc<dyn FleckIO>,
+    fn process_major_tick(&mut self, api: &dyn API) {
+        for srv in &self.services {
+            srv.as_ref().borrow_mut().deref_mut().process_major_tick(api);
+        }
+    }
 }
+/*
 
-impl LocalDiscovery {
-    pub(crate) fn new(io: std::rc::Rc<dyn FleckIO>) -> Self {
-        Self { io }
+    pub(crate) fn process<SP: FnMut(&mut dyn Service, &dyn API) -> ()>(&mut self, mut sp: SP) {
     }
-}
 
-impl crate::FleckService for LocalDiscovery {
-    fn process_major_tick(&self, si: &dyn super::ServiceInterface) {
-        si.send(Packet {
-            addr: Some(crate::io::MULTICAST_ADDRESS.clone().into()),
-            data: None,
-            channel: Some(self.io.local()),
-            msg: Some(crate::msg::Message::build(crate::msg::HeaderType::Hello)),
+    pub(crate) fn process_reverse<SP: FnMut(&mut dyn Service, &dyn API) -> ()>(
+        &mut self,
+        mut sp: SP,
+    ) {
+        let services = self.incoming_cache.get_or_insert_with(|| {
+            self.incoming_order.clone().order()
         });
+
+        for srv in self.services.iter_mut().rev() {
+            sp(srv.as_ref().borrow_mut().deref_mut(), self.api.as_ref().unwrap().as_ref());
+        }
     }
 }
+*/

fleck/src/service/lowlevel.rs

@@ -0,0 +1,54 @@
+use super::{priority, Service, API, IncomingPriority, Never, OutgoingPriority, order, Priority};
+use crate::io::Packet;
+
+use crate as fleck;
+
+crate::service_priority!(SendPacket, out: Priority<order::Postprocessing, order::Last>);
+
+#[derive(Default)]
+pub(crate) struct SendPacket {}
+
+impl Service for SendPacket {
+    fn process_outgoing(&mut self, api: &dyn API, packet: &mut crate::io::Packet) {
+        // use default channel if not specified
+        if packet.channel.is_none() {
+            packet.channel = Some(api.raw_io().global().clone());
+        }
+
+        // serialize if needed
+        match (packet.data.as_ref().is_some(), packet.msg.take()) {
+            (false, Some(msg)) => {
+                packet.data = Some(bincode::serialize(&msg).expect("failed to serialize message"));
+            }
+            _ => {}
+        }
+
+        match &mut packet.channel {
+            Some(ch) => ch.clone().send_packet(packet),
+            _ => {
+                println!("tried to send packet with no channel?");
+            }
+        }
+    }
+}
+
+
+crate::service_priority!(LocalDiscovery);
+pub(crate) struct LocalDiscovery {}
+
+impl LocalDiscovery {
+    pub(crate) fn new() -> Self {
+        Self {}
+    }
+}
+
+impl Service for LocalDiscovery {
+    fn process_major_tick(&mut self, api: &dyn API) {
+        api.send_packet(Packet {
+            addr: Some(crate::io::MULTICAST_ADDRESS.clone().into()),
+            data: None,
+            channel: Some(api.raw_io().local().clone()),
+            msg: Some(crate::msg::Message::build(crate::msg::HeaderType::Hello)),
+        });
+    }
+}

fleck/src/service/priority.rs

@@ -0,0 +1,202 @@
+use std::{
+    any::TypeId,
+    collections::{HashMap, HashSet},
+};
+
+pub trait AbstractServicePriority: 'static + Default {
+    /// What this priority comes strictly after
+    type After: AbstractServicePriority;
+    /// What this priority comes strictly before
+    type Before: AbstractServicePriority;
+
+    /// Is this a fully-abstract node that should be merged during processing?
+    const SKIP: bool = false;
+
+    /// Is this a Never sentinel type?
+    const NEVER: bool = false;
+}
+
+#[derive(Default)]
+pub struct ServicePriority<After: AbstractServicePriority, Before: AbstractServicePriority> {
+    _ghost: std::marker::PhantomData<(After, Before)>,
+}
+
+impl<After: AbstractServicePriority, Before: AbstractServicePriority> AbstractServicePriority
+    for ServicePriority<After, Before>
+{
+    type After = After;
+    type Before = Before;
+
+    const SKIP: bool = false;
+}
+
+#[derive(Default)]
+pub struct Never;
+
+pub struct MaxTag;
+pub struct MinTag;
+
+pub type MinPriority = Fixpoint<MinTag>;
+pub type MaxPriority = Fixpoint<MaxTag>;
+
+pub struct Fixpoint<Tag: 'static> {
+    _ghost: std::marker::PhantomData<Tag>
+}
+
+impl AbstractServicePriority for Never {
+    type After = Self;
+    type Before = Self;
+
+    const NEVER: bool = true;
+}
+
+impl<Tag: 'static> Default for Fixpoint<Tag> {
+    fn default() -> Self { 
+        Self { _ghost: std::marker::PhantomData }
+    }
+}
+
+impl<Tag: 'static> AbstractServicePriority for Fixpoint<Tag> {
+    type After = Self;
+    type Before = Self;
+
+    const SKIP: bool = true;
+}
+
+#[derive(Clone)]
+pub(crate) struct TotalOrder<Assoc: Clone> {
+    // directional adjacency-map of happens-after relationships
+    nodes: HashMap<TypeId, HashSet<TypeId>>,
+    associated: HashMap<TypeId, Vec<Option<Assoc>>>,
+    skip: HashSet<TypeId>,
+}
+
+impl<Assoc: Clone> Default for TotalOrder<Assoc> {
+    fn default() -> Self {
+        Self {
+            nodes: Default::default(),
+            associated: Default::default(),
+            skip: Default::default(),
+        }
+    }
+}
+
+type VisitedSet = HashSet<TypeId>;
+impl<Assoc: Clone> TotalOrder<Assoc> {
+    fn walk_priorities<SP: AbstractServicePriority>(
+        &mut self,
+        visited: &mut VisitedSet,
+        assoc: &Option<Assoc>,
+    ) {
+        let tid = TypeId::of::<SP>();
+        if visited.contains(&tid) {
+            return;
+        }
+        visited.insert(tid);
+        if SP::SKIP {
+            self.skip.insert(tid);
+        }
+
+        // add happens-after link
+        let after_id = TypeId::of::<SP::After>();
+        let before_id = TypeId::of::<SP::Before>();
+        self.nodes
+            .entry(tid)
+            .or_insert_with(|| Default::default())
+            .insert(after_id);
+        self.nodes
+            .entry(before_id)
+            .or_insert_with(|| Default::default())
+            .insert(tid);
+
+        // if we're not at an internal node, continue
+        if self
+            .associated
+            .entry(tid)
+            .or_insert(Vec::new())
+            .iter()
+            .all(Option::is_some)
+        {
+            self.walk_priorities::<SP::Before>(visited, assoc);
+            self.walk_priorities::<SP::After>(visited, assoc);
+        }
+    }
+
+    fn add_priority_internal<SP: AbstractServicePriority>(&mut self, assoc: Option<Assoc>) {
+        let tid = TypeId::of::<SP>();
+        self.associated
+            .entry(tid)
+            .or_insert_with(|| vec![])
+            .push(assoc.clone());
+
+        let mut visited = VisitedSet::default();
+        self.walk_priorities::<SP>(&mut visited, &assoc);
+    }
+
+    pub(crate) fn add_placeholder_priority<SP: AbstractServicePriority>(&mut self) {
+        self.add_priority_internal::<SP>(None);
+    }
+
+    pub(crate) fn add_priority<SP: AbstractServicePriority>(&mut self, assoc: Assoc) {
+        self.add_priority_internal::<SP>(Some(assoc));
+    }
+}
+
+impl<Assoc: Clone> TotalOrder<Assoc> {
+    pub(crate) fn order(mut self) -> Vec<Assoc> {
+        let mut tsort = topological_sort::TopologicalSort::<TypeId>::new();
+
+        for node in self.nodes {
+            tsort.insert(node.0);
+            for adj in node.1 {
+                tsort.insert(adj);
+
+                if adj != node.0 || !self.skip.contains(&adj) {
+                    tsort.add_dependency(adj, node.0);
+                }
+            }
+        }
+
+        let mut tid_order = vec![];
+        while tsort.pop().map(|tid| tid_order.push(tid)).is_some() {}
+        // we expect there to be two items left in the tsort: MaxPriority and Never
+        if tsort.len() != 0 {
+            panic!("Circular dependency detected! tsort: {:?}", tsort);
+        }
+
+        tid_order
+            .iter()
+            .map(|tid| self.associated.remove(tid))
+            .flatten()
+            .flatten()
+            .map(|a| a.unwrap())
+            .collect()
+    }
+}
+
+#[cfg(test)]
+mod order_tests {
+    use super::{AbstractServicePriority, ServicePriority, TotalOrder};
+    use super::{MaxPriority, MinPriority};
+
+    #[test]
+    fn single_priority_test() {
+        let mut order = TotalOrder::default();
+        order.add_priority::<ServicePriority<MinPriority, MaxPriority>>("simple priority");
+        // println!("nodes: {:?}", order.nodes);
+        let result = order.order();
+        // println!("ordering: {:?}", result);
+        assert_eq!(result, vec!["simple priority"]);
+    }
+
+    #[test]
+    fn two_priority_test() {
+        let mut order = TotalOrder::default();
+        type P1 = ServicePriority<MinPriority, MaxPriority>;
+        type P2 = ServicePriority<P1, MaxPriority>;
+        order.add_priority::<P1>("P1");
+        order.add_priority::<P2>("P2");
+        let result = order.order();
+        assert_eq!(result, vec!["P1", "P2"]);
+    }
+}