feat: windows service installation [NR-485539] (#1880)

Author: sigilioso

.goreleaser.yml

@@ -97,6 +97,11 @@ archives:
     builds:
       - newrelic-agent-control-windows
       - newrelic-agent-control-cli-windows
+    files:
+      - src: build/package/windows/install.ps1
+        dst: install.ps1
+      - src: build/package/windows/uninstall.ps1
+        dst: uninstall.ps1
 
 nfpms: # deb and rpm are only built for linux targets
   - package_name: newrelic-agent-control

Cargo.lock

@@ -2740,6 +2740,13 @@ Distributed under the following license(s):
 
 * CDLA-Permissive-2.0
 
+## widestring <https://crates.io/crates/widestring>
+
+Distributed under the following license(s):
+
+* MIT
+* Apache-2.0
+
 ## windows <https://crates.io/crates/windows>
 
 Distributed under the following license(s):
@@ -2803,6 +2810,13 @@ Distributed under the following license(s):
 * MIT
 * Apache-2.0
 
+## windows-service <https://crates.io/crates/windows-service>
+
+Distributed under the following license(s):
+
+* MIT
+* Apache-2.0
+
 ## windows-strings <https://crates.io/crates/windows-strings>
 
 Distributed under the following license(s):

THIRD_PARTY_NOTICES.md

@@ -84,6 +84,7 @@ windows = { workspace = true, features = [
   "Win32_System_Console",
   "Win32_System_Threading",
 ] }
+windows-service = "0.8.0"
 
 [target.'cfg(target_os = "windows")'.dependencies]
 windows-sys = { workspace = true }

agent-control/Cargo.toml

@@ -3,7 +3,6 @@
 //! It implements the basic functionality of parsing the command line arguments and either
 //! performing one-shot actions or starting the main agent control process.
 #![warn(missing_docs)]
-
 use newrelic_agent_control::agent_control::run::on_host::AGENT_CONTROL_MODE_ON_HOST;
 use newrelic_agent_control::agent_control::run::{AgentControlRunConfig, AgentControlRunner};
 use newrelic_agent_control::command::Command;
@@ -16,8 +15,38 @@ use std::error::Error;
 use std::process::ExitCode;
 use tracing::{error, info, trace};
 
+#[cfg(target_os = "windows")]
+use newrelic_agent_control::command::windows::{WINDOWS_SERVICE_NAME, setup_windows_service};
+
+#[cfg(target_os = "windows")]
+windows_service::define_windows_service!(ffi_service_main, service_main);
+
 fn main() -> ExitCode {
-    Command::run(AGENT_CONTROL_MODE_ON_HOST, _main)
+    #[cfg(target_family = "unix")]
+    {
+        Command::run(AGENT_CONTROL_MODE_ON_HOST, _main)
+    }
+
+    #[cfg(target_os = "windows")]
+    {
+        if windows_service::service_dispatcher::start(WINDOWS_SERVICE_NAME, ffi_service_main)
+            .is_err()
+        {
+            // Not running as Windows Service, run normally
+            return Command::run(AGENT_CONTROL_MODE_ON_HOST, |cfg, tracer| {
+                _main(cfg, tracer, false)
+            });
+        }
+        ExitCode::SUCCESS
+    }
+}
+
+#[cfg(target_os = "windows")]
+/// Entry-point for Windows Service
+fn service_main(_arguments: Vec<std::ffi::OsString>) {
+    let _ = Command::run(AGENT_CONTROL_MODE_ON_HOST, |cfg, tracer| {
+        _main(cfg, tracer, true)
+    });
 }
 
 /// This is the actual main function.
@@ -33,6 +62,7 @@ fn main() -> ExitCode {
 fn _main(
     agent_control_run_config: AgentControlRunConfig,
     _tracer: Vec<TracingGuardBox>, // Needs to take ownership of the tracer as it can be shutdown on drop
+    #[cfg(target_os = "windows")] as_windows_service: bool,
 ) -> Result<(), Box<dyn Error>> {
     #[cfg(not(feature = "disable-asroot"))]
     if !is_elevated()? {
@@ -52,12 +82,22 @@ fn _main(
     let (application_event_publisher, application_event_consumer) = pub_sub();
 
     trace!("creating the signal handler");
-    create_shutdown_signal_handler(application_event_publisher)?;
+    create_shutdown_signal_handler(application_event_publisher.clone())?;
+
+    #[cfg(target_os = "windows")]
+    let tear_down_windows_service = as_windows_service
+        .then(|| setup_windows_service(application_event_publisher))
+        .transpose()?;
 
     // Create the actual agent control runner with the rest of required configs and the application_event_consumer
     AgentControlRunner::new(agent_control_run_config, application_event_consumer)?.run()?;
 
-    info!("exiting gracefully");
+    #[cfg(target_os = "windows")]
+    if let Some(tear_down_fn) = tear_down_windows_service {
+        tear_down_fn()?;
+    }
+
+    info!("Exiting gracefully");
 
     Ok(())
 }

agent-control/src/bin/main_onhost.rs

@@ -25,6 +25,9 @@ use std::process::ExitCode;
 use std::sync::Arc;
 use tracing::{error, info};
 
+#[cfg(target_os = "windows")]
+pub mod windows;
+
 /// All possible errors that can happen while running the initialization.
 #[derive(Debug, thiserror::Error)]
 pub enum InitError {

agent-control/src/command.rs

@@ -0,0 +1,85 @@
+//! This module contains functions to handle the Windows version of the main, which involves a Windows Service
+//! running mode.
+
+use crate::event::ApplicationEvent;
+use crate::event::channel::EventPublisher;
+use std::error::Error;
+use tracing::error;
+use windows_service::{
+    service::{
+        ServiceControl, ServiceControlAccept, ServiceExitCode, ServiceState, ServiceStatus,
+        ServiceType,
+    },
+    service_control_handler::{self, ServiceControlHandlerResult},
+};
+
+/// Defines the name for the Windows Service.
+pub const WINDOWS_SERVICE_NAME: &str = "newrelic-agent-control";
+
+/// Type alias to simplify [setup_windows_service] definition.
+type WinServiceResult = Result<(), Box<dyn Error>>;
+
+/// Sets up the Windows Service by creating the status handler and setting the service status as [WindowsServiceStatus::Running].
+/// It returns a function to tear the service down when the Agent Control finishes its execution.
+pub fn setup_windows_service(
+    application_event_publisher: EventPublisher<ApplicationEvent>,
+) -> Result<impl Fn() -> WinServiceResult, Box<dyn Error>> {
+    let windows_status_handler = service_control_handler::register(
+        WINDOWS_SERVICE_NAME,
+        windows_event_handler(application_event_publisher),
+    )?;
+    windows_status_handler.set_service_status(WindowsServiceStatus::Running.into())?;
+
+    Ok(move || {
+        // TODO: check if we should inform of stop-requested in case the graceful shutdown takes too long.
+        windows_status_handler.set_service_status(WindowsServiceStatus::Stopped.into())?;
+        Ok(())
+    })
+}
+
+/// Handles windows services events and stops the Agent Control if the specific events are received.
+/// See the '[Service Control Handler Function](https://learn.microsoft.com/en-us/windows/win32/services/service-control-handler-function)'
+/// page for details.
+pub fn windows_event_handler(
+    publisher: EventPublisher<ApplicationEvent>,
+) -> impl Fn(ServiceControl) -> ServiceControlHandlerResult {
+    move |event: ServiceControl| -> ServiceControlHandlerResult {
+        match event {
+            ServiceControl::Stop => {
+                let _ = publisher
+                    .publish(ApplicationEvent::StopRequested)
+                    .inspect_err(|err| error!("Could not send agent control stop request {err}"));
+                ServiceControlHandlerResult::NoError
+            }
+            // Interrogate needs to return `NoError` even if it is a No-Op operation.
+            ServiceControl::Interrogate => ServiceControlHandlerResult::NoError,
+            _ => ServiceControlHandlerResult::NotImplemented,
+        }
+    }
+}
+
+/// Internal, simplified representation of [ServiceStatus]
+pub enum WindowsServiceStatus {
+    /// Represents that the service is running
+    Running,
+    /// Represents that the service is stopped
+    Stopped,
+}
+
+impl From<WindowsServiceStatus> for ServiceStatus {
+    fn from(value: WindowsServiceStatus) -> Self {
+        let (current_state, controls_accepted) = match value {
+            WindowsServiceStatus::Running => (ServiceState::Running, ServiceControlAccept::STOP),
+            WindowsServiceStatus::Stopped => (ServiceState::Stopped, ServiceControlAccept::empty()),
+        };
+        ServiceStatus {
+            service_type: ServiceType::OWN_PROCESS,
+            current_state,
+            controls_accepted,
+            exit_code: ServiceExitCode::Win32(0),
+            checkpoint: 0,
+            wait_hint: std::time::Duration::default(),
+            process_id: None,
+        }
+    }
+}

agent-control/src/command/windows.rs

@@ -0,0 +1,71 @@
+# PowerShell script to install New Relic Agent Control as a Windows Service
+# Run this script with Administrator privileges
+
+param(
+    [Parameter(Mandatory=$false)]
+    [switch]$ServiceOverwrite = $false
+)
+
+# Check for administrator privileges
+$currentPrincipal = New-Object Security.Principal.WindowsPrincipal([Security.Principal.WindowsIdentity]::GetCurrent())
+if (-not $currentPrincipal.IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)) {
+    Write-Error "Admin permission is required. Please, open a Windows PowerShell session with administrative rights.";
+    exit 1
+}
+
+$serviceName = "newrelic-agent-control"
+$serviceDisplayName = "New Relic Agent Control"
+
+$acDir = [IO.Path]::Combine($env:ProgramFiles, 'New Relic\newrelic-agent-control')
+$acLocalConfigDir = [IO.Path]::Combine($acDir, 'local-data\agent-control')
+$acExecPath = [IO.Path]::Combine($acDir, 'newrelic-agent-control.exe')
+
+$acDataDir = [IO.Path]::Combine($env:ProgramData, 'New Relic\newrelic-agent-control')
+$acLogsDir = [IO.Path]::Combine($acDataDir, 'logs')
+
+# If the service already exists and overwriting is allowed, the service is stopped and removed.
+$existingService = Get-Service -Name $serviceName -ErrorAction SilentlyContinue
+if ($existingService) {
+    if ($ServiceOverwrite -eq $false)
+    {
+        "service $serviceName already exists. Use flag '-ServiceOverwrite' to update it"
+        exit 1
+    }
+    Write-Host "Service '$serviceName' already exists. Stopping and removing..."
+    Stop-Service $serviceName | Out-Null
+
+    $serviceToRemove = Get-WmiObject -Class Win32_Service -Filter "name='$serviceName'"
+    if ($serviceToRemove)
+    {
+        $serviceToRemove.delete() | Out-Null
+    }
+}
+
+$versionData = (& ".\newrelic-agent-control.exe" --version) -replace ',.*$', ''
+Write-Host "Installing $versionData"
+
+Write-Host "Creating New Relic Agent Control directories..."
+
+[System.IO.Directory]::CreateDirectory("$acDir") | Out-Null
+[System.IO.Directory]::CreateDirectory("$acDataDir") | Out-Null
+[System.IO.Directory]::CreateDirectory("$acLogsDir") | Out-Null
+[System.IO.Directory]::CreateDirectory("$acLocalConfigDir") | Out-Null
+
+Write-Host "Copying New Relic Agent Control program files..."
+Copy-Item -Path ".\newrelic-agent-control.exe" -Destination "$acDir"
+
+# Generate configuration
+# TODO: make this configurable through ps1 arguments (identity related args, region, ...)
+& ".\newrelic-agent-control-cli.exe" generate-config --fleet-disabled --region us --agent-set no-agents --output-path "`"$acLocalConfigDir\local_config.yaml`""
+
+# Install the service
+Write-Host "Installing New Relic Agent Control service..."
+New-Service -Name $serviceName -DisplayName "$serviceDisplayName" -BinaryPathName "$acExecPath" -StartupType Automatic | Out-Null
+if ($?)
+{
+    Start-Service -Name $serviceName | Out-Null
+    Write-Host "Installation completed!"
+} else {
+    Write-Host "Error creating service $serviceName"
+    exit 1
+}

build/package/windows/install.ps1

@@ -0,0 +1,34 @@
+# PowerShell script to uninstall the New Relic Agent Control Windows Service
+# Run this script with Administrator privileges
+
+# Check for administrator privileges
+$currentPrincipal = New-Object Security.Principal.WindowsPrincipal([Security.Principal.WindowsIdentity]::GetCurrent())
+if (-not $currentPrincipal.IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)) {
+    Write-Error "Admin permission is required. Please, open a Windows PowerShell session with administrative rights.";
+    exit 1
+}
+
+$serviceName = "newrelic-agent-control"
+$acDir = [IO.Path]::Combine($env:ProgramFiles, 'New Relic\newrelic-agent-control')
+$acExecPath = [IO.Path]::Combine($acDir, 'newrelic-agent-control.exe')
+
+# Stop and remove the service if exists
+$existingService = Get-Service -Name $serviceName -ErrorAction SilentlyContinue
+if ($existingService) {
+    Write-Host "Stopping and removing $serviceName..."
+    Stop-Service $serviceName | Out-Null
+
+    $serviceToRemove = Get-WmiObject -Class Win32_Service -Filter "name='$serviceName'"
+    if ($serviceToRemove)
+    {
+        $serviceToRemove.delete() | Out-Null
+    }
+}
+
+# Remove the executable if exists
+if (Test-Path $acExecPath) {
+    Write-Host "Deleting $acExecPath..."
+    Remove-Item -Path $acExecPath -Force
+}
+
+Write-Host "Uninstallation completed!"