Add feature to prost-build to allow runtime specification of protoc

Opening this as a way of opening the discussion about an issue that I
was running into.  If you would prefer a different approach, I'm happy
to discuss that.

Within multi-language environments, such as bazel, cargo isn't always
able to drive the build process.  However, prost and prost-build
provides an amazing foundation of which to build off.  The general idea
of this commit was to open up prost-build to having tools built off of
it, while still preserving previous behavior.

Currently, if PROTOC or PROTO_INCLUDE are not set at build-time, then
the build fails.  This commit introduces feature, runtime-protoc. This
hides env! invocations when enabled, allowing compilation, under the
assumption that the protoc location will be provided at runtime.  This
wouldn't be my first preference, but I was prioritizing the build-break
if the environment flags were not specified.  I would generally have
preferred grabbing those with option_env! macros and then trying to
gracefully handle the error at runtime protoc has not been provided at
build time or runtime similar, since this is already covered by tests.
That would allow removal of the feature flag.  It would also make the
code a little cleaner, since there's not a great way to do conditionals
with cfg (see rust-lang/rust#71679).

Author: dfreese

prost-build/Cargo.toml

@@ -9,6 +9,11 @@ readme = "README.md"
 description = "A Protocol Buffers implementation for the Rust Language."
 edition = "2018"
 
+[features]
+# Modify prost-build to be built and run as an executable outside of the normal
+# build.rs environment.  Requires explicitly setting the protoc path at runtime.
+runtime-protoc = []
+
 [dependencies]
 bytes = "0.5"
 heck = "0.3"

prost-build/src/lib.rs

@@ -189,6 +189,8 @@ pub struct Config {
     strip_enum_prefix: bool,
     out_dir: Option<PathBuf>,
     extern_paths: Vec<(String, String)>,
+    #[cfg(feature = "runtime-protoc")]
+    protoc: Option<PathBuf>,
 }
 
 impl Config {
@@ -484,6 +486,19 @@ impl Config {
         self
     }
 
+    /// Specifies the path of the protoc executable to be used if using `runtime-protoc`.
+    ///
+    /// If not set, then `compile_protos` will result in an error when the `runtime-protoc` feature
+    /// is enabled, otherwise, `PROTOC` is expected to be set at build time.
+    #[cfg(feature = "runtime-protoc")]
+    pub fn protoc<P>(&mut self, path: P) -> &mut Self
+    where
+        P: Into<PathBuf>,
+    {
+        self.protoc = Some(path.into());
+        self
+    }
+
     /// Compile `.proto` files into Rust files during a Cargo build with additional code generator
     /// configuration options.
     ///
@@ -523,7 +538,7 @@ impl Config {
         let tmp = tempfile::Builder::new().prefix("prost-build").tempdir()?;
         let descriptor_set = tmp.path().join("prost-descriptor-set");
 
-        let mut cmd = Command::new(protoc());
+        let mut cmd = Command::new(self.get_protoc()?);
         cmd.arg("--include_imports")
             .arg("--include_source_info")
             .arg("-o")
@@ -535,7 +550,9 @@ impl Config {
 
         // Set the protoc include after the user includes in case the user wants to
         // override one of the built-in .protos.
-        cmd.arg("-I").arg(protoc_include());
+        if let Some(protoc_include_dir) = get_protoc_include() {
+            cmd.arg("-I").arg(protoc_include_dir);
+        }
 
         for proto in protos {
             cmd.arg(proto.as_ref());
@@ -613,6 +630,23 @@ impl Config {
             .map(to_snake)
             .collect()
     }
+
+    /// Provides a path to a protoc executable, if available.  Provides a means of hiding the
+    /// runtime-protoc feature usage from the rest of the logic.
+    fn get_protoc(&self) -> Result<PathBuf> {
+        #[cfg(not(feature = "runtime-protoc"))]
+        return Ok(protoc().to_path_buf());
+
+        #[cfg(feature = "runtime-protoc")]
+        match &self.protoc {
+            Some(x) => Ok(x.clone()),
+            None => Err(Error::new(
+                ErrorKind::Other,
+                "Protoc was not specified.  Provide it using Config::protoc when building the \
+config or by disabling the runtime-protoc feature",
+            )),
+        }
+    }
 }
 
 impl default::Default for Config {
@@ -626,6 +660,8 @@ impl default::Default for Config {
             strip_enum_prefix: true,
             out_dir: None,
             extern_paths: Vec::new(),
+            #[cfg(feature = "runtime-protoc")]
+            protoc: None,
         }
     }
 }
@@ -680,15 +716,28 @@ where
 }
 
 /// Returns the path to the `protoc` binary.
+#[cfg(not(feature = "runtime-protoc"))]
 pub fn protoc() -> &'static Path {
     Path::new(env!("PROTOC"))
 }
 
 /// Returns the path to the Protobuf include directory.
+#[cfg(not(feature = "runtime-protoc"))]
 pub fn protoc_include() -> &'static Path {
     Path::new(env!("PROTOC_INCLUDE"))
 }
 
+/// Returns the path to the protobuf include directory if the configuration allows it.
+fn get_protoc_include() -> Option<&'static Path> {
+    #[cfg(not(feature = "runtime-protoc"))]
+    return Some(protoc_include());
+
+    // We expect, with runtime-protoc enabled, that all include directories will be passed at
+    // runtime.
+    #[cfg(feature = "runtime-protoc")]
+    None
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -759,10 +808,24 @@ mod tests {
         }
     }
 
+    // Test helper to make sure tests run under both the default and under runtime-protoc, by still
+    // taking advantage of the fact PROTOC is still set by the build.rs file.  This is slightly at
+    // odds with the intended use-case, but seemed like a better option than recreating the build.rs
+    // file logic here to lookup the appopriate protoc executable in third-party for the platform.
+    fn config_new() -> Config {
+        #![allow(unused_mut)]
+        let mut config = Config::new();
+
+        #[cfg(feature = "runtime-protoc")]
+        config.protoc(env!("PROTOC"));
+
+        config
+    }
+
     #[test]
     fn smoke_test() {
         let _ = env_logger::try_init();
-        Config::new()
+        config_new()
             .service_generator(Box::new(ServiceTraitGenerator))
             .compile_protos(&["src/smoke_test.proto"], &["src"])
             .unwrap();
@@ -775,7 +838,7 @@ mod tests {
         let state = Rc::new(RefCell::new(MockState::default()));
         let gen = MockServiceGenerator::new(Rc::clone(&state));
 
-        Config::new()
+        config_new()
             .service_generator(Box::new(gen))
             .compile_protos(&["src/hello.proto", "src/goodbye.proto"], &["src"])
             .unwrap();