Invalidate release distribution on Fastly

We are working on serving Rust releases through Fastly as well as
CloudFront. The logic to invalidate cached released has therefore
been slightly reworked to handle both CDNs.

First, new environment variables have been added to configure the Fastly
integration. An API token is required as is the domain name that should
get invalidated.

Second, a temporary environment variable has been added that enables the
integration. This enables us to test the integration in the dev
environment without requiring any changes to the production environment.

Author: jdno

src/config.rs

@@ -1,4 +1,5 @@
 use crate::discourse::Discourse;
+use crate::fastly::Fastly;
 use crate::github::Github;
 use crate::Context;
 use anyhow::{Context as _, Error};
@@ -192,6 +193,14 @@ pub(crate) struct Config {
 
     /// The app ID associated with the private key being passed.
     pub(crate) github_app_id: Option<u32>,
+
+    /// An API token for Fastly with the `purge_select` scope.
+    pub(crate) fastly_api_token: Option<String>,
+    /// The static domain name that is used with Fastly, e.g. `static.rust-lang.org`.
+    pub(crate) fastly_static_domain: Option<String>,
+
+    /// Temporary variable to test Fastly in the dev environment only.
+    pub(crate) invalidate_fastly: bool,
 }
 
 impl Config {
@@ -226,6 +235,9 @@ impl Config {
             discourse_api_key: maybe_env("DISCOURSE_API_KEY")?,
             github_app_key: maybe_env("GITHUB_APP_KEY")?,
             github_app_id: maybe_env("GITHUB_APP_ID")?,
+            fastly_api_token: maybe_env("FASTLY_API_TOKEN")?,
+            fastly_static_domain: maybe_env("FASTLY_STATIC_DOMAIN")?,
+            invalidate_fastly: bool_env("INVALIDATE_FASTLY")?,
         })
     }
 
@@ -248,6 +260,14 @@ impl Config {
         }
     }
 
+    pub(crate) fn fastly(&self) -> Option<Fastly> {
+        if let (Some(token), Some(domain)) = (&self.fastly_api_token, &self.fastly_static_domain) {
+            Some(Fastly::new(token.clone(), domain.clone()))
+        } else {
+            None
+        }
+    }
+
     pub(crate) fn stable_dev_static_blog_contents(
         &self,
         release: &str,

src/fastly.rs

@@ -0,0 +1,40 @@
+use anyhow::Error;
+use curl::easy::Easy;
+
+pub struct Fastly {
+    api_token: String,
+    domain: String,
+    client: Easy,
+}
+
+impl Fastly {
+    pub fn new(api_token: String, domain: String) -> Self {
+        Self {
+            api_token,
+            domain,
+            client: Easy::new(),
+        }
+    }
+
+    pub fn purge(&mut self, path: &str) -> Result<(), Error> {
+        self.start_new_request()?;
+
+        self.client.post(true)?;
+        self.client.url(&format!(
+            "https://api.fastly.com/purge/{}/{}",
+            self.domain, path
+        ))?;
+
+        self.client.perform().map_err(|error| error.into())
+    }
+
+    fn start_new_request(&mut self) -> anyhow::Result<()> {
+        self.client.reset();
+        self.client.useragent("rust-lang/promote-release")?;
+        let mut headers = curl::easy::List::new();
+        headers.append(&format!("Fastly-Key: {}", self.api_token))?;
+        headers.append("Content-Type: application/json")?;
+        self.client.http_headers(headers)?;
+        Ok(())
+    }
+}

src/main.rs

@@ -5,6 +5,7 @@ mod build_manifest;
 mod config;
 mod curl_helper;
 mod discourse;
+mod fastly;
 mod github;
 mod recompress;
 mod sign;
@@ -18,6 +19,7 @@ use std::time::Duration;
 use std::{collections::HashSet, env};
 
 use crate::build_manifest::BuildManifest;
+use crate::config::{Channel, Config};
 use crate::sign::Signer;
 use crate::smoke_test::SmokeTester;
 use anyhow::Error;
@@ -26,8 +28,6 @@ use curl::easy::Easy;
 use fs2::FileExt;
 use github::{CreateTag, Github};
 
-use crate::config::{Channel, Config};
-
 const TARGET: &str = env!("TARGET");
 
 const BLOG_PRIMARY_BRANCH: &str = "master";
@@ -557,7 +557,12 @@ impl Context {
     }
 
     fn invalidate_releases(&self) -> Result<(), Error> {
-        self.invalidate_cloudfront(&self.config.cloudfront_static_id, &["/dist/*".into()])
+        let paths = ["/dist/*".into()];
+
+        self.invalidate_cloudfront(&self.config.cloudfront_static_id, &paths)?;
+        self.invalidate_fastly(&paths)?;
+
+        Ok(())
     }
 
     fn invalidate_cloudfront(&self, distribution_id: &str, paths: &[String]) -> Result<(), Error> {
@@ -592,6 +597,32 @@ impl Context {
         Ok(())
     }
 
+    fn invalidate_fastly(&self, paths: &[String]) -> Result<(), Error> {
+        // Fastly invalidations are opt-in while we test the integration
+        // Set PROMOTE_RELEASE_INVALIDATE_FASTLY=1 to enable them
+        if !self.config.invalidate_fastly {
+            return Ok(());
+        }
+
+        let mut fastly = match self.config.fastly() {
+            Some(fastly) => fastly,
+            None => {
+                println!();
+                println!("WARNING! Skipped Fastly invalidation of: {:?}", paths);
+                println!("Set PROMOTE_RELEASE_FASTLY_API_TOKEN and PROMOTE_RELEASE_FASTLY_STATIC_DOMAIN if you want to invalidate Fastly");
+                println!();
+                return Ok(());
+            }
+        };
+
+        for path in paths {
+            let path = path.replace('*', "");
+            fastly.purge(&path)?;
+        }
+
+        Ok(())
+    }
+
     fn tag_release(&mut self, rustc_commit: &str, signer: &mut Signer) -> Result<(), Error> {
         if self.config.channel != Channel::Stable {
             // We don't tag non-stable releases