packages feed

nova-cache-0.13.0.0: exe/Main.hs

module Main (main) where

import Control.Applicative ((<|>))
import Control.Exception (IOException, try)
import Data.Bifunctor (first)
import qualified Data.ByteString as BS
import Data.Maybe (fromMaybe)
import Data.String (fromString)
import Data.Text (Text)
import qualified Data.Text as T
import qualified Data.Text.Encoding as TE
import Network.Wai (Response)
import qualified Network.Wai.Handler.Warp as Warp
import Network.Wai.Middleware.RequestLogger (logStdout)
import NovaCache.Server (ServerConfig (..), cacheApp, defaultRootResponse, htmlRootResponse, onExceptionResponse)
import NovaCache.Signing (SecretKey, normalizeKeyText, parseSecretKey, renderPublicKey, toPublicKey)
import NovaCache.Store (newFileStore)
import System.Environment (getArgs, lookupEnv)
import System.Exit (exitFailure)
import System.IO (BufferMode (LineBuffering), hPutStrLn, hSetBuffering, stderr, stdout)
import Text.Read (readMaybe)

-- ---------------------------------------------------------------------------
-- Constants
-- ---------------------------------------------------------------------------

-- | Default server port.
defaultPort :: Int
defaultPort = 5000

-- | Default bind host.  @*@ binds every interface - the server's
-- historical behavior, kept as the default so existing deployments do
-- not silently rebind; a deployment opts into loopback itself via
-- @--host@ or @HOST@.
defaultBindHost :: String
defaultBindHost = "*"

-- | Default store directory.
defaultStoreRoot :: FilePath
defaultStoreRoot = "./nix-cache"

-- | The flag naming the HTML file @GET \/@ serves.
rootPageFlag :: String
rootPageFlag = "--root-page"

-- | Environment variable for the server port.
portEnvVar :: String
portEnvVar = "PORT"

-- | Environment variable for the bind host.
hostEnvVar :: String
hostEnvVar = "HOST"

-- | Environment variable for the store root directory.
storeEnvVar :: String
storeEnvVar = "NIX_CACHE_DIR"

-- | Environment variable for the write API key.
apiKeyEnvVar :: String
apiKeyEnvVar = "CACHE_API_KEY"

-- | Environment variable for the signing key file path.
signingKeyEnvVar :: String
signingKeyEnvVar = "SIGNING_KEY_FILE"

-- | Environment variable to disable request logging.
requestLogEnvVar :: String
requestLogEnvVar = "LOG_REQUESTS"

-- | A subcommand this executable does not have: the server reclaims
-- NARs itself, through @GET \/reclaim@ and @POST \/reclaim@.  Named so
-- that running it stops with a pointer to those requests rather than
-- reaching 'serve', which ignores arguments it does not know and would
-- start a second server over the store.
reclaimNarsCommand :: String
reclaimNarsCommand = "reclaim-nars"

-- ---------------------------------------------------------------------------
-- Main
-- ---------------------------------------------------------------------------

main :: IO ()
main = do
  args <- getArgs
  case args of
    command : _
      | command == reclaimNarsCommand -> do
          hPutStrLn stderr $
            "FATAL: "
              ++ reclaimNarsCommand
              ++ " is not a subcommand: the server removes unreferenced NARs itself."
              ++ " With the write key, GET /reclaim lists them and POST /reclaim removes them;"
              ++ " see the README."
          exitFailure
    _ -> serve args

