mozilla
/
sccache
зеркало из https://github.com/mozilla/sccache.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность
sccache/Cargo.lock

1741 строка
80 KiB
Plaintext
Исходник Обычный вид История

Commit Cargo.lock
2016-05-12 22:03:37 +03:00
[[package]]
name = "aho-corasick"
Update ring
2018-01-07 18:33:04 +03:00
version = "0.6.4"
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
Update ring
2018-01-07 18:33:04 +03:00
"memchr 2.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
]
[[package]]
name = "ansi_term"
Silence some warnings
2018-07-12 13:46:33 +03:00
version = "0.11.0"
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Silence some warnings
2018-07-12 13:46:33 +03:00
dependencies = [
"winapi 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)",
]
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
Ignore CARGO_MAKEFLAGS when calculating Rust hash keys. Fixes #193 Since cargo gained jobserver support it now passes a CARGO_MAKEFLAGS environment variable which is different for every build (it contains file descriptor numbers or semaphore values). sccache uses all environment variables starting with `CARGO_` as inputs to the hash key for Rust compilation so this broke things. I think it was mostly only a problem on Windows, where the values were semaphores. On POSIX platforms the values are file descriptors, which are probably likely to be the same between runs of cargo. This change also adds a test for compiling a simple Rust crate with cargo and verifying that we get a cache hit. I pulled in the `assert_cli` crate to write that test, which worked nicely.
2017-10-25 21:09:27 +03:00
[[package]]
Switch from assert_cli to assert_cmd
2018-07-26 22:52:50 +03:00
name = "assert_cmd"
version = "0.6.0"
Ignore CARGO_MAKEFLAGS when calculating Rust hash keys. Fixes #193 Since cargo gained jobserver support it now passes a CARGO_MAKEFLAGS environment variable which is different for every build (it contains file descriptor numbers or semaphore values). sccache uses all environment variables starting with `CARGO_` as inputs to the hash key for Rust compilation so this broke things. I think it was mostly only a problem on Windows, where the values were semaphores. On POSIX platforms the values are file descriptors, which are probably likely to be the same between runs of cargo. This change also adds a test for compiling a simple Rust crate with cargo and verifying that we get a cache hit. I pulled in the `assert_cli` crate to write that test, which worked nicely.
2017-10-25 21:09:27 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
Switch from assert_cli to assert_cmd
2018-07-26 22:52:50 +03:00
"escargot 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
Refactor system tests to use assert_cmd
2018-07-27 19:07:08 +03:00
"predicates 0.5.2 (git+https://github.com/luser/predicates-rs?branch=function-unsized)",
Switch from assert_cli to assert_cmd
2018-07-26 22:52:50 +03:00
"serde 1.0.27 (registry+https://github.com/rust-lang/crates.io-index)",
Ignore CARGO_MAKEFLAGS when calculating Rust hash keys. Fixes #193 Since cargo gained jobserver support it now passes a CARGO_MAKEFLAGS environment variable which is different for every build (it contains file descriptor numbers or semaphore values). sccache uses all environment variables starting with `CARGO_` as inputs to the hash key for Rust compilation so this broke things. I think it was mostly only a problem on Windows, where the values were semaphores. On POSIX platforms the values are file descriptors, which are probably likely to be the same between runs of cargo. This change also adds a test for compiling a simple Rust crate with cargo and verifying that we get a cache hit. I pulled in the `assert_cli` crate to write that test, which worked nicely.
2017-10-25 21:09:27 +03:00
]
Update clap
2017-04-05 17:42:06 +03:00
[[package]]
name = "atty"
Update ring
2018-01-07 18:33:04 +03:00
version = "0.2.6"
Update clap
2017-04-05 17:42:06 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
cargo update
2018-02-01 18:29:23 +03:00
"libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"termion 1.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
cargo update
2018-02-01 18:29:23 +03:00
"winapi 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)",
Update clap
2017-04-05 17:42:06 +03:00
]
Integrate the Tokio branch of Hyper This commit pulls in Hyper from its master branch which contains the asynchronous/Tokio integration. All instances of HTTP, namely when interacting with S3, are now all powered by async Hyper and work with futures rather than synchronous requests on thread pools.
2017-02-02 03:30:26 +03:00
[[package]]
name = "base64"
Update other deps
2018-01-07 18:58:55 +03:00
version = "0.8.0"
Integrate the Tokio branch of Hyper This commit pulls in Hyper from its master branch which contains the asynchronous/Tokio integration. All instances of HTTP, namely when interacting with S3, are now all powered by async Hyper and work with futures rather than synchronous requests on thread pools.
2017-02-02 03:30:26 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
Update ring
2018-01-07 18:33:04 +03:00
"byteorder 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
Update other deps
2018-01-07 18:58:55 +03:00
"safemem 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
Integrate the Tokio branch of Hyper This commit pulls in Hyper from its master branch which contains the asynchronous/Tokio integration. All instances of HTTP, namely when interacting with S3, are now all powered by async Hyper and work with futures rather than synchronous requests on thread pools.
2017-02-02 03:30:26 +03:00
]
Update dependencies Notably bring in hyper from crates.io
2017-06-14 18:20:12 +03:00
[[package]]
name = "base64"
Update other deps
2018-01-07 18:58:55 +03:00
version = "0.9.0"
Update dependencies Notably bring in hyper from crates.io
2017-06-14 18:20:12 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
Update ring
2018-01-07 18:33:04 +03:00
"byteorder 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
Update dependencies Notably bring in hyper from crates.io
2017-06-14 18:20:12 +03:00
"safemem 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
Move from protobuf to bincode for a wire format This commit migrates away from the `protobuf` crate to instead just working with bincode on the wire as a serialization format. This is done by leveraging a few different crates: * The `bincode` and `serde_derive` crates are used to define serialization for Rust structures as well as provide a bincode implementation. * The `tokio_io::codec::length_delimited` module implements framing via length prefixes to transform an asynchronous stream of bytes into a literal `Stream` of `BytesMut`. * The `tokio_serde_bincode` crate is then used to tie it all together, parsing these `BytesMut` as the request/response types of sccache. Most of the changes here are related to moving away from the protobuf API throughout the codebase (e.g. `has_foo` and `take_foo`) towards a more rustic-ish API that just uses enums/structs. Overall it felt quite natural (as one would expect) to just use the raw enum/struct values. This may not be quite as performant as before but that doesn't really apply to sccache's use case where perf is hugely dominated by actually compiling and hashing, so I'm not too too worried about that. My personal motivation for this is twofold: 1. Using `protobuf` was a little clunky throughout the codebase and definitely had some sharp edges that felt good to smooth out. 2. There's currently what I believe some mysterious segfault and/or stray write happening in sccache and I'm not sure where. The `protobuf` crate had a lot of `unsafe` code and in lieu of actually auditing it I figured it'd be good to kill two birds with one stone. I have no idea if this fixes my segfault problem (I never could reproduce it) but I figured it's worth a shot.
2017-03-22 20:21:52 +03:00
[[package]]
Update other deps
2018-01-07 18:58:55 +03:00
name = "bincode"
version = "0.8.0"
Update dependencies * Mostly upgrade to serde 1.0 * Pull in lots of other updates for other small deps
2017-05-18 23:53:00 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Move from protobuf to bincode for a wire format This commit migrates away from the `protobuf` crate to instead just working with bincode on the wire as a serialization format. This is done by leveraging a few different crates: * The `bincode` and `serde_derive` crates are used to define serialization for Rust structures as well as provide a bincode implementation. * The `tokio_io::codec::length_delimited` module implements framing via length prefixes to transform an asynchronous stream of bytes into a literal `Stream` of `BytesMut`. * The `tokio_serde_bincode` crate is then used to tie it all together, parsing these `BytesMut` as the request/response types of sccache. Most of the changes here are related to moving away from the protobuf API throughout the codebase (e.g. `has_foo` and `take_foo`) towards a more rustic-ish API that just uses enums/structs. Overall it felt quite natural (as one would expect) to just use the raw enum/struct values. This may not be quite as performant as before but that doesn't really apply to sccache's use case where perf is hugely dominated by actually compiling and hashing, so I'm not too too worried about that. My personal motivation for this is twofold: 1. Using `protobuf` was a little clunky throughout the codebase and definitely had some sharp edges that felt good to smooth out. 2. There's currently what I believe some mysterious segfault and/or stray write happening in sccache and I'm not sure where. The `protobuf` crate had a lot of `unsafe` code and in lieu of actually auditing it I figured it'd be good to kill two birds with one stone. I have no idea if this fixes my segfault problem (I never could reproduce it) but I figured it's worth a shot.
2017-03-22 20:21:52 +03:00
dependencies = [
Update ring
2018-01-07 18:33:04 +03:00
"byteorder 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
cargo update
2018-02-01 18:29:23 +03:00
"num-traits 0.1.42 (registry+https://github.com/rust-lang/crates.io-index)",
Update other deps
2018-01-07 18:58:55 +03:00
"serde 1.0.27 (registry+https://github.com/rust-lang/crates.io-index)",
Move from protobuf to bincode for a wire format This commit migrates away from the `protobuf` crate to instead just working with bincode on the wire as a serialization format. This is done by leveraging a few different crates: * The `bincode` and `serde_derive` crates are used to define serialization for Rust structures as well as provide a bincode implementation. * The `tokio_io::codec::length_delimited` module implements framing via length prefixes to transform an asynchronous stream of bytes into a literal `Stream` of `BytesMut`. * The `tokio_serde_bincode` crate is then used to tie it all together, parsing these `BytesMut` as the request/response types of sccache. Most of the changes here are related to moving away from the protobuf API throughout the codebase (e.g. `has_foo` and `take_foo`) towards a more rustic-ish API that just uses enums/structs. Overall it felt quite natural (as one would expect) to just use the raw enum/struct values. This may not be quite as performant as before but that doesn't really apply to sccache's use case where perf is hugely dominated by actually compiling and hashing, so I'm not too too worried about that. My personal motivation for this is twofold: 1. Using `protobuf` was a little clunky throughout the codebase and definitely had some sharp edges that felt good to smooth out. 2. There's currently what I believe some mysterious segfault and/or stray write happening in sccache and I'm not sure where. The `protobuf` crate had a lot of `unsafe` code and in lieu of actually auditing it I figured it'd be good to kill two birds with one stone. I have no idea if this fixes my segfault problem (I never could reproduce it) but I figured it's worth a shot.
2017-03-22 20:21:52 +03:00
]
Update iovec to fix a soundness hole on Windows Also update a few other dependencies that transitively needed fixing
2017-10-06 02:40:25 +03:00
[[package]]
Update ring
2018-01-07 18:33:04 +03:00
name = "bincode"
Update other deps
2018-01-07 18:58:55 +03:00
version = "0.9.2"
Update iovec to fix a soundness hole on Windows Also update a few other dependencies that transitively needed fixing
2017-10-06 02:40:25 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update ring
2018-01-07 18:33:04 +03:00
dependencies = [
"byteorder 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
"serde 1.0.27 (registry+https://github.com/rust-lang/crates.io-index)",
]
Update iovec to fix a soundness hole on Windows Also update a few other dependencies that transitively needed fixing
2017-10-06 02:40:25 +03:00
Integrate the Tokio branch of Hyper This commit pulls in Hyper from its master branch which contains the asynchronous/Tokio integration. All instances of HTTP, namely when interacting with S3, are now all powered by async Hyper and work with futures rather than synchronous requests on thread pools.
2017-02-02 03:30:26 +03:00
[[package]]
name = "bitflags"
Update ring
2018-01-07 18:33:04 +03:00
version = "0.9.1"
Integrate the Tokio branch of Hyper This commit pulls in Hyper from its master branch which contains the asynchronous/Tokio integration. All instances of HTTP, namely when interacting with S3, are now all powered by async Hyper and work with futures rather than synchronous requests on thread pools.
2017-02-02 03:30:26 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update dependencies Notably bring in hyper from crates.io
2017-06-14 18:20:12 +03:00
[[package]]
name = "bitflags"
Update ring
2018-01-07 18:33:04 +03:00
version = "1.0.1"
Update dependencies Notably bring in hyper from crates.io
2017-06-14 18:20:12 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Add a Memcached cache variant This cache module uses a Memcached cluster. To make sccache use this, set SCCACHE_MEMCACHED to a list of tcp://<hostname>:<port> addresses, separated by whitespace.
2017-08-10 17:50:33 +03:00
[[package]]
name = "bufstream"
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "byteorder"
version = "0.4.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
Integrate the Tokio branch of Hyper This commit pulls in Hyper from its master branch which contains the asynchronous/Tokio integration. All instances of HTTP, namely when interacting with S3, are now all powered by async Hyper and work with futures rather than synchronous requests on thread pools.
2017-02-02 03:30:26 +03:00
[[package]]
name = "byteorder"
Update ring
2018-01-07 18:33:04 +03:00
version = "1.2.1"
Integrate the Tokio branch of Hyper This commit pulls in Hyper from its master branch which contains the asynchronous/Tokio integration. All instances of HTTP, namely when interacting with S3, are now all powered by async Hyper and work with futures rather than synchronous requests on thread pools.
2017-02-02 03:30:26 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update to using the new tokio-io crate This is an abstraction of the Tokio stack now and doesn't have much impact on sccache itself but I figured it'd be good to update a few deps and pick up the recent version of things! Plus that and I'd like to start using the length_delimited module soon...
2017-03-09 21:00:18 +03:00
[[package]]
name = "bytes"
cargo update
2018-02-01 18:29:23 +03:00
version = "0.4.6"
Update to using the new tokio-io crate This is an abstraction of the Tokio stack now and doesn't have much impact on sccache itself but I figured it'd be good to update a few deps and pick up the recent version of things! Plus that and I'd like to start using the length_delimited module soon...
2017-03-09 21:00:18 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
Update ring
2018-01-07 18:33:04 +03:00
"byteorder 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
cargo update
2018-02-01 18:29:23 +03:00
"iovec 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
Update to using the new tokio-io crate This is an abstraction of the Tokio stack now and doesn't have much impact on sccache itself but I figured it'd be good to update a few deps and pick up the recent version of things! Plus that and I'd like to start using the length_delimited module soon...
2017-03-09 21:00:18 +03:00
]
Depend on tokio-serde-bincode from crates.io
2017-07-13 21:33:57 +03:00
[[package]]
name = "case"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
Ignore CARGO_MAKEFLAGS when calculating Rust hash keys. Fixes #193 Since cargo gained jobserver support it now passes a CARGO_MAKEFLAGS environment variable which is different for every build (it contains file descriptor numbers or semaphore values). sccache uses all environment variables starting with `CARGO_` as inputs to the hash key for Rust compilation so this broke things. I think it was mostly only a problem on Windows, where the values were semaphores. On POSIX platforms the values are file descriptors, which are probably likely to be the same between runs of cargo. This change also adds a test for compiling a simple Rust crate with cargo and verifying that we get a cache hit. I pulled in the `assert_cli` crate to write that test, which worked nicely.
2017-10-25 21:09:27 +03:00
[[package]]
name = "cc"
cargo update
2018-02-01 18:29:23 +03:00
version = "1.0.4"
Ignore CARGO_MAKEFLAGS when calculating Rust hash keys. Fixes #193 Since cargo gained jobserver support it now passes a CARGO_MAKEFLAGS environment variable which is different for every build (it contains file descriptor numbers or semaphore values). sccache uses all environment variables starting with `CARGO_` as inputs to the hash key for Rust compilation so this broke things. I think it was mostly only a problem on Windows, where the values were semaphores. On POSIX platforms the values are file descriptors, which are probably likely to be the same between runs of cargo. This change also adds a test for compiling a simple Rust crate with cargo and verifying that we get a cache hit. I pulled in the `assert_cli` crate to write that test, which worked nicely.
2017-10-25 21:09:27 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
[[package]]
name = "cfg-if"
Update ring
2018-01-07 18:33:04 +03:00
version = "0.1.2"
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement S3Cache Unlike sccache1, you need to specify both bucket and region, like: SCCACHE_BUCKET=sccache SCCACHE_REGION=us-east-1 Pretty limited testing, no automated tests currently.
2016-06-03 22:09:38 +03:00
[[package]]
name = "chrono"
Update ring
2018-01-07 18:33:04 +03:00
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"num 0.1.41 (registry+https://github.com/rust-lang/crates.io-index)",
"time 0.1.39 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "chrono"
version = "0.4.0"
Implement S3Cache Unlike sccache1, you need to specify both bucket and region, like: SCCACHE_BUCKET=sccache SCCACHE_REGION=us-east-1 Pretty limited testing, no automated tests currently.
2016-06-03 22:09:38 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
Update ring
2018-01-07 18:33:04 +03:00
"num 0.1.41 (registry+https://github.com/rust-lang/crates.io-index)",
"time 0.1.39 (registry+https://github.com/rust-lang/crates.io-index)",
Implement S3Cache Unlike sccache1, you need to specify both bucket and region, like: SCCACHE_BUCKET=sccache SCCACHE_REGION=us-east-1 Pretty limited testing, no automated tests currently.
2016-06-03 22:09:38 +03:00
]
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
[[package]]
name = "clap"
Silence some warnings
2018-07-12 13:46:33 +03:00
version = "2.32.0"
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
Silence some warnings
2018-07-12 13:46:33 +03:00
"ansi_term 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"atty 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)",
update clap to remove a warning with rust 1.23
2018-01-12 14:38:40 +03:00
"bitflags 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
Silence some warnings
2018-07-12 13:46:33 +03:00
"strsim 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
"textwrap 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
Update clap
2017-04-05 17:42:06 +03:00
"unicode-width 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
Update dependencies * Mostly upgrade to serde 1.0 * Pull in lots of other updates for other small deps
2017-05-18 23:53:00 +03:00
"vec_map 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
]
Update dependencies Notably bring in hyper from crates.io
2017-06-14 18:20:12 +03:00
[[package]]
name = "coco"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
Update ring
2018-01-07 18:33:04 +03:00
"either 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
"scopeguard 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
Update dependencies Notably bring in hyper from crates.io
2017-06-14 18:20:12 +03:00
]
Add a Memcached cache variant This cache module uses a Memcached cluster. To make sccache use this, set SCCACHE_MEMCACHED to a list of tcp://<hostname>:<port> addresses, separated by whitespace.
2017-08-10 17:50:33 +03:00
[[package]]
name = "conhash"
version = "0.3.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"log 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
"rust-crypto 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
]
Implement S3Cache Unlike sccache1, you need to specify both bucket and region, like: SCCACHE_BUCKET=sccache SCCACHE_REGION=us-east-1 Pretty limited testing, no automated tests currently.
2016-06-03 22:09:38 +03:00
[[package]]
Integrate the Tokio branch of Hyper This commit pulls in Hyper from its master branch which contains the asynchronous/Tokio integration. All instances of HTTP, namely when interacting with S3, are now all powered by async Hyper and work with futures rather than synchronous requests on thread pools.
2017-02-02 03:30:26 +03:00
name = "core-foundation"
version = "0.2.3"
Implement S3Cache Unlike sccache1, you need to specify both bucket and region, like: SCCACHE_BUCKET=sccache SCCACHE_REGION=us-east-1 Pretty limited testing, no automated tests currently.
2016-06-03 22:09:38 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
Integrate the Tokio branch of Hyper This commit pulls in Hyper from its master branch which contains the asynchronous/Tokio integration. All instances of HTTP, namely when interacting with S3, are now all powered by async Hyper and work with futures rather than synchronous requests on thread pools.
2017-02-02 03:30:26 +03:00
"core-foundation-sys 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
cargo update
2018-02-01 18:29:23 +03:00
"libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
Integrate the Tokio branch of Hyper This commit pulls in Hyper from its master branch which contains the asynchronous/Tokio integration. All instances of HTTP, namely when interacting with S3, are now all powered by async Hyper and work with futures rather than synchronous requests on thread pools.
2017-02-02 03:30:26 +03:00
]
[[package]]
name = "core-foundation-sys"
version = "0.2.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
cargo update
2018-02-01 18:29:23 +03:00
"libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
Integrate the Tokio branch of Hyper This commit pulls in Hyper from its master branch which contains the asynchronous/Tokio integration. All instances of HTTP, namely when interacting with S3, are now all powered by async Hyper and work with futures rather than synchronous requests on thread pools.
2017-02-02 03:30:26 +03:00
]
daemonize the server process on unix
2016-10-26 23:22:52 +03:00
[[package]]
name = "daemonize"
version = "0.2.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
cargo update
2018-02-01 18:29:23 +03:00
"libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
Ignore CARGO_MAKEFLAGS when calculating Rust hash keys. Fixes #193 Since cargo gained jobserver support it now passes a CARGO_MAKEFLAGS environment variable which is different for every build (it contains file descriptor numbers or semaphore values). sccache uses all environment variables starting with `CARGO_` as inputs to the hash key for Rust compilation so this broke things. I think it was mostly only a problem on Windows, where the values were semaphores. On POSIX platforms the values are file descriptors, which are probably likely to be the same between runs of cargo. This change also adds a test for compiling a simple Rust crate with cargo and verifying that we get a cache hit. I pulled in the `assert_cli` crate to write that test, which worked nicely.
2017-10-25 21:09:27 +03:00
]
Depend on tokio-serde-bincode from crates.io
2017-07-13 21:33:57 +03:00
[[package]]
name = "derive-error"
version = "0.0.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"case 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
"quote 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)",
"syn 0.11.11 (registry+https://github.com/rust-lang/crates.io-index)",
]
Ignore CARGO_MAKEFLAGS when calculating Rust hash keys. Fixes #193 Since cargo gained jobserver support it now passes a CARGO_MAKEFLAGS environment variable which is different for every build (it contains file descriptor numbers or semaphore values). sccache uses all environment variables starting with `CARGO_` as inputs to the hash key for Rust compilation so this broke things. I think it was mostly only a problem on Windows, where the values were semaphores. On POSIX platforms the values are file descriptors, which are probably likely to be the same between runs of cargo. This change also adds a test for compiling a simple Rust crate with cargo and verifying that we get a cache hit. I pulled in the `assert_cli` crate to write that test, which worked nicely.
2017-10-25 21:09:27 +03:00
[[package]]
name = "difference"
Update assert_cli and tweak some of the tests using it. Also silence a lint warning from error-chain.
2018-07-26 17:16:55 +03:00
version = "2.0.0"
Ignore CARGO_MAKEFLAGS when calculating Rust hash keys. Fixes #193 Since cargo gained jobserver support it now passes a CARGO_MAKEFLAGS environment variable which is different for every build (it contains file descriptor numbers or semaphore values). sccache uses all environment variables starting with `CARGO_` as inputs to the hash key for Rust compilation so this broke things. I think it was mostly only a problem on Windows, where the values were semaphores. On POSIX platforms the values are file descriptors, which are probably likely to be the same between runs of cargo. This change also adds a test for compiling a simple Rust crate with cargo and verifying that we get a cache hit. I pulled in the `assert_cli` crate to write that test, which worked nicely.
2017-10-25 21:09:27 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Replace `app_dirs` crate with `directories`. Fixes #233. The `app_dirs` crate has become unmaintained and is broken on macOS with Rust 1.25. The `directories` crate provides the same functionality and is maintained, so switch to using that instead.
2018-03-21 15:52:55 +03:00
[[package]]
name = "directories"
version = "0.8.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"winapi 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)",
]
switch back to released version of which, switch to a rusoto branch with a bug fix
2016-08-08 22:06:06 +03:00
[[package]]
name = "dtoa"
Update ring
2018-01-07 18:33:04 +03:00
version = "0.4.2"
switch back to released version of which, switch to a rusoto branch with a bug fix
2016-08-08 22:06:06 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
When hashing Rust compile arguments, sort -L and --cfg args as well as --extern
2017-04-03 17:21:13 +03:00
[[package]]
name = "either"
Update ring
2018-01-07 18:33:04 +03:00
version = "1.4.0"
When hashing Rust compile arguments, sort -L and --cfg args as well as --extern
2017-04-03 17:21:13 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
[[package]]
name = "env_logger"
Update dependencies Notably bring in hyper from crates.io
2017-06-14 18:20:12 +03:00
version = "0.4.3"
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
Update ring
2018-01-07 18:33:04 +03:00
"log 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
"regex 0.2.5 (registry+https://github.com/rust-lang/crates.io-index)",
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
]
Ignore CARGO_MAKEFLAGS when calculating Rust hash keys. Fixes #193 Since cargo gained jobserver support it now passes a CARGO_MAKEFLAGS environment variable which is different for every build (it contains file descriptor numbers or semaphore values). sccache uses all environment variables starting with `CARGO_` as inputs to the hash key for Rust compilation so this broke things. I think it was mostly only a problem on Windows, where the values were semaphores. On POSIX platforms the values are file descriptors, which are probably likely to be the same between runs of cargo. This change also adds a test for compiling a simple Rust crate with cargo and verifying that we get a cache hit. I pulled in the `assert_cli` crate to write that test, which worked nicely.
2017-10-25 21:09:27 +03:00
[[package]]
name = "error-chain"
version = "0.11.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
Update assert_cli and tweak some of the tests using it. Also silence a lint warning from error-chain.
2018-07-26 17:16:55 +03:00
[[package]]
Switch from assert_cli to assert_cmd
2018-07-26 22:52:50 +03:00
name = "escargot"
version = "0.2.0"
Update assert_cli and tweak some of the tests using it. Also silence a lint warning from error-chain.
2018-07-26 17:16:55 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
Switch from assert_cli to assert_cmd
2018-07-26 22:52:50 +03:00
"serde 1.0.27 (registry+https://github.com/rust-lang/crates.io-index)",
"serde_json 1.0.9 (registry+https://github.com/rust-lang/crates.io-index)",
Ignore CARGO_MAKEFLAGS when calculating Rust hash keys. Fixes #193 Since cargo gained jobserver support it now passes a CARGO_MAKEFLAGS environment variable which is different for every build (it contains file descriptor numbers or semaphore values). sccache uses all environment variables starting with `CARGO_` as inputs to the hash key for Rust compilation so this broke things. I think it was mostly only a problem on Windows, where the values were semaphores. On POSIX platforms the values are file descriptors, which are probably likely to be the same between runs of cargo. This change also adds a test for compiling a simple Rust crate with cargo and verifying that we get a cache hit. I pulled in the `assert_cli` crate to write that test, which worked nicely.
2017-10-25 21:09:27 +03:00
]
turn Compiler into CompilerKind, make a Compiler struct to hold some more info about compilers
2016-05-18 21:30:11 +03:00
[[package]]
name = "filetime"
cargo update
2018-02-01 18:29:23 +03:00
version = "0.1.15"
turn Compiler into CompilerKind, make a Compiler struct to hold some more info about compilers
2016-05-18 21:30:11 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
Update ring
2018-01-07 18:33:04 +03:00
"cfg-if 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
cargo update
2018-02-01 18:29:23 +03:00
"libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"redox_syscall 0.1.37 (registry+https://github.com/rust-lang/crates.io-index)",
turn Compiler into CompilerKind, make a Compiler struct to hold some more info about compilers
2016-05-18 21:30:11 +03:00
]
Bits and pieces for distributed Rust
2018-04-12 04:25:15 +03:00
[[package]]
name = "filetime"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"cfg-if 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
"redox_syscall 0.1.37 (registry+https://github.com/rust-lang/crates.io-index)",
]
Implement fetching/storing to cache, interfaces for doing so, implement a disk cache
2016-05-21 21:14:26 +03:00
[[package]]
name = "flate2"
Update ring
2018-01-07 18:33:04 +03:00
version = "0.2.20"
Implement fetching/storing to cache, interfaces for doing so, implement a disk cache
2016-05-21 21:14:26 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
cargo update
2018-02-01 18:29:23 +03:00
"libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"miniz-sys 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
Implement fetching/storing to cache, interfaces for doing so, implement a disk cache
2016-05-21 21:14:26 +03:00
]
Switch from assert_cli to assert_cmd
2018-07-26 22:52:50 +03:00
[[package]]
name = "float-cmp"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"num-traits 0.2.5 (registry+https://github.com/rust-lang/crates.io-index)",
]
Update dependencies * Mostly upgrade to serde 1.0 * Pull in lots of other updates for other small deps
2017-05-18 23:53:00 +03:00
[[package]]
name = "foreign-types"
Update ring
2018-01-07 18:33:04 +03:00
version = "0.3.2"
Update dependencies * Mostly upgrade to serde 1.0 * Pull in lots of other updates for other small deps
2017-05-18 23:53:00 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update ring
2018-01-07 18:33:04 +03:00
dependencies = [
"foreign-types-shared 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
Update dependencies * Mostly upgrade to serde 1.0 * Pull in lots of other updates for other small deps
2017-05-18 23:53:00 +03:00
Don't block sending compile result to client on cache write. Fixes #19. This change makes `get_cached_or_compile` return a `Future` for the cache write instead of blocking on it. The server then waits for the result on a thread. It also changes the server to record cache write timings, and display the average in the stats.
2016-11-03 00:15:14 +03:00
[[package]]
Update ring
2018-01-07 18:33:04 +03:00
name = "foreign-types-shared"
version = "0.1.1"
Don't block sending compile result to client on cache write. Fixes #19. This change makes `get_cached_or_compile` return a `Future` for the cache write instead of blocking on it. The server then waits for the result on a thread. It also changes the server to record cache write timings, and display the average in the stats.
2016-11-03 00:15:14 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Rewrite the server module with Tokio This commit rewrites the `server` module of sccache to be backed with Tokio. The previous version was written with `mio`, which Tokio is built on, but is unfortunately less ergonomic. Tokio is the state-of-the-art for asynchronous programming in Rust and sccache serves as a great testing ground for ergonomics! It's intended that the support added here will eventually extend to many other operations that sccache does as well. For example thread spawning has all been replaced with `CpuPool` to have a shared pool for I/O operations and such (namely the filesystem). Eventually the HTTP requests made by the S3 backend can be integrated with the Tokio branch of Hyper as well to run that on the event loop instead of in a worker thread. I'd also like to eventually extend this with `tokio-process` as well to move process spawning off helper threads as well, but I'm leaving that to a future commit as well. Overall I found the transition was quite smooth, with the high level architecture look like: * The `tokio-proto` crate is used in streaming mode. The streaming part is used for the one RPC sccache gets which requires a second response to be sent later on. This second response is the "response body" in tokio-proto terms. * All of sccache's logic is manifested in an implementation of the `Service` trait. * The transport layer is provided with `tokio_core::io::{Framed, Codec}`, and simple deserialization/serialization is performed with protobuf. Some differences in design are: * The `SccacheService` for now is just a bunch of reference-counted pointers, making it cheap to clone. As the futures it returns progress they will each retain a reference to a cloned copy of the `SccacheService`. Before all this data was just stored and manipulated in a struct directly, but it's now directly managed through shared memory. * The storage backends share a thread pool with the main server instead of spawning threads. And finally, some things I've learned along the way: * Sharing data between futures isn't a trivial operation. It took an explicit decision to use `Rc` and I'm not sure I'm 100% happy with how the ergonomics played out. * Shutdown is pretty tricky here. I've tried to carry over all the previous logic but it definitely required not using `TcpServer` in tokio-proto at the very least, and otherwise required a few custom futures and such to track the various states. I have a hunch that tokio-proto could provide more options out of the box for something like this.
2017-01-31 04:04:03 +03:00
[[package]]
Update ring
2018-01-07 18:33:04 +03:00
name = "fuchsia-zircon"
version = "0.3.3"
Rewrite the server module with Tokio This commit rewrites the `server` module of sccache to be backed with Tokio. The previous version was written with `mio`, which Tokio is built on, but is unfortunately less ergonomic. Tokio is the state-of-the-art for asynchronous programming in Rust and sccache serves as a great testing ground for ergonomics! It's intended that the support added here will eventually extend to many other operations that sccache does as well. For example thread spawning has all been replaced with `CpuPool` to have a shared pool for I/O operations and such (namely the filesystem). Eventually the HTTP requests made by the S3 backend can be integrated with the Tokio branch of Hyper as well to run that on the event loop instead of in a worker thread. I'd also like to eventually extend this with `tokio-process` as well to move process spawning off helper threads as well, but I'm leaving that to a future commit as well. Overall I found the transition was quite smooth, with the high level architecture look like: * The `tokio-proto` crate is used in streaming mode. The streaming part is used for the one RPC sccache gets which requires a second response to be sent later on. This second response is the "response body" in tokio-proto terms. * All of sccache's logic is manifested in an implementation of the `Service` trait. * The transport layer is provided with `tokio_core::io::{Framed, Codec}`, and simple deserialization/serialization is performed with protobuf. Some differences in design are: * The `SccacheService` for now is just a bunch of reference-counted pointers, making it cheap to clone. As the futures it returns progress they will each retain a reference to a cloned copy of the `SccacheService`. Before all this data was just stored and manipulated in a struct directly, but it's now directly managed through shared memory. * The storage backends share a thread pool with the main server instead of spawning threads. And finally, some things I've learned along the way: * Sharing data between futures isn't a trivial operation. It took an explicit decision to use `Rc` and I'm not sure I'm 100% happy with how the ergonomics played out. * Shutdown is pretty tricky here. I've tried to carry over all the previous logic but it definitely required not using `TcpServer` in tokio-proto at the very least, and otherwise required a few custom futures and such to track the various states. I have a hunch that tokio-proto could provide more options out of the box for something like this.
2017-01-31 04:04:03 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
Update ring
2018-01-07 18:33:04 +03:00
"bitflags 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
"fuchsia-zircon-sys 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
Rewrite the server module with Tokio This commit rewrites the `server` module of sccache to be backed with Tokio. The previous version was written with `mio`, which Tokio is built on, but is unfortunately less ergonomic. Tokio is the state-of-the-art for asynchronous programming in Rust and sccache serves as a great testing ground for ergonomics! It's intended that the support added here will eventually extend to many other operations that sccache does as well. For example thread spawning has all been replaced with `CpuPool` to have a shared pool for I/O operations and such (namely the filesystem). Eventually the HTTP requests made by the S3 backend can be integrated with the Tokio branch of Hyper as well to run that on the event loop instead of in a worker thread. I'd also like to eventually extend this with `tokio-process` as well to move process spawning off helper threads as well, but I'm leaving that to a future commit as well. Overall I found the transition was quite smooth, with the high level architecture look like: * The `tokio-proto` crate is used in streaming mode. The streaming part is used for the one RPC sccache gets which requires a second response to be sent later on. This second response is the "response body" in tokio-proto terms. * All of sccache's logic is manifested in an implementation of the `Service` trait. * The transport layer is provided with `tokio_core::io::{Framed, Codec}`, and simple deserialization/serialization is performed with protobuf. Some differences in design are: * The `SccacheService` for now is just a bunch of reference-counted pointers, making it cheap to clone. As the futures it returns progress they will each retain a reference to a cloned copy of the `SccacheService`. Before all this data was just stored and manipulated in a struct directly, but it's now directly managed through shared memory. * The storage backends share a thread pool with the main server instead of spawning threads. And finally, some things I've learned along the way: * Sharing data between futures isn't a trivial operation. It took an explicit decision to use `Rc` and I'm not sure I'm 100% happy with how the ergonomics played out. * Shutdown is pretty tricky here. I've tried to carry over all the previous logic but it definitely required not using `TcpServer` in tokio-proto at the very least, and otherwise required a few custom futures and such to track the various states. I have a hunch that tokio-proto could provide more options out of the box for something like this.
2017-01-31 04:04:03 +03:00
]
Implement fetching/storing to cache, interfaces for doing so, implement a disk cache
2016-05-21 21:14:26 +03:00
[[package]]
Update ring
2018-01-07 18:33:04 +03:00
name = "fuchsia-zircon-sys"
version = "0.3.3"
Implement fetching/storing to cache, interfaces for doing so, implement a disk cache
2016-05-21 21:14:26 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
use local-encoding crate for stdout conversion
2016-09-21 22:57:28 +03:00
[[package]]
Update ring
2018-01-07 18:33:04 +03:00
name = "futures"
Revert "Update to futures 0.1.19 and fix breakage from Option-related changes" futures 0.1.19 was yanked because of the breaking API changes it made. This reverts commit 7079ab87832efab4298757176b1388f1d126ed98.
2018-07-12 13:31:09 +03:00
version = "0.1.18"
Update ring
2018-01-07 18:33:04 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "futures-cpupool"
version = "0.1.8"
Implement S3Cache Unlike sccache1, you need to specify both bucket and region, like: SCCACHE_BUCKET=sccache SCCACHE_REGION=us-east-1 Pretty limited testing, no automated tests currently.
2016-06-03 22:09:38 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
Revert "Update to futures 0.1.19 and fix breakage from Option-related changes" futures 0.1.19 was yanked because of the breaking API changes it made. This reverts commit 7079ab87832efab4298757176b1388f1d126ed98.
2018-07-12 13:31:09 +03:00
"futures 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
Implement S3Cache Unlike sccache1, you need to specify both bucket and region, like: SCCACHE_BUCKET=sccache SCCACHE_REGION=us-east-1 Pretty limited testing, no automated tests currently.
2016-06-03 22:09:38 +03:00
]
Update ring
2018-01-07 18:33:04 +03:00
[[package]]
name = "gcc"
version = "0.3.54"
source = "registry+https://github.com/rust-lang/crates.io-index"
Integrate the Tokio branch of Hyper This commit pulls in Hyper from its master branch which contains the asynchronous/Tokio integration. All instances of HTTP, namely when interacting with S3, are now all powered by async Hyper and work with futures rather than synchronous requests on thread pools.
2017-02-02 03:30:26 +03:00
[[package]]
name = "getopts"
cargo update
2018-02-01 18:29:23 +03:00
version = "0.2.17"
Integrate the Tokio branch of Hyper This commit pulls in Hyper from its master branch which contains the asynchronous/Tokio integration. All instances of HTTP, namely when interacting with S3, are now all powered by async Hyper and work with futures rather than synchronous requests on thread pools.
2017-02-02 03:30:26 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement S3Cache Unlike sccache1, you need to specify both bucket and region, like: SCCACHE_BUCKET=sccache SCCACHE_REGION=us-east-1 Pretty limited testing, no automated tests currently.
2016-06-03 22:09:38 +03:00
[[package]]
name = "httparse"
cargo update
2018-02-01 18:29:23 +03:00
version = "1.2.4"
Implement S3Cache Unlike sccache1, you need to specify both bucket and region, like: SCCACHE_BUCKET=sccache SCCACHE_REGION=us-east-1 Pretty limited testing, no automated tests currently.
2016-06-03 22:09:38 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "hyper"
cargo update
2018-02-01 18:29:23 +03:00
version = "0.11.16"
Update dependencies Notably bring in hyper from crates.io
2017-06-14 18:20:12 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement S3Cache Unlike sccache1, you need to specify both bucket and region, like: SCCACHE_BUCKET=sccache SCCACHE_REGION=us-east-1 Pretty limited testing, no automated tests currently.
2016-06-03 22:09:38 +03:00
dependencies = [
Update ring
2018-01-07 18:33:04 +03:00
"base64 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
cargo update
2018-02-01 18:29:23 +03:00
"bytes 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
Revert "Update to futures 0.1.19 and fix breakage from Option-related changes" futures 0.1.19 was yanked because of the breaking API changes it made. This reverts commit 7079ab87832efab4298757176b1388f1d126ed98.
2018-07-12 13:31:09 +03:00
"futures 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"futures-cpupool 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
cargo update
2018-02-01 18:29:23 +03:00
"httparse 1.2.4 (registry+https://github.com/rust-lang/crates.io-index)",
"iovec 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
Implement S3Cache Unlike sccache1, you need to specify both bucket and region, like: SCCACHE_BUCKET=sccache SCCACHE_REGION=us-east-1 Pretty limited testing, no automated tests currently.
2016-06-03 22:09:38 +03:00
"language-tags 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"log 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
"mime 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
"percent-encoding 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
cargo update
2018-02-01 18:29:23 +03:00
"relay 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"time 0.1.39 (registry+https://github.com/rust-lang/crates.io-index)",
cargo update
2018-02-01 18:29:23 +03:00
"tokio-core 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"tokio-io 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
Update to using the new tokio-io crate This is an abstraction of the Tokio stack now and doesn't have much impact on sccache itself but I figured it'd be good to update a few deps and pick up the recent version of things! Plus that and I'd like to start using the length_delimited module soon...
2017-03-09 21:00:18 +03:00
"tokio-proto 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
Integrate the Tokio branch of Hyper This commit pulls in Hyper from its master branch which contains the asynchronous/Tokio integration. All instances of HTTP, namely when interacting with S3, are now all powered by async Hyper and work with futures rather than synchronous requests on thread pools.
2017-02-02 03:30:26 +03:00
"tokio-service 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"unicase 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
Implement S3Cache Unlike sccache1, you need to specify both bucket and region, like: SCCACHE_BUCKET=sccache SCCACHE_REGION=us-east-1 Pretty limited testing, no automated tests currently.
2016-06-03 22:09:38 +03:00
]
Integrate the Tokio branch of Hyper This commit pulls in Hyper from its master branch which contains the asynchronous/Tokio integration. All instances of HTTP, namely when interacting with S3, are now all powered by async Hyper and work with futures rather than synchronous requests on thread pools.
2017-02-02 03:30:26 +03:00
[[package]]
name = "hyper-tls"
Update ring
2018-01-07 18:33:04 +03:00
version = "0.1.2"
Use hyper-tls from crates.io
2017-06-15 01:30:32 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Integrate the Tokio branch of Hyper This commit pulls in Hyper from its master branch which contains the asynchronous/Tokio integration. All instances of HTTP, namely when interacting with S3, are now all powered by async Hyper and work with futures rather than synchronous requests on thread pools.
2017-02-02 03:30:26 +03:00
dependencies = [
Revert "Update to futures 0.1.19 and fix breakage from Option-related changes" futures 0.1.19 was yanked because of the breaking API changes it made. This reverts commit 7079ab87832efab4298757176b1388f1d126ed98.
2018-07-12 13:31:09 +03:00
"futures 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",
cargo update
2018-02-01 18:29:23 +03:00
"hyper 0.11.16 (registry+https://github.com/rust-lang/crates.io-index)",
"native-tls 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-core 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"tokio-io 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
Integrate the Tokio branch of Hyper This commit pulls in Hyper from its master branch which contains the asynchronous/Tokio integration. All instances of HTTP, namely when interacting with S3, are now all powered by async Hyper and work with futures rather than synchronous requests on thread pools.
2017-02-02 03:30:26 +03:00
"tokio-service 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"tokio-tls 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
Integrate the Tokio branch of Hyper This commit pulls in Hyper from its master branch which contains the asynchronous/Tokio integration. All instances of HTTP, namely when interacting with S3, are now all powered by async Hyper and work with futures rather than synchronous requests on thread pools.
2017-02-02 03:30:26 +03:00
]
Implement S3Cache Unlike sccache1, you need to specify both bucket and region, like: SCCACHE_BUCKET=sccache SCCACHE_REGION=us-east-1 Pretty limited testing, no automated tests currently.
2016-06-03 22:09:38 +03:00
[[package]]
name = "idna"
Update ring
2018-01-07 18:33:04 +03:00
version = "0.1.4"
Implement S3Cache Unlike sccache1, you need to specify both bucket and region, like: SCCACHE_BUCKET=sccache SCCACHE_REGION=us-east-1 Pretty limited testing, no automated tests currently.
2016-06-03 22:09:38 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
Update dependencies Notably bring in hyper from crates.io
2017-06-14 18:20:12 +03:00
"matches 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"unicode-bidi 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)",
"unicode-normalization 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
Update to using the new tokio-io crate This is an abstraction of the Tokio stack now and doesn't have much impact on sccache itself but I figured it'd be good to update a few deps and pick up the recent version of things! Plus that and I'd like to start using the length_delimited module soon...
2017-03-09 21:00:18 +03:00
]
[[package]]
name = "iovec"
cargo update
2018-02-01 18:29:23 +03:00
version = "0.1.2"
Update to using the new tokio-io crate This is an abstraction of the Tokio stack now and doesn't have much impact on sccache itself but I figured it'd be good to update a few deps and pick up the recent version of things! Plus that and I'd like to start using the length_delimited module soon...
2017-03-09 21:00:18 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
cargo update
2018-02-01 18:29:23 +03:00
"libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
Update to using the new tokio-io crate This is an abstraction of the Tokio stack now and doesn't have much impact on sccache itself but I figured it'd be good to update a few deps and pick up the recent version of things! Plus that and I'd like to start using the length_delimited module soon...
2017-03-09 21:00:18 +03:00
"winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
Implement S3Cache Unlike sccache1, you need to specify both bucket and region, like: SCCACHE_BUCKET=sccache SCCACHE_REGION=us-east-1 Pretty limited testing, no automated tests currently.
2016-06-03 22:09:38 +03:00
]
When hashing Rust compile arguments, sort -L and --cfg args as well as --extern
2017-04-03 17:21:13 +03:00
[[package]]
name = "itertools"
cargo update
2018-02-01 18:29:23 +03:00
version = "0.7.6"
When hashing Rust compile arguments, sort -L and --cfg args as well as --extern
2017-04-03 17:21:13 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
Update ring
2018-01-07 18:33:04 +03:00
"either 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
When hashing Rust compile arguments, sort -L and --cfg args as well as --extern
2017-04-03 17:21:13 +03:00
]
Update to a released rusoto, and 'cargo update' while we're at it
2016-07-15 18:06:16 +03:00
[[package]]
name = "itoa"
Update ring
2018-01-07 18:33:04 +03:00
version = "0.3.4"
Update to a released rusoto, and 'cargo update' while we're at it
2016-07-15 18:06:16 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Add jobserver support to sccache This commit alters the main sccache server to operate and orchestrate its own GNU make style jobserver. This is primarily intended for interoperation with rustc itself. The Rust compiler currently has a multithreaded mode where it will execute code generation and optimization on the LLVM side of things in parallel. This parallelism, however, can overload a machine quickly if not properly accounted for (e.g. if 10 rustcs all spawn 10 threads...). The usage of a GNU make style jobserver is intended to arbitrate and rate limit all these rustc instances to ensure that one build's maximal parallelism never exceeds a particular amount. Currently for Rust Cargo is the primary driver for setting up a jobserver. Cargo will create this and manage this per compilation, ensuring that any one `cargo build` invocation never exceeds a maximal parallelism. When sccache enters the picture, however, the story gets slightly more odd. The jobserver implementation on Unix relies on inheritance of file descriptors in spawned processes. With sccache, however, there's no inheritance as the actual rustc invocation is spawned by the server, not the client. In this case the env vars used to configure the jobsever are usually incorrect. To handle this problem this commit bakes a jobserver directly into sccache itself. The jobserver then overrides whatever jobserver the client has configured in its own env vars to ensure correct operation. The settings of each jobserver may be misconfigured (there's no way to configure sccache's jobserver right now), but hopefully that's not too much of a problem for the forseeable future. The implementation here was to provide a thin wrapper around the `jobserver` crate with a futures-based interface. This interface was then hooked into the mock command infrastructure to automatically acquire a jobserver token when spawning a process and automatically drop the token when the process exits. Additionally, all spawned processes will now automatically receive a configured jobserver. cc rust-lang/rust#42867, the original motivation for this commit
2017-09-27 19:14:51 +03:00
[[package]]
name = "jobserver"
update jobserver to 0.1.11 to pick up a fix for shutting down the worker thread
2018-03-16 20:39:18 +03:00
version = "0.1.11"
Add jobserver support to sccache This commit alters the main sccache server to operate and orchestrate its own GNU make style jobserver. This is primarily intended for interoperation with rustc itself. The Rust compiler currently has a multithreaded mode where it will execute code generation and optimization on the LLVM side of things in parallel. This parallelism, however, can overload a machine quickly if not properly accounted for (e.g. if 10 rustcs all spawn 10 threads...). The usage of a GNU make style jobserver is intended to arbitrate and rate limit all these rustc instances to ensure that one build's maximal parallelism never exceeds a particular amount. Currently for Rust Cargo is the primary driver for setting up a jobserver. Cargo will create this and manage this per compilation, ensuring that any one `cargo build` invocation never exceeds a maximal parallelism. When sccache enters the picture, however, the story gets slightly more odd. The jobserver implementation on Unix relies on inheritance of file descriptors in spawned processes. With sccache, however, there's no inheritance as the actual rustc invocation is spawned by the server, not the client. In this case the env vars used to configure the jobsever are usually incorrect. To handle this problem this commit bakes a jobserver directly into sccache itself. The jobserver then overrides whatever jobserver the client has configured in its own env vars to ensure correct operation. The settings of each jobserver may be misconfigured (there's no way to configure sccache's jobserver right now), but hopefully that's not too much of a problem for the forseeable future. The implementation here was to provide a thin wrapper around the `jobserver` crate with a futures-based interface. This interface was then hooked into the mock command infrastructure to automatically acquire a jobserver token when spawning a process and automatically drop the token when the process exits. Additionally, all spawned processes will now automatically receive a configured jobserver. cc rust-lang/rust#42867, the original motivation for this commit
2017-09-27 19:14:51 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
cargo update
2018-02-01 18:29:23 +03:00
"libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
update jobserver to 0.1.11 to pick up a fix for shutting down the worker thread
2018-03-16 20:39:18 +03:00
"log 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
"rand 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
Add jobserver support to sccache This commit alters the main sccache server to operate and orchestrate its own GNU make style jobserver. This is primarily intended for interoperation with rustc itself. The Rust compiler currently has a multithreaded mode where it will execute code generation and optimization on the LLVM side of things in parallel. This parallelism, however, can overload a machine quickly if not properly accounted for (e.g. if 10 rustcs all spawn 10 threads...). The usage of a GNU make style jobserver is intended to arbitrate and rate limit all these rustc instances to ensure that one build's maximal parallelism never exceeds a particular amount. Currently for Rust Cargo is the primary driver for setting up a jobserver. Cargo will create this and manage this per compilation, ensuring that any one `cargo build` invocation never exceeds a maximal parallelism. When sccache enters the picture, however, the story gets slightly more odd. The jobserver implementation on Unix relies on inheritance of file descriptors in spawned processes. With sccache, however, there's no inheritance as the actual rustc invocation is spawned by the server, not the client. In this case the env vars used to configure the jobsever are usually incorrect. To handle this problem this commit bakes a jobserver directly into sccache itself. The jobserver then overrides whatever jobserver the client has configured in its own env vars to ensure correct operation. The settings of each jobserver may be misconfigured (there's no way to configure sccache's jobserver right now), but hopefully that's not too much of a problem for the forseeable future. The implementation here was to provide a thin wrapper around the `jobserver` crate with a futures-based interface. This interface was then hooked into the mock command infrastructure to automatically acquire a jobserver token when spawning a process and automatically drop the token when the process exits. Additionally, all spawned processes will now automatically receive a configured jobserver. cc rust-lang/rust#42867, the original motivation for this commit
2017-09-27 19:14:51 +03:00
]
Implement GCS backend
2017-05-06 03:02:48 +03:00
[[package]]
name = "jsonwebtoken"
Update ring
2018-01-07 18:33:04 +03:00
version = "4.0.0"
Implement GCS backend
2017-05-06 03:02:48 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
Update ring
2018-01-07 18:33:04 +03:00
"base64 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
"chrono 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
"error-chain 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)",
"ring 0.12.1 (registry+https://github.com/rust-lang/crates.io-index)",
"serde 1.0.27 (registry+https://github.com/rust-lang/crates.io-index)",
"serde_derive 1.0.27 (registry+https://github.com/rust-lang/crates.io-index)",
"serde_json 1.0.9 (registry+https://github.com/rust-lang/crates.io-index)",
"untrusted 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
Implement GCS backend
2017-05-06 03:02:48 +03:00
]
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
[[package]]
name = "kernel32-sys"
version = "0.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
Update to a released rusoto, and 'cargo update' while we're at it
2016-07-15 18:06:16 +03:00
"winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
"winapi-build 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
Implement S3Cache Unlike sccache1, you need to specify both bucket and region, like: SCCACHE_BUCKET=sccache SCCACHE_REGION=us-east-1 Pretty limited testing, no automated tests currently.
2016-06-03 22:09:38 +03:00
[[package]]
name = "language-tags"
version = "0.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
Integrate the Tokio branch of Hyper This commit pulls in Hyper from its master branch which contains the asynchronous/Tokio integration. All instances of HTTP, namely when interacting with S3, are now all powered by async Hyper and work with futures rather than synchronous requests on thread pools.
2017-02-02 03:30:26 +03:00
[[package]]
name = "lazy_static"
Update ring
2018-01-07 18:33:04 +03:00
version = "0.2.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "lazy_static"
version = "1.0.0"
Integrate the Tokio branch of Hyper This commit pulls in Hyper from its master branch which contains the asynchronous/Tokio integration. All instances of HTTP, namely when interacting with S3, are now all powered by async Hyper and work with futures rather than synchronous requests on thread pools.
2017-02-02 03:30:26 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Rewrite the server module with Tokio This commit rewrites the `server` module of sccache to be backed with Tokio. The previous version was written with `mio`, which Tokio is built on, but is unfortunately less ergonomic. Tokio is the state-of-the-art for asynchronous programming in Rust and sccache serves as a great testing ground for ergonomics! It's intended that the support added here will eventually extend to many other operations that sccache does as well. For example thread spawning has all been replaced with `CpuPool` to have a shared pool for I/O operations and such (namely the filesystem). Eventually the HTTP requests made by the S3 backend can be integrated with the Tokio branch of Hyper as well to run that on the event loop instead of in a worker thread. I'd also like to eventually extend this with `tokio-process` as well to move process spawning off helper threads as well, but I'm leaving that to a future commit as well. Overall I found the transition was quite smooth, with the high level architecture look like: * The `tokio-proto` crate is used in streaming mode. The streaming part is used for the one RPC sccache gets which requires a second response to be sent later on. This second response is the "response body" in tokio-proto terms. * All of sccache's logic is manifested in an implementation of the `Service` trait. * The transport layer is provided with `tokio_core::io::{Framed, Codec}`, and simple deserialization/serialization is performed with protobuf. Some differences in design are: * The `SccacheService` for now is just a bunch of reference-counted pointers, making it cheap to clone. As the futures it returns progress they will each retain a reference to a cloned copy of the `SccacheService`. Before all this data was just stored and manipulated in a struct directly, but it's now directly managed through shared memory. * The storage backends share a thread pool with the main server instead of spawning threads. And finally, some things I've learned along the way: * Sharing data between futures isn't a trivial operation. It took an explicit decision to use `Rc` and I'm not sure I'm 100% happy with how the ergonomics played out. * Shutdown is pretty tricky here. I've tried to carry over all the previous logic but it definitely required not using `TcpServer` in tokio-proto at the very least, and otherwise required a few custom futures and such to track the various states. I have a hunch that tokio-proto could provide more options out of the box for something like this.
2017-01-31 04:04:03 +03:00
[[package]]
name = "lazycell"
Update ring
2018-01-07 18:33:04 +03:00
version = "0.6.0"
Rewrite the server module with Tokio This commit rewrites the `server` module of sccache to be backed with Tokio. The previous version was written with `mio`, which Tokio is built on, but is unfortunately less ergonomic. Tokio is the state-of-the-art for asynchronous programming in Rust and sccache serves as a great testing ground for ergonomics! It's intended that the support added here will eventually extend to many other operations that sccache does as well. For example thread spawning has all been replaced with `CpuPool` to have a shared pool for I/O operations and such (namely the filesystem). Eventually the HTTP requests made by the S3 backend can be integrated with the Tokio branch of Hyper as well to run that on the event loop instead of in a worker thread. I'd also like to eventually extend this with `tokio-process` as well to move process spawning off helper threads as well, but I'm leaving that to a future commit as well. Overall I found the transition was quite smooth, with the high level architecture look like: * The `tokio-proto` crate is used in streaming mode. The streaming part is used for the one RPC sccache gets which requires a second response to be sent later on. This second response is the "response body" in tokio-proto terms. * All of sccache's logic is manifested in an implementation of the `Service` trait. * The transport layer is provided with `tokio_core::io::{Framed, Codec}`, and simple deserialization/serialization is performed with protobuf. Some differences in design are: * The `SccacheService` for now is just a bunch of reference-counted pointers, making it cheap to clone. As the futures it returns progress they will each retain a reference to a cloned copy of the `SccacheService`. Before all this data was just stored and manipulated in a struct directly, but it's now directly managed through shared memory. * The storage backends share a thread pool with the main server instead of spawning threads. And finally, some things I've learned along the way: * Sharing data between futures isn't a trivial operation. It took an explicit decision to use `Rc` and I'm not sure I'm 100% happy with how the ergonomics played out. * Shutdown is pretty tricky here. I've tried to carry over all the previous logic but it definitely required not using `TcpServer` in tokio-proto at the very least, and otherwise required a few custom futures and such to track the various states. I have a hunch that tokio-proto could provide more options out of the box for something like this.
2017-01-31 04:04:03 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
[[package]]
name = "libc"
cargo update
2018-02-01 18:29:23 +03:00
version = "0.2.36"
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Make DiskCache limit the size of the on-disk cache by using LruDiskCache. Fixes #29
2016-11-29 03:59:42 +03:00
[[package]]
name = "linked-hash-map"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
use local-encoding crate for stdout conversion
2016-09-21 22:57:28 +03:00
[[package]]
name = "local-encoding"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
"skeptic 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
"winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
]
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
[[package]]
name = "log"
Update ring
2018-01-07 18:33:04 +03:00
version = "0.3.9"
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Make DiskCache limit the size of the on-disk cache by using LruDiskCache. Fixes #29
2016-11-29 03:59:42 +03:00
dependencies = [
Update ring
2018-01-07 18:33:04 +03:00
"log 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
Make DiskCache limit the size of the on-disk cache by using LruDiskCache. Fixes #29
2016-11-29 03:59:42 +03:00
]
Update iovec to fix a soundness hole on Windows Also update a few other dependencies that transitively needed fixing
2017-10-06 02:40:25 +03:00
[[package]]
Update ring
2018-01-07 18:33:04 +03:00
name = "log"
version = "0.4.1"
Update iovec to fix a soundness hole on Windows Also update a few other dependencies that transitively needed fixing
2017-10-06 02:40:25 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
Update ring
2018-01-07 18:33:04 +03:00
"cfg-if 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
Update iovec to fix a soundness hole on Windows Also update a few other dependencies that transitively needed fixing
2017-10-06 02:40:25 +03:00
]
[[package]]
Update ring
2018-01-07 18:33:04 +03:00
name = "lru-disk-cache"
Bump lru-disk-cache to 0.2.0 so we can publish it to crates.io because we made an API change
2018-01-30 19:54:20 +03:00
version = "0.2.0"
Update iovec to fix a soundness hole on Windows Also update a few other dependencies that transitively needed fixing
2017-10-06 02:40:25 +03:00
dependencies = [
cargo update
2018-02-01 18:29:23 +03:00
"filetime 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"linked-hash-map 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
cargo update
2018-02-01 18:29:23 +03:00
"tempdir 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"walkdir 1.0.7 (registry+https://github.com/rust-lang/crates.io-index)",
Update iovec to fix a soundness hole on Windows Also update a few other dependencies that transitively needed fixing
2017-10-06 02:40:25 +03:00
]
Implement S3Cache Unlike sccache1, you need to specify both bucket and region, like: SCCACHE_BUCKET=sccache SCCACHE_REGION=us-east-1 Pretty limited testing, no automated tests currently.
2016-06-03 22:09:38 +03:00
[[package]]
name = "matches"
Update dependencies Notably bring in hyper from crates.io
2017-06-14 18:20:12 +03:00
version = "0.1.6"
Implement S3Cache Unlike sccache1, you need to specify both bucket and region, like: SCCACHE_BUCKET=sccache SCCACHE_REGION=us-east-1 Pretty limited testing, no automated tests currently.
2016-06-03 22:09:38 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Add a Memcached cache variant This cache module uses a Memcached cluster. To make sccache use this, set SCCACHE_MEMCACHED to a list of tcp://<hostname>:<port> addresses, separated by whitespace.
2017-08-10 17:50:33 +03:00
[[package]]
name = "memcached-rs"
version = "0.1.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"bufstream 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
"byteorder 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
"conhash 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
"rand 0.3.20 (registry+https://github.com/rust-lang/crates.io-index)",
"semver 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
"unix_socket 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
[[package]]
name = "memchr"
Update ring
2018-01-07 18:33:04 +03:00
version = "2.0.1"
Integrate the Tokio branch of Hyper This commit pulls in Hyper from its master branch which contains the asynchronous/Tokio integration. All instances of HTTP, namely when interacting with S3, are now all powered by async Hyper and work with futures rather than synchronous requests on thread pools.
2017-02-02 03:30:26 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
cargo update
2018-02-01 18:29:23 +03:00
"libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
Integrate the Tokio branch of Hyper This commit pulls in Hyper from its master branch which contains the asynchronous/Tokio integration. All instances of HTTP, namely when interacting with S3, are now all powered by async Hyper and work with futures rather than synchronous requests on thread pools.
2017-02-02 03:30:26 +03:00
]
Implement S3Cache Unlike sccache1, you need to specify both bucket and region, like: SCCACHE_BUCKET=sccache SCCACHE_REGION=us-east-1 Pretty limited testing, no automated tests currently.
2016-06-03 22:09:38 +03:00
[[package]]
name = "mime"
Update ring
2018-01-07 18:33:04 +03:00
version = "0.3.5"
Implement S3Cache Unlike sccache1, you need to specify both bucket and region, like: SCCACHE_BUCKET=sccache SCCACHE_REGION=us-east-1 Pretty limited testing, no automated tests currently.
2016-06-03 22:09:38 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
Update ring
2018-01-07 18:33:04 +03:00
"unicase 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
Implement S3Cache Unlike sccache1, you need to specify both bucket and region, like: SCCACHE_BUCKET=sccache SCCACHE_REGION=us-east-1 Pretty limited testing, no automated tests currently.
2016-06-03 22:09:38 +03:00
]
Implement fetching/storing to cache, interfaces for doing so, implement a disk cache
2016-05-21 21:14:26 +03:00
[[package]]
name = "miniz-sys"
Update ring
2018-01-07 18:33:04 +03:00
version = "0.1.10"
Implement fetching/storing to cache, interfaces for doing so, implement a disk cache
2016-05-21 21:14:26 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
cargo update
2018-02-01 18:29:23 +03:00
"cc 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
Implement fetching/storing to cache, interfaces for doing so, implement a disk cache
2016-05-21 21:14:26 +03:00
]
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
[[package]]
name = "mio"
Update ring
2018-01-07 18:33:04 +03:00
version = "0.6.12"
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
Update ring
2018-01-07 18:33:04 +03:00
"fuchsia-zircon 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
"fuchsia-zircon-sys 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
cargo update
2018-02-01 18:29:23 +03:00
"iovec 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
Rewrite the server module with Tokio This commit rewrites the `server` module of sccache to be backed with Tokio. The previous version was written with `mio`, which Tokio is built on, but is unfortunately less ergonomic. Tokio is the state-of-the-art for asynchronous programming in Rust and sccache serves as a great testing ground for ergonomics! It's intended that the support added here will eventually extend to many other operations that sccache does as well. For example thread spawning has all been replaced with `CpuPool` to have a shared pool for I/O operations and such (namely the filesystem). Eventually the HTTP requests made by the S3 backend can be integrated with the Tokio branch of Hyper as well to run that on the event loop instead of in a worker thread. I'd also like to eventually extend this with `tokio-process` as well to move process spawning off helper threads as well, but I'm leaving that to a future commit as well. Overall I found the transition was quite smooth, with the high level architecture look like: * The `tokio-proto` crate is used in streaming mode. The streaming part is used for the one RPC sccache gets which requires a second response to be sent later on. This second response is the "response body" in tokio-proto terms. * All of sccache's logic is manifested in an implementation of the `Service` trait. * The transport layer is provided with `tokio_core::io::{Framed, Codec}`, and simple deserialization/serialization is performed with protobuf. Some differences in design are: * The `SccacheService` for now is just a bunch of reference-counted pointers, making it cheap to clone. As the futures it returns progress they will each retain a reference to a cloned copy of the `SccacheService`. Before all this data was just stored and manipulated in a struct directly, but it's now directly managed through shared memory. * The storage backends share a thread pool with the main server instead of spawning threads. And finally, some things I've learned along the way: * Sharing data between futures isn't a trivial operation. It took an explicit decision to use `Rc` and I'm not sure I'm 100% happy with how the ergonomics played out. * Shutdown is pretty tricky here. I've tried to carry over all the previous logic but it definitely required not using `TcpServer` in tokio-proto at the very least, and otherwise required a few custom futures and such to track the various states. I have a hunch that tokio-proto could provide more options out of the box for something like this.
2017-01-31 04:04:03 +03:00
"kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"lazycell 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
cargo update
2018-02-01 18:29:23 +03:00
"libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"log 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
Update to using the new tokio-io crate This is an abstraction of the Tokio stack now and doesn't have much impact on sccache itself but I figured it'd be good to update a few deps and pick up the recent version of things! Plus that and I'd like to start using the length_delimited module soon...
2017-03-09 21:00:18 +03:00
"miow 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"net2 0.2.31 (registry+https://github.com/rust-lang/crates.io-index)",
Rewrite the server module with Tokio This commit rewrites the `server` module of sccache to be backed with Tokio. The previous version was written with `mio`, which Tokio is built on, but is unfortunately less ergonomic. Tokio is the state-of-the-art for asynchronous programming in Rust and sccache serves as a great testing ground for ergonomics! It's intended that the support added here will eventually extend to many other operations that sccache does as well. For example thread spawning has all been replaced with `CpuPool` to have a shared pool for I/O operations and such (namely the filesystem). Eventually the HTTP requests made by the S3 backend can be integrated with the Tokio branch of Hyper as well to run that on the event loop instead of in a worker thread. I'd also like to eventually extend this with `tokio-process` as well to move process spawning off helper threads as well, but I'm leaving that to a future commit as well. Overall I found the transition was quite smooth, with the high level architecture look like: * The `tokio-proto` crate is used in streaming mode. The streaming part is used for the one RPC sccache gets which requires a second response to be sent later on. This second response is the "response body" in tokio-proto terms. * All of sccache's logic is manifested in an implementation of the `Service` trait. * The transport layer is provided with `tokio_core::io::{Framed, Codec}`, and simple deserialization/serialization is performed with protobuf. Some differences in design are: * The `SccacheService` for now is just a bunch of reference-counted pointers, making it cheap to clone. As the futures it returns progress they will each retain a reference to a cloned copy of the `SccacheService`. Before all this data was just stored and manipulated in a struct directly, but it's now directly managed through shared memory. * The storage backends share a thread pool with the main server instead of spawning threads. And finally, some things I've learned along the way: * Sharing data between futures isn't a trivial operation. It took an explicit decision to use `Rc` and I'm not sure I'm 100% happy with how the ergonomics played out. * Shutdown is pretty tricky here. I've tried to carry over all the previous logic but it definitely required not using `TcpServer` in tokio-proto at the very least, and otherwise required a few custom futures and such to track the various states. I have a hunch that tokio-proto could provide more options out of the box for something like this.
2017-01-31 04:04:03 +03:00
"slab 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
Update to a released rusoto, and 'cargo update' while we're at it
2016-07-15 18:06:16 +03:00
"winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
]
Integrate process spawning with tokio-process This commit replaces all process spawning with the futures-powered versions in the `tokio-process` crate. Most functions were already ready to return futures, but a few minor updates were made to ensure that functions could return futures. Additionally, some `&CpuPool` arguments have shown up to allow executing work on a thread pool, such as filesystem operations. A number of compilers write data to tempdirs and such before running a compiler, and these are all executed on thread pools rather than the main thread. My main takeaway from this commit is that translating synchronous to asynchronous code isn't always easy. The "easy" version ends up being relatively wasteful in terms of clones for low-level performance, but probably shouldn't matter much in the context of spawning processes. Other than that though I found that there was a translation for all patterns found didn't actually hit any bugs (yet at least) from the translation.
2017-02-01 03:19:35 +03:00
[[package]]
name = "mio-named-pipes"
Update ring
2018-01-07 18:33:04 +03:00
version = "0.1.6"
Integrate process spawning with tokio-process This commit replaces all process spawning with the futures-powered versions in the `tokio-process` crate. Most functions were already ready to return futures, but a few minor updates were made to ensure that functions could return futures. Additionally, some `&CpuPool` arguments have shown up to allow executing work on a thread pool, such as filesystem operations. A number of compilers write data to tempdirs and such before running a compiler, and these are all executed on thread pools rather than the main thread. My main takeaway from this commit is that translating synchronous to asynchronous code isn't always easy. The "easy" version ends up being relatively wasteful in terms of clones for low-level performance, but probably shouldn't matter much in the context of spawning processes. Other than that though I found that there was a translation for all patterns found didn't actually hit any bugs (yet at least) from the translation.
2017-02-01 03:19:35 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
Update ring
2018-01-07 18:33:04 +03:00
"log 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
"mio 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)",
"miow 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
cargo update
2018-02-01 18:29:23 +03:00
"winapi 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)",
Integrate process spawning with tokio-process This commit replaces all process spawning with the futures-powered versions in the `tokio-process` crate. Most functions were already ready to return futures, but a few minor updates were made to ensure that functions could return futures. Additionally, some `&CpuPool` arguments have shown up to allow executing work on a thread pool, such as filesystem operations. A number of compilers write data to tempdirs and such before running a compiler, and these are all executed on thread pools rather than the main thread. My main takeaway from this commit is that translating synchronous to asynchronous code isn't always easy. The "easy" version ends up being relatively wasteful in terms of clones for low-level performance, but probably shouldn't matter much in the context of spawning processes. Other than that though I found that there was a translation for all patterns found didn't actually hit any bugs (yet at least) from the translation.
2017-02-01 03:19:35 +03:00
]
[[package]]
name = "mio-uds"
Update dependencies * Mostly upgrade to serde 1.0 * Pull in lots of other updates for other small deps
2017-05-18 23:53:00 +03:00
version = "0.6.4"
Integrate process spawning with tokio-process This commit replaces all process spawning with the futures-powered versions in the `tokio-process` crate. Most functions were already ready to return futures, but a few minor updates were made to ensure that functions could return futures. Additionally, some `&CpuPool` arguments have shown up to allow executing work on a thread pool, such as filesystem operations. A number of compilers write data to tempdirs and such before running a compiler, and these are all executed on thread pools rather than the main thread. My main takeaway from this commit is that translating synchronous to asynchronous code isn't always easy. The "easy" version ends up being relatively wasteful in terms of clones for low-level performance, but probably shouldn't matter much in the context of spawning processes. Other than that though I found that there was a translation for all patterns found didn't actually hit any bugs (yet at least) from the translation.
2017-02-01 03:19:35 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
cargo update
2018-02-01 18:29:23 +03:00
"libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"mio 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)",
Integrate process spawning with tokio-process This commit replaces all process spawning with the futures-powered versions in the `tokio-process` crate. Most functions were already ready to return futures, but a few minor updates were made to ensure that functions could return futures. Additionally, some `&CpuPool` arguments have shown up to allow executing work on a thread pool, such as filesystem operations. A number of compilers write data to tempdirs and such before running a compiler, and these are all executed on thread pools rather than the main thread. My main takeaway from this commit is that translating synchronous to asynchronous code isn't always easy. The "easy" version ends up being relatively wasteful in terms of clones for low-level performance, but probably shouldn't matter much in the context of spawning processes. Other than that though I found that there was a translation for all patterns found didn't actually hit any bugs (yet at least) from the translation.
2017-02-01 03:19:35 +03:00
]
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
[[package]]
name = "miow"
Update to using the new tokio-io crate This is an abstraction of the Tokio stack now and doesn't have much impact on sccache itself but I figured it'd be good to update a few deps and pick up the recent version of things! Plus that and I'd like to start using the length_delimited module soon...
2017-03-09 21:00:18 +03:00
version = "0.2.1"
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"net2 0.2.31 (registry+https://github.com/rust-lang/crates.io-index)",
Update to a released rusoto, and 'cargo update' while we're at it
2016-07-15 18:06:16 +03:00
"winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
"ws2_32-sys 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
Update ring
2018-01-07 18:33:04 +03:00
[[package]]
name = "miow"
version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
cargo update
2018-02-01 18:29:23 +03:00
"socket2 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
"winapi 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
]
Implement fetching/storing to cache, interfaces for doing so, implement a disk cache
2016-05-21 21:14:26 +03:00
[[package]]
name = "msdos_time"
Update dependencies * Mostly upgrade to serde 1.0 * Pull in lots of other updates for other small deps
2017-05-18 23:53:00 +03:00
version = "0.1.5"
Implement fetching/storing to cache, interfaces for doing so, implement a disk cache
2016-05-21 21:14:26 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"time 0.1.39 (registry+https://github.com/rust-lang/crates.io-index)",
Update to a released rusoto, and 'cargo update' while we're at it
2016-07-15 18:06:16 +03:00
"winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
Implement fetching/storing to cache, interfaces for doing so, implement a disk cache
2016-05-21 21:14:26 +03:00
]
Integrate the Tokio branch of Hyper This commit pulls in Hyper from its master branch which contains the asynchronous/Tokio integration. All instances of HTTP, namely when interacting with S3, are now all powered by async Hyper and work with futures rather than synchronous requests on thread pools.
2017-02-02 03:30:26 +03:00
[[package]]
name = "native-tls"
cargo update
2018-02-01 18:29:23 +03:00
version = "0.1.5"
Integrate the Tokio branch of Hyper This commit pulls in Hyper from its master branch which contains the asynchronous/Tokio integration. All instances of HTTP, namely when interacting with S3, are now all powered by async Hyper and work with futures rather than synchronous requests on thread pools.
2017-02-02 03:30:26 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
cargo update
2018-02-01 18:29:23 +03:00
"lazy_static 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"openssl 0.9.23 (registry+https://github.com/rust-lang/crates.io-index)",
Update to schannel version 0.1.11
2018-03-05 20:38:37 +03:00
"schannel 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"security-framework 0.1.16 (registry+https://github.com/rust-lang/crates.io-index)",
"security-framework-sys 0.1.16 (registry+https://github.com/rust-lang/crates.io-index)",
cargo update
2018-02-01 18:29:23 +03:00
"tempdir 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
Integrate the Tokio branch of Hyper This commit pulls in Hyper from its master branch which contains the asynchronous/Tokio integration. All instances of HTTP, namely when interacting with S3, are now all powered by async Hyper and work with futures rather than synchronous requests on thread pools.
2017-02-02 03:30:26 +03:00
]
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
[[package]]
name = "net2"
Update ring
2018-01-07 18:33:04 +03:00
version = "0.2.31"
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
Update ring
2018-01-07 18:33:04 +03:00
"cfg-if 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
"kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
cargo update
2018-02-01 18:29:23 +03:00
"libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
Update to a released rusoto, and 'cargo update' while we're at it
2016-07-15 18:06:16 +03:00
"winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
"ws2_32-sys 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
Add a Memcached cache variant This cache module uses a Memcached cluster. To make sccache use this, set SCCACHE_MEMCACHED to a list of tcp://<hostname>:<port> addresses, separated by whitespace.
2017-08-10 17:50:33 +03:00
[[package]]
name = "nom"
version = "1.2.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
drop format_size code in favor of number_prefix crate
2016-05-12 22:46:22 +03:00
[[package]]
name = "num"
Update ring
2018-01-07 18:33:04 +03:00
version = "0.1.41"
drop format_size code in favor of number_prefix crate
2016-05-12 22:46:22 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
Update ring
2018-01-07 18:33:04 +03:00
"num-integer 0.1.35 (registry+https://github.com/rust-lang/crates.io-index)",
"num-iter 0.1.34 (registry+https://github.com/rust-lang/crates.io-index)",
cargo update
2018-02-01 18:29:23 +03:00
"num-traits 0.1.42 (registry+https://github.com/rust-lang/crates.io-index)",
drop format_size code in favor of number_prefix crate
2016-05-12 22:46:22 +03:00
]
[[package]]
name = "num-integer"
Update ring
2018-01-07 18:33:04 +03:00
version = "0.1.35"
drop format_size code in favor of number_prefix crate
2016-05-12 22:46:22 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
cargo update
2018-02-01 18:29:23 +03:00
"num-traits 0.1.42 (registry+https://github.com/rust-lang/crates.io-index)",
drop format_size code in favor of number_prefix crate
2016-05-12 22:46:22 +03:00
]
[[package]]
name = "num-iter"
Update ring
2018-01-07 18:33:04 +03:00
version = "0.1.34"
drop format_size code in favor of number_prefix crate
2016-05-12 22:46:22 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
Update ring
2018-01-07 18:33:04 +03:00
"num-integer 0.1.35 (registry+https://github.com/rust-lang/crates.io-index)",
cargo update
2018-02-01 18:29:23 +03:00
"num-traits 0.1.42 (registry+https://github.com/rust-lang/crates.io-index)",
drop format_size code in favor of number_prefix crate
2016-05-12 22:46:22 +03:00
]
[[package]]
name = "num-traits"
cargo update
2018-02-01 18:29:23 +03:00
version = "0.1.42"
drop format_size code in favor of number_prefix crate
2016-05-12 22:46:22 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Switch from assert_cli to assert_cmd
2018-07-26 22:52:50 +03:00
[[package]]
name = "num-traits"
version = "0.2.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement S3Cache Unlike sccache1, you need to specify both bucket and region, like: SCCACHE_BUCKET=sccache SCCACHE_REGION=us-east-1 Pretty limited testing, no automated tests currently.
2016-06-03 22:09:38 +03:00
[[package]]
name = "num_cpus"
Update ring
2018-01-07 18:33:04 +03:00
version = "1.8.0"
Implement S3Cache Unlike sccache1, you need to specify both bucket and region, like: SCCACHE_BUCKET=sccache SCCACHE_REGION=us-east-1 Pretty limited testing, no automated tests currently.
2016-06-03 22:09:38 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
cargo update
2018-02-01 18:29:23 +03:00
"libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
Implement S3Cache Unlike sccache1, you need to specify both bucket and region, like: SCCACHE_BUCKET=sccache SCCACHE_REGION=us-east-1 Pretty limited testing, no automated tests currently.
2016-06-03 22:09:38 +03:00
]
drop format_size code in favor of number_prefix crate
2016-05-12 22:46:22 +03:00
[[package]]
name = "number_prefix"
Update dependencies * Mostly upgrade to serde 1.0 * Pull in lots of other updates for other small deps
2017-05-18 23:53:00 +03:00
version = "0.2.7"
drop format_size code in favor of number_prefix crate
2016-05-12 22:46:22 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
cargo update
2018-02-01 18:29:23 +03:00
"num-traits 0.1.42 (registry+https://github.com/rust-lang/crates.io-index)",
drop format_size code in favor of number_prefix crate
2016-05-12 22:46:22 +03:00
]
Integrate the Tokio branch of Hyper This commit pulls in Hyper from its master branch which contains the asynchronous/Tokio integration. All instances of HTTP, namely when interacting with S3, are now all powered by async Hyper and work with futures rather than synchronous requests on thread pools.
2017-02-02 03:30:26 +03:00
[[package]]
name = "openssl"
Update ring
2018-01-07 18:33:04 +03:00
version = "0.9.23"
Integrate the Tokio branch of Hyper This commit pulls in Hyper from its master branch which contains the asynchronous/Tokio integration. All instances of HTTP, namely when interacting with S3, are now all powered by async Hyper and work with futures rather than synchronous requests on thread pools.
2017-02-02 03:30:26 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
Update dependencies Notably bring in hyper from crates.io
2017-06-14 18:20:12 +03:00
"bitflags 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"foreign-types 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
"lazy_static 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
cargo update
2018-02-01 18:29:23 +03:00
"libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
"openssl-sys 0.9.24 (registry+https://github.com/rust-lang/crates.io-index)",
Integrate the Tokio branch of Hyper This commit pulls in Hyper from its master branch which contains the asynchronous/Tokio integration. All instances of HTTP, namely when interacting with S3, are now all powered by async Hyper and work with futures rather than synchronous requests on thread pools.
2017-02-02 03:30:26 +03:00
]
[[package]]
name = "openssl-sys"
cargo update
2018-02-01 18:29:23 +03:00
version = "0.9.24"
Integrate the Tokio branch of Hyper This commit pulls in Hyper from its master branch which contains the asynchronous/Tokio integration. All instances of HTTP, namely when interacting with S3, are now all powered by async Hyper and work with futures rather than synchronous requests on thread pools.
2017-02-02 03:30:26 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
cargo update
2018-02-01 18:29:23 +03:00
"cc 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
Update dependencies * Mostly upgrade to serde 1.0 * Pull in lots of other updates for other small deps
2017-05-18 23:53:00 +03:00
"pkg-config 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"vcpkg 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
Integrate the Tokio branch of Hyper This commit pulls in Hyper from its master branch which contains the asynchronous/Tokio integration. All instances of HTTP, namely when interacting with S3, are now all powered by async Hyper and work with futures rather than synchronous requests on thread pools.
2017-02-02 03:30:26 +03:00
]
Update dependencies Notably bring in hyper from crates.io
2017-06-14 18:20:12 +03:00
[[package]]
name = "percent-encoding"
Update ring
2018-01-07 18:33:04 +03:00
version = "1.0.1"
Update dependencies Notably bring in hyper from crates.io
2017-06-14 18:20:12 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Integrate the Tokio branch of Hyper This commit pulls in Hyper from its master branch which contains the asynchronous/Tokio integration. All instances of HTTP, namely when interacting with S3, are now all powered by async Hyper and work with futures rather than synchronous requests on thread pools.
2017-02-02 03:30:26 +03:00
[[package]]
name = "pkg-config"
version = "0.3.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement fetching/storing to cache, interfaces for doing so, implement a disk cache
2016-05-21 21:14:26 +03:00
[[package]]
name = "podio"
cargo update
2018-02-01 18:29:23 +03:00
version = "0.1.6"
Implement fetching/storing to cache, interfaces for doing so, implement a disk cache
2016-05-21 21:14:26 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Switch from assert_cli to assert_cmd
2018-07-26 22:52:50 +03:00
[[package]]
name = "predicates"
version = "0.5.2"
Refactor system tests to use assert_cmd
2018-07-27 19:07:08 +03:00
source = "git+https://github.com/luser/predicates-rs?branch=function-unsized#56592bae5e0dbce03b0d6f82a5063844d336c91a"
Switch from assert_cli to assert_cmd
2018-07-26 22:52:50 +03:00
dependencies = [
"difference 2.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
"float-cmp 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
"regex 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
]
use local-encoding crate for stdout conversion
2016-09-21 22:57:28 +03:00
[[package]]
name = "pulldown-cmark"
version = "0.0.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
cargo update
2018-02-01 18:29:23 +03:00
"getopts 0.2.17 (registry+https://github.com/rust-lang/crates.io-index)",
use local-encoding crate for stdout conversion
2016-09-21 22:57:28 +03:00
]
Move from protobuf to bincode for a wire format This commit migrates away from the `protobuf` crate to instead just working with bincode on the wire as a serialization format. This is done by leveraging a few different crates: * The `bincode` and `serde_derive` crates are used to define serialization for Rust structures as well as provide a bincode implementation. * The `tokio_io::codec::length_delimited` module implements framing via length prefixes to transform an asynchronous stream of bytes into a literal `Stream` of `BytesMut`. * The `tokio_serde_bincode` crate is then used to tie it all together, parsing these `BytesMut` as the request/response types of sccache. Most of the changes here are related to moving away from the protobuf API throughout the codebase (e.g. `has_foo` and `take_foo`) towards a more rustic-ish API that just uses enums/structs. Overall it felt quite natural (as one would expect) to just use the raw enum/struct values. This may not be quite as performant as before but that doesn't really apply to sccache's use case where perf is hugely dominated by actually compiling and hashing, so I'm not too too worried about that. My personal motivation for this is twofold: 1. Using `protobuf` was a little clunky throughout the codebase and definitely had some sharp edges that felt good to smooth out. 2. There's currently what I believe some mysterious segfault and/or stray write happening in sccache and I'm not sure where. The `protobuf` crate had a lot of `unsafe` code and in lieu of actually auditing it I figured it'd be good to kill two birds with one stone. I have no idea if this fixes my segfault problem (I never could reproduce it) but I figured it's worth a shot.
2017-03-22 20:21:52 +03:00
[[package]]
name = "quote"
version = "0.3.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
[[package]]
name = "rand"
Update ring
2018-01-07 18:33:04 +03:00
version = "0.3.20"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"fuchsia-zircon 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
cargo update
2018-02-01 18:29:23 +03:00
"libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "rand"
version = "0.4.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"fuchsia-zircon 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
"winapi 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
]
[[package]]
name = "rayon"
version = "0.8.2"
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
Update ring
2018-01-07 18:33:04 +03:00
"rayon-core 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
]
Switch from SHA-1 to SHA-512 Local benchmarking showed that the implementation of SHA-512 in the *ring* crate is 3x faster than the implementation of SHA-1 in the `sha1` crate. I've also noticed that 80%+ of sccache's runtime on a fully cached build is spent hashing. With this change I noticed a decrease from 108s to 92s when building a fully cached LLVM from the network. Not a huge win but if the network were faster could perhaps add up! Closes #108
2017-04-21 07:09:15 +03:00
[[package]]
name = "rayon-core"
Update ring
2018-01-07 18:33:04 +03:00
version = "1.3.0"
Switch from SHA-1 to SHA-512 Local benchmarking showed that the implementation of SHA-512 in the *ring* crate is 3x faster than the implementation of SHA-1 in the `sha1` crate. I've also noticed that 80%+ of sccache's runtime on a fully cached build is spent hashing. With this change I noticed a decrease from 108s to 92s when building a fully cached LLVM from the network. Not a huge win but if the network were faster could perhaps add up! Closes #108
2017-04-21 07:09:15 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
Update dependencies Notably bring in hyper from crates.io
2017-06-14 18:20:12 +03:00
"coco 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"lazy_static 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)",
cargo update
2018-02-01 18:29:23 +03:00
"libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
"rand 0.3.20 (registry+https://github.com/rust-lang/crates.io-index)",
Switch from SHA-1 to SHA-512 Local benchmarking showed that the implementation of SHA-512 in the *ring* crate is 3x faster than the implementation of SHA-1 in the `sha1` crate. I've also noticed that 80%+ of sccache's runtime on a fully cached build is spent hashing. With this change I noticed a decrease from 108s to 92s when building a fully cached LLVM from the network. Not a huge win but if the network were faster could perhaps add up! Closes #108
2017-04-21 07:09:15 +03:00
]
Add a Redis cache variant This cache module uses a Redis instance. To make sccache use this, set SCCACHE_REDIS to redis://[:<passwd>@]<hostname>[:port][/<db>]. The maximum and current cache size is retrieved from the INFO and CONFIG GET redis command.
2017-02-16 22:56:41 +03:00
[[package]]
name = "redis"
version = "0.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"sha1 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"url 1.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
Add a Redis cache variant This cache module uses a Redis instance. To make sccache use this, set SCCACHE_REDIS to redis://[:<passwd>@]<hostname>[:port][/<db>]. The maximum and current cache size is retrieved from the INFO and CONFIG GET redis command.
2017-02-16 22:56:41 +03:00
]
Update dependencies * Mostly upgrade to serde 1.0 * Pull in lots of other updates for other small deps
2017-05-18 23:53:00 +03:00
[[package]]
name = "redox_syscall"
Update ring
2018-01-07 18:33:04 +03:00
version = "0.1.37"
Update dependencies * Mostly upgrade to serde 1.0 * Pull in lots of other updates for other small deps
2017-05-18 23:53:00 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update ring
2018-01-07 18:33:04 +03:00
[[package]]
name = "redox_termios"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"redox_syscall 0.1.37 (registry+https://github.com/rust-lang/crates.io-index)",
]
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
[[package]]
name = "regex"
Update ring
2018-01-07 18:33:04 +03:00
version = "0.2.5"
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
Update ring
2018-01-07 18:33:04 +03:00
"aho-corasick 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)",
"memchr 2.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
"regex-syntax 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
"thread_local 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
Update dependencies * Mostly upgrade to serde 1.0 * Pull in lots of other updates for other small deps
2017-05-18 23:53:00 +03:00
"utf8-ranges 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
]
Switch from assert_cli to assert_cmd
2018-07-26 22:52:50 +03:00
[[package]]
name = "regex"
version = "1.0.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"aho-corasick 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)",
"memchr 2.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
"regex-syntax 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
"thread_local 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
"utf8-ranges 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
[[package]]
name = "regex-syntax"
Update ring
2018-01-07 18:33:04 +03:00
version = "0.4.2"
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Switch from assert_cli to assert_cmd
2018-07-26 22:52:50 +03:00
[[package]]
name = "regex-syntax"
version = "0.6.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"ucd-util 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
Update ring
2018-01-07 18:33:04 +03:00
[[package]]
name = "relay"
cargo update
2018-02-01 18:29:23 +03:00
version = "0.1.1"
Update ring
2018-01-07 18:33:04 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
Revert "Update to futures 0.1.19 and fix breakage from Option-related changes" futures 0.1.19 was yanked because of the breaking API changes it made. This reverts commit 7079ab87832efab4298757176b1388f1d126ed98.
2018-07-12 13:31:09 +03:00
"futures 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",
cargo update
2018-02-01 18:29:23 +03:00
]
[[package]]
name = "remove_dir_all"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
"winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
]
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
[[package]]
name = "retry"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
Update ring
2018-01-07 18:33:04 +03:00
"rand 0.3.20 (registry+https://github.com/rust-lang/crates.io-index)",
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
]
Switch from SHA-1 to SHA-512 Local benchmarking showed that the implementation of SHA-512 in the *ring* crate is 3x faster than the implementation of SHA-1 in the `sha1` crate. I've also noticed that 80%+ of sccache's runtime on a fully cached build is spent hashing. With this change I noticed a decrease from 108s to 92s when building a fully cached LLVM from the network. Not a huge win but if the network were faster could perhaps add up! Closes #108
2017-04-21 07:09:15 +03:00
[[package]]
name = "ring"
Update ring
2018-01-07 18:33:04 +03:00
version = "0.12.1"
Switch from SHA-1 to SHA-512 Local benchmarking showed that the implementation of SHA-512 in the *ring* crate is 3x faster than the implementation of SHA-1 in the `sha1` crate. I've also noticed that 80%+ of sccache's runtime on a fully cached build is spent hashing. With this change I noticed a decrease from 108s to 92s when building a fully cached LLVM from the network. Not a huge win but if the network were faster could perhaps add up! Closes #108
2017-04-21 07:09:15 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
Update ring
2018-01-07 18:33:04 +03:00
"gcc 0.3.54 (registry+https://github.com/rust-lang/crates.io-index)",
"lazy_static 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)",
cargo update
2018-02-01 18:29:23 +03:00
"libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"rayon 0.8.2 (registry+https://github.com/rust-lang/crates.io-index)",
"untrusted 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
Implement S3Cache Unlike sccache1, you need to specify both bucket and region, like: SCCACHE_BUCKET=sccache SCCACHE_REGION=us-east-1 Pretty limited testing, no automated tests currently.
2016-06-03 22:09:38 +03:00
[[package]]
drop rusoto, import some simple s3 code and use that
2016-08-12 21:03:37 +03:00
name = "rust-crypto"
version = "0.2.36"
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement S3Cache Unlike sccache1, you need to specify both bucket and region, like: SCCACHE_BUCKET=sccache SCCACHE_REGION=us-east-1 Pretty limited testing, no automated tests currently.
2016-06-03 22:09:38 +03:00
dependencies = [
Update ring
2018-01-07 18:33:04 +03:00
"gcc 0.3.54 (registry+https://github.com/rust-lang/crates.io-index)",
cargo update
2018-02-01 18:29:23 +03:00
"libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"rand 0.3.20 (registry+https://github.com/rust-lang/crates.io-index)",
Update dependencies * Mostly upgrade to serde 1.0 * Pull in lots of other updates for other small deps
2017-05-18 23:53:00 +03:00
"rustc-serialize 0.3.24 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"time 0.1.39 (registry+https://github.com/rust-lang/crates.io-index)",
Implement S3Cache Unlike sccache1, you need to specify both bucket and region, like: SCCACHE_BUCKET=sccache SCCACHE_REGION=us-east-1 Pretty limited testing, no automated tests currently.
2016-06-03 22:09:38 +03:00
]
drop format_size code in favor of number_prefix crate
2016-05-12 22:46:22 +03:00
[[package]]
name = "rustc-serialize"
Update dependencies * Mostly upgrade to serde 1.0 * Pull in lots of other updates for other small deps
2017-05-18 23:53:00 +03:00
version = "0.3.24"
drop format_size code in favor of number_prefix crate
2016-05-12 22:46:22 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update dependencies Notably bring in hyper from crates.io
2017-06-14 18:20:12 +03:00
[[package]]
name = "safemem"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
Update dependencies * Mostly upgrade to serde 1.0 * Pull in lots of other updates for other small deps
2017-05-18 23:53:00 +03:00
[[package]]
name = "same-file"
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
"winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
]
Rebuild Cargo.lock with cargo 0.23
2017-12-05 16:32:33 +03:00
[[package]]
name = "sccache"
(cargo-release) start next development iteration 0.2.8-alpha.0
2018-07-12 14:33:52 +03:00
version = "0.2.8-alpha.0"
Rebuild Cargo.lock with cargo 0.23
2017-12-05 16:32:33 +03:00
dependencies = [
Switch from assert_cli to assert_cmd
2018-07-26 22:52:50 +03:00
"assert_cmd 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
Always request color output from rustc. Fixes #99 This change makes sccache run rustc with `--color=always`, removing any other --color option from the compiler options so that it's not included in the cache key. A `color_mode` method is added to the `CompilerHasher` trait, and the value is sent back to the client in the `CompileFinished` method, so the client can determine whether specific --color options were passed without having to do its own commandline parsing. The client uses the new `strip-ansi-escapes` crate to remove escape codes from the compiler output in situations where color output is not desired: * When `--color=never` was passed on the compiler commandline. * When `--color=auto` is in effect (the default) but the output is not a terminal. The existing cargo tests were lightly modified to run compile once with `--color=never` and once with `--color=always` to validate that cache hits are not affected by color options.
2018-02-02 15:11:11 +03:00
"atty 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)",
Update other deps
2018-01-07 18:58:55 +03:00
"base64 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
"bincode 0.9.2 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"byteorder 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
switch from the gcc crate to its successor, cc, for tests
2018-02-01 18:35:56 +03:00
"cc 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"chrono 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
Silence some warnings
2018-07-12 13:46:33 +03:00
"clap 2.32.0 (registry+https://github.com/rust-lang/crates.io-index)",
Rebuild Cargo.lock with cargo 0.23
2017-12-05 16:32:33 +03:00
"daemonize 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
Replace `app_dirs` crate with `directories`. Fixes #233. The `app_dirs` crate has become unmaintained and is broken on macOS with Rust 1.25. The `directories` crate provides the same functionality and is maintained, so switch to using that instead.
2018-03-21 15:52:55 +03:00
"directories 0.8.4 (registry+https://github.com/rust-lang/crates.io-index)",
Rebuild Cargo.lock with cargo 0.23
2017-12-05 16:32:33 +03:00
"env_logger 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
"error-chain 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)",
cargo update
2018-02-01 18:29:23 +03:00
"filetime 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)",
Revert "Update to futures 0.1.19 and fix breakage from Option-related changes" futures 0.1.19 was yanked because of the breaking API changes it made. This reverts commit 7079ab87832efab4298757176b1388f1d126ed98.
2018-07-12 13:31:09 +03:00
"futures 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"futures-cpupool 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
cargo update
2018-02-01 18:29:23 +03:00
"hyper 0.11.16 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"hyper-tls 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
cargo update
2018-02-01 18:29:23 +03:00
"itertools 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)",
update jobserver to 0.1.11 to pick up a fix for shutting down the worker thread
2018-03-16 20:39:18 +03:00
"jobserver 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"jsonwebtoken 4.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
Rebuild Cargo.lock with cargo 0.23
2017-12-05 16:32:33 +03:00
"kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
Fix those TODOs about using lazy_static and remove some (now) extraneous static lifetimes on consts while I'm there.
2018-01-30 19:14:37 +03:00
"lazy_static 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
cargo update
2018-02-01 18:29:23 +03:00
"libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
Rebuild Cargo.lock with cargo 0.23
2017-12-05 16:32:33 +03:00
"local-encoding 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"log 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
Bump lru-disk-cache to 0.2.0 so we can publish it to crates.io because we made an API change
2018-01-30 19:54:20 +03:00
"lru-disk-cache 0.2.0",
Add a Memcached cache variant This cache module uses a Memcached cluster. To make sccache use this, set SCCACHE_MEMCACHED to a list of tcp://<hostname>:<port> addresses, separated by whitespace.
2017-08-10 17:50:33 +03:00
"memcached-rs 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"mio-named-pipes 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
cargo update
2018-02-01 18:29:23 +03:00
"native-tls 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
Add jobserver support to sccache This commit alters the main sccache server to operate and orchestrate its own GNU make style jobserver. This is primarily intended for interoperation with rustc itself. The Rust compiler currently has a multithreaded mode where it will execute code generation and optimization on the LLVM side of things in parallel. This parallelism, however, can overload a machine quickly if not properly accounted for (e.g. if 10 rustcs all spawn 10 threads...). The usage of a GNU make style jobserver is intended to arbitrate and rate limit all these rustc instances to ensure that one build's maximal parallelism never exceeds a particular amount. Currently for Rust Cargo is the primary driver for setting up a jobserver. Cargo will create this and manage this per compilation, ensuring that any one `cargo build` invocation never exceeds a maximal parallelism. When sccache enters the picture, however, the story gets slightly more odd. The jobserver implementation on Unix relies on inheritance of file descriptors in spawned processes. With sccache, however, there's no inheritance as the actual rustc invocation is spawned by the server, not the client. In this case the env vars used to configure the jobsever are usually incorrect. To handle this problem this commit bakes a jobserver directly into sccache itself. The jobserver then overrides whatever jobserver the client has configured in its own env vars to ensure correct operation. The settings of each jobserver may be misconfigured (there's no way to configure sccache's jobserver right now), but hopefully that's not too much of a problem for the forseeable future. The implementation here was to provide a thin wrapper around the `jobserver` crate with a futures-based interface. This interface was then hooked into the mock command infrastructure to automatically acquire a jobserver token when spawning a process and automatically drop the token when the process exits. Additionally, all spawned processes will now automatically receive a configured jobserver. cc rust-lang/rust#42867, the original motivation for this commit
2017-09-27 19:14:51 +03:00
"num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
Rebuild Cargo.lock with cargo 0.23
2017-12-05 16:32:33 +03:00
"number_prefix 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"openssl 0.9.23 (registry+https://github.com/rust-lang/crates.io-index)",
Refactor system tests to use assert_cmd
2018-07-27 19:07:08 +03:00
"predicates 0.5.2 (git+https://github.com/luser/predicates-rs?branch=function-unsized)",
Rebuild Cargo.lock with cargo 0.23
2017-12-05 16:32:33 +03:00
"redis 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"regex 0.2.5 (registry+https://github.com/rust-lang/crates.io-index)",
Rebuild Cargo.lock with cargo 0.23
2017-12-05 16:32:33 +03:00
"retry 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
switch to ring version 0.12.1
2018-02-01 14:29:38 +03:00
"ring 0.12.1 (registry+https://github.com/rust-lang/crates.io-index)",
Rebuild Cargo.lock with cargo 0.23
2017-12-05 16:32:33 +03:00
"rust-crypto 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"serde 1.0.27 (registry+https://github.com/rust-lang/crates.io-index)",
"serde_derive 1.0.27 (registry+https://github.com/rust-lang/crates.io-index)",
"serde_json 1.0.9 (registry+https://github.com/rust-lang/crates.io-index)",
Always request color output from rustc. Fixes #99 This change makes sccache run rustc with `--color=always`, removing any other --color option from the compiler options so that it's not included in the cache key. A `color_mode` method is added to the `CompilerHasher` trait, and the value is sent back to the client in the `CompileFinished` method, so the client can determine whether specific --color options were passed without having to do its own commandline parsing. The client uses the new `strip-ansi-escapes` crate to remove escape codes from the compiler output in situations where color output is not desired: * When `--color=never` was passed on the compiler commandline. * When `--color=auto` is in effect (the default) but the output is not a terminal. The existing cargo tests were lightly modified to run compile once with `--color=never` and once with `--color=always` to validate that cache hits are not affected by color options.
2018-02-02 15:11:11 +03:00
"strip-ansi-escapes 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
Bits and pieces for distributed Rust
2018-04-12 04:25:15 +03:00
"tar 0.4.15 (registry+https://github.com/rust-lang/crates.io-index)",
cargo update
2018-02-01 18:29:23 +03:00
"tempdir 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"tempfile 2.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
"time 0.1.39 (registry+https://github.com/rust-lang/crates.io-index)",
cargo update
2018-02-01 18:29:23 +03:00
"tokio-core 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"tokio-io 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-process 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
Rebuild Cargo.lock with cargo 0.23
2017-12-05 16:32:33 +03:00
"tokio-proto 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-serde-bincode 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-service 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"tokio-tls 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-uds 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
Allow configuration of caches with a config file
2018-06-04 20:28:39 +03:00
"toml 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"url 1.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
=updated uuid to 0.6
2018-02-28 22:30:50 +03:00
"uuid 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"which 1.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
Rebuild Cargo.lock with cargo 0.23
2017-12-05 16:32:33 +03:00
"winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
Properly chain error when failing to create temp dir in hash_source_files
2018-01-12 14:35:50 +03:00
"zip 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
Rebuild Cargo.lock with cargo 0.23
2017-12-05 16:32:33 +03:00
]
Integrate the Tokio branch of Hyper This commit pulls in Hyper from its master branch which contains the asynchronous/Tokio integration. All instances of HTTP, namely when interacting with S3, are now all powered by async Hyper and work with futures rather than synchronous requests on thread pools.
2017-02-02 03:30:26 +03:00
[[package]]
name = "schannel"
Update to schannel version 0.1.11
2018-03-05 20:38:37 +03:00
version = "0.1.11"
Integrate the Tokio branch of Hyper This commit pulls in Hyper from its master branch which contains the asynchronous/Tokio integration. All instances of HTTP, namely when interacting with S3, are now all powered by async Hyper and work with futures rather than synchronous requests on thread pools.
2017-02-02 03:30:26 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
Update ring
2018-01-07 18:33:04 +03:00
"lazy_static 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
cargo update
2018-02-01 18:29:23 +03:00
"winapi 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)",
Integrate the Tokio branch of Hyper This commit pulls in Hyper from its master branch which contains the asynchronous/Tokio integration. All instances of HTTP, namely when interacting with S3, are now all powered by async Hyper and work with futures rather than synchronous requests on thread pools.
2017-02-02 03:30:26 +03:00
]
Rewrite the server module with Tokio This commit rewrites the `server` module of sccache to be backed with Tokio. The previous version was written with `mio`, which Tokio is built on, but is unfortunately less ergonomic. Tokio is the state-of-the-art for asynchronous programming in Rust and sccache serves as a great testing ground for ergonomics! It's intended that the support added here will eventually extend to many other operations that sccache does as well. For example thread spawning has all been replaced with `CpuPool` to have a shared pool for I/O operations and such (namely the filesystem). Eventually the HTTP requests made by the S3 backend can be integrated with the Tokio branch of Hyper as well to run that on the event loop instead of in a worker thread. I'd also like to eventually extend this with `tokio-process` as well to move process spawning off helper threads as well, but I'm leaving that to a future commit as well. Overall I found the transition was quite smooth, with the high level architecture look like: * The `tokio-proto` crate is used in streaming mode. The streaming part is used for the one RPC sccache gets which requires a second response to be sent later on. This second response is the "response body" in tokio-proto terms. * All of sccache's logic is manifested in an implementation of the `Service` trait. * The transport layer is provided with `tokio_core::io::{Framed, Codec}`, and simple deserialization/serialization is performed with protobuf. Some differences in design are: * The `SccacheService` for now is just a bunch of reference-counted pointers, making it cheap to clone. As the futures it returns progress they will each retain a reference to a cloned copy of the `SccacheService`. Before all this data was just stored and manipulated in a struct directly, but it's now directly managed through shared memory. * The storage backends share a thread pool with the main server instead of spawning threads. And finally, some things I've learned along the way: * Sharing data between futures isn't a trivial operation. It took an explicit decision to use `Rc` and I'm not sure I'm 100% happy with how the ergonomics played out. * Shutdown is pretty tricky here. I've tried to carry over all the previous logic but it definitely required not using `TcpServer` in tokio-proto at the very least, and otherwise required a few custom futures and such to track the various states. I have a hunch that tokio-proto could provide more options out of the box for something like this.
2017-01-31 04:04:03 +03:00
[[package]]
name = "scoped-tls"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
Update dependencies Notably bring in hyper from crates.io
2017-06-14 18:20:12 +03:00
[[package]]
name = "scopeguard"
Update ring
2018-01-07 18:33:04 +03:00
version = "0.3.3"
Update dependencies Notably bring in hyper from crates.io
2017-06-14 18:20:12 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Integrate the Tokio branch of Hyper This commit pulls in Hyper from its master branch which contains the asynchronous/Tokio integration. All instances of HTTP, namely when interacting with S3, are now all powered by async Hyper and work with futures rather than synchronous requests on thread pools.
2017-02-02 03:30:26 +03:00
[[package]]
name = "security-framework"
Update ring
2018-01-07 18:33:04 +03:00
version = "0.1.16"
Integrate the Tokio branch of Hyper This commit pulls in Hyper from its master branch which contains the asynchronous/Tokio integration. All instances of HTTP, namely when interacting with S3, are now all powered by async Hyper and work with futures rather than synchronous requests on thread pools.
2017-02-02 03:30:26 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"core-foundation 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
"core-foundation-sys 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
cargo update
2018-02-01 18:29:23 +03:00
"libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"security-framework-sys 0.1.16 (registry+https://github.com/rust-lang/crates.io-index)",
Integrate the Tokio branch of Hyper This commit pulls in Hyper from its master branch which contains the asynchronous/Tokio integration. All instances of HTTP, namely when interacting with S3, are now all powered by async Hyper and work with futures rather than synchronous requests on thread pools.
2017-02-02 03:30:26 +03:00
]
[[package]]
name = "security-framework-sys"
Update ring
2018-01-07 18:33:04 +03:00
version = "0.1.16"
Integrate the Tokio branch of Hyper This commit pulls in Hyper from its master branch which contains the asynchronous/Tokio integration. All instances of HTTP, namely when interacting with S3, are now all powered by async Hyper and work with futures rather than synchronous requests on thread pools.
2017-02-02 03:30:26 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"core-foundation-sys 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
cargo update
2018-02-01 18:29:23 +03:00
"libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
Integrate the Tokio branch of Hyper This commit pulls in Hyper from its master branch which contains the asynchronous/Tokio integration. All instances of HTTP, namely when interacting with S3, are now all powered by async Hyper and work with futures rather than synchronous requests on thread pools.
2017-02-02 03:30:26 +03:00
]
Add a Memcached cache variant This cache module uses a Memcached cluster. To make sccache use this, set SCCACHE_MEMCACHED to a list of tcp://<hostname>:<port> addresses, separated by whitespace.
2017-08-10 17:50:33 +03:00
[[package]]
name = "semver"
version = "0.2.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"nom 1.2.4 (registry+https://github.com/rust-lang/crates.io-index)",
]
Implement S3Cache Unlike sccache1, you need to specify both bucket and region, like: SCCACHE_BUCKET=sccache SCCACHE_REGION=us-east-1 Pretty limited testing, no automated tests currently.
2016-06-03 22:09:38 +03:00
[[package]]
name = "serde"
Update ring
2018-01-07 18:33:04 +03:00
version = "1.0.27"
Move from protobuf to bincode for a wire format This commit migrates away from the `protobuf` crate to instead just working with bincode on the wire as a serialization format. This is done by leveraging a few different crates: * The `bincode` and `serde_derive` crates are used to define serialization for Rust structures as well as provide a bincode implementation. * The `tokio_io::codec::length_delimited` module implements framing via length prefixes to transform an asynchronous stream of bytes into a literal `Stream` of `BytesMut`. * The `tokio_serde_bincode` crate is then used to tie it all together, parsing these `BytesMut` as the request/response types of sccache. Most of the changes here are related to moving away from the protobuf API throughout the codebase (e.g. `has_foo` and `take_foo`) towards a more rustic-ish API that just uses enums/structs. Overall it felt quite natural (as one would expect) to just use the raw enum/struct values. This may not be quite as performant as before but that doesn't really apply to sccache's use case where perf is hugely dominated by actually compiling and hashing, so I'm not too too worried about that. My personal motivation for this is twofold: 1. Using `protobuf` was a little clunky throughout the codebase and definitely had some sharp edges that felt good to smooth out. 2. There's currently what I believe some mysterious segfault and/or stray write happening in sccache and I'm not sure where. The `protobuf` crate had a lot of `unsafe` code and in lieu of actually auditing it I figured it'd be good to kill two birds with one stone. I have no idea if this fixes my segfault problem (I never could reproduce it) but I figured it's worth a shot.
2017-03-22 20:21:52 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Switch from assert_cli to assert_cmd
2018-07-26 22:52:50 +03:00
dependencies = [
"serde_derive 1.0.27 (registry+https://github.com/rust-lang/crates.io-index)",
]
Move from protobuf to bincode for a wire format This commit migrates away from the `protobuf` crate to instead just working with bincode on the wire as a serialization format. This is done by leveraging a few different crates: * The `bincode` and `serde_derive` crates are used to define serialization for Rust structures as well as provide a bincode implementation. * The `tokio_io::codec::length_delimited` module implements framing via length prefixes to transform an asynchronous stream of bytes into a literal `Stream` of `BytesMut`. * The `tokio_serde_bincode` crate is then used to tie it all together, parsing these `BytesMut` as the request/response types of sccache. Most of the changes here are related to moving away from the protobuf API throughout the codebase (e.g. `has_foo` and `take_foo`) towards a more rustic-ish API that just uses enums/structs. Overall it felt quite natural (as one would expect) to just use the raw enum/struct values. This may not be quite as performant as before but that doesn't really apply to sccache's use case where perf is hugely dominated by actually compiling and hashing, so I'm not too too worried about that. My personal motivation for this is twofold: 1. Using `protobuf` was a little clunky throughout the codebase and definitely had some sharp edges that felt good to smooth out. 2. There's currently what I believe some mysterious segfault and/or stray write happening in sccache and I'm not sure where. The `protobuf` crate had a lot of `unsafe` code and in lieu of actually auditing it I figured it'd be good to kill two birds with one stone. I have no idea if this fixes my segfault problem (I never could reproduce it) but I figured it's worth a shot.
2017-03-22 20:21:52 +03:00
[[package]]
Update dependencies * Mostly upgrade to serde 1.0 * Pull in lots of other updates for other small deps
2017-05-18 23:53:00 +03:00
name = "serde_derive"
Update ring
2018-01-07 18:33:04 +03:00
version = "1.0.27"
Move from protobuf to bincode for a wire format This commit migrates away from the `protobuf` crate to instead just working with bincode on the wire as a serialization format. This is done by leveraging a few different crates: * The `bincode` and `serde_derive` crates are used to define serialization for Rust structures as well as provide a bincode implementation. * The `tokio_io::codec::length_delimited` module implements framing via length prefixes to transform an asynchronous stream of bytes into a literal `Stream` of `BytesMut`. * The `tokio_serde_bincode` crate is then used to tie it all together, parsing these `BytesMut` as the request/response types of sccache. Most of the changes here are related to moving away from the protobuf API throughout the codebase (e.g. `has_foo` and `take_foo`) towards a more rustic-ish API that just uses enums/structs. Overall it felt quite natural (as one would expect) to just use the raw enum/struct values. This may not be quite as performant as before but that doesn't really apply to sccache's use case where perf is hugely dominated by actually compiling and hashing, so I'm not too too worried about that. My personal motivation for this is twofold: 1. Using `protobuf` was a little clunky throughout the codebase and definitely had some sharp edges that felt good to smooth out. 2. There's currently what I believe some mysterious segfault and/or stray write happening in sccache and I'm not sure where. The `protobuf` crate had a lot of `unsafe` code and in lieu of actually auditing it I figured it'd be good to kill two birds with one stone. I have no idea if this fixes my segfault problem (I never could reproduce it) but I figured it's worth a shot.
2017-03-22 20:21:52 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
Update dependencies * Mostly upgrade to serde 1.0 * Pull in lots of other updates for other small deps
2017-05-18 23:53:00 +03:00
"quote 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"serde_derive_internals 0.19.0 (registry+https://github.com/rust-lang/crates.io-index)",
Update dependencies * Mostly upgrade to serde 1.0 * Pull in lots of other updates for other small deps
2017-05-18 23:53:00 +03:00
"syn 0.11.11 (registry+https://github.com/rust-lang/crates.io-index)",
Move from protobuf to bincode for a wire format This commit migrates away from the `protobuf` crate to instead just working with bincode on the wire as a serialization format. This is done by leveraging a few different crates: * The `bincode` and `serde_derive` crates are used to define serialization for Rust structures as well as provide a bincode implementation. * The `tokio_io::codec::length_delimited` module implements framing via length prefixes to transform an asynchronous stream of bytes into a literal `Stream` of `BytesMut`. * The `tokio_serde_bincode` crate is then used to tie it all together, parsing these `BytesMut` as the request/response types of sccache. Most of the changes here are related to moving away from the protobuf API throughout the codebase (e.g. `has_foo` and `take_foo`) towards a more rustic-ish API that just uses enums/structs. Overall it felt quite natural (as one would expect) to just use the raw enum/struct values. This may not be quite as performant as before but that doesn't really apply to sccache's use case where perf is hugely dominated by actually compiling and hashing, so I'm not too too worried about that. My personal motivation for this is twofold: 1. Using `protobuf` was a little clunky throughout the codebase and definitely had some sharp edges that felt good to smooth out. 2. There's currently what I believe some mysterious segfault and/or stray write happening in sccache and I'm not sure where. The `protobuf` crate had a lot of `unsafe` code and in lieu of actually auditing it I figured it'd be good to kill two birds with one stone. I have no idea if this fixes my segfault problem (I never could reproduce it) but I figured it's worth a shot.
2017-03-22 20:21:52 +03:00
]
[[package]]
Update dependencies * Mostly upgrade to serde 1.0 * Pull in lots of other updates for other small deps
2017-05-18 23:53:00 +03:00
name = "serde_derive_internals"
Update ring
2018-01-07 18:33:04 +03:00
version = "0.19.0"
Implement S3Cache Unlike sccache1, you need to specify both bucket and region, like: SCCACHE_BUCKET=sccache SCCACHE_REGION=us-east-1 Pretty limited testing, no automated tests currently.
2016-06-03 22:09:38 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Move from protobuf to bincode for a wire format This commit migrates away from the `protobuf` crate to instead just working with bincode on the wire as a serialization format. This is done by leveraging a few different crates: * The `bincode` and `serde_derive` crates are used to define serialization for Rust structures as well as provide a bincode implementation. * The `tokio_io::codec::length_delimited` module implements framing via length prefixes to transform an asynchronous stream of bytes into a literal `Stream` of `BytesMut`. * The `tokio_serde_bincode` crate is then used to tie it all together, parsing these `BytesMut` as the request/response types of sccache. Most of the changes here are related to moving away from the protobuf API throughout the codebase (e.g. `has_foo` and `take_foo`) towards a more rustic-ish API that just uses enums/structs. Overall it felt quite natural (as one would expect) to just use the raw enum/struct values. This may not be quite as performant as before but that doesn't really apply to sccache's use case where perf is hugely dominated by actually compiling and hashing, so I'm not too too worried about that. My personal motivation for this is twofold: 1. Using `protobuf` was a little clunky throughout the codebase and definitely had some sharp edges that felt good to smooth out. 2. There's currently what I believe some mysterious segfault and/or stray write happening in sccache and I'm not sure where. The `protobuf` crate had a lot of `unsafe` code and in lieu of actually auditing it I figured it'd be good to kill two birds with one stone. I have no idea if this fixes my segfault problem (I never could reproduce it) but I figured it's worth a shot.
2017-03-22 20:21:52 +03:00
dependencies = [
Update dependencies * Mostly upgrade to serde 1.0 * Pull in lots of other updates for other small deps
2017-05-18 23:53:00 +03:00
"syn 0.11.11 (registry+https://github.com/rust-lang/crates.io-index)",
"synom 0.11.3 (registry+https://github.com/rust-lang/crates.io-index)",
Move from protobuf to bincode for a wire format This commit migrates away from the `protobuf` crate to instead just working with bincode on the wire as a serialization format. This is done by leveraging a few different crates: * The `bincode` and `serde_derive` crates are used to define serialization for Rust structures as well as provide a bincode implementation. * The `tokio_io::codec::length_delimited` module implements framing via length prefixes to transform an asynchronous stream of bytes into a literal `Stream` of `BytesMut`. * The `tokio_serde_bincode` crate is then used to tie it all together, parsing these `BytesMut` as the request/response types of sccache. Most of the changes here are related to moving away from the protobuf API throughout the codebase (e.g. `has_foo` and `take_foo`) towards a more rustic-ish API that just uses enums/structs. Overall it felt quite natural (as one would expect) to just use the raw enum/struct values. This may not be quite as performant as before but that doesn't really apply to sccache's use case where perf is hugely dominated by actually compiling and hashing, so I'm not too too worried about that. My personal motivation for this is twofold: 1. Using `protobuf` was a little clunky throughout the codebase and definitely had some sharp edges that felt good to smooth out. 2. There's currently what I believe some mysterious segfault and/or stray write happening in sccache and I'm not sure where. The `protobuf` crate had a lot of `unsafe` code and in lieu of actually auditing it I figured it'd be good to kill two birds with one stone. I have no idea if this fixes my segfault problem (I never could reproduce it) but I figured it's worth a shot.
2017-03-22 20:21:52 +03:00
]
Implement S3Cache Unlike sccache1, you need to specify both bucket and region, like: SCCACHE_BUCKET=sccache SCCACHE_REGION=us-east-1 Pretty limited testing, no automated tests currently.
2016-06-03 22:09:38 +03:00
[[package]]
name = "serde_json"
Update ring
2018-01-07 18:33:04 +03:00
version = "1.0.9"
Implement S3Cache Unlike sccache1, you need to specify both bucket and region, like: SCCACHE_BUCKET=sccache SCCACHE_REGION=us-east-1 Pretty limited testing, no automated tests currently.
2016-06-03 22:09:38 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
Update ring
2018-01-07 18:33:04 +03:00
"dtoa 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
"itoa 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)",
cargo update
2018-02-01 18:29:23 +03:00
"num-traits 0.1.42 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"serde 1.0.27 (registry+https://github.com/rust-lang/crates.io-index)",
Implement S3Cache Unlike sccache1, you need to specify both bucket and region, like: SCCACHE_BUCKET=sccache SCCACHE_REGION=us-east-1 Pretty limited testing, no automated tests currently.
2016-06-03 22:09:38 +03:00
]
turn Compiler into CompilerKind, make a Compiler struct to hold some more info about compilers
2016-05-18 21:30:11 +03:00
[[package]]
name = "sha1"
bump sha1 crate to 0.2.0
2016-07-15 17:42:08 +03:00
version = "0.2.0"
turn Compiler into CompilerKind, make a Compiler struct to hold some more info about compilers
2016-05-18 21:30:11 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
use local-encoding crate for stdout conversion
2016-09-21 22:57:28 +03:00
[[package]]
name = "skeptic"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"pulldown-cmark 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
cargo update
2018-02-01 18:29:23 +03:00
"tempdir 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
use local-encoding crate for stdout conversion
2016-09-21 22:57:28 +03:00
]
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
[[package]]
name = "slab"
Rewrite the server module with Tokio This commit rewrites the `server` module of sccache to be backed with Tokio. The previous version was written with `mio`, which Tokio is built on, but is unfortunately less ergonomic. Tokio is the state-of-the-art for asynchronous programming in Rust and sccache serves as a great testing ground for ergonomics! It's intended that the support added here will eventually extend to many other operations that sccache does as well. For example thread spawning has all been replaced with `CpuPool` to have a shared pool for I/O operations and such (namely the filesystem). Eventually the HTTP requests made by the S3 backend can be integrated with the Tokio branch of Hyper as well to run that on the event loop instead of in a worker thread. I'd also like to eventually extend this with `tokio-process` as well to move process spawning off helper threads as well, but I'm leaving that to a future commit as well. Overall I found the transition was quite smooth, with the high level architecture look like: * The `tokio-proto` crate is used in streaming mode. The streaming part is used for the one RPC sccache gets which requires a second response to be sent later on. This second response is the "response body" in tokio-proto terms. * All of sccache's logic is manifested in an implementation of the `Service` trait. * The transport layer is provided with `tokio_core::io::{Framed, Codec}`, and simple deserialization/serialization is performed with protobuf. Some differences in design are: * The `SccacheService` for now is just a bunch of reference-counted pointers, making it cheap to clone. As the futures it returns progress they will each retain a reference to a cloned copy of the `SccacheService`. Before all this data was just stored and manipulated in a struct directly, but it's now directly managed through shared memory. * The storage backends share a thread pool with the main server instead of spawning threads. And finally, some things I've learned along the way: * Sharing data between futures isn't a trivial operation. It took an explicit decision to use `Rc` and I'm not sure I'm 100% happy with how the ergonomics played out. * Shutdown is pretty tricky here. I've tried to carry over all the previous logic but it definitely required not using `TcpServer` in tokio-proto at the very least, and otherwise required a few custom futures and such to track the various states. I have a hunch that tokio-proto could provide more options out of the box for something like this.
2017-01-31 04:04:03 +03:00
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
Update iovec to fix a soundness hole on Windows Also update a few other dependencies that transitively needed fixing
2017-10-06 02:40:25 +03:00
[[package]]
name = "slab"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
Rewrite the server module with Tokio This commit rewrites the `server` module of sccache to be backed with Tokio. The previous version was written with `mio`, which Tokio is built on, but is unfortunately less ergonomic. Tokio is the state-of-the-art for asynchronous programming in Rust and sccache serves as a great testing ground for ergonomics! It's intended that the support added here will eventually extend to many other operations that sccache does as well. For example thread spawning has all been replaced with `CpuPool` to have a shared pool for I/O operations and such (namely the filesystem). Eventually the HTTP requests made by the S3 backend can be integrated with the Tokio branch of Hyper as well to run that on the event loop instead of in a worker thread. I'd also like to eventually extend this with `tokio-process` as well to move process spawning off helper threads as well, but I'm leaving that to a future commit as well. Overall I found the transition was quite smooth, with the high level architecture look like: * The `tokio-proto` crate is used in streaming mode. The streaming part is used for the one RPC sccache gets which requires a second response to be sent later on. This second response is the "response body" in tokio-proto terms. * All of sccache's logic is manifested in an implementation of the `Service` trait. * The transport layer is provided with `tokio_core::io::{Framed, Codec}`, and simple deserialization/serialization is performed with protobuf. Some differences in design are: * The `SccacheService` for now is just a bunch of reference-counted pointers, making it cheap to clone. As the futures it returns progress they will each retain a reference to a cloned copy of the `SccacheService`. Before all this data was just stored and manipulated in a struct directly, but it's now directly managed through shared memory. * The storage backends share a thread pool with the main server instead of spawning threads. And finally, some things I've learned along the way: * Sharing data between futures isn't a trivial operation. It took an explicit decision to use `Rc` and I'm not sure I'm 100% happy with how the ergonomics played out. * Shutdown is pretty tricky here. I've tried to carry over all the previous logic but it definitely required not using `TcpServer` in tokio-proto at the very least, and otherwise required a few custom futures and such to track the various states. I have a hunch that tokio-proto could provide more options out of the box for something like this.
2017-01-31 04:04:03 +03:00
[[package]]
name = "smallvec"
version = "0.2.1"
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update ring
2018-01-07 18:33:04 +03:00
[[package]]
name = "socket2"
cargo update
2018-02-01 18:29:23 +03:00
version = "0.3.1"
Update ring
2018-01-07 18:33:04 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"cfg-if 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
cargo update
2018-02-01 18:29:23 +03:00
"libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
"winapi 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
]
Always request color output from rustc. Fixes #99 This change makes sccache run rustc with `--color=always`, removing any other --color option from the compiler options so that it's not included in the cache key. A `color_mode` method is added to the `CompilerHasher` trait, and the value is sent back to the client in the `CompileFinished` method, so the client can determine whether specific --color options were passed without having to do its own commandline parsing. The client uses the new `strip-ansi-escapes` crate to remove escape codes from the compiler output in situations where color output is not desired: * When `--color=never` was passed on the compiler commandline. * When `--color=auto` is in effect (the default) but the output is not a terminal. The existing cargo tests were lightly modified to run compile once with `--color=never` and once with `--color=always` to validate that cache hits are not affected by color options.
2018-02-02 15:11:11 +03:00
[[package]]
name = "strip-ansi-escapes"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"vte 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
]
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
[[package]]
name = "strsim"
Silence some warnings
2018-07-12 13:46:33 +03:00
version = "0.7.0"
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Move from protobuf to bincode for a wire format This commit migrates away from the `protobuf` crate to instead just working with bincode on the wire as a serialization format. This is done by leveraging a few different crates: * The `bincode` and `serde_derive` crates are used to define serialization for Rust structures as well as provide a bincode implementation. * The `tokio_io::codec::length_delimited` module implements framing via length prefixes to transform an asynchronous stream of bytes into a literal `Stream` of `BytesMut`. * The `tokio_serde_bincode` crate is then used to tie it all together, parsing these `BytesMut` as the request/response types of sccache. Most of the changes here are related to moving away from the protobuf API throughout the codebase (e.g. `has_foo` and `take_foo`) towards a more rustic-ish API that just uses enums/structs. Overall it felt quite natural (as one would expect) to just use the raw enum/struct values. This may not be quite as performant as before but that doesn't really apply to sccache's use case where perf is hugely dominated by actually compiling and hashing, so I'm not too too worried about that. My personal motivation for this is twofold: 1. Using `protobuf` was a little clunky throughout the codebase and definitely had some sharp edges that felt good to smooth out. 2. There's currently what I believe some mysterious segfault and/or stray write happening in sccache and I'm not sure where. The `protobuf` crate had a lot of `unsafe` code and in lieu of actually auditing it I figured it'd be good to kill two birds with one stone. I have no idea if this fixes my segfault problem (I never could reproduce it) but I figured it's worth a shot.
2017-03-22 20:21:52 +03:00
[[package]]
name = "syn"
Update dependencies * Mostly upgrade to serde 1.0 * Pull in lots of other updates for other small deps
2017-05-18 23:53:00 +03:00
version = "0.11.11"
Move from protobuf to bincode for a wire format This commit migrates away from the `protobuf` crate to instead just working with bincode on the wire as a serialization format. This is done by leveraging a few different crates: * The `bincode` and `serde_derive` crates are used to define serialization for Rust structures as well as provide a bincode implementation. * The `tokio_io::codec::length_delimited` module implements framing via length prefixes to transform an asynchronous stream of bytes into a literal `Stream` of `BytesMut`. * The `tokio_serde_bincode` crate is then used to tie it all together, parsing these `BytesMut` as the request/response types of sccache. Most of the changes here are related to moving away from the protobuf API throughout the codebase (e.g. `has_foo` and `take_foo`) towards a more rustic-ish API that just uses enums/structs. Overall it felt quite natural (as one would expect) to just use the raw enum/struct values. This may not be quite as performant as before but that doesn't really apply to sccache's use case where perf is hugely dominated by actually compiling and hashing, so I'm not too too worried about that. My personal motivation for this is twofold: 1. Using `protobuf` was a little clunky throughout the codebase and definitely had some sharp edges that felt good to smooth out. 2. There's currently what I believe some mysterious segfault and/or stray write happening in sccache and I'm not sure where. The `protobuf` crate had a lot of `unsafe` code and in lieu of actually auditing it I figured it'd be good to kill two birds with one stone. I have no idea if this fixes my segfault problem (I never could reproduce it) but I figured it's worth a shot.
2017-03-22 20:21:52 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"quote 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)",
"synom 0.11.3 (registry+https://github.com/rust-lang/crates.io-index)",
"unicode-xid 0.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "synom"
version = "0.11.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"unicode-xid 0.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
]
Rewrite the server module with Tokio This commit rewrites the `server` module of sccache to be backed with Tokio. The previous version was written with `mio`, which Tokio is built on, but is unfortunately less ergonomic. Tokio is the state-of-the-art for asynchronous programming in Rust and sccache serves as a great testing ground for ergonomics! It's intended that the support added here will eventually extend to many other operations that sccache does as well. For example thread spawning has all been replaced with `CpuPool` to have a shared pool for I/O operations and such (namely the filesystem). Eventually the HTTP requests made by the S3 backend can be integrated with the Tokio branch of Hyper as well to run that on the event loop instead of in a worker thread. I'd also like to eventually extend this with `tokio-process` as well to move process spawning off helper threads as well, but I'm leaving that to a future commit as well. Overall I found the transition was quite smooth, with the high level architecture look like: * The `tokio-proto` crate is used in streaming mode. The streaming part is used for the one RPC sccache gets which requires a second response to be sent later on. This second response is the "response body" in tokio-proto terms. * All of sccache's logic is manifested in an implementation of the `Service` trait. * The transport layer is provided with `tokio_core::io::{Framed, Codec}`, and simple deserialization/serialization is performed with protobuf. Some differences in design are: * The `SccacheService` for now is just a bunch of reference-counted pointers, making it cheap to clone. As the futures it returns progress they will each retain a reference to a cloned copy of the `SccacheService`. Before all this data was just stored and manipulated in a struct directly, but it's now directly managed through shared memory. * The storage backends share a thread pool with the main server instead of spawning threads. And finally, some things I've learned along the way: * Sharing data between futures isn't a trivial operation. It took an explicit decision to use `Rc` and I'm not sure I'm 100% happy with how the ergonomics played out. * Shutdown is pretty tricky here. I've tried to carry over all the previous logic but it definitely required not using `TcpServer` in tokio-proto at the very least, and otherwise required a few custom futures and such to track the various states. I have a hunch that tokio-proto could provide more options out of the box for something like this.
2017-01-31 04:04:03 +03:00
[[package]]
name = "take"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
Bits and pieces for distributed Rust
2018-04-12 04:25:15 +03:00
[[package]]
name = "tar"
version = "0.4.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"filetime 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
"redox_syscall 0.1.37 (registry+https://github.com/rust-lang/crates.io-index)",
"xattr 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
[[package]]
name = "tempdir"
cargo update
2018-02-01 18:29:23 +03:00
version = "0.3.6"
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
cargo update
2018-02-01 18:29:23 +03:00
"rand 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
"remove_dir_all 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
]
Atomically create compiler outputs from cache entries. Fixes #122. I was seeing intermittent rustc panics when compiling with sccache. It turns out that rustc will wind up looking for rlibs in the output dir and sometimes it finds the ones that we're in the middle of writing out from cache and it panics trying to read the half-written file. This change makes us write the cache entry to a tempfile and atomically rename it to the final name.
2017-05-17 23:38:12 +03:00
[[package]]
name = "tempfile"
Update ring
2018-01-07 18:33:04 +03:00
version = "2.2.0"
Atomically create compiler outputs from cache entries. Fixes #122. I was seeing intermittent rustc panics when compiling with sccache. It turns out that rustc will wind up looking for rlibs in the output dir and sometimes it finds the ones that we're in the middle of writing out from cache and it panics trying to read the half-written file. This change makes us write the cache entry to a tempfile and atomically rename it to the final name.
2017-05-17 23:38:12 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
cargo update
2018-02-01 18:29:23 +03:00
"libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"rand 0.3.20 (registry+https://github.com/rust-lang/crates.io-index)",
"redox_syscall 0.1.37 (registry+https://github.com/rust-lang/crates.io-index)",
Atomically create compiler outputs from cache entries. Fixes #122. I was seeing intermittent rustc panics when compiling with sccache. It turns out that rustc will wind up looking for rlibs in the output dir and sometimes it finds the ones that we're in the middle of writing out from cache and it panics trying to read the half-written file. This change makes us write the cache entry to a tempfile and atomically rename it to the final name.
2017-05-17 23:38:12 +03:00
"winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
]
Update to a released rusoto, and 'cargo update' while we're at it
2016-07-15 18:06:16 +03:00
[[package]]
Update ring
2018-01-07 18:33:04 +03:00
name = "termion"
version = "1.5.1"
Update to a released rusoto, and 'cargo update' while we're at it
2016-07-15 18:06:16 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
cargo update
2018-02-01 18:29:23 +03:00
"libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"redox_syscall 0.1.37 (registry+https://github.com/rust-lang/crates.io-index)",
"redox_termios 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
Implement S3Cache Unlike sccache1, you need to specify both bucket and region, like: SCCACHE_BUCKET=sccache SCCACHE_REGION=us-east-1 Pretty limited testing, no automated tests currently.
2016-06-03 22:09:38 +03:00
]
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
[[package]]
Update ring
2018-01-07 18:33:04 +03:00
name = "textwrap"
Silence some warnings
2018-07-12 13:46:33 +03:00
version = "0.10.0"
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
Update ring
2018-01-07 18:33:04 +03:00
"unicode-width 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
]
[[package]]
name = "thread_local"
Update ring
2018-01-07 18:33:04 +03:00
version = "0.3.5"
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
Update ring
2018-01-07 18:33:04 +03:00
"lazy_static 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
"unreachable 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
]
[[package]]
name = "time"
Update ring
2018-01-07 18:33:04 +03:00
version = "0.1.39"
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
cargo update
2018-02-01 18:29:23 +03:00
"libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"redox_syscall 0.1.37 (registry+https://github.com/rust-lang/crates.io-index)",
cargo update
2018-02-01 18:29:23 +03:00
"winapi 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)",
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
]
Rewrite the server module with Tokio This commit rewrites the `server` module of sccache to be backed with Tokio. The previous version was written with `mio`, which Tokio is built on, but is unfortunately less ergonomic. Tokio is the state-of-the-art for asynchronous programming in Rust and sccache serves as a great testing ground for ergonomics! It's intended that the support added here will eventually extend to many other operations that sccache does as well. For example thread spawning has all been replaced with `CpuPool` to have a shared pool for I/O operations and such (namely the filesystem). Eventually the HTTP requests made by the S3 backend can be integrated with the Tokio branch of Hyper as well to run that on the event loop instead of in a worker thread. I'd also like to eventually extend this with `tokio-process` as well to move process spawning off helper threads as well, but I'm leaving that to a future commit as well. Overall I found the transition was quite smooth, with the high level architecture look like: * The `tokio-proto` crate is used in streaming mode. The streaming part is used for the one RPC sccache gets which requires a second response to be sent later on. This second response is the "response body" in tokio-proto terms. * All of sccache's logic is manifested in an implementation of the `Service` trait. * The transport layer is provided with `tokio_core::io::{Framed, Codec}`, and simple deserialization/serialization is performed with protobuf. Some differences in design are: * The `SccacheService` for now is just a bunch of reference-counted pointers, making it cheap to clone. As the futures it returns progress they will each retain a reference to a cloned copy of the `SccacheService`. Before all this data was just stored and manipulated in a struct directly, but it's now directly managed through shared memory. * The storage backends share a thread pool with the main server instead of spawning threads. And finally, some things I've learned along the way: * Sharing data between futures isn't a trivial operation. It took an explicit decision to use `Rc` and I'm not sure I'm 100% happy with how the ergonomics played out. * Shutdown is pretty tricky here. I've tried to carry over all the previous logic but it definitely required not using `TcpServer` in tokio-proto at the very least, and otherwise required a few custom futures and such to track the various states. I have a hunch that tokio-proto could provide more options out of the box for something like this.
2017-01-31 04:04:03 +03:00
[[package]]
name = "tokio-core"
cargo update
2018-02-01 18:29:23 +03:00
version = "0.1.12"
Rewrite the server module with Tokio This commit rewrites the `server` module of sccache to be backed with Tokio. The previous version was written with `mio`, which Tokio is built on, but is unfortunately less ergonomic. Tokio is the state-of-the-art for asynchronous programming in Rust and sccache serves as a great testing ground for ergonomics! It's intended that the support added here will eventually extend to many other operations that sccache does as well. For example thread spawning has all been replaced with `CpuPool` to have a shared pool for I/O operations and such (namely the filesystem). Eventually the HTTP requests made by the S3 backend can be integrated with the Tokio branch of Hyper as well to run that on the event loop instead of in a worker thread. I'd also like to eventually extend this with `tokio-process` as well to move process spawning off helper threads as well, but I'm leaving that to a future commit as well. Overall I found the transition was quite smooth, with the high level architecture look like: * The `tokio-proto` crate is used in streaming mode. The streaming part is used for the one RPC sccache gets which requires a second response to be sent later on. This second response is the "response body" in tokio-proto terms. * All of sccache's logic is manifested in an implementation of the `Service` trait. * The transport layer is provided with `tokio_core::io::{Framed, Codec}`, and simple deserialization/serialization is performed with protobuf. Some differences in design are: * The `SccacheService` for now is just a bunch of reference-counted pointers, making it cheap to clone. As the futures it returns progress they will each retain a reference to a cloned copy of the `SccacheService`. Before all this data was just stored and manipulated in a struct directly, but it's now directly managed through shared memory. * The storage backends share a thread pool with the main server instead of spawning threads. And finally, some things I've learned along the way: * Sharing data between futures isn't a trivial operation. It took an explicit decision to use `Rc` and I'm not sure I'm 100% happy with how the ergonomics played out. * Shutdown is pretty tricky here. I've tried to carry over all the previous logic but it definitely required not using `TcpServer` in tokio-proto at the very least, and otherwise required a few custom futures and such to track the various states. I have a hunch that tokio-proto could provide more options out of the box for something like this.
2017-01-31 04:04:03 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
cargo update
2018-02-01 18:29:23 +03:00
"bytes 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
Revert "Update to futures 0.1.19 and fix breakage from Option-related changes" futures 0.1.19 was yanked because of the breaking API changes it made. This reverts commit 7079ab87832efab4298757176b1388f1d126ed98.
2018-07-12 13:31:09 +03:00
"futures 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",
cargo update
2018-02-01 18:29:23 +03:00
"iovec 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"mio 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)",
Rewrite the server module with Tokio This commit rewrites the `server` module of sccache to be backed with Tokio. The previous version was written with `mio`, which Tokio is built on, but is unfortunately less ergonomic. Tokio is the state-of-the-art for asynchronous programming in Rust and sccache serves as a great testing ground for ergonomics! It's intended that the support added here will eventually extend to many other operations that sccache does as well. For example thread spawning has all been replaced with `CpuPool` to have a shared pool for I/O operations and such (namely the filesystem). Eventually the HTTP requests made by the S3 backend can be integrated with the Tokio branch of Hyper as well to run that on the event loop instead of in a worker thread. I'd also like to eventually extend this with `tokio-process` as well to move process spawning off helper threads as well, but I'm leaving that to a future commit as well. Overall I found the transition was quite smooth, with the high level architecture look like: * The `tokio-proto` crate is used in streaming mode. The streaming part is used for the one RPC sccache gets which requires a second response to be sent later on. This second response is the "response body" in tokio-proto terms. * All of sccache's logic is manifested in an implementation of the `Service` trait. * The transport layer is provided with `tokio_core::io::{Framed, Codec}`, and simple deserialization/serialization is performed with protobuf. Some differences in design are: * The `SccacheService` for now is just a bunch of reference-counted pointers, making it cheap to clone. As the futures it returns progress they will each retain a reference to a cloned copy of the `SccacheService`. Before all this data was just stored and manipulated in a struct directly, but it's now directly managed through shared memory. * The storage backends share a thread pool with the main server instead of spawning threads. And finally, some things I've learned along the way: * Sharing data between futures isn't a trivial operation. It took an explicit decision to use `Rc` and I'm not sure I'm 100% happy with how the ergonomics played out. * Shutdown is pretty tricky here. I've tried to carry over all the previous logic but it definitely required not using `TcpServer` in tokio-proto at the very least, and otherwise required a few custom futures and such to track the various states. I have a hunch that tokio-proto could provide more options out of the box for something like this.
2017-01-31 04:04:03 +03:00
"scoped-tls 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
Update iovec to fix a soundness hole on Windows Also update a few other dependencies that transitively needed fixing
2017-10-06 02:40:25 +03:00
"slab 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"tokio-io 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
Update to using the new tokio-io crate This is an abstraction of the Tokio stack now and doesn't have much impact on sccache itself but I figured it'd be good to update a few deps and pick up the recent version of things! Plus that and I'd like to start using the length_delimited module soon...
2017-03-09 21:00:18 +03:00
]
[[package]]
name = "tokio-io"
Update ring
2018-01-07 18:33:04 +03:00
version = "0.1.4"
Update to using the new tokio-io crate This is an abstraction of the Tokio stack now and doesn't have much impact on sccache itself but I figured it'd be good to update a few deps and pick up the recent version of things! Plus that and I'd like to start using the length_delimited module soon...
2017-03-09 21:00:18 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
cargo update
2018-02-01 18:29:23 +03:00
"bytes 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
Revert "Update to futures 0.1.19 and fix breakage from Option-related changes" futures 0.1.19 was yanked because of the breaking API changes it made. This reverts commit 7079ab87832efab4298757176b1388f1d126ed98.
2018-07-12 13:31:09 +03:00
"futures 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"log 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
Rewrite the server module with Tokio This commit rewrites the `server` module of sccache to be backed with Tokio. The previous version was written with `mio`, which Tokio is built on, but is unfortunately less ergonomic. Tokio is the state-of-the-art for asynchronous programming in Rust and sccache serves as a great testing ground for ergonomics! It's intended that the support added here will eventually extend to many other operations that sccache does as well. For example thread spawning has all been replaced with `CpuPool` to have a shared pool for I/O operations and such (namely the filesystem). Eventually the HTTP requests made by the S3 backend can be integrated with the Tokio branch of Hyper as well to run that on the event loop instead of in a worker thread. I'd also like to eventually extend this with `tokio-process` as well to move process spawning off helper threads as well, but I'm leaving that to a future commit as well. Overall I found the transition was quite smooth, with the high level architecture look like: * The `tokio-proto` crate is used in streaming mode. The streaming part is used for the one RPC sccache gets which requires a second response to be sent later on. This second response is the "response body" in tokio-proto terms. * All of sccache's logic is manifested in an implementation of the `Service` trait. * The transport layer is provided with `tokio_core::io::{Framed, Codec}`, and simple deserialization/serialization is performed with protobuf. Some differences in design are: * The `SccacheService` for now is just a bunch of reference-counted pointers, making it cheap to clone. As the futures it returns progress they will each retain a reference to a cloned copy of the `SccacheService`. Before all this data was just stored and manipulated in a struct directly, but it's now directly managed through shared memory. * The storage backends share a thread pool with the main server instead of spawning threads. And finally, some things I've learned along the way: * Sharing data between futures isn't a trivial operation. It took an explicit decision to use `Rc` and I'm not sure I'm 100% happy with how the ergonomics played out. * Shutdown is pretty tricky here. I've tried to carry over all the previous logic but it definitely required not using `TcpServer` in tokio-proto at the very least, and otherwise required a few custom futures and such to track the various states. I have a hunch that tokio-proto could provide more options out of the box for something like this.
2017-01-31 04:04:03 +03:00
]
Integrate process spawning with tokio-process This commit replaces all process spawning with the futures-powered versions in the `tokio-process` crate. Most functions were already ready to return futures, but a few minor updates were made to ensure that functions could return futures. Additionally, some `&CpuPool` arguments have shown up to allow executing work on a thread pool, such as filesystem operations. A number of compilers write data to tempdirs and such before running a compiler, and these are all executed on thread pools rather than the main thread. My main takeaway from this commit is that translating synchronous to asynchronous code isn't always easy. The "easy" version ends up being relatively wasteful in terms of clones for low-level performance, but probably shouldn't matter much in the context of spawning processes. Other than that though I found that there was a translation for all patterns found didn't actually hit any bugs (yet at least) from the translation.
2017-02-01 03:19:35 +03:00
[[package]]
name = "tokio-process"
Update ring
2018-01-07 18:33:04 +03:00
version = "0.1.5"
Integrate process spawning with tokio-process This commit replaces all process spawning with the futures-powered versions in the `tokio-process` crate. Most functions were already ready to return futures, but a few minor updates were made to ensure that functions could return futures. Additionally, some `&CpuPool` arguments have shown up to allow executing work on a thread pool, such as filesystem operations. A number of compilers write data to tempdirs and such before running a compiler, and these are all executed on thread pools rather than the main thread. My main takeaway from this commit is that translating synchronous to asynchronous code isn't always easy. The "easy" version ends up being relatively wasteful in terms of clones for low-level performance, but probably shouldn't matter much in the context of spawning processes. Other than that though I found that there was a translation for all patterns found didn't actually hit any bugs (yet at least) from the translation.
2017-02-01 03:19:35 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
Revert "Update to futures 0.1.19 and fix breakage from Option-related changes" futures 0.1.19 was yanked because of the breaking API changes it made. This reverts commit 7079ab87832efab4298757176b1388f1d126ed98.
2018-07-12 13:31:09 +03:00
"futures 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",
cargo update
2018-02-01 18:29:23 +03:00
"libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"mio 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)",
"mio-named-pipes 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
cargo update
2018-02-01 18:29:23 +03:00
"tokio-core 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"tokio-io 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-signal 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
cargo update
2018-02-01 18:29:23 +03:00
"winapi 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)",
Integrate process spawning with tokio-process This commit replaces all process spawning with the futures-powered versions in the `tokio-process` crate. Most functions were already ready to return futures, but a few minor updates were made to ensure that functions could return futures. Additionally, some `&CpuPool` arguments have shown up to allow executing work on a thread pool, such as filesystem operations. A number of compilers write data to tempdirs and such before running a compiler, and these are all executed on thread pools rather than the main thread. My main takeaway from this commit is that translating synchronous to asynchronous code isn't always easy. The "easy" version ends up being relatively wasteful in terms of clones for low-level performance, but probably shouldn't matter much in the context of spawning processes. Other than that though I found that there was a translation for all patterns found didn't actually hit any bugs (yet at least) from the translation.
2017-02-01 03:19:35 +03:00
]
Rewrite the server module with Tokio This commit rewrites the `server` module of sccache to be backed with Tokio. The previous version was written with `mio`, which Tokio is built on, but is unfortunately less ergonomic. Tokio is the state-of-the-art for asynchronous programming in Rust and sccache serves as a great testing ground for ergonomics! It's intended that the support added here will eventually extend to many other operations that sccache does as well. For example thread spawning has all been replaced with `CpuPool` to have a shared pool for I/O operations and such (namely the filesystem). Eventually the HTTP requests made by the S3 backend can be integrated with the Tokio branch of Hyper as well to run that on the event loop instead of in a worker thread. I'd also like to eventually extend this with `tokio-process` as well to move process spawning off helper threads as well, but I'm leaving that to a future commit as well. Overall I found the transition was quite smooth, with the high level architecture look like: * The `tokio-proto` crate is used in streaming mode. The streaming part is used for the one RPC sccache gets which requires a second response to be sent later on. This second response is the "response body" in tokio-proto terms. * All of sccache's logic is manifested in an implementation of the `Service` trait. * The transport layer is provided with `tokio_core::io::{Framed, Codec}`, and simple deserialization/serialization is performed with protobuf. Some differences in design are: * The `SccacheService` for now is just a bunch of reference-counted pointers, making it cheap to clone. As the futures it returns progress they will each retain a reference to a cloned copy of the `SccacheService`. Before all this data was just stored and manipulated in a struct directly, but it's now directly managed through shared memory. * The storage backends share a thread pool with the main server instead of spawning threads. And finally, some things I've learned along the way: * Sharing data between futures isn't a trivial operation. It took an explicit decision to use `Rc` and I'm not sure I'm 100% happy with how the ergonomics played out. * Shutdown is pretty tricky here. I've tried to carry over all the previous logic but it definitely required not using `TcpServer` in tokio-proto at the very least, and otherwise required a few custom futures and such to track the various states. I have a hunch that tokio-proto could provide more options out of the box for something like this.
2017-01-31 04:04:03 +03:00
[[package]]
name = "tokio-proto"
Update to using the new tokio-io crate This is an abstraction of the Tokio stack now and doesn't have much impact on sccache itself but I figured it'd be good to update a few deps and pick up the recent version of things! Plus that and I'd like to start using the length_delimited module soon...
2017-03-09 21:00:18 +03:00
version = "0.1.1"
Rewrite the server module with Tokio This commit rewrites the `server` module of sccache to be backed with Tokio. The previous version was written with `mio`, which Tokio is built on, but is unfortunately less ergonomic. Tokio is the state-of-the-art for asynchronous programming in Rust and sccache serves as a great testing ground for ergonomics! It's intended that the support added here will eventually extend to many other operations that sccache does as well. For example thread spawning has all been replaced with `CpuPool` to have a shared pool for I/O operations and such (namely the filesystem). Eventually the HTTP requests made by the S3 backend can be integrated with the Tokio branch of Hyper as well to run that on the event loop instead of in a worker thread. I'd also like to eventually extend this with `tokio-process` as well to move process spawning off helper threads as well, but I'm leaving that to a future commit as well. Overall I found the transition was quite smooth, with the high level architecture look like: * The `tokio-proto` crate is used in streaming mode. The streaming part is used for the one RPC sccache gets which requires a second response to be sent later on. This second response is the "response body" in tokio-proto terms. * All of sccache's logic is manifested in an implementation of the `Service` trait. * The transport layer is provided with `tokio_core::io::{Framed, Codec}`, and simple deserialization/serialization is performed with protobuf. Some differences in design are: * The `SccacheService` for now is just a bunch of reference-counted pointers, making it cheap to clone. As the futures it returns progress they will each retain a reference to a cloned copy of the `SccacheService`. Before all this data was just stored and manipulated in a struct directly, but it's now directly managed through shared memory. * The storage backends share a thread pool with the main server instead of spawning threads. And finally, some things I've learned along the way: * Sharing data between futures isn't a trivial operation. It took an explicit decision to use `Rc` and I'm not sure I'm 100% happy with how the ergonomics played out. * Shutdown is pretty tricky here. I've tried to carry over all the previous logic but it definitely required not using `TcpServer` in tokio-proto at the very least, and otherwise required a few custom futures and such to track the various states. I have a hunch that tokio-proto could provide more options out of the box for something like this.
2017-01-31 04:04:03 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
Revert "Update to futures 0.1.19 and fix breakage from Option-related changes" futures 0.1.19 was yanked because of the breaking API changes it made. This reverts commit 7079ab87832efab4298757176b1388f1d126ed98.
2018-07-12 13:31:09 +03:00
"futures 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"log 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
"net2 0.2.31 (registry+https://github.com/rust-lang/crates.io-index)",
"rand 0.3.20 (registry+https://github.com/rust-lang/crates.io-index)",
Rewrite the server module with Tokio This commit rewrites the `server` module of sccache to be backed with Tokio. The previous version was written with `mio`, which Tokio is built on, but is unfortunately less ergonomic. Tokio is the state-of-the-art for asynchronous programming in Rust and sccache serves as a great testing ground for ergonomics! It's intended that the support added here will eventually extend to many other operations that sccache does as well. For example thread spawning has all been replaced with `CpuPool` to have a shared pool for I/O operations and such (namely the filesystem). Eventually the HTTP requests made by the S3 backend can be integrated with the Tokio branch of Hyper as well to run that on the event loop instead of in a worker thread. I'd also like to eventually extend this with `tokio-process` as well to move process spawning off helper threads as well, but I'm leaving that to a future commit as well. Overall I found the transition was quite smooth, with the high level architecture look like: * The `tokio-proto` crate is used in streaming mode. The streaming part is used for the one RPC sccache gets which requires a second response to be sent later on. This second response is the "response body" in tokio-proto terms. * All of sccache's logic is manifested in an implementation of the `Service` trait. * The transport layer is provided with `tokio_core::io::{Framed, Codec}`, and simple deserialization/serialization is performed with protobuf. Some differences in design are: * The `SccacheService` for now is just a bunch of reference-counted pointers, making it cheap to clone. As the futures it returns progress they will each retain a reference to a cloned copy of the `SccacheService`. Before all this data was just stored and manipulated in a struct directly, but it's now directly managed through shared memory. * The storage backends share a thread pool with the main server instead of spawning threads. And finally, some things I've learned along the way: * Sharing data between futures isn't a trivial operation. It took an explicit decision to use `Rc` and I'm not sure I'm 100% happy with how the ergonomics played out. * Shutdown is pretty tricky here. I've tried to carry over all the previous logic but it definitely required not using `TcpServer` in tokio-proto at the very least, and otherwise required a few custom futures and such to track the various states. I have a hunch that tokio-proto could provide more options out of the box for something like this.
2017-01-31 04:04:03 +03:00
"slab 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
"smallvec 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
"take 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
cargo update
2018-02-01 18:29:23 +03:00
"tokio-core 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"tokio-io 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
Rewrite the server module with Tokio This commit rewrites the `server` module of sccache to be backed with Tokio. The previous version was written with `mio`, which Tokio is built on, but is unfortunately less ergonomic. Tokio is the state-of-the-art for asynchronous programming in Rust and sccache serves as a great testing ground for ergonomics! It's intended that the support added here will eventually extend to many other operations that sccache does as well. For example thread spawning has all been replaced with `CpuPool` to have a shared pool for I/O operations and such (namely the filesystem). Eventually the HTTP requests made by the S3 backend can be integrated with the Tokio branch of Hyper as well to run that on the event loop instead of in a worker thread. I'd also like to eventually extend this with `tokio-process` as well to move process spawning off helper threads as well, but I'm leaving that to a future commit as well. Overall I found the transition was quite smooth, with the high level architecture look like: * The `tokio-proto` crate is used in streaming mode. The streaming part is used for the one RPC sccache gets which requires a second response to be sent later on. This second response is the "response body" in tokio-proto terms. * All of sccache's logic is manifested in an implementation of the `Service` trait. * The transport layer is provided with `tokio_core::io::{Framed, Codec}`, and simple deserialization/serialization is performed with protobuf. Some differences in design are: * The `SccacheService` for now is just a bunch of reference-counted pointers, making it cheap to clone. As the futures it returns progress they will each retain a reference to a cloned copy of the `SccacheService`. Before all this data was just stored and manipulated in a struct directly, but it's now directly managed through shared memory. * The storage backends share a thread pool with the main server instead of spawning threads. And finally, some things I've learned along the way: * Sharing data between futures isn't a trivial operation. It took an explicit decision to use `Rc` and I'm not sure I'm 100% happy with how the ergonomics played out. * Shutdown is pretty tricky here. I've tried to carry over all the previous logic but it definitely required not using `TcpServer` in tokio-proto at the very least, and otherwise required a few custom futures and such to track the various states. I have a hunch that tokio-proto could provide more options out of the box for something like this.
2017-01-31 04:04:03 +03:00
"tokio-service 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
Move from protobuf to bincode for a wire format This commit migrates away from the `protobuf` crate to instead just working with bincode on the wire as a serialization format. This is done by leveraging a few different crates: * The `bincode` and `serde_derive` crates are used to define serialization for Rust structures as well as provide a bincode implementation. * The `tokio_io::codec::length_delimited` module implements framing via length prefixes to transform an asynchronous stream of bytes into a literal `Stream` of `BytesMut`. * The `tokio_serde_bincode` crate is then used to tie it all together, parsing these `BytesMut` as the request/response types of sccache. Most of the changes here are related to moving away from the protobuf API throughout the codebase (e.g. `has_foo` and `take_foo`) towards a more rustic-ish API that just uses enums/structs. Overall it felt quite natural (as one would expect) to just use the raw enum/struct values. This may not be quite as performant as before but that doesn't really apply to sccache's use case where perf is hugely dominated by actually compiling and hashing, so I'm not too too worried about that. My personal motivation for this is twofold: 1. Using `protobuf` was a little clunky throughout the codebase and definitely had some sharp edges that felt good to smooth out. 2. There's currently what I believe some mysterious segfault and/or stray write happening in sccache and I'm not sure where. The `protobuf` crate had a lot of `unsafe` code and in lieu of actually auditing it I figured it'd be good to kill two birds with one stone. I have no idea if this fixes my segfault problem (I never could reproduce it) but I figured it's worth a shot.
2017-03-22 20:21:52 +03:00
[[package]]
name = "tokio-serde"
version = "0.1.0"
Depend on tokio-serde-bincode from crates.io
2017-07-13 21:33:57 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Move from protobuf to bincode for a wire format This commit migrates away from the `protobuf` crate to instead just working with bincode on the wire as a serialization format. This is done by leveraging a few different crates: * The `bincode` and `serde_derive` crates are used to define serialization for Rust structures as well as provide a bincode implementation. * The `tokio_io::codec::length_delimited` module implements framing via length prefixes to transform an asynchronous stream of bytes into a literal `Stream` of `BytesMut`. * The `tokio_serde_bincode` crate is then used to tie it all together, parsing these `BytesMut` as the request/response types of sccache. Most of the changes here are related to moving away from the protobuf API throughout the codebase (e.g. `has_foo` and `take_foo`) towards a more rustic-ish API that just uses enums/structs. Overall it felt quite natural (as one would expect) to just use the raw enum/struct values. This may not be quite as performant as before but that doesn't really apply to sccache's use case where perf is hugely dominated by actually compiling and hashing, so I'm not too too worried about that. My personal motivation for this is twofold: 1. Using `protobuf` was a little clunky throughout the codebase and definitely had some sharp edges that felt good to smooth out. 2. There's currently what I believe some mysterious segfault and/or stray write happening in sccache and I'm not sure where. The `protobuf` crate had a lot of `unsafe` code and in lieu of actually auditing it I figured it'd be good to kill two birds with one stone. I have no idea if this fixes my segfault problem (I never could reproduce it) but I figured it's worth a shot.
2017-03-22 20:21:52 +03:00
dependencies = [
cargo update
2018-02-01 18:29:23 +03:00
"bytes 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
Revert "Update to futures 0.1.19 and fix breakage from Option-related changes" futures 0.1.19 was yanked because of the breaking API changes it made. This reverts commit 7079ab87832efab4298757176b1388f1d126ed98.
2018-07-12 13:31:09 +03:00
"futures 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",
Move from protobuf to bincode for a wire format This commit migrates away from the `protobuf` crate to instead just working with bincode on the wire as a serialization format. This is done by leveraging a few different crates: * The `bincode` and `serde_derive` crates are used to define serialization for Rust structures as well as provide a bincode implementation. * The `tokio_io::codec::length_delimited` module implements framing via length prefixes to transform an asynchronous stream of bytes into a literal `Stream` of `BytesMut`. * The `tokio_serde_bincode` crate is then used to tie it all together, parsing these `BytesMut` as the request/response types of sccache. Most of the changes here are related to moving away from the protobuf API throughout the codebase (e.g. `has_foo` and `take_foo`) towards a more rustic-ish API that just uses enums/structs. Overall it felt quite natural (as one would expect) to just use the raw enum/struct values. This may not be quite as performant as before but that doesn't really apply to sccache's use case where perf is hugely dominated by actually compiling and hashing, so I'm not too too worried about that. My personal motivation for this is twofold: 1. Using `protobuf` was a little clunky throughout the codebase and definitely had some sharp edges that felt good to smooth out. 2. There's currently what I believe some mysterious segfault and/or stray write happening in sccache and I'm not sure where. The `protobuf` crate had a lot of `unsafe` code and in lieu of actually auditing it I figured it'd be good to kill two birds with one stone. I have no idea if this fixes my segfault problem (I never could reproduce it) but I figured it's worth a shot.
2017-03-22 20:21:52 +03:00
]
[[package]]
name = "tokio-serde-bincode"
Depend on tokio-serde-bincode from crates.io
2017-07-13 21:33:57 +03:00
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
Move from protobuf to bincode for a wire format This commit migrates away from the `protobuf` crate to instead just working with bincode on the wire as a serialization format. This is done by leveraging a few different crates: * The `bincode` and `serde_derive` crates are used to define serialization for Rust structures as well as provide a bincode implementation. * The `tokio_io::codec::length_delimited` module implements framing via length prefixes to transform an asynchronous stream of bytes into a literal `Stream` of `BytesMut`. * The `tokio_serde_bincode` crate is then used to tie it all together, parsing these `BytesMut` as the request/response types of sccache. Most of the changes here are related to moving away from the protobuf API throughout the codebase (e.g. `has_foo` and `take_foo`) towards a more rustic-ish API that just uses enums/structs. Overall it felt quite natural (as one would expect) to just use the raw enum/struct values. This may not be quite as performant as before but that doesn't really apply to sccache's use case where perf is hugely dominated by actually compiling and hashing, so I'm not too too worried about that. My personal motivation for this is twofold: 1. Using `protobuf` was a little clunky throughout the codebase and definitely had some sharp edges that felt good to smooth out. 2. There's currently what I believe some mysterious segfault and/or stray write happening in sccache and I'm not sure where. The `protobuf` crate had a lot of `unsafe` code and in lieu of actually auditing it I figured it'd be good to kill two birds with one stone. I have no idea if this fixes my segfault problem (I never could reproduce it) but I figured it's worth a shot.
2017-03-22 20:21:52 +03:00
dependencies = [
Update dependencies * Mostly upgrade to serde 1.0 * Pull in lots of other updates for other small deps
2017-05-18 23:53:00 +03:00
"bincode 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
cargo update
2018-02-01 18:29:23 +03:00
"bytes 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
Depend on tokio-serde-bincode from crates.io
2017-07-13 21:33:57 +03:00
"derive-error 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
Revert "Update to futures 0.1.19 and fix breakage from Option-related changes" futures 0.1.19 was yanked because of the breaking API changes it made. This reverts commit 7079ab87832efab4298757176b1388f1d126ed98.
2018-07-12 13:31:09 +03:00
"futures 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"serde 1.0.27 (registry+https://github.com/rust-lang/crates.io-index)",
Depend on tokio-serde-bincode from crates.io
2017-07-13 21:33:57 +03:00
"tokio-serde 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
Move from protobuf to bincode for a wire format This commit migrates away from the `protobuf` crate to instead just working with bincode on the wire as a serialization format. This is done by leveraging a few different crates: * The `bincode` and `serde_derive` crates are used to define serialization for Rust structures as well as provide a bincode implementation. * The `tokio_io::codec::length_delimited` module implements framing via length prefixes to transform an asynchronous stream of bytes into a literal `Stream` of `BytesMut`. * The `tokio_serde_bincode` crate is then used to tie it all together, parsing these `BytesMut` as the request/response types of sccache. Most of the changes here are related to moving away from the protobuf API throughout the codebase (e.g. `has_foo` and `take_foo`) towards a more rustic-ish API that just uses enums/structs. Overall it felt quite natural (as one would expect) to just use the raw enum/struct values. This may not be quite as performant as before but that doesn't really apply to sccache's use case where perf is hugely dominated by actually compiling and hashing, so I'm not too too worried about that. My personal motivation for this is twofold: 1. Using `protobuf` was a little clunky throughout the codebase and definitely had some sharp edges that felt good to smooth out. 2. There's currently what I believe some mysterious segfault and/or stray write happening in sccache and I'm not sure where. The `protobuf` crate had a lot of `unsafe` code and in lieu of actually auditing it I figured it'd be good to kill two birds with one stone. I have no idea if this fixes my segfault problem (I never could reproduce it) but I figured it's worth a shot.
2017-03-22 20:21:52 +03:00
]
Rewrite the server module with Tokio This commit rewrites the `server` module of sccache to be backed with Tokio. The previous version was written with `mio`, which Tokio is built on, but is unfortunately less ergonomic. Tokio is the state-of-the-art for asynchronous programming in Rust and sccache serves as a great testing ground for ergonomics! It's intended that the support added here will eventually extend to many other operations that sccache does as well. For example thread spawning has all been replaced with `CpuPool` to have a shared pool for I/O operations and such (namely the filesystem). Eventually the HTTP requests made by the S3 backend can be integrated with the Tokio branch of Hyper as well to run that on the event loop instead of in a worker thread. I'd also like to eventually extend this with `tokio-process` as well to move process spawning off helper threads as well, but I'm leaving that to a future commit as well. Overall I found the transition was quite smooth, with the high level architecture look like: * The `tokio-proto` crate is used in streaming mode. The streaming part is used for the one RPC sccache gets which requires a second response to be sent later on. This second response is the "response body" in tokio-proto terms. * All of sccache's logic is manifested in an implementation of the `Service` trait. * The transport layer is provided with `tokio_core::io::{Framed, Codec}`, and simple deserialization/serialization is performed with protobuf. Some differences in design are: * The `SccacheService` for now is just a bunch of reference-counted pointers, making it cheap to clone. As the futures it returns progress they will each retain a reference to a cloned copy of the `SccacheService`. Before all this data was just stored and manipulated in a struct directly, but it's now directly managed through shared memory. * The storage backends share a thread pool with the main server instead of spawning threads. And finally, some things I've learned along the way: * Sharing data between futures isn't a trivial operation. It took an explicit decision to use `Rc` and I'm not sure I'm 100% happy with how the ergonomics played out. * Shutdown is pretty tricky here. I've tried to carry over all the previous logic but it definitely required not using `TcpServer` in tokio-proto at the very least, and otherwise required a few custom futures and such to track the various states. I have a hunch that tokio-proto could provide more options out of the box for something like this.
2017-01-31 04:04:03 +03:00
[[package]]
name = "tokio-service"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
Revert "Update to futures 0.1.19 and fix breakage from Option-related changes" futures 0.1.19 was yanked because of the breaking API changes it made. This reverts commit 7079ab87832efab4298757176b1388f1d126ed98.
2018-07-12 13:31:09 +03:00
"futures 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",
Rewrite the server module with Tokio This commit rewrites the `server` module of sccache to be backed with Tokio. The previous version was written with `mio`, which Tokio is built on, but is unfortunately less ergonomic. Tokio is the state-of-the-art for asynchronous programming in Rust and sccache serves as a great testing ground for ergonomics! It's intended that the support added here will eventually extend to many other operations that sccache does as well. For example thread spawning has all been replaced with `CpuPool` to have a shared pool for I/O operations and such (namely the filesystem). Eventually the HTTP requests made by the S3 backend can be integrated with the Tokio branch of Hyper as well to run that on the event loop instead of in a worker thread. I'd also like to eventually extend this with `tokio-process` as well to move process spawning off helper threads as well, but I'm leaving that to a future commit as well. Overall I found the transition was quite smooth, with the high level architecture look like: * The `tokio-proto` crate is used in streaming mode. The streaming part is used for the one RPC sccache gets which requires a second response to be sent later on. This second response is the "response body" in tokio-proto terms. * All of sccache's logic is manifested in an implementation of the `Service` trait. * The transport layer is provided with `tokio_core::io::{Framed, Codec}`, and simple deserialization/serialization is performed with protobuf. Some differences in design are: * The `SccacheService` for now is just a bunch of reference-counted pointers, making it cheap to clone. As the futures it returns progress they will each retain a reference to a cloned copy of the `SccacheService`. Before all this data was just stored and manipulated in a struct directly, but it's now directly managed through shared memory. * The storage backends share a thread pool with the main server instead of spawning threads. And finally, some things I've learned along the way: * Sharing data between futures isn't a trivial operation. It took an explicit decision to use `Rc` and I'm not sure I'm 100% happy with how the ergonomics played out. * Shutdown is pretty tricky here. I've tried to carry over all the previous logic but it definitely required not using `TcpServer` in tokio-proto at the very least, and otherwise required a few custom futures and such to track the various states. I have a hunch that tokio-proto could provide more options out of the box for something like this.
2017-01-31 04:04:03 +03:00
]
Integrate process spawning with tokio-process This commit replaces all process spawning with the futures-powered versions in the `tokio-process` crate. Most functions were already ready to return futures, but a few minor updates were made to ensure that functions could return futures. Additionally, some `&CpuPool` arguments have shown up to allow executing work on a thread pool, such as filesystem operations. A number of compilers write data to tempdirs and such before running a compiler, and these are all executed on thread pools rather than the main thread. My main takeaway from this commit is that translating synchronous to asynchronous code isn't always easy. The "easy" version ends up being relatively wasteful in terms of clones for low-level performance, but probably shouldn't matter much in the context of spawning processes. Other than that though I found that there was a translation for all patterns found didn't actually hit any bugs (yet at least) from the translation.
2017-02-01 03:19:35 +03:00
[[package]]
name = "tokio-signal"
Update ring
2018-01-07 18:33:04 +03:00
version = "0.1.3"
Integrate process spawning with tokio-process This commit replaces all process spawning with the futures-powered versions in the `tokio-process` crate. Most functions were already ready to return futures, but a few minor updates were made to ensure that functions could return futures. Additionally, some `&CpuPool` arguments have shown up to allow executing work on a thread pool, such as filesystem operations. A number of compilers write data to tempdirs and such before running a compiler, and these are all executed on thread pools rather than the main thread. My main takeaway from this commit is that translating synchronous to asynchronous code isn't always easy. The "easy" version ends up being relatively wasteful in terms of clones for low-level performance, but probably shouldn't matter much in the context of spawning processes. Other than that though I found that there was a translation for all patterns found didn't actually hit any bugs (yet at least) from the translation.
2017-02-01 03:19:35 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
Revert "Update to futures 0.1.19 and fix breakage from Option-related changes" futures 0.1.19 was yanked because of the breaking API changes it made. This reverts commit 7079ab87832efab4298757176b1388f1d126ed98.
2018-07-12 13:31:09 +03:00
"futures 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",
cargo update
2018-02-01 18:29:23 +03:00
"libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"mio 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)",
Update dependencies * Mostly upgrade to serde 1.0 * Pull in lots of other updates for other small deps
2017-05-18 23:53:00 +03:00
"mio-uds 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)",
cargo update
2018-02-01 18:29:23 +03:00
"tokio-core 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"tokio-io 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
cargo update
2018-02-01 18:29:23 +03:00
"winapi 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)",
Integrate process spawning with tokio-process This commit replaces all process spawning with the futures-powered versions in the `tokio-process` crate. Most functions were already ready to return futures, but a few minor updates were made to ensure that functions could return futures. Additionally, some `&CpuPool` arguments have shown up to allow executing work on a thread pool, such as filesystem operations. A number of compilers write data to tempdirs and such before running a compiler, and these are all executed on thread pools rather than the main thread. My main takeaway from this commit is that translating synchronous to asynchronous code isn't always easy. The "easy" version ends up being relatively wasteful in terms of clones for low-level performance, but probably shouldn't matter much in the context of spawning processes. Other than that though I found that there was a translation for all patterns found didn't actually hit any bugs (yet at least) from the translation.
2017-02-01 03:19:35 +03:00
]
Implement S3Cache Unlike sccache1, you need to specify both bucket and region, like: SCCACHE_BUCKET=sccache SCCACHE_REGION=us-east-1 Pretty limited testing, no automated tests currently.
2016-06-03 22:09:38 +03:00
[[package]]
Integrate the Tokio branch of Hyper This commit pulls in Hyper from its master branch which contains the asynchronous/Tokio integration. All instances of HTTP, namely when interacting with S3, are now all powered by async Hyper and work with futures rather than synchronous requests on thread pools.
2017-02-02 03:30:26 +03:00
name = "tokio-tls"
Update ring
2018-01-07 18:33:04 +03:00
version = "0.1.4"
Implement S3Cache Unlike sccache1, you need to specify both bucket and region, like: SCCACHE_BUCKET=sccache SCCACHE_REGION=us-east-1 Pretty limited testing, no automated tests currently.
2016-06-03 22:09:38 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Integrate the Tokio branch of Hyper This commit pulls in Hyper from its master branch which contains the asynchronous/Tokio integration. All instances of HTTP, namely when interacting with S3, are now all powered by async Hyper and work with futures rather than synchronous requests on thread pools.
2017-02-02 03:30:26 +03:00
dependencies = [
Revert "Update to futures 0.1.19 and fix breakage from Option-related changes" futures 0.1.19 was yanked because of the breaking API changes it made. This reverts commit 7079ab87832efab4298757176b1388f1d126ed98.
2018-07-12 13:31:09 +03:00
"futures 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",
cargo update
2018-02-01 18:29:23 +03:00
"native-tls 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-core 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"tokio-io 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
Integrate the Tokio branch of Hyper This commit pulls in Hyper from its master branch which contains the asynchronous/Tokio integration. All instances of HTTP, namely when interacting with S3, are now all powered by async Hyper and work with futures rather than synchronous requests on thread pools.
2017-02-02 03:30:26 +03:00
]
Implement S3Cache Unlike sccache1, you need to specify both bucket and region, like: SCCACHE_BUCKET=sccache SCCACHE_REGION=us-east-1 Pretty limited testing, no automated tests currently.
2016-06-03 22:09:38 +03:00
Remove raw `poll` in favor of `tokio-uds` Now that we've got tokio at our fingertips it's much easier to time out simple operations!
2017-02-17 19:43:43 +03:00
[[package]]
name = "tokio-uds"
Update ring
2018-01-07 18:33:04 +03:00
version = "0.1.7"
Remove raw `poll` in favor of `tokio-uds` Now that we've got tokio at our fingertips it's much easier to time out simple operations!
2017-02-17 19:43:43 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
cargo update
2018-02-01 18:29:23 +03:00
"bytes 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
Revert "Update to futures 0.1.19 and fix breakage from Option-related changes" futures 0.1.19 was yanked because of the breaking API changes it made. This reverts commit 7079ab87832efab4298757176b1388f1d126ed98.
2018-07-12 13:31:09 +03:00
"futures 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",
cargo update
2018-02-01 18:29:23 +03:00
"iovec 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"log 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
"mio 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)",
Update dependencies * Mostly upgrade to serde 1.0 * Pull in lots of other updates for other small deps
2017-05-18 23:53:00 +03:00
"mio-uds 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)",
cargo update
2018-02-01 18:29:23 +03:00
"tokio-core 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"tokio-io 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
Remove raw `poll` in favor of `tokio-uds` Now that we've got tokio at our fingertips it's much easier to time out simple operations!
2017-02-17 19:43:43 +03:00
]
Allow configuration of caches with a config file
2018-06-04 20:28:39 +03:00
[[package]]
name = "toml"
version = "0.4.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"serde 1.0.27 (registry+https://github.com/rust-lang/crates.io-index)",
]
Switch from assert_cli to assert_cmd
2018-07-26 22:52:50 +03:00
[[package]]
name = "ucd-util"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement S3Cache Unlike sccache1, you need to specify both bucket and region, like: SCCACHE_BUCKET=sccache SCCACHE_REGION=us-east-1 Pretty limited testing, no automated tests currently.
2016-06-03 22:09:38 +03:00
[[package]]
name = "unicase"
Update ring
2018-01-07 18:33:04 +03:00
version = "2.1.0"
Implement S3Cache Unlike sccache1, you need to specify both bucket and region, like: SCCACHE_BUCKET=sccache SCCACHE_REGION=us-east-1 Pretty limited testing, no automated tests currently.
2016-06-03 22:09:38 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
Update ring
2018-01-07 18:33:04 +03:00
"version_check 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
Implement S3Cache Unlike sccache1, you need to specify both bucket and region, like: SCCACHE_BUCKET=sccache SCCACHE_REGION=us-east-1 Pretty limited testing, no automated tests currently.
2016-06-03 22:09:38 +03:00
]
[[package]]
name = "unicode-bidi"
Update ring
2018-01-07 18:33:04 +03:00
version = "0.3.4"
Implement S3Cache Unlike sccache1, you need to specify both bucket and region, like: SCCACHE_BUCKET=sccache SCCACHE_REGION=us-east-1 Pretty limited testing, no automated tests currently.
2016-06-03 22:09:38 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
Update dependencies Notably bring in hyper from crates.io
2017-06-14 18:20:12 +03:00
"matches 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
Implement S3Cache Unlike sccache1, you need to specify both bucket and region, like: SCCACHE_BUCKET=sccache SCCACHE_REGION=us-east-1 Pretty limited testing, no automated tests currently.
2016-06-03 22:09:38 +03:00
]
[[package]]
name = "unicode-normalization"
Update ring
2018-01-07 18:33:04 +03:00
version = "0.1.5"
Update clap
2017-04-05 17:42:06 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
[[package]]
name = "unicode-width"
Update clap
2017-04-05 17:42:06 +03:00
version = "0.1.4"
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Move from protobuf to bincode for a wire format This commit migrates away from the `protobuf` crate to instead just working with bincode on the wire as a serialization format. This is done by leveraging a few different crates: * The `bincode` and `serde_derive` crates are used to define serialization for Rust structures as well as provide a bincode implementation. * The `tokio_io::codec::length_delimited` module implements framing via length prefixes to transform an asynchronous stream of bytes into a literal `Stream` of `BytesMut`. * The `tokio_serde_bincode` crate is then used to tie it all together, parsing these `BytesMut` as the request/response types of sccache. Most of the changes here are related to moving away from the protobuf API throughout the codebase (e.g. `has_foo` and `take_foo`) towards a more rustic-ish API that just uses enums/structs. Overall it felt quite natural (as one would expect) to just use the raw enum/struct values. This may not be quite as performant as before but that doesn't really apply to sccache's use case where perf is hugely dominated by actually compiling and hashing, so I'm not too too worried about that. My personal motivation for this is twofold: 1. Using `protobuf` was a little clunky throughout the codebase and definitely had some sharp edges that felt good to smooth out. 2. There's currently what I believe some mysterious segfault and/or stray write happening in sccache and I'm not sure where. The `protobuf` crate had a lot of `unsafe` code and in lieu of actually auditing it I figured it'd be good to kill two birds with one stone. I have no idea if this fixes my segfault problem (I never could reproduce it) but I figured it's worth a shot.
2017-03-22 20:21:52 +03:00
[[package]]
name = "unicode-xid"
version = "0.0.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
Add a Memcached cache variant This cache module uses a Memcached cluster. To make sccache use this, set SCCACHE_MEMCACHED to a list of tcp://<hostname>:<port> addresses, separated by whitespace.
2017-08-10 17:50:33 +03:00
[[package]]
name = "unix_socket"
version = "0.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"cfg-if 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
cargo update
2018-02-01 18:29:23 +03:00
"libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
Add a Memcached cache variant This cache module uses a Memcached cluster. To make sccache use this, set SCCACHE_MEMCACHED to a list of tcp://<hostname>:<port> addresses, separated by whitespace.
2017-08-10 17:50:33 +03:00
]
Update dependencies * Mostly upgrade to serde 1.0 * Pull in lots of other updates for other small deps
2017-05-18 23:53:00 +03:00
[[package]]
name = "unreachable"
Update ring
2018-01-07 18:33:04 +03:00
version = "1.0.0"
Update dependencies * Mostly upgrade to serde 1.0 * Pull in lots of other updates for other small deps
2017-05-18 23:53:00 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"void 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
]
Switch from SHA-1 to SHA-512 Local benchmarking showed that the implementation of SHA-512 in the *ring* crate is 3x faster than the implementation of SHA-1 in the `sha1` crate. I've also noticed that 80%+ of sccache's runtime on a fully cached build is spent hashing. With this change I noticed a decrease from 108s to 92s when building a fully cached LLVM from the network. Not a huge win but if the network were faster could perhaps add up! Closes #108
2017-04-21 07:09:15 +03:00
[[package]]
name = "untrusted"
Update ring
2018-01-07 18:33:04 +03:00
version = "0.5.1"
Switch from SHA-1 to SHA-512 Local benchmarking showed that the implementation of SHA-512 in the *ring* crate is 3x faster than the implementation of SHA-1 in the `sha1` crate. I've also noticed that 80%+ of sccache's runtime on a fully cached build is spent hashing. With this change I noticed a decrease from 108s to 92s when building a fully cached LLVM from the network. Not a huge win but if the network were faster could perhaps add up! Closes #108
2017-04-21 07:09:15 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Integrate the Tokio branch of Hyper This commit pulls in Hyper from its master branch which contains the asynchronous/Tokio integration. All instances of HTTP, namely when interacting with S3, are now all powered by async Hyper and work with futures rather than synchronous requests on thread pools.
2017-02-02 03:30:26 +03:00
[[package]]
Update ring
2018-01-07 18:33:04 +03:00
name = "url"
version = "1.6.0"
Integrate the Tokio branch of Hyper This commit pulls in Hyper from its master branch which contains the asynchronous/Tokio integration. All instances of HTTP, namely when interacting with S3, are now all powered by async Hyper and work with futures rather than synchronous requests on thread pools.
2017-02-02 03:30:26 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
Update ring
2018-01-07 18:33:04 +03:00
"idna 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
"matches 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
"percent-encoding 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
Integrate the Tokio branch of Hyper This commit pulls in Hyper from its master branch which contains the asynchronous/Tokio integration. All instances of HTTP, namely when interacting with S3, are now all powered by async Hyper and work with futures rather than synchronous requests on thread pools.
2017-02-02 03:30:26 +03:00
]
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
[[package]]
name = "utf8-ranges"
Update dependencies * Mostly upgrade to serde 1.0 * Pull in lots of other updates for other small deps
2017-05-18 23:53:00 +03:00
version = "1.0.0"
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Always request color output from rustc. Fixes #99 This change makes sccache run rustc with `--color=always`, removing any other --color option from the compiler options so that it's not included in the cache key. A `color_mode` method is added to the `CompilerHasher` trait, and the value is sent back to the client in the `CompileFinished` method, so the client can determine whether specific --color options were passed without having to do its own commandline parsing. The client uses the new `strip-ansi-escapes` crate to remove escape codes from the compiler output in situations where color output is not desired: * When `--color=never` was passed on the compiler commandline. * When `--color=auto` is in effect (the default) but the output is not a terminal. The existing cargo tests were lightly modified to run compile once with `--color=never` and once with `--color=always` to validate that cache hits are not affected by color options.
2018-02-02 15:11:11 +03:00
[[package]]
name = "utf8parse"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
Use a named unix socket or named pipe to let the background server notify the client that it started successfully
2017-01-27 22:39:47 +03:00
[[package]]
name = "uuid"
=updated uuid to 0.6
2018-02-28 22:30:50 +03:00
version = "0.6.0"
Use a named unix socket or named pipe to let the background server notify the client that it started successfully
2017-01-27 22:39:47 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
=updated uuid to 0.6
2018-02-28 22:30:50 +03:00
"rand 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
Use a named unix socket or named pipe to let the background server notify the client that it started successfully
2017-01-27 22:39:47 +03:00
]
Update ring
2018-01-07 18:33:04 +03:00
[[package]]
name = "vcpkg"
version = "0.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
[[package]]
name = "vec_map"
Update dependencies * Mostly upgrade to serde 1.0 * Pull in lots of other updates for other small deps
2017-05-18 23:53:00 +03:00
version = "0.8.0"
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update ring
2018-01-07 18:33:04 +03:00
[[package]]
name = "version_check"
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
Make DiskCache limit the size of the on-disk cache by using LruDiskCache. Fixes #29
2016-11-29 03:59:42 +03:00
[[package]]
Update dependencies * Mostly upgrade to serde 1.0 * Pull in lots of other updates for other small deps
2017-05-18 23:53:00 +03:00
name = "void"
Make DiskCache limit the size of the on-disk cache by using LruDiskCache. Fixes #29
2016-11-29 03:59:42 +03:00
version = "1.0.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
Update dependencies * Mostly upgrade to serde 1.0 * Pull in lots of other updates for other small deps
2017-05-18 23:53:00 +03:00
Always request color output from rustc. Fixes #99 This change makes sccache run rustc with `--color=always`, removing any other --color option from the compiler options so that it's not included in the cache key. A `color_mode` method is added to the `CompilerHasher` trait, and the value is sent back to the client in the `CompileFinished` method, so the client can determine whether specific --color options were passed without having to do its own commandline parsing. The client uses the new `strip-ansi-escapes` crate to remove escape codes from the compiler output in situations where color output is not desired: * When `--color=never` was passed on the compiler commandline. * When `--color=auto` is in effect (the default) but the output is not a terminal. The existing cargo tests were lightly modified to run compile once with `--color=never` and once with `--color=always` to validate that cache hits are not affected by color options.
2018-02-02 15:11:11 +03:00
[[package]]
name = "vte"
version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"utf8parse 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
Update dependencies * Mostly upgrade to serde 1.0 * Pull in lots of other updates for other small deps
2017-05-18 23:53:00 +03:00
[[package]]
name = "walkdir"
version = "1.0.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
Make DiskCache limit the size of the on-disk cache by using LruDiskCache. Fixes #29
2016-11-29 03:59:42 +03:00
dependencies = [
"kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
Update dependencies * Mostly upgrade to serde 1.0 * Pull in lots of other updates for other small deps
2017-05-18 23:53:00 +03:00
"same-file 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
Make DiskCache limit the size of the on-disk cache by using LruDiskCache. Fixes #29
2016-11-29 03:59:42 +03:00
"winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
]
Started using which crate (#14)
2016-07-14 13:38:26 +03:00
[[package]]
name = "which"
Update ring
2018-01-07 18:33:04 +03:00
version = "1.0.3"
switch back to released version of which, switch to a rusoto branch with a bug fix
2016-08-08 22:06:06 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Started using which crate (#14)
2016-07-14 13:38:26 +03:00
dependencies = [
cargo update
2018-02-01 18:29:23 +03:00
"libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
Started using which crate (#14)
2016-07-14 13:38:26 +03:00
]
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
[[package]]
name = "winapi"
Update to a released rusoto, and 'cargo update' while we're at it
2016-07-15 18:06:16 +03:00
version = "0.2.8"
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update ring
2018-01-07 18:33:04 +03:00
[[package]]
name = "winapi"
cargo update
2018-02-01 18:29:23 +03:00
version = "0.3.4"
Update ring
2018-01-07 18:33:04 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
cargo update
2018-02-01 18:29:23 +03:00
"winapi-i686-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
"winapi-x86_64-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
]
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
[[package]]
name = "winapi-build"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
Update ring
2018-01-07 18:33:04 +03:00
[[package]]
name = "winapi-i686-pc-windows-gnu"
cargo update
2018-02-01 18:29:23 +03:00
version = "0.4.0"
Update ring
2018-01-07 18:33:04 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "winapi-x86_64-pc-windows-gnu"
cargo update
2018-02-01 18:29:23 +03:00
version = "0.4.0"
Update ring
2018-01-07 18:33:04 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
[[package]]
name = "ws2_32-sys"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
Update to a released rusoto, and 'cargo update' while we're at it
2016-07-15 18:06:16 +03:00
"winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
Commit Cargo.lock
2016-05-12 22:03:37 +03:00
"winapi-build 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
Bits and pieces for distributed Rust
2018-04-12 04:25:15 +03:00
[[package]]
name = "xattr"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
]
Implement fetching/storing to cache, interfaces for doing so, implement a disk cache
2016-05-21 21:14:26 +03:00
[[package]]
name = "zip"
Properly chain error when failing to create temp dir in hash_source_files
2018-01-12 14:35:50 +03:00
version = "0.2.3"
Implement fetching/storing to cache, interfaces for doing so, implement a disk cache
2016-05-21 21:14:26 +03:00
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
Update ring
2018-01-07 18:33:04 +03:00
"flate2 0.2.20 (registry+https://github.com/rust-lang/crates.io-index)",
Update dependencies * Mostly upgrade to serde 1.0 * Pull in lots of other updates for other small deps
2017-05-18 23:53:00 +03:00
"msdos_time 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
cargo update
2018-02-01 18:29:23 +03:00
"podio 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
Update ring
2018-01-07 18:33:04 +03:00
"time 0.1.39 (registry+https://github.com/rust-lang/crates.io-index)",
Implement fetching/storing to cache, interfaces for doing so, implement a disk cache
2016-05-21 21:14:26 +03:00
]
make connecting to server a little more lenient when starting the server
2016-10-26 01:14:21 +03:00
[metadata]
Update ring
2018-01-07 18:33:04 +03:00
"checksum aho-corasick 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)" = "d6531d44de723825aa81398a6415283229725a00fa30713812ab9323faa82fc4"
Silence some warnings
2018-07-12 13:46:33 +03:00
"checksum ansi_term 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ee49baf6cb617b853aa8d93bf420db2383fab46d314482ca2803b40d5fde979b"
Switch from assert_cli to assert_cmd
2018-07-26 22:52:50 +03:00
"checksum assert_cmd 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)" = "11d61ba2f519654febb9a504d172cfc21c667c9889e707b9860d78dd5e2b69b3"
Update ring
2018-01-07 18:33:04 +03:00
"checksum atty 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)" = "8352656fd42c30a0c3c89d26dea01e3b77c0ab2af18230835c15e2e13cd51859"
"checksum base64 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "7c4a342b450b268e1be8036311e2c613d7f8a7ed31214dff1cc3b60852a3168d"
"checksum base64 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)" = "229d032f1a99302697f10b27167ae6d03d49d032e6a8e2550e8d3fc13356d2b4"
Update dependencies * Mostly upgrade to serde 1.0 * Pull in lots of other updates for other small deps
2017-05-18 23:53:00 +03:00
"checksum bincode 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "e103c8b299b28a9c6990458b7013dc4a8356a9b854c51b9883241f5866fac36e"
Update other deps
2018-01-07 18:58:55 +03:00
"checksum bincode 0.9.2 (registry+https://github.com/rust-lang/crates.io-index)" = "9a6301db0b49fb63551bc15b5ae348147101cdf323242b93ec7546d5002ff1af"
Update dependencies Notably bring in hyper from crates.io
2017-06-14 18:20:12 +03:00
"checksum bitflags 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)" = "4efd02e230a02e18f92fc2735f44597385ed02ad8f831e7c1c1156ee5e1ab3a5"
Update ring
2018-01-07 18:33:04 +03:00
"checksum bitflags 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "b3c30d3802dfb7281680d6285f2ccdaa8c2d8fee41f93805dba5c4cf50dc23cf"
Add a Memcached cache variant This cache module uses a Memcached cluster. To make sccache use this, set SCCACHE_MEMCACHED to a list of tcp://<hostname>:<port> addresses, separated by whitespace.
2017-08-10 17:50:33 +03:00
"checksum bufstream 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "f2f382711e76b9de6c744cc00d0497baba02fb00a787f088c879f01d09468e32"
"checksum byteorder 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "96c8b41881888cc08af32d47ac4edd52bc7fa27fef774be47a92443756451304"
Update ring
2018-01-07 18:33:04 +03:00
"checksum byteorder 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "652805b7e73fada9d85e9a6682a4abd490cb52d96aeecc12e33a0de34dfd0d23"
cargo update
2018-02-01 18:29:23 +03:00
"checksum bytes 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)" = "1b7db437d718977f6dc9b2e3fd6fc343c02ac6b899b73fdd2179163447bd9ce9"
Depend on tokio-serde-bincode from crates.io
2017-07-13 21:33:57 +03:00
"checksum case 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "e88b166b48e29667f5443df64df3c61dc07dc2b1a0b0d231800e07f09a33ecc1"
cargo update
2018-02-01 18:29:23 +03:00
"checksum cc 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)" = "deaf9ec656256bb25b404c51ef50097207b9cbb29c933d31f92cae5a8a0ffee0"
Update ring
2018-01-07 18:33:04 +03:00
"checksum cfg-if 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "d4c819a1287eb618df47cc647173c5c4c66ba19d888a6e50d605672aed3140de"
"checksum chrono 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "158b0bd7d75cbb6bf9c25967a48a2e9f77da95876b858eadfabaa99cd069de6e"
"checksum chrono 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "7c20ebe0b2b08b0aeddba49c609fe7957ba2e33449882cb186a180bc60682fa9"
Silence some warnings
2018-07-12 13:46:33 +03:00
"checksum clap 2.32.0 (registry+https://github.com/rust-lang/crates.io-index)" = "b957d88f4b6a63b9d70d5f454ac8011819c6efa7727858f458ab71c756ce2d3e"
Update dependencies Notably bring in hyper from crates.io
2017-06-14 18:20:12 +03:00
"checksum coco 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "c06169f5beb7e31c7c67ebf5540b8b472d23e3eade3b2ec7d1f5b504a85f91bd"
Add a Memcached cache variant This cache module uses a Memcached cluster. To make sccache use this, set SCCACHE_MEMCACHED to a list of tcp://<hostname>:<port> addresses, separated by whitespace.
2017-08-10 17:50:33 +03:00
"checksum conhash 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "f45d5b02557fc2358078db5b1e1c7d801145bcd08428403121d4f108342ec5fe"
Integrate the Tokio branch of Hyper This commit pulls in Hyper from its master branch which contains the asynchronous/Tokio integration. All instances of HTTP, namely when interacting with S3, are now all powered by async Hyper and work with futures rather than synchronous requests on thread pools.
2017-02-02 03:30:26 +03:00
"checksum core-foundation 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "25bfd746d203017f7d5cbd31ee5d8e17f94b6521c7af77ece6c9e4b2d4b16c67"
"checksum core-foundation-sys 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "065a5d7ffdcbc8fa145d6f0746f3555025b9097a9e9cda59f7467abae670c78d"
daemonize the server process on unix
2016-10-26 23:22:52 +03:00
"checksum daemonize 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "0239832c1b4ca406d5ec73728cf4c7336d25cf85dd32db9e047e9e706ee0e935"
Depend on tokio-serde-bincode from crates.io
2017-07-13 21:33:57 +03:00
"checksum derive-error 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)" = "629f1bb3abce791912ca85a24676fff54464f7deb122906adabc90fb96e876d3"
Update assert_cli and tweak some of the tests using it. Also silence a lint warning from error-chain.
2018-07-26 17:16:55 +03:00
"checksum difference 2.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "524cbf6897b527295dff137cec09ecf3a05f4fddffd7dfcd1585403449e74198"
Replace `app_dirs` crate with `directories`. Fixes #233. The `app_dirs` crate has become unmaintained and is broken on macOS with Rust 1.25. The `directories` crate provides the same functionality and is maintained, so switch to using that instead.
2018-03-21 15:52:55 +03:00
"checksum directories 0.8.4 (registry+https://github.com/rust-lang/crates.io-index)" = "f4b2a45602b0c40b8ccb331cfda4a60769b050471df8235154c94ffe67eade9d"
Update ring
2018-01-07 18:33:04 +03:00
"checksum dtoa 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "09c3753c3db574d215cba4ea76018483895d7bff25a31b49ba45db21c48e50ab"
"checksum either 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "740178ddf48b1a9e878e6d6509a1442a2d42fd2928aae8e7a6f8a36fb01981b3"
Update dependencies Notably bring in hyper from crates.io
2017-06-14 18:20:12 +03:00
"checksum env_logger 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)" = "3ddf21e73e016298f5cb37d6ef8e8da8e39f91f9ec8b0df44b7deb16a9f8cd5b"
Ignore CARGO_MAKEFLAGS when calculating Rust hash keys. Fixes #193 Since cargo gained jobserver support it now passes a CARGO_MAKEFLAGS environment variable which is different for every build (it contains file descriptor numbers or semaphore values). sccache uses all environment variables starting with `CARGO_` as inputs to the hash key for Rust compilation so this broke things. I think it was mostly only a problem on Windows, where the values were semaphores. On POSIX platforms the values are file descriptors, which are probably likely to be the same between runs of cargo. This change also adds a test for compiling a simple Rust crate with cargo and verifying that we get a cache hit. I pulled in the `assert_cli` crate to write that test, which worked nicely.
2017-10-25 21:09:27 +03:00
"checksum error-chain 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ff511d5dc435d703f4971bc399647c9bc38e20cb41452e3b9feb4765419ed3f3"
Switch from assert_cli to assert_cmd
2018-07-26 22:52:50 +03:00
"checksum escargot 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ddeb6acd0f12aeba309aa295bcad6d4d88603406640bf2595c887a7a9684a4bd"
cargo update
2018-02-01 18:29:23 +03:00
"checksum filetime 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)" = "714653f3e34871534de23771ac7b26e999651a0a228f47beb324dfdf1dd4b10f"
Bits and pieces for distributed Rust
2018-04-12 04:25:15 +03:00
"checksum filetime 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "08530a39af0bd442c40aabb9e854f442a83bd2403feb1ed58fbe982dec2385f3"
Update ring
2018-01-07 18:33:04 +03:00
"checksum flate2 0.2.20 (registry+https://github.com/rust-lang/crates.io-index)" = "e6234dd4468ae5d1e2dbb06fe2b058696fdc50a339c68a393aefbf00bc81e423"
Switch from assert_cli to assert_cmd
2018-07-26 22:52:50 +03:00
"checksum float-cmp 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "134a8fa843d80a51a5b77d36d42bc2def9edcb0262c914861d08129fd1926600"
Update ring
2018-01-07 18:33:04 +03:00
"checksum foreign-types 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)" = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1"
"checksum foreign-types-shared 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"
"checksum fuchsia-zircon 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "2e9763c69ebaae630ba35f74888db465e49e259ba1bc0eda7d06f4a067615d82"
"checksum fuchsia-zircon-sys 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "3dcaa9ae7725d12cdb85b3ad99a434db70b468c09ded17e012d86b5c1010f7a7"
Revert "Update to futures 0.1.19 and fix breakage from Option-related changes" futures 0.1.19 was yanked because of the breaking API changes it made. This reverts commit 7079ab87832efab4298757176b1388f1d126ed98.
2018-07-12 13:31:09 +03:00
"checksum futures 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)" = "0bab5b5e94f5c31fc764ba5dd9ad16568aae5d4825538c01d6bca680c9bf94a7"
Update ring
2018-01-07 18:33:04 +03:00
"checksum futures-cpupool 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "ab90cde24b3319636588d0c35fe03b1333857621051837ed769faefb4c2162e4"
"checksum gcc 0.3.54 (registry+https://github.com/rust-lang/crates.io-index)" = "5e33ec290da0d127825013597dbdfc28bee4964690c7ce1166cbc2a7bd08b1bb"
cargo update
2018-02-01 18:29:23 +03:00
"checksum getopts 0.2.17 (registry+https://github.com/rust-lang/crates.io-index)" = "b900c08c1939860ce8b54dc6a89e26e00c04c380fd0e09796799bd7f12861e05"
"checksum httparse 1.2.4 (registry+https://github.com/rust-lang/crates.io-index)" = "c2f407128745b78abc95c0ffbe4e5d37427fdc0d45470710cfef8c44522a2e37"
"checksum hyper 0.11.16 (registry+https://github.com/rust-lang/crates.io-index)" = "6a82c41828dd6f271f4d6ebc3f1db78239a4b2b3d355dfdb5f8bbf55f004463a"
Update ring
2018-01-07 18:33:04 +03:00
"checksum hyper-tls 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "9c81fa95203e2a6087242c38691a0210f23e9f3f8f944350bd676522132e2985"
"checksum idna 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "014b298351066f1512874135335d62a789ffe78a9974f94b43ed5621951eaf7d"
cargo update
2018-02-01 18:29:23 +03:00
"checksum iovec 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "dbe6e417e7d0975db6512b90796e8ce223145ac4e33c377e4a42882a0e88bb08"
"checksum itertools 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)" = "b07332223953b5051bceb67e8c4700aa65291535568e1f12408c43c4a42c0394"
Update ring
2018-01-07 18:33:04 +03:00
"checksum itoa 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)" = "8324a32baf01e2ae060e9de58ed0bc2320c9a2833491ee36cd3b4c414de4db8c"
update jobserver to 0.1.11 to pick up a fix for shutting down the worker thread
2018-03-16 20:39:18 +03:00
"checksum jobserver 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)" = "60af5f849e1981434e4a31d3d782c4774ae9b434ce55b101a96ecfd09147e8be"
Update ring
2018-01-07 18:33:04 +03:00
"checksum jsonwebtoken 4.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "50ff506fbf25106dea8f97be2f9b43d67b7f02a4b5ced6b1ff3543dd08cecee0"
make connecting to server a little more lenient when starting the server
2016-10-26 01:14:21 +03:00
"checksum kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7507624b29483431c0ba2d82aece8ca6cdba9382bff4ddd0f7490560c056098d"
"checksum language-tags 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "a91d884b6667cd606bb5a69aa0c99ba811a115fc68915e7056ec08a46e93199a"
Update ring
2018-01-07 18:33:04 +03:00
"checksum lazy_static 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)" = "76f033c7ad61445c5b347c7382dd1237847eb1bce590fe50365dcb33d546be73"
"checksum lazy_static 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "c8f31047daa365f19be14b47c29df4f7c3b581832407daabe6ae77397619237d"
"checksum lazycell 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)" = "a6f08839bc70ef4a3fe1d566d5350f519c5912ea86be0df1740a7d247c7fc0ef"
cargo update
2018-02-01 18:29:23 +03:00
"checksum libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)" = "1e5d97d6708edaa407429faa671b942dc0f2727222fb6b6539bf1db936e4b121"
Make DiskCache limit the size of the on-disk cache by using LruDiskCache. Fixes #29
2016-11-29 03:59:42 +03:00
"checksum linked-hash-map 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "bda158e0dabeb97ee8a401f4d17e479d6b891a14de0bba79d5cc2d4d325b5e48"
make connecting to server a little more lenient when starting the server
2016-10-26 01:14:21 +03:00
"checksum local-encoding 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "e1ceb20f39ff7ae42f3ff9795f3986b1daad821caaa1e1732a0944103a5a1a66"
Update ring
2018-01-07 18:33:04 +03:00
"checksum log 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)" = "e19e8d5c34a3e0e2223db8e060f9e8264aeeb5c5fc64a4ee9965c062211c024b"
"checksum log 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)" = "89f010e843f2b1a31dbd316b3b8d443758bc634bed37aabade59c686d644e0a2"
Update dependencies Notably bring in hyper from crates.io
2017-06-14 18:20:12 +03:00
"checksum matches 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "100aabe6b8ff4e4a7e32c1c13523379802df0772b82466207ac25b013f193376"
Add a Memcached cache variant This cache module uses a Memcached cluster. To make sccache use this, set SCCACHE_MEMCACHED to a list of tcp://<hostname>:<port> addresses, separated by whitespace.
2017-08-10 17:50:33 +03:00
"checksum memcached-rs 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "92bb8680fa02c632e8fdf462f1fa6a244aef0af380877dd150c56d117d748671"
Update ring
2018-01-07 18:33:04 +03:00
"checksum memchr 2.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "796fba70e76612589ed2ce7f45282f5af869e0fdd7cc6199fa1aa1f1d591ba9d"
"checksum mime 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)" = "e2e00e17be181010a91dbfefb01660b17311059dc8c7f48b9017677721e732bd"
"checksum miniz-sys 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)" = "609ce024854aeb19a0ef7567d348aaa5a746b32fb72e336df7fcc16869d7e2b4"
"checksum mio 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)" = "75f72a93f046f1517e3cfddc0a096eb756a2ba727d36edc8227dee769a50a9b0"
"checksum mio-named-pipes 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "f5e374eff525ce1c5b7687c4cef63943e7686524a387933ad27ca7ec43779cb3"
Update dependencies * Mostly upgrade to serde 1.0 * Pull in lots of other updates for other small deps
2017-05-18 23:53:00 +03:00
"checksum mio-uds 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)" = "1731a873077147b626d89cc6c2a0db6288d607496c5d10c0cfcf3adc697ec673"
Update to using the new tokio-io crate This is an abstraction of the Tokio stack now and doesn't have much impact on sccache itself but I figured it'd be good to update a few deps and pick up the recent version of things! Plus that and I'd like to start using the length_delimited module soon...
2017-03-09 21:00:18 +03:00
"checksum miow 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "8c1f2f3b1cf331de6896aabf6e9d55dca90356cc9960cca7eaaf408a355ae919"
Update ring
2018-01-07 18:33:04 +03:00
"checksum miow 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "9224c91f82b3c47cf53dcf78dfaa20d6888fbcc5d272d5f2fcdf8a697f3c987d"
Update dependencies * Mostly upgrade to serde 1.0 * Pull in lots of other updates for other small deps
2017-05-18 23:53:00 +03:00
"checksum msdos_time 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "65ba9d75bcea84e07812618fedf284a64776c2f2ea0cad6bca7f69739695a958"
cargo update
2018-02-01 18:29:23 +03:00
"checksum native-tls 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "f74dbadc8b43df7864539cedb7bc91345e532fdd913cfdc23ad94f4d2d40fbc0"
Update ring
2018-01-07 18:33:04 +03:00
"checksum net2 0.2.31 (registry+https://github.com/rust-lang/crates.io-index)" = "3a80f842784ef6c9a958b68b7516bc7e35883c614004dd94959a4dca1b716c09"
Add a Memcached cache variant This cache module uses a Memcached cluster. To make sccache use this, set SCCACHE_MEMCACHED to a list of tcp://<hostname>:<port> addresses, separated by whitespace.
2017-08-10 17:50:33 +03:00
"checksum nom 1.2.4 (registry+https://github.com/rust-lang/crates.io-index)" = "a5b8c256fd9471521bcb84c3cdba98921497f1a331cbc15b8030fc63b82050ce"
Update ring
2018-01-07 18:33:04 +03:00
"checksum num 0.1.41 (registry+https://github.com/rust-lang/crates.io-index)" = "cc4083e14b542ea3eb9b5f33ff48bd373a92d78687e74f4cc0a30caeb754f0ca"
"checksum num-integer 0.1.35 (registry+https://github.com/rust-lang/crates.io-index)" = "d1452e8b06e448a07f0e6ebb0bb1d92b8890eea63288c0b627331d53514d0fba"
"checksum num-iter 0.1.34 (registry+https://github.com/rust-lang/crates.io-index)" = "7485fcc84f85b4ecd0ea527b14189281cf27d60e583ae65ebc9c088b13dffe01"
cargo update
2018-02-01 18:29:23 +03:00
"checksum num-traits 0.1.42 (registry+https://github.com/rust-lang/crates.io-index)" = "9936036cc70fe4a8b2d338ab665900323290efb03983c86cbe235ae800ad8017"
Switch from assert_cli to assert_cmd
2018-07-26 22:52:50 +03:00
"checksum num-traits 0.2.5 (registry+https://github.com/rust-lang/crates.io-index)" = "630de1ef5cc79d0cdd78b7e33b81f083cbfe90de0f4b2b2f07f905867c70e9fe"
Update ring
2018-01-07 18:33:04 +03:00
"checksum num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "c51a3322e4bca9d212ad9a158a02abc6934d005490c054a2778df73a70aa0a30"
Update dependencies * Mostly upgrade to serde 1.0 * Pull in lots of other updates for other small deps
2017-05-18 23:53:00 +03:00
"checksum number_prefix 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)" = "59a14be9c211cb9c602bad35ac99f41e9a84b44d71b8cbd3040e3bd02a214902"
Update ring
2018-01-07 18:33:04 +03:00
"checksum openssl 0.9.23 (registry+https://github.com/rust-lang/crates.io-index)" = "169a4b9160baf9b9b1ab975418c673686638995ba921683a7f1e01470dcb8854"
cargo update
2018-02-01 18:29:23 +03:00
"checksum openssl-sys 0.9.24 (registry+https://github.com/rust-lang/crates.io-index)" = "14ba54ac7d5a4eabd1d5f2c1fdeb7e7c14debfa669d94b983d01b465e767ba9e"
Update ring
2018-01-07 18:33:04 +03:00
"checksum percent-encoding 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "31010dd2e1ac33d5b46a5b413495239882813e0369f8ed8a5e266f173602f831"
Integrate the Tokio branch of Hyper This commit pulls in Hyper from its master branch which contains the asynchronous/Tokio integration. All instances of HTTP, namely when interacting with S3, are now all powered by async Hyper and work with futures rather than synchronous requests on thread pools.
2017-02-02 03:30:26 +03:00
"checksum pkg-config 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)" = "3a8b4c6b8165cd1a1cd4b9b120978131389f64bdaf456435caa41e630edba903"
cargo update
2018-02-01 18:29:23 +03:00
"checksum podio 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "780fb4b6698bbf9cf2444ea5d22411cef2953f0824b98f33cf454ec5615645bd"
Refactor system tests to use assert_cmd
2018-07-27 19:07:08 +03:00
"checksum predicates 0.5.2 (git+https://github.com/luser/predicates-rs?branch=function-unsized)" = "<none>"
make connecting to server a little more lenient when starting the server
2016-10-26 01:14:21 +03:00
"checksum pulldown-cmark 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)" = "8361e81576d2e02643b04950e487ec172b687180da65c731c03cf336784e6c07"
Move from protobuf to bincode for a wire format This commit migrates away from the `protobuf` crate to instead just working with bincode on the wire as a serialization format. This is done by leveraging a few different crates: * The `bincode` and `serde_derive` crates are used to define serialization for Rust structures as well as provide a bincode implementation. * The `tokio_io::codec::length_delimited` module implements framing via length prefixes to transform an asynchronous stream of bytes into a literal `Stream` of `BytesMut`. * The `tokio_serde_bincode` crate is then used to tie it all together, parsing these `BytesMut` as the request/response types of sccache. Most of the changes here are related to moving away from the protobuf API throughout the codebase (e.g. `has_foo` and `take_foo`) towards a more rustic-ish API that just uses enums/structs. Overall it felt quite natural (as one would expect) to just use the raw enum/struct values. This may not be quite as performant as before but that doesn't really apply to sccache's use case where perf is hugely dominated by actually compiling and hashing, so I'm not too too worried about that. My personal motivation for this is twofold: 1. Using `protobuf` was a little clunky throughout the codebase and definitely had some sharp edges that felt good to smooth out. 2. There's currently what I believe some mysterious segfault and/or stray write happening in sccache and I'm not sure where. The `protobuf` crate had a lot of `unsafe` code and in lieu of actually auditing it I figured it'd be good to kill two birds with one stone. I have no idea if this fixes my segfault problem (I never could reproduce it) but I figured it's worth a shot.
2017-03-22 20:21:52 +03:00
"checksum quote 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)" = "7a6e920b65c65f10b2ae65c831a81a073a89edd28c7cce89475bff467ab4167a"
Update ring
2018-01-07 18:33:04 +03:00
"checksum rand 0.3.20 (registry+https://github.com/rust-lang/crates.io-index)" = "512870020642bb8c221bf68baa1b2573da814f6ccfe5c9699b1c303047abe9b1"
cargo update
2018-02-01 18:29:23 +03:00
"checksum rand 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "eba5f8cb59cc50ed56be8880a5c7b496bfd9bd26394e176bc67884094145c2c5"
Update ring
2018-01-07 18:33:04 +03:00
"checksum rayon 0.8.2 (registry+https://github.com/rust-lang/crates.io-index)" = "b614fe08b6665cb9a231d07ac1364b0ef3cb3698f1239ee0c4c3a88a524f54c8"
"checksum rayon-core 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "e64b609139d83da75902f88fd6c01820046840a18471e4dfcd5ac7c0f46bea53"
Add a Redis cache variant This cache module uses a Redis instance. To make sccache use this, set SCCACHE_REDIS to redis://[:<passwd>@]<hostname>[:port][/<db>]. The maximum and current cache size is retrieved from the INFO and CONFIG GET redis command.
2017-02-16 22:56:41 +03:00
"checksum redis 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "02a92e223490cc63d9230c4cdf132a48ce154ab1e063558e3841e219c2ea3f91"
Update ring
2018-01-07 18:33:04 +03:00
"checksum redox_syscall 0.1.37 (registry+https://github.com/rust-lang/crates.io-index)" = "0d92eecebad22b767915e4d529f89f28ee96dbbf5a4810d2b844373f136417fd"
"checksum redox_termios 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "7e891cfe48e9100a70a3b6eb652fef28920c117d366339687bd5576160db0f76"
"checksum regex 0.2.5 (registry+https://github.com/rust-lang/crates.io-index)" = "744554e01ccbd98fff8c457c3b092cd67af62a555a43bfe97ae8a0451f7799fa"
Switch from assert_cli to assert_cmd
2018-07-26 22:52:50 +03:00
"checksum regex 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "5bbbea44c5490a1e84357ff28b7d518b4619a159fed5d25f6c1de2d19cc42814"
Update ring
2018-01-07 18:33:04 +03:00
"checksum regex-syntax 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "8e931c58b93d86f080c734bfd2bce7dd0079ae2331235818133c8be7f422e20e"
Switch from assert_cli to assert_cmd
2018-07-26 22:52:50 +03:00
"checksum regex-syntax 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)" = "747ba3b235651f6e2f67dfa8bcdcd073ddb7c243cb21c442fc12395dfcac212d"
cargo update
2018-02-01 18:29:23 +03:00
"checksum relay 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "1576e382688d7e9deecea24417e350d3062d97e32e45d70b1cde65994ff1489a"
"checksum remove_dir_all 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "b5d2f806b0fcdabd98acd380dc8daef485e22bcb7cddc811d1337967f2528cf5"
make connecting to server a little more lenient when starting the server
2016-10-26 01:14:21 +03:00
"checksum retry 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "29460f6011a25fc70b22010e796bd98330baccaa0005cba6f90b858a510dec0d"
Update ring
2018-01-07 18:33:04 +03:00
"checksum ring 0.12.1 (registry+https://github.com/rust-lang/crates.io-index)" = "6f7d28b30a72c01b458428e0ae988d4149c20d902346902be881e3edc4bb325c"
make connecting to server a little more lenient when starting the server
2016-10-26 01:14:21 +03:00
"checksum rust-crypto 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)" = "f76d05d3993fd5f4af9434e8e436db163a12a9d40e1a58a726f27a01dfd12a2a"
Update dependencies * Mostly upgrade to serde 1.0 * Pull in lots of other updates for other small deps
2017-05-18 23:53:00 +03:00
"checksum rustc-serialize 0.3.24 (registry+https://github.com/rust-lang/crates.io-index)" = "dcf128d1287d2ea9d80910b5f1120d0b8eede3fbf1abe91c40d39ea7d51e6fda"
Update dependencies Notably bring in hyper from crates.io
2017-06-14 18:20:12 +03:00
"checksum safemem 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "e27a8b19b835f7aea908818e871f5cc3a5a186550c30773be987e155e8163d8f"
Update dependencies * Mostly upgrade to serde 1.0 * Pull in lots of other updates for other small deps
2017-05-18 23:53:00 +03:00
"checksum same-file 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "d931a44fdaa43b8637009e7632a02adc4f2b2e0733c08caa4cf00e8da4a117a7"
Update to schannel version 0.1.11
2018-03-05 20:38:37 +03:00
"checksum schannel 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)" = "fbaffce35eb61c5b00846e73128b0cd62717e7c0ec46abbec132370d013975b4"
Rewrite the server module with Tokio This commit rewrites the `server` module of sccache to be backed with Tokio. The previous version was written with `mio`, which Tokio is built on, but is unfortunately less ergonomic. Tokio is the state-of-the-art for asynchronous programming in Rust and sccache serves as a great testing ground for ergonomics! It's intended that the support added here will eventually extend to many other operations that sccache does as well. For example thread spawning has all been replaced with `CpuPool` to have a shared pool for I/O operations and such (namely the filesystem). Eventually the HTTP requests made by the S3 backend can be integrated with the Tokio branch of Hyper as well to run that on the event loop instead of in a worker thread. I'd also like to eventually extend this with `tokio-process` as well to move process spawning off helper threads as well, but I'm leaving that to a future commit as well. Overall I found the transition was quite smooth, with the high level architecture look like: * The `tokio-proto` crate is used in streaming mode. The streaming part is used for the one RPC sccache gets which requires a second response to be sent later on. This second response is the "response body" in tokio-proto terms. * All of sccache's logic is manifested in an implementation of the `Service` trait. * The transport layer is provided with `tokio_core::io::{Framed, Codec}`, and simple deserialization/serialization is performed with protobuf. Some differences in design are: * The `SccacheService` for now is just a bunch of reference-counted pointers, making it cheap to clone. As the futures it returns progress they will each retain a reference to a cloned copy of the `SccacheService`. Before all this data was just stored and manipulated in a struct directly, but it's now directly managed through shared memory. * The storage backends share a thread pool with the main server instead of spawning threads. And finally, some things I've learned along the way: * Sharing data between futures isn't a trivial operation. It took an explicit decision to use `Rc` and I'm not sure I'm 100% happy with how the ergonomics played out. * Shutdown is pretty tricky here. I've tried to carry over all the previous logic but it definitely required not using `TcpServer` in tokio-proto at the very least, and otherwise required a few custom futures and such to track the various states. I have a hunch that tokio-proto could provide more options out of the box for something like this.
2017-01-31 04:04:03 +03:00
"checksum scoped-tls 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "f417c22df063e9450888a7561788e9bd46d3bb3c1466435b4eccb903807f147d"
Update ring
2018-01-07 18:33:04 +03:00
"checksum scopeguard 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "94258f53601af11e6a49f722422f6e3425c52b06245a5cf9bc09908b174f5e27"
"checksum security-framework 0.1.16 (registry+https://github.com/rust-lang/crates.io-index)" = "dfa44ee9c54ce5eecc9de7d5acbad112ee58755239381f687e564004ba4a2332"
"checksum security-framework-sys 0.1.16 (registry+https://github.com/rust-lang/crates.io-index)" = "5421621e836278a0b139268f36eee0dc7e389b784dc3f79d8f11aabadf41bead"
Add a Memcached cache variant This cache module uses a Memcached cluster. To make sccache use this, set SCCACHE_MEMCACHED to a list of tcp://<hostname>:<port> addresses, separated by whitespace.
2017-08-10 17:50:33 +03:00
"checksum semver 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "2d5b7638a1f03815d94e88cb3b3c08e87f0db4d683ef499d1836aaf70a45623f"
Update ring
2018-01-07 18:33:04 +03:00
"checksum serde 1.0.27 (registry+https://github.com/rust-lang/crates.io-index)" = "db99f3919e20faa51bb2996057f5031d8685019b5a06139b1ce761da671b8526"
"checksum serde_derive 1.0.27 (registry+https://github.com/rust-lang/crates.io-index)" = "f4ba7591cfe93755e89eeecdbcc668885624829b020050e6aec99c2a03bd3fd0"
"checksum serde_derive_internals 0.19.0 (registry+https://github.com/rust-lang/crates.io-index)" = "6e03f1c9530c3fb0a0a5c9b826bdd9246a5921ae995d75f512ac917fc4dd55b5"
"checksum serde_json 1.0.9 (registry+https://github.com/rust-lang/crates.io-index)" = "c9db7266c7d63a4c4b7fe8719656ccdd51acf1bed6124b174f933b009fb10bcb"
make connecting to server a little more lenient when starting the server
2016-10-26 01:14:21 +03:00
"checksum sha1 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "cc30b1e1e8c40c121ca33b86c23308a090d19974ef001b4bf6e61fd1a0fb095c"
"checksum skeptic 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "24ebf8a06f5f8bae61ae5bbc7af7aac4ef6907ae975130faba1199e5fe82256a"
Rewrite the server module with Tokio This commit rewrites the `server` module of sccache to be backed with Tokio. The previous version was written with `mio`, which Tokio is built on, but is unfortunately less ergonomic. Tokio is the state-of-the-art for asynchronous programming in Rust and sccache serves as a great testing ground for ergonomics! It's intended that the support added here will eventually extend to many other operations that sccache does as well. For example thread spawning has all been replaced with `CpuPool` to have a shared pool for I/O operations and such (namely the filesystem). Eventually the HTTP requests made by the S3 backend can be integrated with the Tokio branch of Hyper as well to run that on the event loop instead of in a worker thread. I'd also like to eventually extend this with `tokio-process` as well to move process spawning off helper threads as well, but I'm leaving that to a future commit as well. Overall I found the transition was quite smooth, with the high level architecture look like: * The `tokio-proto` crate is used in streaming mode. The streaming part is used for the one RPC sccache gets which requires a second response to be sent later on. This second response is the "response body" in tokio-proto terms. * All of sccache's logic is manifested in an implementation of the `Service` trait. * The transport layer is provided with `tokio_core::io::{Framed, Codec}`, and simple deserialization/serialization is performed with protobuf. Some differences in design are: * The `SccacheService` for now is just a bunch of reference-counted pointers, making it cheap to clone. As the futures it returns progress they will each retain a reference to a cloned copy of the `SccacheService`. Before all this data was just stored and manipulated in a struct directly, but it's now directly managed through shared memory. * The storage backends share a thread pool with the main server instead of spawning threads. And finally, some things I've learned along the way: * Sharing data between futures isn't a trivial operation. It took an explicit decision to use `Rc` and I'm not sure I'm 100% happy with how the ergonomics played out. * Shutdown is pretty tricky here. I've tried to carry over all the previous logic but it definitely required not using `TcpServer` in tokio-proto at the very least, and otherwise required a few custom futures and such to track the various states. I have a hunch that tokio-proto could provide more options out of the box for something like this.
2017-01-31 04:04:03 +03:00
"checksum slab 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "17b4fcaed89ab08ef143da37bc52adbcc04d4a69014f4c1208d6b51f0c47bc23"
Update iovec to fix a soundness hole on Windows Also update a few other dependencies that transitively needed fixing
2017-10-06 02:40:25 +03:00
"checksum slab 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "fdeff4cd9ecff59ec7e3744cbca73dfe5ac35c2aedb2cfba8a1c715a18912e9d"
Rewrite the server module with Tokio This commit rewrites the `server` module of sccache to be backed with Tokio. The previous version was written with `mio`, which Tokio is built on, but is unfortunately less ergonomic. Tokio is the state-of-the-art for asynchronous programming in Rust and sccache serves as a great testing ground for ergonomics! It's intended that the support added here will eventually extend to many other operations that sccache does as well. For example thread spawning has all been replaced with `CpuPool` to have a shared pool for I/O operations and such (namely the filesystem). Eventually the HTTP requests made by the S3 backend can be integrated with the Tokio branch of Hyper as well to run that on the event loop instead of in a worker thread. I'd also like to eventually extend this with `tokio-process` as well to move process spawning off helper threads as well, but I'm leaving that to a future commit as well. Overall I found the transition was quite smooth, with the high level architecture look like: * The `tokio-proto` crate is used in streaming mode. The streaming part is used for the one RPC sccache gets which requires a second response to be sent later on. This second response is the "response body" in tokio-proto terms. * All of sccache's logic is manifested in an implementation of the `Service` trait. * The transport layer is provided with `tokio_core::io::{Framed, Codec}`, and simple deserialization/serialization is performed with protobuf. Some differences in design are: * The `SccacheService` for now is just a bunch of reference-counted pointers, making it cheap to clone. As the futures it returns progress they will each retain a reference to a cloned copy of the `SccacheService`. Before all this data was just stored and manipulated in a struct directly, but it's now directly managed through shared memory. * The storage backends share a thread pool with the main server instead of spawning threads. And finally, some things I've learned along the way: * Sharing data between futures isn't a trivial operation. It took an explicit decision to use `Rc` and I'm not sure I'm 100% happy with how the ergonomics played out. * Shutdown is pretty tricky here. I've tried to carry over all the previous logic but it definitely required not using `TcpServer` in tokio-proto at the very least, and otherwise required a few custom futures and such to track the various states. I have a hunch that tokio-proto could provide more options out of the box for something like this.
2017-01-31 04:04:03 +03:00
"checksum smallvec 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "4c8cbcd6df1e117c2210e13ab5109635ad68a929fcbb8964dc965b76cb5ee013"
cargo update
2018-02-01 18:29:23 +03:00
"checksum socket2 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "a76b792959eba82f021c9028c8ecb6396f085268d6d46af2ed96a829cc758d7c"
Always request color output from rustc. Fixes #99 This change makes sccache run rustc with `--color=always`, removing any other --color option from the compiler options so that it's not included in the cache key. A `color_mode` method is added to the `CompilerHasher` trait, and the value is sent back to the client in the `CompileFinished` method, so the client can determine whether specific --color options were passed without having to do its own commandline parsing. The client uses the new `strip-ansi-escapes` crate to remove escape codes from the compiler output in situations where color output is not desired: * When `--color=never` was passed on the compiler commandline. * When `--color=auto` is in effect (the default) but the output is not a terminal. The existing cargo tests were lightly modified to run compile once with `--color=never` and once with `--color=always` to validate that cache hits are not affected by color options.
2018-02-02 15:11:11 +03:00
"checksum strip-ansi-escapes 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "9d63676e2abafa709460982ddc02a3bb586b6d15a49b75c212e06edd3933acee"
Silence some warnings
2018-07-12 13:46:33 +03:00
"checksum strsim 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "bb4f380125926a99e52bc279241539c018323fab05ad6368b56f93d9369ff550"
Update dependencies * Mostly upgrade to serde 1.0 * Pull in lots of other updates for other small deps
2017-05-18 23:53:00 +03:00
"checksum syn 0.11.11 (registry+https://github.com/rust-lang/crates.io-index)" = "d3b891b9015c88c576343b9b3e41c2c11a51c219ef067b264bd9c8aa9b441dad"
Move from protobuf to bincode for a wire format This commit migrates away from the `protobuf` crate to instead just working with bincode on the wire as a serialization format. This is done by leveraging a few different crates: * The `bincode` and `serde_derive` crates are used to define serialization for Rust structures as well as provide a bincode implementation. * The `tokio_io::codec::length_delimited` module implements framing via length prefixes to transform an asynchronous stream of bytes into a literal `Stream` of `BytesMut`. * The `tokio_serde_bincode` crate is then used to tie it all together, parsing these `BytesMut` as the request/response types of sccache. Most of the changes here are related to moving away from the protobuf API throughout the codebase (e.g. `has_foo` and `take_foo`) towards a more rustic-ish API that just uses enums/structs. Overall it felt quite natural (as one would expect) to just use the raw enum/struct values. This may not be quite as performant as before but that doesn't really apply to sccache's use case where perf is hugely dominated by actually compiling and hashing, so I'm not too too worried about that. My personal motivation for this is twofold: 1. Using `protobuf` was a little clunky throughout the codebase and definitely had some sharp edges that felt good to smooth out. 2. There's currently what I believe some mysterious segfault and/or stray write happening in sccache and I'm not sure where. The `protobuf` crate had a lot of `unsafe` code and in lieu of actually auditing it I figured it'd be good to kill two birds with one stone. I have no idea if this fixes my segfault problem (I never could reproduce it) but I figured it's worth a shot.
2017-03-22 20:21:52 +03:00
"checksum synom 0.11.3 (registry+https://github.com/rust-lang/crates.io-index)" = "a393066ed9010ebaed60b9eafa373d4b1baac186dd7e008555b0f702b51945b6"
Rewrite the server module with Tokio This commit rewrites the `server` module of sccache to be backed with Tokio. The previous version was written with `mio`, which Tokio is built on, but is unfortunately less ergonomic. Tokio is the state-of-the-art for asynchronous programming in Rust and sccache serves as a great testing ground for ergonomics! It's intended that the support added here will eventually extend to many other operations that sccache does as well. For example thread spawning has all been replaced with `CpuPool` to have a shared pool for I/O operations and such (namely the filesystem). Eventually the HTTP requests made by the S3 backend can be integrated with the Tokio branch of Hyper as well to run that on the event loop instead of in a worker thread. I'd also like to eventually extend this with `tokio-process` as well to move process spawning off helper threads as well, but I'm leaving that to a future commit as well. Overall I found the transition was quite smooth, with the high level architecture look like: * The `tokio-proto` crate is used in streaming mode. The streaming part is used for the one RPC sccache gets which requires a second response to be sent later on. This second response is the "response body" in tokio-proto terms. * All of sccache's logic is manifested in an implementation of the `Service` trait. * The transport layer is provided with `tokio_core::io::{Framed, Codec}`, and simple deserialization/serialization is performed with protobuf. Some differences in design are: * The `SccacheService` for now is just a bunch of reference-counted pointers, making it cheap to clone. As the futures it returns progress they will each retain a reference to a cloned copy of the `SccacheService`. Before all this data was just stored and manipulated in a struct directly, but it's now directly managed through shared memory. * The storage backends share a thread pool with the main server instead of spawning threads. And finally, some things I've learned along the way: * Sharing data between futures isn't a trivial operation. It took an explicit decision to use `Rc` and I'm not sure I'm 100% happy with how the ergonomics played out. * Shutdown is pretty tricky here. I've tried to carry over all the previous logic but it definitely required not using `TcpServer` in tokio-proto at the very least, and otherwise required a few custom futures and such to track the various states. I have a hunch that tokio-proto could provide more options out of the box for something like this.
2017-01-31 04:04:03 +03:00
"checksum take 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "b157868d8ac1f56b64604539990685fa7611d8fa9e5476cf0c02cf34d32917c5"
Bits and pieces for distributed Rust
2018-04-12 04:25:15 +03:00
"checksum tar 0.4.15 (registry+https://github.com/rust-lang/crates.io-index)" = "6af6b94659f9a571bf769a5b71f54079393585ee0bfdd71b691be22d7d6b1d18"
cargo update
2018-02-01 18:29:23 +03:00
"checksum tempdir 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)" = "f73eebdb68c14bcb24aef74ea96079830e7fa7b31a6106e42ea7ee887c1e134e"
Update ring
2018-01-07 18:33:04 +03:00
"checksum tempfile 2.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "11ce2fe9db64b842314052e2421ac61a73ce41b898dc8e3750398b219c5fc1e0"
"checksum termion 1.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "689a3bdfaab439fd92bc87df5c4c78417d3cbe537487274e9b0b2dce76e92096"
Silence some warnings
2018-07-12 13:46:33 +03:00
"checksum textwrap 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "307686869c93e71f94da64286f9a9524c0f308a9e1c87a583de8e9c9039ad3f6"
Update ring
2018-01-07 18:33:04 +03:00
"checksum thread_local 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)" = "279ef31c19ededf577bfd12dfae728040a21f635b06a24cd670ff510edd38963"
"checksum time 0.1.39 (registry+https://github.com/rust-lang/crates.io-index)" = "a15375f1df02096fb3317256ce2cee6a1f42fc84ea5ad5fc8c421cfe40c73098"
cargo update
2018-02-01 18:29:23 +03:00
"checksum tokio-core 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)" = "52b4e32d8edbf29501aabb3570f027c6ceb00ccef6538f4bddba0200503e74e8"
Update ring
2018-01-07 18:33:04 +03:00
"checksum tokio-io 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "514aae203178929dbf03318ad7c683126672d4d96eccb77b29603d33c9e25743"
"checksum tokio-process 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "2e76e0cd21a4ae5362697e85f98aa5d26c88f09ce9fc367b57c0643ba0b022c2"
Update to using the new tokio-io crate This is an abstraction of the Tokio stack now and doesn't have much impact on sccache itself but I figured it'd be good to update a few deps and pick up the recent version of things! Plus that and I'd like to start using the length_delimited module soon...
2017-03-09 21:00:18 +03:00
"checksum tokio-proto 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "8fbb47ae81353c63c487030659494b295f6cb6576242f907f203473b191b0389"
Depend on tokio-serde-bincode from crates.io
2017-07-13 21:33:57 +03:00
"checksum tokio-serde 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "894168193c4f80862a2244ff953b69145a9961a9efba39500e0970b083d0649c"
"checksum tokio-serde-bincode 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "02e35c8d60a5e87cfb30dd562a309e56f8a6d36617b0a76c87f04d5466607ca8"
Rewrite the server module with Tokio This commit rewrites the `server` module of sccache to be backed with Tokio. The previous version was written with `mio`, which Tokio is built on, but is unfortunately less ergonomic. Tokio is the state-of-the-art for asynchronous programming in Rust and sccache serves as a great testing ground for ergonomics! It's intended that the support added here will eventually extend to many other operations that sccache does as well. For example thread spawning has all been replaced with `CpuPool` to have a shared pool for I/O operations and such (namely the filesystem). Eventually the HTTP requests made by the S3 backend can be integrated with the Tokio branch of Hyper as well to run that on the event loop instead of in a worker thread. I'd also like to eventually extend this with `tokio-process` as well to move process spawning off helper threads as well, but I'm leaving that to a future commit as well. Overall I found the transition was quite smooth, with the high level architecture look like: * The `tokio-proto` crate is used in streaming mode. The streaming part is used for the one RPC sccache gets which requires a second response to be sent later on. This second response is the "response body" in tokio-proto terms. * All of sccache's logic is manifested in an implementation of the `Service` trait. * The transport layer is provided with `tokio_core::io::{Framed, Codec}`, and simple deserialization/serialization is performed with protobuf. Some differences in design are: * The `SccacheService` for now is just a bunch of reference-counted pointers, making it cheap to clone. As the futures it returns progress they will each retain a reference to a cloned copy of the `SccacheService`. Before all this data was just stored and manipulated in a struct directly, but it's now directly managed through shared memory. * The storage backends share a thread pool with the main server instead of spawning threads. And finally, some things I've learned along the way: * Sharing data between futures isn't a trivial operation. It took an explicit decision to use `Rc` and I'm not sure I'm 100% happy with how the ergonomics played out. * Shutdown is pretty tricky here. I've tried to carry over all the previous logic but it definitely required not using `TcpServer` in tokio-proto at the very least, and otherwise required a few custom futures and such to track the various states. I have a hunch that tokio-proto could provide more options out of the box for something like this.
2017-01-31 04:04:03 +03:00
"checksum tokio-service 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "24da22d077e0f15f55162bdbdc661228c1581892f52074fb242678d015b45162"
Update ring
2018-01-07 18:33:04 +03:00
"checksum tokio-signal 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "57c4031b97651d28c87a0a071e1c2809d70609d3120ce285b302eb7d52c96906"
"checksum tokio-tls 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "772f4b04e560117fe3b0a53e490c16ddc8ba6ec437015d91fa385564996ed913"
"checksum tokio-uds 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "65ae5d255ce739e8537221ed2942e0445f4b3b813daebac1c0050ddaaa3587f9"
Allow configuration of caches with a config file
2018-06-04 20:28:39 +03:00
"checksum toml 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)" = "a0263c6c02c4db6c8f7681f9fd35e90de799ebd4cfdeab77a38f4ff6b3d8c0d9"
Switch from assert_cli to assert_cmd
2018-07-26 22:52:50 +03:00
"checksum ucd-util 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "fd2be2d6639d0f8fe6cdda291ad456e23629558d466e2789d2c3e9892bda285d"
Update ring
2018-01-07 18:33:04 +03:00
"checksum unicase 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "284b6d3db520d67fbe88fd778c21510d1b0ba4a551e5d0fbb023d33405f6de8a"
"checksum unicode-bidi 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)" = "49f2bd0c6468a8230e1db229cff8029217cf623c767ea5d60bfbd42729ea54d5"
"checksum unicode-normalization 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "51ccda9ef9efa3f7ef5d91e8f9b83bbe6955f9bf86aec89d5cce2c874625920f"
Update clap
2017-04-05 17:42:06 +03:00
"checksum unicode-width 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "bf3a113775714a22dcb774d8ea3655c53a32debae63a063acc00a91cc586245f"
Move from protobuf to bincode for a wire format This commit migrates away from the `protobuf` crate to instead just working with bincode on the wire as a serialization format. This is done by leveraging a few different crates: * The `bincode` and `serde_derive` crates are used to define serialization for Rust structures as well as provide a bincode implementation. * The `tokio_io::codec::length_delimited` module implements framing via length prefixes to transform an asynchronous stream of bytes into a literal `Stream` of `BytesMut`. * The `tokio_serde_bincode` crate is then used to tie it all together, parsing these `BytesMut` as the request/response types of sccache. Most of the changes here are related to moving away from the protobuf API throughout the codebase (e.g. `has_foo` and `take_foo`) towards a more rustic-ish API that just uses enums/structs. Overall it felt quite natural (as one would expect) to just use the raw enum/struct values. This may not be quite as performant as before but that doesn't really apply to sccache's use case where perf is hugely dominated by actually compiling and hashing, so I'm not too too worried about that. My personal motivation for this is twofold: 1. Using `protobuf` was a little clunky throughout the codebase and definitely had some sharp edges that felt good to smooth out. 2. There's currently what I believe some mysterious segfault and/or stray write happening in sccache and I'm not sure where. The `protobuf` crate had a lot of `unsafe` code and in lieu of actually auditing it I figured it'd be good to kill two birds with one stone. I have no idea if this fixes my segfault problem (I never could reproduce it) but I figured it's worth a shot.
2017-03-22 20:21:52 +03:00
"checksum unicode-xid 0.0.4 (registry+https://github.com/rust-lang/crates.io-index)" = "8c1f860d7d29cf02cb2f3f359fd35991af3d30bac52c57d265a3c461074cb4dc"
Add a Memcached cache variant This cache module uses a Memcached cluster. To make sccache use this, set SCCACHE_MEMCACHED to a list of tcp://<hostname>:<port> addresses, separated by whitespace.
2017-08-10 17:50:33 +03:00
"checksum unix_socket 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)" = "6aa2700417c405c38f5e6902d699345241c28c0b7ade4abaad71e35a87eb1564"
Update ring
2018-01-07 18:33:04 +03:00
"checksum unreachable 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "382810877fe448991dfc7f0dd6e3ae5d58088fd0ea5e35189655f84e6814fa56"
"checksum untrusted 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "f392d7819dbe58833e26872f5f6f0d68b7bbbe90fc3667e98731c4a15ad9a7ae"
"checksum url 1.6.0 (registry+https://github.com/rust-lang/crates.io-index)" = "fa35e768d4daf1d85733418a49fb42e10d7f633e394fccab4ab7aba897053fe2"
Update dependencies * Mostly upgrade to serde 1.0 * Pull in lots of other updates for other small deps
2017-05-18 23:53:00 +03:00
"checksum utf8-ranges 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "662fab6525a98beff2921d7f61a39e7d59e0b425ebc7d0d9e66d316e55124122"
Always request color output from rustc. Fixes #99 This change makes sccache run rustc with `--color=always`, removing any other --color option from the compiler options so that it's not included in the cache key. A `color_mode` method is added to the `CompilerHasher` trait, and the value is sent back to the client in the `CompileFinished` method, so the client can determine whether specific --color options were passed without having to do its own commandline parsing. The client uses the new `strip-ansi-escapes` crate to remove escape codes from the compiler output in situations where color output is not desired: * When `--color=never` was passed on the compiler commandline. * When `--color=auto` is in effect (the default) but the output is not a terminal. The existing cargo tests were lightly modified to run compile once with `--color=never` and once with `--color=always` to validate that cache hits are not affected by color options.
2018-02-02 15:11:11 +03:00
"checksum utf8parse 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "a15ea87f3194a3a454c78d79082b4f5e85f6956ddb6cb86bbfbe4892aa3c0323"
=updated uuid to 0.6
2018-02-28 22:30:50 +03:00
"checksum uuid 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)" = "2bcacdce7c75ad110c0dba131d6628c64398593e3895025d043ee2fcf97c4b6e"
Update ring
2018-01-07 18:33:04 +03:00
"checksum vcpkg 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "9e0a7d8bed3178a8fb112199d466eeca9ed09a14ba8ad67718179b4fd5487d0b"
Update dependencies * Mostly upgrade to serde 1.0 * Pull in lots of other updates for other small deps
2017-05-18 23:53:00 +03:00
"checksum vec_map 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "887b5b631c2ad01628bbbaa7dd4c869f80d3186688f8d0b6f58774fbe324988c"
Update ring
2018-01-07 18:33:04 +03:00
"checksum version_check 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "6b772017e347561807c1aa192438c5fd74242a670a6cffacc40f2defd1dc069d"
Update dependencies * Mostly upgrade to serde 1.0 * Pull in lots of other updates for other small deps
2017-05-18 23:53:00 +03:00
"checksum void 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "6a02e4885ed3bc0f2de90ea6dd45ebcbb66dacffe03547fadbb0eeae2770887d"
Always request color output from rustc. Fixes #99 This change makes sccache run rustc with `--color=always`, removing any other --color option from the compiler options so that it's not included in the cache key. A `color_mode` method is added to the `CompilerHasher` trait, and the value is sent back to the client in the `CompileFinished` method, so the client can determine whether specific --color options were passed without having to do its own commandline parsing. The client uses the new `strip-ansi-escapes` crate to remove escape codes from the compiler output in situations where color output is not desired: * When `--color=never` was passed on the compiler commandline. * When `--color=auto` is in effect (the default) but the output is not a terminal. The existing cargo tests were lightly modified to run compile once with `--color=never` and once with `--color=always` to validate that cache hits are not affected by color options.
2018-02-02 15:11:11 +03:00
"checksum vte 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)" = "a01634c75db59478405de08d8567c40c578bba80c565217ee709934b551720d8"
Update dependencies * Mostly upgrade to serde 1.0 * Pull in lots of other updates for other small deps
2017-05-18 23:53:00 +03:00
"checksum walkdir 1.0.7 (registry+https://github.com/rust-lang/crates.io-index)" = "bb08f9e670fab86099470b97cd2b252d6527f0b3cc1401acdb595ffc9dd288ff"
Update ring
2018-01-07 18:33:04 +03:00
"checksum which 1.0.3 (registry+https://github.com/rust-lang/crates.io-index)" = "4be6cfa54dab45266e98b5d7be2f8ce959ddd49abd141a05d52dce4b07f803bb"
make connecting to server a little more lenient when starting the server
2016-10-26 01:14:21 +03:00
"checksum winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)" = "167dc9d6949a9b857f3451275e911c3f44255842c1f7a76f33c55103a909087a"
cargo update
2018-02-01 18:29:23 +03:00
"checksum winapi 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)" = "04e3bd221fcbe8a271359c04f21a76db7d0c6028862d1bb5512d85e1e2eb5bb3"
make connecting to server a little more lenient when starting the server
2016-10-26 01:14:21 +03:00
"checksum winapi-build 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "2d315eee3b34aca4797b2da6b13ed88266e6d612562a0c46390af8299fc699bc"
cargo update
2018-02-01 18:29:23 +03:00
"checksum winapi-i686-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
"checksum winapi-x86_64-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
make connecting to server a little more lenient when starting the server
2016-10-26 01:14:21 +03:00
"checksum ws2_32-sys 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "d59cefebd0c892fa2dd6de581e937301d8552cb44489cdff035c6187cb63fa5e"
Bits and pieces for distributed Rust
2018-04-12 04:25:15 +03:00
"checksum xattr 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "abb373b92de38a4301d66bec009929b4fb83120ea1c4a401be89dbe0b9777443"
Properly chain error when failing to create temp dir in hash_source_files
2018-01-12 14:35:50 +03:00
"checksum zip 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "a8e9988af1aa47bb7ccb1a61fd1261c45f646dda65ea00c6562d6b611403acf9"