reactor
/
ptth
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
ptth/Cargo.lock

2565 lines
60 KiB
Plaintext
Raw Normal View History

:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
# This file is automatically @generated by Cargo.
# It is not intended for manual editing.
[[package]]
name = "ahash"
version = "0.3.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e8fd72866655d1904d6b0997d0b07ba561047d070fbe29de039031c641b61217"
dependencies = [
"const-random",
]
[[package]]
name = "aho-corasick"
version = "0.7.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7404febffaa47dac81aa44dba71523c9d069b1bdc50a77db41195149e17f68e5"
dependencies = [
"memchr",
]
[[package]]
name = "always_equal"
version = "0.1.0"
[[package]]
name = "ansi_term"
version = "0.11.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ee49baf6cb617b853aa8d93bf420db2383fab46d314482ca2803b40d5fde979b"
dependencies = [
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
"winapi",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
]
[[package]]
name = "ansi_term"
version = "0.12.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d52a9bb7ec0cf484c551830a7ce27bd20d67eac647e1befb56b0be4ee39a55d2"
dependencies = [
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
"winapi",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
]
[[package]]
name = "anyhow"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "1.0.39"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "81cddc5f91628367664cc7c69714ff08deee8a3efc54623011c772544d7b2767"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
:heavy_plus_sign: update: add ArcSwap to update gauges lock-free
2020-12-20 19:35:32 +00:00
[[package]]
name = "arc-swap"
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
version = "1.2.0"
:heavy_plus_sign: update: add ArcSwap to update gauges lock-free
2020-12-20 19:35:32 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
checksum = "d4d7d63395147b81a9e570bcc6243aaf71c017bd666d4909cfef0085bdda8d73"
:heavy_plus_sign: update: add ArcSwap to update gauges lock-free
2020-12-20 19:35:32 +00:00
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
[[package]]
name = "arrayref"
version = "0.3.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a4c527152e37cf757a3f78aae5a06fbeefdb07ccc535c980a3208ee3060dd544"
[[package]]
name = "arrayvec"
version = "0.5.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "23b62fc65de8e4e7f52534fb52b0f3ed04746ae267519eef2a83941e8085068b"
:heavy_plus_sign: update: add heim for measuring process RSS
2020-12-20 18:52:53 +00:00
[[package]]
name = "async-channel"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "1.6.1"
:heavy_plus_sign: update: add heim for measuring process RSS
2020-12-20 18:52:53 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "2114d64672151c0c5eaa5e131ec84a74f06e1e559830dabba01ca30605d66319"
:heavy_plus_sign: update: add heim for measuring process RSS
2020-12-20 18:52:53 +00:00
dependencies = [
"concurrent-queue",
"event-listener",
"futures-core",
]
[[package]]
name = "async-executor"
version = "1.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "eb877970c7b440ead138f6321a3b5395d6061183af779340b65e20c0fede9146"
dependencies = [
"async-task",
"concurrent-queue",
"fastrand",
"futures-lite",
"once_cell",
"vec-arena",
]
[[package]]
name = "async-fs"
version = "1.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8b3ca4f8ff117c37c278a2f7415ce9be55560b846b5bc4412aaa5d29c1c3dae2"
dependencies = [
"async-lock",
"blocking",
"futures-lite",
]
[[package]]
name = "async-io"
version = "1.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9315f8f07556761c3e48fec2e6b276004acf426e6dc068b2c2251854d65ee0fd"
dependencies = [
"concurrent-queue",
"fastrand",
"futures-lite",
"libc",
"log",
"nb-connect",
"once_cell",
"parking",
"polling",
"vec-arena",
"waker-fn",
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
"winapi",
:heavy_plus_sign: update: add heim for measuring process RSS
2020-12-20 18:52:53 +00:00
]
[[package]]
name = "async-lock"
version = "2.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1996609732bde4a9988bc42125f55f2af5f3c36370e27c778d5191a4a1b63bfb"
dependencies = [
"event-listener",
]
[[package]]
name = "async-net"
version = "1.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "06de475c85affe184648202401d7622afb32f0f74e02192857d0201a16defbe5"
dependencies = [
"async-io",
"blocking",
"fastrand",
"futures-lite",
]
[[package]]
name = "async-process"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "1.0.2"
:heavy_plus_sign: update: add heim for measuring process RSS
2020-12-20 18:52:53 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "ef37b86e2fa961bae5a4d212708ea0154f904ce31d1a4a7f47e1bbc33a0c040b"
:heavy_plus_sign: update: add heim for measuring process RSS
2020-12-20 18:52:53 +00:00
dependencies = [
"async-io",
"blocking",
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
"cfg-if 1.0.0",
:heavy_plus_sign: update: add heim for measuring process RSS
2020-12-20 18:52:53 +00:00
"event-listener",
"futures-lite",
"once_cell",
"signal-hook",
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
"winapi",
:heavy_plus_sign: update: add heim for measuring process RSS
2020-12-20 18:52:53 +00:00
]
[[package]]
name = "async-task"
version = "4.0.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e91831deabf0d6d7ec49552e489aed63b7456a7a3c46cff62adad428110b0af0"
[[package]]
name = "async-trait"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "0.1.48"
:heavy_plus_sign: update: add heim for measuring process RSS
2020-12-20 18:52:53 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "36ea56748e10732c49404c153638a15ec3d6211ec5ff35d9bb20e13b93576adf"
:heavy_plus_sign: update: add heim for measuring process RSS
2020-12-20 18:52:53 +00:00
dependencies = [
"proc-macro2",
"quote",
"syn",
]
[[package]]
name = "atomic-waker"
version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "065374052e7df7ee4047b1160cca5e1467a12351a40b3da123c870ba0b8eda2a"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
[[package]]
name = "atty"
version = "0.2.14"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
dependencies = [
"hermit-abi",
"libc",
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
"winapi",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
]
[[package]]
name = "autocfg"
version = "1.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cdb031dd78e28731d87d56cc8ffef4a8f36ca26c38fe2de700543e627f8a464a"
:arrow_up: deps: cargo update
2020-12-12 05:31:29 +00:00
[[package]]
name = "base64"
version = "0.13.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "904dfeac50f3cdaba28fc6f57fdcddb75f49ed61346676a78c4ffe55877802fd"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
[[package]]
name = "bitflags"
version = "1.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cf1de2fe8c75bc145a2f577add951f8134889b4795d47466a54a5c846d691693"
[[package]]
name = "blake3"
version = "0.3.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e9ff35b701f3914bdb8fad3368d822c766ef2858b2583198e41639b936f09d3f"
dependencies = [
"arrayref",
"arrayvec",
"cc",
"cfg-if 0.1.10",
"constant_time_eq",
"crypto-mac",
"digest 0.9.0",
]
[[package]]
name = "block-buffer"
version = "0.7.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c0940dc441f31689269e10ac70eb1002a3a1d3ad1390e030043662eb7fe4688b"
dependencies = [
"block-padding",
"byte-tools",
"byteorder",
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
"generic-array 0.12.4",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
]
[[package]]
name = "block-padding"
version = "0.1.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fa79dedbb091f449f1f39e53edf88d5dbe95f895dae6135a8d7b881fb5af73f5"
dependencies = [
"byte-tools",
]
:heavy_plus_sign: update: add heim for measuring process RSS
2020-12-20 18:52:53 +00:00
[[package]]
name = "blocking"
version = "1.0.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c5e170dbede1f740736619b776d7251cb1b9095c435c34d8ca9f57fcd2f335e9"
dependencies = [
"async-channel",
"async-task",
"atomic-waker",
"fastrand",
"futures-lite",
"once_cell",
]
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
[[package]]
name = "bumpalo"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "3.6.1"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "63396b8a4b9de3f4fdfb320ab6080762242f66a8ef174c49d8e19b674db4cdbe"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
[[package]]
name = "byte-tools"
version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e3b5ca7a04898ad4bcd41c90c5285445ff5b791899bb1b0abdd2a2aa791211d7"
[[package]]
name = "byteorder"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "1.4.3"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
[[package]]
name = "bytes"
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
version = "1.0.1"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
checksum = "b700ce4376041dcd0a327fd0097c41095743c4c8af8887265942faf1100bd040"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
:heavy_plus_sign: update: add heim for measuring process RSS
2020-12-20 18:52:53 +00:00
[[package]]
name = "cache-padded"
version = "1.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "631ae5198c9be5e753e5cc215e1bd73c2b466a3565173db433f52bb9d3e66dba"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
[[package]]
name = "cc"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "1.0.67"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "e3c69b077ad434294d3ce9f1f6143a2a4b89a8a2d54ef813d85003a4fd1137fd"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
[[package]]
name = "cfg-if"
version = "0.1.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"
[[package]]
name = "cfg-if"
version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
[[package]]
name = "chrono"
version = "0.4.19"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "670ad68c9088c2a963aaa298cb369688cf3f9465ce5e2d4ca10e6e0098a1ce73"
dependencies = [
"libc",
"num-integer",
"num-traits",
:star: new: add code for scraper keys to expire and have limited durations
2020-12-12 17:11:22 +00:00
"serde",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
"time",
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
"winapi",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
]
[[package]]
name = "clap"
version = "2.33.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "37e58ac78573c40708d45522f0d80fa2f01cc4f9b4e2bf749807255454312002"
dependencies = [
"ansi_term 0.11.0",
"atty",
"bitflags",
"strsim",
"textwrap",
"unicode-width",
"vec_map",
]
:heavy_plus_sign: update: add heim for measuring process RSS
2020-12-20 18:52:53 +00:00
[[package]]
name = "concurrent-queue"
version = "1.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "30ed07550be01594c6026cff2a1d7fe9c8f683caa798e12b68694ac9e88286a3"
dependencies = [
"cache-padded",
]
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
[[package]]
name = "const-random"
:arrow_up: deps: cargo update
2020-12-12 05:31:29 +00:00
version = "0.1.13"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: deps: cargo update
2020-12-12 05:31:29 +00:00
checksum = "f590d95d011aa80b063ffe3253422ed5aa462af4e9867d43ce8337562bac77c4"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
"const-random-macro",
"proc-macro-hack",
]
[[package]]
name = "const-random-macro"
:arrow_up: deps: cargo update
2020-12-12 05:31:29 +00:00
version = "0.1.13"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: deps: cargo update
2020-12-12 05:31:29 +00:00
checksum = "615f6e27d000a2bffbc7f2f6a8669179378fa27ee4d0a509e985dfc0a7defb40"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
"getrandom",
:arrow_up: deps: cargo update
2020-12-12 05:31:29 +00:00
"lazy_static",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
"proc-macro-hack",
:arrow_up: deps: cargo update
2020-12-12 05:31:29 +00:00
"tiny-keccak",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
]
[[package]]
name = "constant_time_eq"
version = "0.1.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "245097e9a4535ee1e3e3931fcfcd55a796a44c643e8596ff6566d68f09b87bbc"
[[package]]
name = "core-foundation"
version = "0.9.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0a89e2ae426ea83155dccf10c0fa6b1463ef6d5fcb44cee0b224a408fa640a62"
dependencies = [
"core-foundation-sys",
"libc",
]
[[package]]
name = "core-foundation-sys"
version = "0.8.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ea221b5284a47e40033bf9b66f35f984ec0ea2931eb03505246cd27a963f981b"
:arrow_up: deps: cargo update
2020-12-12 05:31:29 +00:00
[[package]]
name = "crunchy"
version = "0.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
[[package]]
name = "crypto-mac"
version = "0.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b584a330336237c1eecd3e94266efb216c56ed91225d634cb2991c5f3fd1aeab"
dependencies = [
"generic-array 0.14.4",
"subtle",
]
[[package]]
name = "ctrlc"
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
version = "3.1.8"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
checksum = "c15b8ec3b5755a188c141c1f6a98e76de31b936209bf066b647979e2a84764a9"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
"nix 0.20.0",
"winapi",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
]
:heavy_plus_sign: update: add heim for measuring process RSS
2020-12-20 18:52:53 +00:00
[[package]]
name = "darwin-libproc"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cc629b7cf42586fee31dae31f9ab73fa5ff5f0170016aa61be5fcbc12a90c516"
dependencies = [
"darwin-libproc-sys",
"libc",
"memchr",
]
[[package]]
name = "darwin-libproc-sys"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ef0aa083b94c54aa4cfd9bbfd37856714c139d1dc511af80270558c7ba3b4816"
dependencies = [
"libc",
]
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
[[package]]
name = "dashmap"
version = "3.11.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0f260e2fc850179ef410018660006951c1b55b79e8087e87111a2c388994b9b5"
dependencies = [
"ahash",
"cfg-if 0.1.10",
"num_cpus",
]
add debug_proxy which I can probably use to inject network problems during tests
2021-03-05 03:17:56 +00:00
[[package]]
name = "debug_proxy"
version = "0.1.0"
dependencies = [
"anyhow",
wip: debug proxy now owns a filter which can drop or modify request bodies
2021-03-06 22:58:23 +00:00
"async-trait",
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
"futures-util",
add debug_proxy which I can probably use to inject network problems during tests
2021-03-05 03:17:56 +00:00
"http",
"hyper",
"reqwest",
:arrow_up: deps: replace ulid with rusty_ulid so I can drop rand 0.6.x
2021-03-21 03:09:44 +00:00
"rusty_ulid",
add debug_proxy which I can probably use to inject network problems during tests
2021-03-05 03:17:56 +00:00
"tokio",
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
"tokio-stream",
add debug_proxy which I can probably use to inject network problems during tests
2021-03-05 03:17:56 +00:00
"tracing",
"tracing-subscriber",
]
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
[[package]]
name = "digest"
version = "0.8.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f3d0c8c8752312f9713efd397ff63acb9f85585afbf179282e720e7704954dd5"
dependencies = [
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
"generic-array 0.12.4",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
]
[[package]]
name = "digest"
version = "0.9.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d3dd60d1080a57a05ab032377049e0591415d2b31afd7028356dbf3cc6dcb066"
dependencies = [
"generic-array 0.14.4",
]
:arrow_up: deps: replace ulid with rusty_ulid so I can drop rand 0.6.x
2021-03-21 03:09:44 +00:00
[[package]]
name = "doc-comment"
version = "0.3.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fea41bba32d969b513997752735605054bc0dfa92b4c56bf1189f2e174be7a10"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
[[package]]
name = "either"
version = "1.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e78d4f1cc4ae33bbfc157ed5d5a5ef3bc29227303d595861deb238fcec4e9457"
[[package]]
name = "encoding_rs"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "0.8.28"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "80df024fbc5ac80f87dfef0d9f5209a252f2a497f7f42944cff24d8253cac065"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
"cfg-if 1.0.0",
]
:heavy_plus_sign: update: add heim for measuring process RSS
2020-12-20 18:52:53 +00:00
[[package]]
name = "event-listener"
version = "2.5.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f7531096570974c3a9dcf9e4b8e1cede1ec26cf5046219fb3b9d897503b9be59"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
[[package]]
name = "fake-simd"
version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e88a8acf291dafb59c2d96e8f59828f3838bb1a70398823ade51a84de6a6deed"
:heavy_plus_sign: update: add heim for measuring process RSS
2020-12-20 18:52:53 +00:00
[[package]]
name = "fastrand"
version = "1.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ca5faf057445ce5c9d4329e382b2ce7ca38550ef3b73a5348362d5f24e0c7fe3"
dependencies = [
"instant",
]
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
[[package]]
name = "fnv"
version = "1.0.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
[[package]]
name = "foreign-types"
version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1"
dependencies = [
"foreign-types-shared",
]
[[package]]
name = "foreign-types-shared"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"
[[package]]
name = "form_urlencoded"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "1.0.1"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "5fc25a87fa4fd2094bffb06925852034d90a17f0d1e05197d4956d3555752191"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
"matches",
"percent-encoding",
]
[[package]]
name = "futures"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "0.3.13"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "7f55667319111d593ba876406af7c409c0ebb44dc4be6132a783ccf163ea14c1"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
"futures-channel",
"futures-core",
"futures-executor",
"futures-io",
"futures-sink",
"futures-task",
"futures-util",
]
[[package]]
name = "futures-channel"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "0.3.13"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "8c2dd2df839b57db9ab69c2c9d8f3e8c81984781937fe2807dc6dcf3b2ad2939"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
"futures-core",
"futures-sink",
]
[[package]]
name = "futures-core"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "0.3.13"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "15496a72fabf0e62bdc3df11a59a3787429221dd0710ba8ef163d6f7a9112c94"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
[[package]]
name = "futures-executor"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "0.3.13"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "891a4b7b96d84d5940084b2a37632dd65deeae662c114ceaa2c879629c9c0ad1"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
"futures-core",
"futures-task",
"futures-util",
]
[[package]]
name = "futures-io"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "0.3.13"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "d71c2c65c57704c32f5241c1223167c2c3294fd34ac020c807ddbe6db287ba59"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
:heavy_plus_sign: update: add heim for measuring process RSS
2020-12-20 18:52:53 +00:00
[[package]]
name = "futures-lite"
version = "1.11.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b4481d0cd0de1d204a4fa55e7d45f07b1d958abcb06714b3446438e2eff695fb"
dependencies = [
"fastrand",
"futures-core",
"futures-io",
"memchr",
"parking",
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
"pin-project-lite",
:heavy_plus_sign: update: add heim for measuring process RSS
2020-12-20 18:52:53 +00:00
"waker-fn",
]
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
[[package]]
name = "futures-macro"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "0.3.13"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "ea405816a5139fb39af82c2beb921d52143f556038378d6db21183a5c37fbfb7"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
"proc-macro-hack",
"proc-macro2",
"quote",
"syn",
]
[[package]]
name = "futures-sink"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "0.3.13"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "85754d98985841b7d4f5e8e6fbfa4a4ac847916893ec511a2917ccd8525b8bb3"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
[[package]]
name = "futures-task"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "0.3.13"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "fa189ef211c15ee602667a6fcfe1c1fd9e07d42250d2156382820fba33c9df80"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
:heavy_plus_sign: update: add heim for measuring process RSS
2020-12-20 18:52:53 +00:00
[[package]]
name = "futures-timer"
version = "3.0.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e64b03909df88034c26dc1547e8970b91f98bdb65165d6a4e9110d94263dbb2c"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
[[package]]
name = "futures-util"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "0.3.13"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "1812c7ab8aedf8d6f2701a43e1243acdbcc2b36ab26e2ad421eb99ac963d96d1"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
"futures-channel",
"futures-core",
"futures-io",
"futures-macro",
"futures-sink",
"futures-task",
"memchr",
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
"pin-project-lite",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
"pin-utils",
"proc-macro-hack",
"proc-macro-nested",
"slab",
]
[[package]]
name = "generic-array"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "0.12.4"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "ffdf9f34f1447443d37393cc6c2b8313aebddcd96906caf34e54c68d8e57d7bd"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
"typenum",
]
[[package]]
name = "generic-array"
version = "0.14.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "501466ecc8a30d1d3b7fc9229b122b2ce8ed6e9d9223f1138d4babb253e51817"
dependencies = [
"typenum",
"version_check",
]
[[package]]
name = "getopts"
version = "0.2.21"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "14dbbfd5c71d70241ecf9e6f13737f7b5ce823821063188d7e46c41d371eebd5"
dependencies = [
"unicode-width",
]
[[package]]
name = "getrandom"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "0.2.2"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "c9495705279e7140bf035dde1f6e750c162df8b625267cd52cc44e0b156732c8"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
"cfg-if 1.0.0",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
"libc",
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
"wasi",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
]
:heavy_plus_sign: update: add heim for measuring process RSS
2020-12-20 18:52:53 +00:00
[[package]]
name = "glob"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9b919933a397b79c37e33b77bb2aa3dc8eb6e165ad809e58ff75bc7db2e34574"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
[[package]]
name = "h2"
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
version = "0.3.1"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
checksum = "d832b01df74254fe364568d6ddc294443f61cbec82816b60904303af87efae78"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
"bytes",
"fnv",
"futures-core",
"futures-sink",
"futures-util",
"http",
"indexmap",
"slab",
"tokio",
"tokio-util",
"tracing",
]
[[package]]
name = "handlebars"
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
version = "3.5.3"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
checksum = "cdb0867bbc5a3da37a753e78021d5fcf8a4db00e18dd2dd90fd36e24190e162d"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
"log",
"pest",
"pest_derive",
"quick-error",
"serde",
"serde_json",
]
[[package]]
name = "hashbrown"
version = "0.9.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d7afe4a420e3fe79967a00898cc1f4db7c8a49a9333a29f8a4bd76a253d5cd04"
[[package]]
name = "heck"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "0.3.2"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "87cbf45460356b7deeb5e3415b5563308c0a9b057c85e12b06ad551f98d0a6ac"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
"unicode-segmentation",
]
:heavy_plus_sign: update: add heim for measuring process RSS
2020-12-20 18:52:53 +00:00
[[package]]
name = "heim"
version = "0.1.0-rc.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b8a653442b9bdd11a77d3753a60443c60c4437d3acac8e6c3d4a6a9acd7cceed"
dependencies = [
"heim-common",
"heim-process",
"heim-runtime",
]
[[package]]
name = "heim-common"
version = "0.1.0-rc.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d767e6e47cf88abe7c9a5ebb4df82f180d30d9c0ba0269b6d166482461765834"
dependencies = [
"cfg-if 1.0.0",
"core-foundation",
"futures-core",
"futures-util",
"lazy_static",
"libc",
"mach",
"nix 0.19.1",
"pin-utils",
"uom",
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
"winapi",
:heavy_plus_sign: update: add heim for measuring process RSS
2020-12-20 18:52:53 +00:00
]
[[package]]
name = "heim-cpu"
version = "0.1.0-rc.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9ba5fb13a3b90581d22b4edf99e87c54316444622ae123d36816a227a7caa6df"
dependencies = [
"cfg-if 1.0.0",
"futures",
"glob",
"heim-common",
"heim-runtime",
"lazy_static",
"libc",
"mach",
"ntapi",
"smol",
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
"winapi",
:heavy_plus_sign: update: add heim for measuring process RSS
2020-12-20 18:52:53 +00:00
]
[[package]]
name = "heim-host"
version = "0.1.0-rc.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9abf6cd02bc4f6e6aa31a7f80702a2d0e574f4f2c6156a93c3550eb036304722"
dependencies = [
"cfg-if 1.0.0",
"heim-common",
"heim-runtime",
"lazy_static",
"libc",
"log",
"mach",
"ntapi",
"platforms",
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
"winapi",
:heavy_plus_sign: update: add heim for measuring process RSS
2020-12-20 18:52:53 +00:00
]
[[package]]
name = "heim-net"
version = "0.1.0-rc.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d13afa5e9b71c813c1e087bb27f51ae87d3a6d68a2bdd045bae4322dfae4948b"
dependencies = [
"bitflags",
"cfg-if 1.0.0",
"heim-common",
"heim-runtime",
"libc",
"macaddr",
"nix 0.19.1",
]
[[package]]
name = "heim-process"
version = "0.1.1-rc.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "386870aac75d29b817fe709f1ef4303553e0af369e3c71d04beceeb50ae2cf39"
dependencies = [
"async-trait",
"cfg-if 1.0.0",
"darwin-libproc",
"futures",
"heim-common",
"heim-cpu",
"heim-host",
"heim-net",
"heim-runtime",
"lazy_static",
"libc",
"mach",
"memchr",
"ntapi",
"ordered-float",
"smol",
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
"winapi",
:heavy_plus_sign: update: add heim for measuring process RSS
2020-12-20 18:52:53 +00:00
]
[[package]]
name = "heim-runtime"
version = "0.1.0-rc.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "54ec7e5238c8f0dd0cc60914d31a5a7aadd4cde74c966a76c1caed1f5224e9b8"
dependencies = [
"futures",
"futures-timer",
"once_cell",
"smol",
]
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
[[package]]
name = "hermit-abi"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "0.1.18"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "322f4de77956e22ed0e5032c359a0f1273f1f7f0d79bfa3b8ffbc730d7fbcc5c"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
"libc",
]
[[package]]
name = "http"
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
version = "0.2.3"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
checksum = "7245cd7449cc792608c3c8a9eaf69bd4eabbabf802713748fd739c98b82f0747"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
"bytes",
"fnv",
"itoa",
]
[[package]]
name = "http-body"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "0.4.1"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "5dfb77c123b4e2f72a2069aeae0b4b4949cc7e966df277813fc16347e7549737"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
"bytes",
"http",
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
"pin-project-lite",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
]
[[package]]
name = "httparse"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "1.3.5"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "615caabe2c3160b313d52ccc905335f4ed5f10881dd63dc5699d47e90be85691"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
[[package]]
name = "httpdate"
version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "494b4d60369511e7dea41cf646832512a94e542f68bb9c49e54518e0f468eb47"
[[package]]
name = "hyper"
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
version = "0.14.4"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
checksum = "e8e946c2b1349055e0b72ae281b238baf1a3ea7307c7e9f9d64673bdd9c26ac7"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
"bytes",
"futures-channel",
"futures-core",
"futures-util",
"h2",
"http",
"http-body",
"httparse",
"httpdate",
"itoa",
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
"pin-project",
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
"socket2 0.3.19",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
"tokio",
"tower-service",
"tracing",
"want",
]
[[package]]
name = "hyper-tls"
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
version = "0.5.0"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
checksum = "d6183ddfa99b85da61a140bea0efc93fdf56ceaa041b37d553518030827f9905"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
"bytes",
"hyper",
"native-tls",
"tokio",
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
"tokio-native-tls",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
]
[[package]]
name = "idna"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "0.2.2"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "89829a5d69c23d348314a7ac337fe39173b61149a9864deabd260983aed48c21"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
"matches",
"unicode-bidi",
"unicode-normalization",
]
[[package]]
name = "indexmap"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "1.6.2"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "824845a0bf897a9042383849b02c1bc219c2383772efcd5c6f9766fa4b81aef3"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
:arrow_up: deps: replace ulid with rusty_ulid so I can drop rand 0.6.x
2021-03-21 03:09:44 +00:00
"autocfg",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
"hashbrown",
]
:heavy_plus_sign: update: add heim for measuring process RSS
2020-12-20 18:52:53 +00:00
[[package]]
name = "instant"
version = "0.1.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "61124eeebbd69b8190558df225adf7e4caafce0d743919e5d6b19652314ec5ec"
dependencies = [
"cfg-if 1.0.0",
]
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
[[package]]
name = "ipnet"
version = "2.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "47be2f14c678be2fdcab04ab1171db51b2762ce6f0a8ee87c8dd4a04ed216135"
[[package]]
name = "itertools"
version = "0.9.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "284f18f85651fe11e8a991b2adb42cb078325c996ed026d994719efcfca1d54b"
dependencies = [
"either",
]
[[package]]
name = "itoa"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "0.4.7"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "dd25036021b0de88a0aff6b850051563c6516d0bf53f8638938edbb9de732736"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
[[package]]
name = "js-sys"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "0.3.49"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "dc15e39392125075f60c95ba416f5381ff6c3a948ff02ab12464715adf56c821"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
"wasm-bindgen",
]
[[package]]
name = "lazy_static"
version = "1.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
[[package]]
name = "libc"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "0.2.90"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "ba4aede83fc3617411dc6993bc8c70919750c1c257c6ca6a502aed6e0e2394ae"
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
[[package]]
name = "lock_api"
version = "0.4.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dd96ffd135b2fd7b973ac026d28085defbe8983df057ced3eb4f2130b0831312"
dependencies = [
"scopeguard",
]
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
[[package]]
name = "log"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "0.4.14"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "51b9bbe6c47d51fc3e1a9b945965946b4c44142ab8792c50835a980d362c2710"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
"cfg-if 1.0.0",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
]
:heavy_plus_sign: update: add heim for measuring process RSS
2020-12-20 18:52:53 +00:00
[[package]]
name = "macaddr"
version = "1.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "baee0bbc17ce759db233beb01648088061bf678383130602a298e6998eedb2d8"
[[package]]
name = "mach"
version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b823e83b2affd8f40a9ee8c29dbc56404c1e34cd2710921f2801e2cf29527afa"
dependencies = [
"libc",
]
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
[[package]]
name = "maplit"
version = "1.0.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3e2e65a1a2e43cfcb47a895c4c8b10d1f4a61097f9f254f183aee60cad9c651d"
[[package]]
name = "matchers"
version = "0.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f099785f7595cc4b4553a174ce30dd7589ef93391ff414dbb67f62392b9e0ce1"
dependencies = [
"regex-automata",
]
[[package]]
name = "matches"
version = "0.1.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7ffc5c5338469d4d3ea17d269fa8ea3512ad247247c30bd2df69e68309ed0a08"
[[package]]
name = "memchr"
version = "2.3.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0ee1c47aaa256ecabcaea351eae4a9b01ef39ed810004e298d2511ed284b1525"
[[package]]
name = "mime"
version = "0.3.16"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2a60c7ce501c71e03a9c9c0d35b861413ae925bd979cc7a4e30d060069aaac8d"
[[package]]
name = "mio"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "0.7.10"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "2182a122f3b7f3f5329cb1972cee089ba2459a0a80a56935e6e674f096f8d839"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
"libc",
"log",
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
"miow",
"ntapi",
"winapi",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
]
[[package]]
name = "miow"
:arrow_up: deps: cargo update
2020-12-12 05:31:29 +00:00
version = "0.3.6"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: deps: cargo update
2020-12-12 05:31:29 +00:00
checksum = "5a33c1b55807fbed163481b5ba66db4b2fa6cde694a5027be10fb724206c5897"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
"socket2 0.3.19",
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
"winapi",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
]
[[package]]
name = "native-tls"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "0.2.7"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "b8d96b2e1c8da3957d58100b09f102c6d9cfdfced01b7ec5a8974044bb09dbd4"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
"lazy_static",
"libc",
"log",
"openssl",
"openssl-probe",
"openssl-sys",
"schannel",
"security-framework",
"security-framework-sys",
"tempfile",
]
:heavy_plus_sign: update: add heim for measuring process RSS
2020-12-20 18:52:53 +00:00
[[package]]
name = "nb-connect"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "1.1.0"
:heavy_plus_sign: update: add heim for measuring process RSS
2020-12-20 18:52:53 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "a19900e7eee95eb2b3c2e26d12a874cc80aaf750e31be6fcbe743ead369fa45d"
:heavy_plus_sign: update: add heim for measuring process RSS
2020-12-20 18:52:53 +00:00
dependencies = [
"libc",
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
"socket2 0.4.0",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
]
[[package]]
name = "nix"
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
version = "0.19.1"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
checksum = "b2ccba0cfe4fdf15982d1674c69b1fd80bad427d293849982668dfe454bd61f2"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
"bitflags",
"cc",
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
"cfg-if 1.0.0",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
"libc",
]
:heavy_plus_sign: update: add heim for measuring process RSS
2020-12-20 18:52:53 +00:00
[[package]]
name = "nix"
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
version = "0.20.0"
:heavy_plus_sign: update: add heim for measuring process RSS
2020-12-20 18:52:53 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
checksum = "fa9b4819da1bc61c0ea48b63b7bc8604064dd43013e7cc325df098d49cd7c18a"
:heavy_plus_sign: update: add heim for measuring process RSS
2020-12-20 18:52:53 +00:00
dependencies = [
"bitflags",
"cc",
"cfg-if 1.0.0",
"libc",
]
[[package]]
name = "ntapi"
version = "0.3.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3f6bb902e437b6d86e03cce10a7e2af662292c5dfef23b65899ea3ac9354ad44"
dependencies = [
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
"winapi",
:heavy_plus_sign: update: add heim for measuring process RSS
2020-12-20 18:52:53 +00:00
]
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
[[package]]
name = "num-integer"
version = "0.1.44"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d2cc698a63b549a70bc047073d2949cce27cd1c7b0a4a862d08a8031bc2801db"
dependencies = [
:arrow_up: deps: replace ulid with rusty_ulid so I can drop rand 0.6.x
2021-03-21 03:09:44 +00:00
"autocfg",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
"num-traits",
]
:heavy_plus_sign: update: add heim for measuring process RSS
2020-12-20 18:52:53 +00:00
[[package]]
name = "num-rational"
version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "12ac428b1cb17fce6f731001d307d351ec70a6d202fc2e60f7d4c5e42d8f4f07"
dependencies = [
:arrow_up: deps: replace ulid with rusty_ulid so I can drop rand 0.6.x
2021-03-21 03:09:44 +00:00
"autocfg",
:heavy_plus_sign: update: add heim for measuring process RSS
2020-12-20 18:52:53 +00:00
"num-integer",
"num-traits",
]
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
[[package]]
name = "num-traits"
version = "0.2.14"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9a64b1ec5cda2586e284722486d802acf1f7dbdc623e2bfc57e65ca1cd099290"
dependencies = [
:arrow_up: deps: replace ulid with rusty_ulid so I can drop rand 0.6.x
2021-03-21 03:09:44 +00:00
"autocfg",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
]
[[package]]
name = "num_cpus"
version = "1.13.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "05499f3756671c15885fee9034446956fff3f243d6077b91e5767df161f766b3"
dependencies = [
"hermit-abi",
"libc",
]
[[package]]
name = "once_cell"
:arrow_up: deps: cargo update
2020-12-12 05:31:29 +00:00
version = "1.5.2"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: deps: cargo update
2020-12-12 05:31:29 +00:00
checksum = "13bd41f508810a131401606d54ac32a467c97172d74ba7662562ebba5ad07fa0"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
[[package]]
name = "opaque-debug"
version = "0.2.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2839e79665f131bdb5782e51f2c6c9599c133c6098982a54c794358bf432529c"
[[package]]
name = "openssl"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "0.10.33"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "a61075b62a23fef5a29815de7536d940aa35ce96d18ce0cc5076272db678a577"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
"bitflags",
:arrow_up: deps: cargo update
2020-12-12 05:31:29 +00:00
"cfg-if 1.0.0",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
"foreign-types",
"libc",
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
"once_cell",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
"openssl-sys",
]
[[package]]
name = "openssl-probe"
version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "77af24da69f9d9341038eba93a073b1fdaaa1b788221b00a69bce9e762cb32de"
[[package]]
name = "openssl-sys"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "0.9.61"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "313752393519e876837e09e1fa183ddef0be7735868dced3196f4472d536277f"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
:arrow_up: deps: replace ulid with rusty_ulid so I can drop rand 0.6.x
2021-03-21 03:09:44 +00:00
"autocfg",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
"cc",
"libc",
"pkg-config",
"vcpkg",
]
:heavy_plus_sign: update: add heim for measuring process RSS
2020-12-20 18:52:53 +00:00
[[package]]
name = "ordered-float"
version = "2.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dacdec97876ef3ede8c50efc429220641a0b11ba0048b4b0c357bccbc47c5204"
dependencies = [
"num-traits",
]
[[package]]
name = "parking"
version = "2.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "427c3892f9e783d91cc128285287e70a59e206ca452770ece88a76f7a3eddd72"
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
[[package]]
name = "parking_lot"
version = "0.11.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6d7744ac029df22dca6284efe4e898991d28e3085c706c972bcd7da4a27a15eb"
dependencies = [
"instant",
"lock_api",
"parking_lot_core",
]
[[package]]
name = "parking_lot_core"
version = "0.8.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fa7a782938e745763fe6907fc6ba86946d72f49fe7e21de074e08128a99fb018"
dependencies = [
"cfg-if 1.0.0",
"instant",
"libc",
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
"redox_syscall",
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
"smallvec",
"winapi",
]
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
[[package]]
name = "percent-encoding"
version = "2.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d4fd5641d01c8f18a23da7b6fe29298ff4b55afcccdf78973b24cf3175fee32e"
[[package]]
name = "pest"
version = "2.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "10f4872ae94d7b90ae48754df22fd42ad52ce740b8f370b03da4835417403e53"
dependencies = [
"ucd-trie",
]
[[package]]
name = "pest_derive"
version = "2.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "833d1ae558dc601e9a60366421196a8d94bc0ac980476d0b67e1d0988d72b2d0"
dependencies = [
"pest",
"pest_generator",
]
[[package]]
name = "pest_generator"
version = "2.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "99b8db626e31e5b81787b9783425769681b347011cc59471e33ea46d2ea0cf55"
dependencies = [
"pest",
"pest_meta",
"proc-macro2",
"quote",
"syn",
]
[[package]]
name = "pest_meta"
version = "2.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "54be6e404f5317079812fc8f9f5279de376d8856929e21c184ecf6bbd692a11d"
dependencies = [
"maplit",
"pest",
"sha-1",
]
[[package]]
name = "pin-project"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "1.0.5"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "96fa8ebb90271c4477f144354485b8068bd8f6b78b428b01ba892ca26caf0b63"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
"pin-project-internal",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
]
[[package]]
name = "pin-project-internal"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "1.0.5"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "758669ae3558c6f74bd2a18b41f7ac0b5a195aea6639d6a9b5e5d1ad5ba24c0b"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
"proc-macro2",
"quote",
"syn",
]
:arrow_up: deps: cargo update
2020-12-12 05:31:29 +00:00
[[package]]
name = "pin-project-lite"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "0.2.6"
:arrow_up: deps: cargo update
2020-12-12 05:31:29 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "dc0e1f259c92177c30a4c9d177246edd0a3568b25756a977d0632cf8fa37e905"
:arrow_up: deps: cargo update
2020-12-12 05:31:29 +00:00
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
[[package]]
name = "pin-utils"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
[[package]]
name = "pkg-config"
version = "0.3.19"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3831453b3449ceb48b6d9c7ad7c96d5ea673e9b470a1dc578c2ce6521230884c"
:heavy_plus_sign: update: add heim for measuring process RSS
2020-12-20 18:52:53 +00:00
[[package]]
name = "platforms"
version = "1.0.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cc77a3fc329982cbf3ea772aa265b742a550998bad65747c630406ee52dac425"
[[package]]
name = "polling"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "2.0.3"
:heavy_plus_sign: update: add heim for measuring process RSS
2020-12-20 18:52:53 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "4fc12d774e799ee9ebae13f4076ca003b40d18a11ac0f3641e6f899618580b7b"
:heavy_plus_sign: update: add heim for measuring process RSS
2020-12-20 18:52:53 +00:00
dependencies = [
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
"cfg-if 1.0.0",
:heavy_plus_sign: update: add heim for measuring process RSS
2020-12-20 18:52:53 +00:00
"libc",
"log",
"wepoll-sys",
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
"winapi",
:heavy_plus_sign: update: add heim for measuring process RSS
2020-12-20 18:52:53 +00:00
]
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
[[package]]
name = "ppv-lite86"
version = "0.2.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ac74c624d6b2d21f425f752262f42188365d7b8ff1aff74c82e45136510a4857"
[[package]]
name = "proc-macro-error"
version = "1.0.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c"
dependencies = [
"proc-macro-error-attr",
"proc-macro2",
"quote",
"syn",
"version_check",
]
[[package]]
name = "proc-macro-error-attr"
version = "1.0.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869"
dependencies = [
"proc-macro2",
"quote",
"version_check",
]
[[package]]
name = "proc-macro-hack"
version = "0.5.19"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dbf0c48bc1d91375ae5c3cd81e3722dff1abcf81a30960240640d223f59fe0e5"
[[package]]
name = "proc-macro-nested"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "0.1.7"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "bc881b2c22681370c6a780e47af9840ef841837bc98118431d4e1868bd0c1086"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
[[package]]
name = "proc-macro2"
version = "1.0.24"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1e0704ee1a7e00d7bb417d0770ea303c1bccbabf0ef1667dae92b5967f5f8a71"
dependencies = [
"unicode-xid",
]
[[package]]
name = "ptth"
:tada: release: bump versions to 1.1.0 for everything in prod I forgot to set the version in Cargo.toml files for 1.0.0. I'm not gonna do 0.x versions because this is already live somewhere and I don't like that 0.x adds complexity to versioning.
2021-01-21 02:49:32 +00:00
version = "1.1.0"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
:white_check_mark: test: add a test that uses debug_proxy
2021-03-06 18:55:05 +00:00
"anyhow",
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
"base64",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
"blake3",
:white_check_mark: test: add end-to-end test for scraper API
2020-12-13 01:54:54 +00:00
"chrono",
:recycle: refactor: debug_proxy into a lib
2021-03-05 04:03:40 +00:00
"debug_proxy",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
"ptth_relay",
"ptth_server",
"reqwest",
"tokio",
"tracing",
"tracing-subscriber",
]
[[package]]
name = "ptth_core"
:tada: release: bump versions to 1.1.0 for everything in prod I forgot to set the version in Cargo.toml files for 1.0.0. I'm not gonna do 0.x versions because this is already live somewhere and I don't like that 0.x adds complexity to versioning.
2021-01-21 02:49:32 +00:00
version = "1.1.0"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
"ctrlc",
"futures",
"hyper",
"serde",
"thiserror",
"tokio",
"tracing",
"tracing-futures",
]
[[package]]
name = "ptth_file_server"
:tada: release: bump versions to 1.1.0 for everything in prod I forgot to set the version in Cargo.toml files for 1.0.0. I'm not gonna do 0.x versions because this is already live somewhere and I don't like that 0.x adds complexity to versioning.
2021-01-21 02:49:32 +00:00
version = "1.1.0"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
"anyhow",
:heavy_plus_sign: update: add ArcSwap to update gauges lock-free
2020-12-20 19:35:32 +00:00
"arc-swap",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
"handlebars",
"http",
"hyper",
"ptth_core",
"ptth_server",
"serde",
"structopt",
"tokio",
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
"tokio-stream",
:heavy_plus_sign: update: add InstanceMetrics and replace ServerInfo
2020-12-18 20:43:34 +00:00
"tracing",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
"tracing-subscriber",
:heavy_plus_sign: update: measuring CPU usage every minute
2020-12-20 23:17:31 +00:00
"uom",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
]
:construction: wip: idea for tunneling TCP over HTTP There's a lot of missing pieces, but the big picture is like this: - Use 2 completely separate HTTP streams, and try to keep them alive as long as possible, each in basically half-duplex mode - Each stream has a long-running PUT and GET, sort of like station307 - Each end has to be terminated by a native app that either connects to a local TCP server, or acts as a local TCP server - No clue how it would work for multiple connections on the same port. Poorly, I guess? - It's probably gonna run like garbage because we're splitting TCP into 2 TCP streams, and although backpressure might work, the ACKs will be less efficient. And the congestion control might get confused My only goal is to tunnel Tracy over it, so that I can have that remotely.
2021-01-12 00:22:55 +00:00
[[package]]
name = "ptth_forwarding"
version = "0.1.0"
dependencies = [
"anyhow",
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
"base64",
update: both the downstream POCs work, with the bogus downstream.
2021-01-12 00:36:13 +00:00
"clap",
:construction: wip: idea for tunneling TCP over HTTP There's a lot of missing pieces, but the big picture is like this: - Use 2 completely separate HTTP streams, and try to keep them alive as long as possible, each in basically half-duplex mode - Each stream has a long-running PUT and GET, sort of like station307 - Each end has to be terminated by a native app that either connects to a local TCP server, or acts as a local TCP server - No clue how it would work for multiple connections on the same port. Poorly, I guess? - It's probably gonna run like garbage because we're splitting TCP into 2 TCP streams, and although backpressure might work, the ACKs will be less efficient. And the congestion control might get confused My only goal is to tunnel Tracy over it, so that I can have that remotely.
2021-01-12 00:22:55 +00:00
"futures",
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
"futures-util",
:construction: wip: idea for tunneling TCP over HTTP There's a lot of missing pieces, but the big picture is like this: - Use 2 completely separate HTTP streams, and try to keep them alive as long as possible, each in basically half-duplex mode - Each stream has a long-running PUT and GET, sort of like station307 - Each end has to be terminated by a native app that either connects to a local TCP server, or acts as a local TCP server - No clue how it would work for multiple connections on the same port. Poorly, I guess? - It's probably gonna run like garbage because we're splitting TCP into 2 TCP streams, and although backpressure might work, the ACKs will be less efficient. And the congestion control might get confused My only goal is to tunnel Tracy over it, so that I can have that remotely.
2021-01-12 00:22:55 +00:00
"reqwest",
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
"rmp-serde 0.15.4",
:construction: wip: idea for tunneling TCP over HTTP There's a lot of missing pieces, but the big picture is like this: - Use 2 completely separate HTTP streams, and try to keep them alive as long as possible, each in basically half-duplex mode - Each stream has a long-running PUT and GET, sort of like station307 - Each end has to be terminated by a native app that either connects to a local TCP server, or acts as a local TCP server - No clue how it would work for multiple connections on the same port. Poorly, I guess? - It's probably gonna run like garbage because we're splitting TCP into 2 TCP streams, and although backpressure might work, the ACKs will be less efficient. And the congestion control might get confused My only goal is to tunnel Tracy over it, so that I can have that remotely.
2021-01-12 00:22:55 +00:00
"serde",
"serde_json",
"structopt",
"thiserror",
"tokio",
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
"tokio-stream",
:construction: wip: idea for tunneling TCP over HTTP There's a lot of missing pieces, but the big picture is like this: - Use 2 completely separate HTTP streams, and try to keep them alive as long as possible, each in basically half-duplex mode - Each stream has a long-running PUT and GET, sort of like station307 - Each end has to be terminated by a native app that either connects to a local TCP server, or acts as a local TCP server - No clue how it would work for multiple connections on the same port. Poorly, I guess? - It's probably gonna run like garbage because we're splitting TCP into 2 TCP streams, and although backpressure might work, the ACKs will be less efficient. And the congestion control might get confused My only goal is to tunnel Tracy over it, so that I can have that remotely.
2021-01-12 00:22:55 +00:00
"tracing",
"tracing-futures",
"tracing-subscriber",
]
[[package]]
name = "ptth_forwarding_relay"
version = "0.1.0"
dependencies = [
"anyhow",
"futures",
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
"futures-util",
:construction: wip: idea for tunneling TCP over HTTP There's a lot of missing pieces, but the big picture is like this: - Use 2 completely separate HTTP streams, and try to keep them alive as long as possible, each in basically half-duplex mode - Each stream has a long-running PUT and GET, sort of like station307 - Each end has to be terminated by a native app that either connects to a local TCP server, or acts as a local TCP server - No clue how it would work for multiple connections on the same port. Poorly, I guess? - It's probably gonna run like garbage because we're splitting TCP into 2 TCP streams, and although backpressure might work, the ACKs will be less efficient. And the congestion control might get confused My only goal is to tunnel Tracy over it, so that I can have that remotely.
2021-01-12 00:22:55 +00:00
"hyper",
:arrow_up: deps: replace ulid with rusty_ulid so I can drop rand 0.6.x
2021-03-21 03:09:44 +00:00
"rusty_ulid",
:construction: wip: idea for tunneling TCP over HTTP There's a lot of missing pieces, but the big picture is like this: - Use 2 completely separate HTTP streams, and try to keep them alive as long as possible, each in basically half-duplex mode - Each stream has a long-running PUT and GET, sort of like station307 - Each end has to be terminated by a native app that either connects to a local TCP server, or acts as a local TCP server - No clue how it would work for multiple connections on the same port. Poorly, I guess? - It's probably gonna run like garbage because we're splitting TCP into 2 TCP streams, and although backpressure might work, the ACKs will be less efficient. And the congestion control might get confused My only goal is to tunnel Tracy over it, so that I can have that remotely.
2021-01-12 00:22:55 +00:00
"thiserror",
"tokio",
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
"tokio-stream",
:construction: wip: idea for tunneling TCP over HTTP There's a lot of missing pieces, but the big picture is like this: - Use 2 completely separate HTTP streams, and try to keep them alive as long as possible, each in basically half-duplex mode - Each stream has a long-running PUT and GET, sort of like station307 - Each end has to be terminated by a native app that either connects to a local TCP server, or acts as a local TCP server - No clue how it would work for multiple connections on the same port. Poorly, I guess? - It's probably gonna run like garbage because we're splitting TCP into 2 TCP streams, and although backpressure might work, the ACKs will be less efficient. And the congestion control might get confused My only goal is to tunnel Tracy over it, so that I can have that remotely.
2021-01-12 00:22:55 +00:00
"tracing",
"tracing-futures",
"tracing-subscriber",
]
:construction: wip: outlining idea for Redis-like KV store in ptth_server
2021-01-03 18:09:00 +00:00
[[package]]
name = "ptth_kv"
version = "0.1.0"
dependencies = [
:construction: wip: adding http service to ptth_kv
2021-01-03 20:57:12 +00:00
"anyhow",
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
"base64",
:construction: wip: adding http service to ptth_kv
2021-01-03 20:57:12 +00:00
"hyper",
:construction: wip: outlining idea for Redis-like KV store in ptth_server
2021-01-03 18:09:00 +00:00
"thiserror",
:white_check_mark: test: ptth_kv is slower with async, but still fast enough
2021-01-03 20:05:05 +00:00
"tokio",
:construction: wip: outlining idea for Redis-like KV store in ptth_server
2021-01-03 18:09:00 +00:00
]
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
[[package]]
name = "ptth_relay"
:tada: release: bump versions to 1.1.0 for everything in prod I forgot to set the version in Cargo.toml files for 1.0.0. I'm not gonna do 0.x versions because this is already live somewhere and I don't like that 0.x adds complexity to versioning.
2021-01-21 02:49:32 +00:00
version = "1.1.0"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
"base64",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
"blake3",
"chrono",
:star: new: add subcommand in ptth_relay to hash API keys from the terminal
2020-12-16 14:57:47 +00:00
"clap",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
"dashmap",
"futures",
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
"futures-util",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
"handlebars",
"http",
"hyper",
"itertools",
"ptth_core",
:arrow_up: deps: replace ulid with rusty_ulid so I can drop rand 0.6.x
2021-03-21 03:09:44 +00:00
"rand",
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
"rmp-serde 0.14.4",
:arrow_up: deps: replace ulid with rusty_ulid so I can drop rand 0.6.x
2021-03-21 03:09:44 +00:00
"rusty_ulid",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
"serde",
:construction: wip: add server list API endpoint
2020-12-14 07:07:13 +00:00
"serde_json",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
"thiserror",
"tokio",
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
"tokio-stream",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
"toml",
"tracing",
"tracing-futures",
"tracing-subscriber",
]
[[package]]
name = "ptth_server"
:tada: release: bump versions to 1.1.0 for everything in prod I forgot to set the version in Cargo.toml files for 1.0.0. I'm not gonna do 0.x versions because this is already live somewhere and I don't like that 0.x adds complexity to versioning.
2021-01-21 02:49:32 +00:00
version = "1.1.0"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
"aho-corasick",
"always_equal",
"anyhow",
:heavy_plus_sign: update: add ArcSwap to update gauges lock-free
2020-12-20 19:35:32 +00:00
"arc-swap",
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
"base64",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
"blake3",
:heavy_plus_sign: update: add InstanceMetrics and replace ServerInfo
2020-12-18 20:43:34 +00:00
"chrono",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
"futures",
"handlebars",
:heavy_plus_sign: update: add heim for measuring process RSS
2020-12-20 18:52:53 +00:00
"heim",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
"http",
"lazy_static",
"maplit",
"percent-encoding",
"ptth_core",
"pulldown-cmark",
:arrow_up: deps: replace ulid with rusty_ulid so I can drop rand 0.6.x
2021-03-21 03:09:44 +00:00
"rand",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
"regex",
"reqwest",
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
"rmp-serde 0.14.4",
:arrow_up: deps: replace ulid with rusty_ulid so I can drop rand 0.6.x
2021-03-21 03:09:44 +00:00
"rusty_ulid",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
"serde",
:star: new: add JSON API in server for dir listings
2020-12-15 05:15:17 +00:00
"serde_json",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
"structopt",
"thiserror",
"tokio",
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
"tokio-stream",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
"toml",
"tracing",
"tracing-futures",
"tracing-subscriber",
:heavy_plus_sign: update: add heim for measuring process RSS
2020-12-20 18:52:53 +00:00
"uom",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
]
:heavy_plus_sign: update: add prototype for `tail -f` based on polling
2020-12-21 00:59:05 +00:00
[[package]]
name = "ptth_tail"
version = "0.1.0"
dependencies = [
"anyhow",
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
"futures-util",
:heavy_plus_sign: update: add prototype for `tail -f` based on polling
2020-12-21 00:59:05 +00:00
"reqwest",
"tokio",
"tracing",
"tracing-subscriber",
]
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
[[package]]
name = "pulldown-cmark"
version = "0.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ffade02495f22453cd593159ea2f59827aae7f53fa8323f756799b670881dcf8"
dependencies = [
"bitflags",
"getopts",
"memchr",
"unicase",
]
[[package]]
name = "quick-error"
version = "2.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3ac73b1112776fc109b2e61909bc46c7e1bf0d7f690ffb1676553acce16d5cda"
[[package]]
name = "quote"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "1.0.9"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "c3d0b9745dc2debf507c8422de05d7226cc1f0644216dfdfead988f9b1ab32a7"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
"proc-macro2",
]
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
[[package]]
name = "rand"
version = "0.8.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0ef9e7e66b4468674bfcb0c81af8b7fa0bb154fa9f28eb840da5c447baeb8d7e"
dependencies = [
"libc",
:arrow_up: deps: replace ulid with rusty_ulid so I can drop rand 0.6.x
2021-03-21 03:09:44 +00:00
"rand_chacha",
"rand_core",
"rand_hc",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
]
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
[[package]]
name = "rand_chacha"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e12735cf05c9e10bf21534da50a147b924d555dc7a547c42e6bb2d5b6017ae0d"
dependencies = [
"ppv-lite86",
:arrow_up: deps: replace ulid with rusty_ulid so I can drop rand 0.6.x
2021-03-21 03:09:44 +00:00
"rand_core",
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
]
[[package]]
name = "rand_core"
version = "0.6.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "34cf66eb183df1c5876e2dcf6b13d57340741e8dc255b48e40a26de954d06ae7"
dependencies = [
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
"getrandom",
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
]
[[package]]
name = "rand_hc"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3190ef7066a446f2e7f42e239d161e905420ccab01eb967c9eb27d21b2322a73"
dependencies = [
:arrow_up: deps: replace ulid with rusty_ulid so I can drop rand 0.6.x
2021-03-21 03:09:44 +00:00
"rand_core",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
]
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
[[package]]
name = "redox_syscall"
version = "0.2.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "94341e4e44e24f6b591b59e47a8a027df12e008d73fd5672dbea9cc22f4507d9"
dependencies = [
"bitflags",
]
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
[[package]]
name = "regex"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "1.4.5"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "957056ecddbeba1b26965114e191d2e8589ce74db242b6ea25fc4062427a5c19"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
"aho-corasick",
"memchr",
"regex-syntax",
]
[[package]]
name = "regex-automata"
version = "0.1.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ae1ded71d66a4a97f5e961fd0cb25a5f366a42a41570d16a763a69c092c26ae4"
dependencies = [
"byteorder",
"regex-syntax",
]
[[package]]
name = "regex-syntax"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "0.6.23"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "24d5f089152e60f62d28b835fbff2cd2e8dc0baf1ac13343bef92ab7eed84548"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
[[package]]
name = "remove_dir_all"
version = "0.5.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3acd125665422973a33ac9d3dd2df85edad0f4ae9b00dafb1a05e43a9f5ef8e7"
dependencies = [
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
"winapi",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
]
[[package]]
name = "reqwest"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "0.11.2"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "bf12057f289428dbf5c591c74bf10392e4a8003f993405a902f20117019022d4"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
"base64",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
"bytes",
"encoding_rs",
"futures-core",
"futures-util",
"http",
"http-body",
"hyper",
"hyper-tls",
"ipnet",
"js-sys",
"lazy_static",
"log",
"mime",
"native-tls",
"percent-encoding",
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
"pin-project-lite",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
"serde",
"serde_urlencoded",
"tokio",
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
"tokio-native-tls",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
"url",
"wasm-bindgen",
"wasm-bindgen-futures",
"web-sys",
"winreg",
]
[[package]]
name = "rmp"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "0.8.10"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "4f55e5fa1446c4d5dd1f5daeed2a4fe193071771a2636274d0d7a3b082aa7ad6"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
"byteorder",
"num-traits",
]
[[package]]
name = "rmp-serde"
version = "0.14.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4ce7d70c926fe472aed493b902010bccc17fa9f7284145cb8772fd22fdb052d8"
dependencies = [
"byteorder",
"rmp",
"serde",
]
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
[[package]]
name = "rmp-serde"
version = "0.15.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "839395ef53057db96b84c9238ab29e1a13f2e5c8ec9f66bef853ab4197303924"
dependencies = [
"byteorder",
"rmp",
"serde",
]
:arrow_up: deps: replace ulid with rusty_ulid so I can drop rand 0.6.x
2021-03-21 03:09:44 +00:00
[[package]]
name = "rusty_ulid"
version = "0.10.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1f20752f9e92feede73bccf88845bb4004b28fac9fdcb2e0c8731d939df67b2d"
dependencies = [
"chrono",
"doc-comment",
"rand",
"serde",
]
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
[[package]]
name = "ryu"
version = "1.0.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "71d301d4193d031abdd79ff7e3dd721168a9572ef3fe51a1517aba235bd8f86e"
[[package]]
name = "schannel"
version = "0.1.19"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8f05ba609c234e60bee0d547fe94a4c7e9da733d1c962cf6e59efa4cd9c8bc75"
dependencies = [
"lazy_static",
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
"winapi",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
]
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
[[package]]
name = "scopeguard"
version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
[[package]]
name = "security-framework"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "2.1.2"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "d493c5f39e02dfb062cd8f33301f90f9b13b650e8c1b1d0fd75c19dd64bff69d"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
"bitflags",
"core-foundation",
"core-foundation-sys",
"libc",
"security-framework-sys",
]
[[package]]
name = "security-framework-sys"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "2.1.1"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "dee48cdde5ed250b0d3252818f646e174ab414036edb884dde62d80a3ac6082d"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
"core-foundation-sys",
"libc",
]
[[package]]
name = "serde"
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
version = "1.0.124"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
checksum = "bd761ff957cb2a45fbb9ab3da6512de9de55872866160b23c25f1a841e99d29f"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
"serde_derive",
]
[[package]]
name = "serde_derive"
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
version = "1.0.124"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
checksum = "1800f7693e94e186f5e25a28291ae1570da908aff7d97a095dec1e56ff99069b"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
"proc-macro2",
"quote",
"syn",
]
[[package]]
name = "serde_json"
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
version = "1.0.64"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
checksum = "799e97dc9fdae36a5c8b8f2cae9ce2ee9fdce2058c57a93e6099d919fd982f79"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
"itoa",
"ryu",
"serde",
]
[[package]]
name = "serde_urlencoded"
:arrow_up: deps: cargo update
2020-12-12 05:31:29 +00:00
version = "0.7.0"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: deps: cargo update
2020-12-12 05:31:29 +00:00
checksum = "edfa57a7f8d9c1d260a549e7224100f6c43d43f9103e06dd8b4095a9b2b43ce9"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
:arrow_up: deps: cargo update
2020-12-12 05:31:29 +00:00
"form_urlencoded",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
"itoa",
:arrow_up: deps: cargo update
2020-12-12 05:31:29 +00:00
"ryu",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
"serde",
]
[[package]]
name = "sha-1"
version = "0.8.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f7d94d0bede923b3cea61f3f1ff57ff8cdfd77b400fb8f9998949e0cf04163df"
dependencies = [
"block-buffer",
"digest 0.8.1",
"fake-simd",
"opaque-debug",
]
[[package]]
name = "sharded-slab"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "0.1.1"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "79c719719ee05df97490f80a45acfc99e5a30ce98a1e4fb67aee422745ae14e3"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
"lazy_static",
]
:heavy_plus_sign: update: add heim for measuring process RSS
2020-12-20 18:52:53 +00:00
[[package]]
name = "signal-hook"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "0.3.7"
:heavy_plus_sign: update: add heim for measuring process RSS
2020-12-20 18:52:53 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "6aa894ef3fade0ee7243422f4fbbd6c2b48e6de767e621d37ef65f2310f53cea"
:heavy_plus_sign: update: add heim for measuring process RSS
2020-12-20 18:52:53 +00:00
dependencies = [
"libc",
"signal-hook-registry",
]
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
[[package]]
name = "signal-hook-registry"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "1.3.0"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "16f1d0fef1604ba8f7a073c7e701f213e056707210e9020af4528e0101ce11a6"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
"libc",
]
[[package]]
name = "slab"
version = "0.4.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c111b5bd5695e56cffe5129854aa230b39c93a305372fdbb2668ca2394eea9f8"
[[package]]
name = "smallvec"
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
version = "1.6.1"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
checksum = "fe0f37c9e8f3c5a4a66ad655a93c74daac4ad00c441533bf5c6e7990bb42604e"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
:heavy_plus_sign: update: add heim for measuring process RSS
2020-12-20 18:52:53 +00:00
[[package]]
name = "smol"
version = "1.2.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "85cf3b5351f3e783c1d79ab5fc604eeed8b8ae9abd36b166e8b87a089efd85e4"
dependencies = [
"async-channel",
"async-executor",
"async-fs",
"async-io",
"async-lock",
"async-net",
"async-process",
"blocking",
"futures-lite",
"once_cell",
]
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
[[package]]
name = "socket2"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "0.3.19"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "122e570113d28d773067fab24266b66753f6ea915758651696b6e35e49f88d6e"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
:arrow_up: deps: cargo update
2020-12-12 05:31:29 +00:00
"cfg-if 1.0.0",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
"libc",
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
"winapi",
]
[[package]]
name = "socket2"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9e3dfc207c526015c632472a77be09cf1b6e46866581aecae5cc38fb4235dea2"
dependencies = [
"libc",
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
"winapi",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
]
[[package]]
name = "strsim"
version = "0.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8ea5119cdb4c55b55d432abb513a0429384878c15dde60cc77b1c99de1a95a6a"
[[package]]
name = "structopt"
:arrow_up: deps: cargo update
2020-12-12 05:31:29 +00:00
version = "0.3.21"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: deps: cargo update
2020-12-12 05:31:29 +00:00
checksum = "5277acd7ee46e63e5168a80734c9f6ee81b1367a7d8772a2d765df2a3705d28c"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
"clap",
"lazy_static",
"structopt-derive",
]
[[package]]
name = "structopt-derive"
:arrow_up: deps: cargo update
2020-12-12 05:31:29 +00:00
version = "0.4.14"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: deps: cargo update
2020-12-12 05:31:29 +00:00
checksum = "5ba9cdfda491b814720b6b06e0cac513d922fc407582032e8706e9f137976f90"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
"heck",
"proc-macro-error",
"proc-macro2",
"quote",
"syn",
]
[[package]]
name = "subtle"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "2.4.0"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "1e81da0851ada1f3e9d4312c704aa4f8806f0f9d69faaf8df2f3464b4a9437c2"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
[[package]]
name = "syn"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "1.0.64"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "3fd9d1e9976102a03c542daa2eff1b43f9d72306342f3f8b3ed5fb8908195d6f"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
"proc-macro2",
"quote",
"unicode-xid",
]
[[package]]
name = "tempfile"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "3.2.0"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "dac1c663cfc93810f88aed9b8941d48cabf856a1b111c29a40439018d870eb22"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
"cfg-if 1.0.0",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
"libc",
:arrow_up: deps: replace ulid with rusty_ulid so I can drop rand 0.6.x
2021-03-21 03:09:44 +00:00
"rand",
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
"redox_syscall",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
"remove_dir_all",
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
"winapi",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
]
[[package]]
name = "textwrap"
version = "0.11.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060"
dependencies = [
"unicode-width",
]
[[package]]
name = "thiserror"
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
version = "1.0.24"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
checksum = "e0f4a65597094d4483ddaed134f409b2cb7c1beccf25201a9f73c719254fa98e"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
"thiserror-impl",
]
[[package]]
name = "thiserror-impl"
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
version = "1.0.24"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
checksum = "7765189610d8241a44529806d6fd1f2e0a08734313a35d5b3a556f92b381f3c0"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
"proc-macro2",
"quote",
"syn",
]
[[package]]
name = "thread_local"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "1.1.3"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "8018d24e04c95ac8790716a5987d0fec4f8b27249ffa0f7d33f1369bdfb88cbd"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
"once_cell",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
]
[[package]]
name = "time"
version = "0.1.44"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6db9e6914ab8b1ae1c260a4ae7a49b6c5611b40328a735b21862567685e73255"
dependencies = [
"libc",
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
"wasi",
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
"winapi",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
]
:arrow_up: deps: cargo update
2020-12-12 05:31:29 +00:00
[[package]]
name = "tiny-keccak"
version = "2.0.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2c9d3793400a45f954c52e73d068316d76b6f4e36977e3fcebb13a2721e80237"
dependencies = [
"crunchy",
]
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
[[package]]
name = "tinyvec"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "1.1.1"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "317cca572a0e89c3ce0ca1f1bdc9369547fe318a683418e42ac8f59d14701023"
:arrow_up: deps: cargo update
2020-12-12 05:31:29 +00:00
dependencies = [
"tinyvec_macros",
]
[[package]]
name = "tinyvec_macros"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cda74da7e1a664f795bb1f8a87ec406fb89a02522cf6e50620d016add6dbbf5c"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
[[package]]
name = "tokio"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "1.4.0"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "134af885d758d645f0f0505c9a8b3f9bf8a348fd822e112ab5248138348f1722"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
:arrow_up: deps: replace ulid with rusty_ulid so I can drop rand 0.6.x
2021-03-21 03:09:44 +00:00
"autocfg",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
"bytes",
"libc",
"memchr",
"mio",
"num_cpus",
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
"once_cell",
"parking_lot",
"pin-project-lite",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
"signal-hook-registry",
"tokio-macros",
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
"winapi",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
]
[[package]]
name = "tokio-macros"
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
version = "1.1.0"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
checksum = "caf7b11a536f46a809a8a9f0bb4237020f70ecbf115b842360afb127ea2fda57"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
"proc-macro2",
"quote",
"syn",
]
[[package]]
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
name = "tokio-native-tls"
version = "0.3.0"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
checksum = "f7d995660bd2b7f8c1568414c1126076c13fbb725c40112dc0120b78eb9b717b"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
"native-tls",
"tokio",
]
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
[[package]]
name = "tokio-stream"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "0.1.5"
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "e177a5d8c3bf36de9ebe6d58537d8879e964332f93fb3339e43f618c81361af0"
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
dependencies = [
"futures-core",
"pin-project-lite",
"tokio",
]
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
[[package]]
name = "tokio-util"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "0.6.5"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "5143d049e85af7fbc36f5454d990e62c2df705b3589f123b71f441b6b59f443f"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
"bytes",
"futures-core",
"futures-sink",
"log",
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
"pin-project-lite",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
"tokio",
]
[[package]]
name = "toml"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "0.5.8"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "a31142970826733df8241ef35dc040ef98c679ab14d7c3e54d827099b3acecaa"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
"serde",
]
[[package]]
name = "tower-service"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "0.3.1"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "360dfd1d6d30e05fda32ace2c8c70e9c0a9da713275777f5a4dbb8a1893930c6"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
[[package]]
name = "tracing"
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
version = "0.1.25"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
checksum = "01ebdc2bb4498ab1ab5f5b73c5803825e60199229ccba0698170e3be0e7f959f"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
:arrow_up: deps: cargo update
2020-12-12 05:31:29 +00:00
"cfg-if 1.0.0",
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
"pin-project-lite",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
"tracing-attributes",
"tracing-core",
]
[[package]]
name = "tracing-attributes"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "0.1.15"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "c42e6fa53307c8a17e4ccd4dc81cf5ec38db9209f59b222210375b54ee40d1e2"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
"proc-macro2",
"quote",
"syn",
]
[[package]]
name = "tracing-core"
version = "0.1.17"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f50de3927f93d202783f4513cda820ab47ef17f624b03c096e86ef00c67e6b5f"
dependencies = [
"lazy_static",
]
[[package]]
name = "tracing-futures"
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
version = "0.2.5"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
checksum = "97d095ae15e245a057c8e8451bab9b3ee1e1f68e9ba2b4fbc18d0ac5237835f2"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
"pin-project",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
"tracing",
]
[[package]]
name = "tracing-log"
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
version = "0.1.2"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
checksum = "a6923477a48e41c1951f1999ef8bb5a3023eb723ceadafe78ffb65dc366761e3"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
"lazy_static",
"log",
"tracing-core",
]
[[package]]
name = "tracing-serde"
version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fb65ea441fbb84f9f6748fd496cf7f63ec9af5bca94dd86456978d055e8eb28b"
dependencies = [
"serde",
"tracing-core",
]
[[package]]
name = "tracing-subscriber"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "0.2.17"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "705096c6f83bf68ea5d357a6aa01829ddbdac531b357b45abeca842938085baa"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
"ansi_term 0.12.1",
"chrono",
"lazy_static",
"matchers",
"regex",
"serde",
"serde_json",
"sharded-slab",
"smallvec",
"thread_local",
"tracing",
"tracing-core",
"tracing-log",
"tracing-serde",
]
[[package]]
name = "try-lock"
version = "0.2.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "59547bce71d9c38b83d9c0e92b6066c4253371f15005def0c30d9657f50c7642"
[[package]]
name = "typenum"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "1.13.0"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "879f6906492a7cd215bfa4cf595b600146ccfac0c79bcbd1f3000162af5e8b06"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
[[package]]
name = "ucd-trie"
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "56dee185309b50d1f11bfedef0fe6d036842e3fb77413abef29f8f8d1c5d4c1c"
[[package]]
name = "unicase"
version = "2.6.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "50f37be617794602aabbeee0be4f259dc1778fabe05e2d67ee8f79326d5cb4f6"
dependencies = [
"version_check",
]
[[package]]
name = "unicode-bidi"
version = "0.3.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "49f2bd0c6468a8230e1db229cff8029217cf623c767ea5d60bfbd42729ea54d5"
dependencies = [
"matches",
]
[[package]]
name = "unicode-normalization"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "0.1.17"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "07fbfce1c8a97d547e8b5334978438d9d6ec8c20e38f56d4a4374d181493eaef"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
"tinyvec",
]
[[package]]
name = "unicode-segmentation"
:arrow_up: deps: cargo update
2020-12-12 05:31:29 +00:00
version = "1.7.1"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: deps: cargo update
2020-12-12 05:31:29 +00:00
checksum = "bb0d2e7be6ae3a5fa87eed5fb451aff96f2573d2694942e40543ae0bbe19c796"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
[[package]]
name = "unicode-width"
version = "0.1.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9337591893a19b88d8d87f2cec1e73fad5cdfd10e5a6f349f498ad6ea2ffb1e3"
[[package]]
name = "unicode-xid"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f7fe0bb3479651439c9112f72b6c505038574c9fbb575ed1bf3b797fa39dd564"
:heavy_plus_sign: update: add heim for measuring process RSS
2020-12-20 18:52:53 +00:00
[[package]]
name = "uom"
version = "0.30.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e76503e636584f1e10b9b3b9498538279561adcef5412927ba00c2b32c4ce5ed"
dependencies = [
"num-rational",
"num-traits",
"typenum",
]
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
[[package]]
name = "url"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "2.2.1"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "9ccd964113622c8e9322cfac19eb1004a07e636c545f325da085d5cdde6f1f8b"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
"form_urlencoded",
"idna",
"matches",
"percent-encoding",
]
[[package]]
name = "vcpkg"
:arrow_up: deps: cargo update
2020-12-12 05:31:29 +00:00
version = "0.2.11"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: deps: cargo update
2020-12-12 05:31:29 +00:00
checksum = "b00bca6106a5e23f3eee943593759b7fcddb00554332e856d990c893966879fb"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
:heavy_plus_sign: update: add heim for measuring process RSS
2020-12-20 18:52:53 +00:00
[[package]]
name = "vec-arena"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "1.1.0"
:heavy_plus_sign: update: add heim for measuring process RSS
2020-12-20 18:52:53 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "34b2f665b594b07095e3ac3f718e13c2197143416fae4c5706cffb7b1af8d7f1"
:heavy_plus_sign: update: add heim for measuring process RSS
2020-12-20 18:52:53 +00:00
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
[[package]]
name = "vec_map"
version = "0.8.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f1bddf1187be692e79c5ffeab891132dfb0f236ed36a43c7ed39f1165ee20191"
[[package]]
name = "version_check"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "0.9.3"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "5fecdca9a5291cc2b8dcf7dc02453fee791a280f3743cb0905f8822ae463b3fe"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
:heavy_plus_sign: update: add heim for measuring process RSS
2020-12-20 18:52:53 +00:00
[[package]]
name = "waker-fn"
version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9d5b2c62b4012a3e1eca5a7e077d13b3bf498c4073e33ccd58626607748ceeca"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
[[package]]
name = "want"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1ce8a968cb1cd110d136ff8b819a556d6fb6d919363c61534f6860c7eb172ba0"
dependencies = [
"log",
"try-lock",
]
[[package]]
name = "wasi"
version = "0.10.0+wasi-snapshot-preview1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1a143597ca7c7793eff794def352d41792a93c481eb1042423ff7ff72ba2c31f"
[[package]]
name = "wasm-bindgen"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "0.2.72"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "8fe8f61dba8e5d645a4d8132dc7a0a66861ed5e1045d2c0ed940fab33bac0fbe"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
:arrow_up: deps: cargo update
2020-12-12 05:31:29 +00:00
"cfg-if 1.0.0",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
"serde",
"serde_json",
"wasm-bindgen-macro",
]
[[package]]
name = "wasm-bindgen-backend"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "0.2.72"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "046ceba58ff062da072c7cb4ba5b22a37f00a302483f7e2a6cdc18fedbdc1fd3"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
"bumpalo",
"lazy_static",
"log",
"proc-macro2",
"quote",
"syn",
"wasm-bindgen-shared",
]
[[package]]
name = "wasm-bindgen-futures"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "0.4.22"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "73157efb9af26fb564bb59a009afd1c7c334a44db171d280690d0c3faaec3468"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
:arrow_up: deps: cargo update
2020-12-12 05:31:29 +00:00
"cfg-if 1.0.0",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
"js-sys",
"wasm-bindgen",
"web-sys",
]
[[package]]
name = "wasm-bindgen-macro"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "0.2.72"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "0ef9aa01d36cda046f797c57959ff5f3c615c9cc63997a8d545831ec7976819b"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
"quote",
"wasm-bindgen-macro-support",
]
[[package]]
name = "wasm-bindgen-macro-support"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "0.2.72"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "96eb45c1b2ee33545a813a92dbb53856418bf7eb54ab34f7f7ff1448a5b3735d"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
"proc-macro2",
"quote",
"syn",
"wasm-bindgen-backend",
"wasm-bindgen-shared",
]
[[package]]
name = "wasm-bindgen-shared"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "0.2.72"
:arrow_up: deps: cargo update
2020-12-12 05:31:29 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "b7148f4696fb4960a346eaa60bbfb42a1ac4ebba21f750f75fc1375b098d5ffa"
:arrow_up: deps: cargo update
2020-12-12 05:31:29 +00:00
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
[[package]]
name = "web-sys"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
version = "0.3.49"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
:arrow_up: update important crates to Tokio 1.4.0
2021-03-21 03:01:06 +00:00
checksum = "59fe19d70f5dacc03f6e46777213facae5ac3801575d56ca6cbd4c93dcd12310"
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
dependencies = [
"js-sys",
"wasm-bindgen",
]
:heavy_plus_sign: update: add heim for measuring process RSS
2020-12-20 18:52:53 +00:00
[[package]]
name = "wepoll-sys"
version = "3.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0fcb14dea929042224824779fbc82d9fab8d2e6d3cbc0ac404de8edf489e77ff"
dependencies = [
"cc",
]
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
[[package]]
name = "winapi"
version = "0.3.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
dependencies = [
"winapi-i686-pc-windows-gnu",
"winapi-x86_64-pc-windows-gnu",
]
[[package]]
name = "winapi-i686-pc-windows-gnu"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
[[package]]
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 = "winreg"
version = "0.7.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0120db82e8a1e0b9fb3345a539c478767c0048d842860994d96113d5b667bd69"
dependencies = [
:arrow_up: deps: upgrade everything to Tokio 1.2.0 And pretend I didn't completely goober the Docker build somehow
2021-03-06 21:15:41 +00:00
"winapi",
:whale: build (ptth_relay): clean up Docker build process The new method is much nicer and doesn't require the manual make-old-git step. The top-level command is actually build_and_minimize.bash, which uses `git archive` to unpack the last Git commit and build with _that_ Dockerfile and Docker context. This is better for determinism. It's similar to our build process for that one big project at work.
2020-12-12 01:53:20 +00:00
]