-- | Run the cache server.
serve :: [String] -> IO ()
serve args = do
  -- Under systemd, stdout is a pipe to the journal, which GHC buffers by
  -- block.  The request logger flushes after each line it writes, so
  -- without this the startup lines would wait for the first request, or,
  -- with request logging off, for a block to fill.
  hSetBuffering stdout LineBuffering
  portEnv <- lookupEnv portEnvVar
  hostEnv <- lookupEnv hostEnvVar
  storeEnv <- lookupEnv storeEnvVar
  apiKeyEnv <- lookupEnv apiKeyEnvVar
  sigKeyPath <- lookupEnv signingKeyEnvVar
  logRequestsEnv <- lookupEnv requestLogEnvVar

  -- Order-independent flag parsing: take the value following a flag wherever it
  -- appears, so e.g. `--allow-open-writes --port 8080` still honours --port.
  let argValue flag = case dropWhile (/= flag) args of
        (_ : v : _) -> Just v
        _ -> Nothing
      port = case argValue "--port" >>= readMaybe of
        Just p -> p
        Nothing -> maybe defaultPort (fromMaybe defaultPort . readMaybe) portEnv
      bindHost = fromMaybe defaultBindHost (argValue "--host" <|> hostEnv)
      storeRoot = fromMaybe (fromMaybe defaultStoreRoot storeEnv) (argValue "--store")
      allowOpenWrites = "--allow-open-writes" `elem` args
      rootPage = argValue rootPageFlag

  store <- newFileStore storeRoot
  apiKey <- loadApiKey apiKeyEnv
  sigKey <- loadSigningKey sigKeyPath
  pubKey <- derivePublicKeyLine sigKey
  rootResponse <- loadRootResponse rootPage

  let cfg =
        ServerConfig
          { scStore = store,
            scApiKey = apiKey,
            scSigningKey = sigKey,
            scRootResponse = rootResponse
          }

  let logRequests = logRequestsEnv /= Just "0"
      requestLogger = if logRequests then logStdout else id

  putStrLn ("nova-cache-server listening on " ++ bindHost ++ ":" ++ show port)
  putStrLn ("store root: " ++ storeRoot)
  putStrLn ("signing: " ++ maybe "disabled" (const "enabled") sigKey)
  mapM_ (\k -> putStrLn ("public key: " ++ T.unpack k)) pubKey
  putStrLn ("write auth: " ++ maybe "disabled (open writes!)" (const "enabled") apiKey)
  putStrLn ("request logging: " ++ if logRequests then "enabled" else "disabled (LOG_REQUESTS=0)")
  putStrLn ("root page: " ++ fromMaybe "none, plain text" rootPage)

  case apiKey of
    Nothing
      | not allowOpenWrites -> do
          hPutStrLn stderr $
            "FATAL: "
              ++ apiKeyEnvVar
              ++ " is not set - refusing to start with unauthenticated writes. "
              ++ "Set "
              ++ apiKeyEnvVar
              ++ ", or pass --allow-open-writes to override (not recommended on a public host)."
          exitFailure
    _ -> pure ()

  let settings =
        Warp.setHost (fromString bindHost)
          $ Warp.setPort port
          $ Warp.setOnExceptionResponse onExceptionResponse Warp.defaultSettings
  Warp.runSettings settings (requestLogger (cacheApp cfg))

-- ---------------------------------------------------------------------------
-- Root response
-- ---------------------------------------------------------------------------

-- | The response for @GET \/@: the HTML file 'rootPageFlag' names, read
-- once at startup, or the library's line of plain text without one.  A
-- file that cannot be read stops the server at startup.
loadRootResponse :: Maybe FilePath -> IO (IO Response)
loadRootResponse Nothing = pure defaultRootResponse
loadRootResponse (Just path) = do
  readResult <- try (BS.readFile path) :: IO (Either IOException BS.ByteString)
  case readResult of
    Right page -> pure (htmlRootResponse page)
    Left err -> do
      hPutStrLn stderr ("FATAL: cannot read the root page " ++ path ++ ": " ++ show err)
      exitFailure

-- ---------------------------------------------------------------------------
-- Credential loading
-- ---------------------------------------------------------------------------

-- | Normalize and validate the write API key.  A key that normalizes to
-- empty (BOM or whitespace only - the classic copy-paste artifact) would
-- arm the auth gate with an empty secret that an empty bearer token
-- matches, so it is a startup error, never an armed guard.
loadApiKey :: Maybe String -> IO (Maybe BS.ByteString)
loadApiKey Nothing = pure Nothing
loadApiKey (Just raw)
  | T.null normalized = do
      hPutStrLn stderr $
        "FATAL: "
          ++ apiKeyEnvVar
          ++ " is set but empty after normalization - refusing to arm write auth with an empty key. "
          ++ "Set a real key, or unset it and pass --allow-open-writes to run open."
      exitFailure
  | otherwise = pure (Just (TE.encodeUtf8 normalized))
  where
    normalized = normalizeKeyText (T.pack raw)

-- | Load a signing key from a file, if configured.  A configured key that
-- fails to load is FATAL: falling back to unsigned would persist narinfos
-- no trust anchor can verify (the same fail-closed policy as signing).
loadSigningKey :: Maybe FilePath -> IO (Maybe SecretKey)
loadSigningKey Nothing = pure Nothing
loadSigningKey (Just path) = do
  raw <- BS.readFile path
  case first show (TE.decodeUtf8' raw) >>= parseSecretKey . normalizeKeyText of
    Left err -> do
      hPutStrLn stderr ("FATAL: cannot load the signing key from " ++ path ++ ": " ++ err)
      exitFailure
    Right sk -> pure (Just sk)

-- | Derive the rendered public key line from the signing key, if any,
-- for the startup log, so the key an operator publishes can be checked
-- against the key in use; on a derivation failure the log omits it.
derivePublicKeyLine :: Maybe SecretKey -> IO (Maybe Text)
derivePublicKeyLine Nothing = pure Nothing
derivePublicKeyLine (Just sk) = case toPublicKey sk of
  Left err -> do
    hPutStrLn stderr ("WARNING: cannot derive the public key from the signing key: " ++ err)
    pure Nothing
  Right pk -> pure (Just (renderPublicKey pk))