Add run_command_async (#993)

## 🎟️ Tracking

<!-- Paste the link to the Jira or GitHub issue or otherwise describe /
point to where this change is coming from. -->

## 📔 Objective

<!-- Describe what the purpose of this PR is, for example what bug
you're fixing or new feature you're adding. -->

- Bumps .NET to 8 (latest LTS)
- Uses `[LibraryImport]` for auto-marshalling of function
- Adds `run_command_async` method in `bitwarden-c` that allows for a
non-blocking call that can notify the caller when the action is
completed.
- `Task`-ifies one of the C# SDK calls into the SDK. 
- This only updates one method to be async for now but all of them can
be changed
- This is a breaking change so would be a good idea before a `1.0.0`
release.


## 📸 Screenshots

<!-- Required for any UI changes; delete if not applicable. Use fixed
width images for better display. -->

## ⏰ Reminders before review

- Contributor guidelines followed
- All formatters and local linters executed and passed
- Written new unit and / or integration tests where applicable
- Protected functional changes with optionality (feature flags)
- Used internationalization (i18n) for all UI strings
- CI builds passed
- Communicated to DevOps any deployment requirements
- Updated any necessary documentation (Confluence, contributing docs) or
informed the documentation
  team

## 🦮 Reviewer guidelines

<!-- Suggested interactions but feel free to use (or not) as you desire!
-->

- 👍 (`:+1:`) or similar for great changes
- 📝 (`:memo:`) or ℹ️ (`:information_source:`) for notes or general info
- ❓ (`:question:`) for questions
- 🤔 (`:thinking:`) or 💭 (`:thought_balloon:`) for more open inquiry
that's not quite a confirmed
  issue and could potentially benefit from discussion
- 🎨 (`:art:`) for suggestions / improvements
- ❌ (`:x:`) or ⚠️ (`:warning:`) for more significant problems or
concerns needing attention
- 🌱 (`:seedling:`) or ♻️ (`:recycle:`) for future improvements or
indications of technical debt
- ⛏ (`:pick:`) for minor or nitpick changes

---------

Co-authored-by: Oscar Hinton <[email protected]>

Author: justindbaur

Cargo.lock

@@ -1,6 +1,11 @@
-use std::{ffi::CStr, os::raw::c_char, str};
+use std::{
+    ffi::{CStr, CString},
+    os::raw::c_char,
+    str,
+};
 
 use bitwarden_json::client::Client;
+use tokio::task::JoinHandle;
 
 use crate::{box_ptr, ffi_ref};
 
@@ -28,6 +33,46 @@ pub extern "C" fn run_command(c_str_ptr: *const c_char, client_ptr: *const CClie
     }
 }
 
+type OnCompletedCallback = unsafe extern "C" fn(result: *mut c_char) -> ();
+
+#[no_mangle]
+pub extern "C" fn run_command_async(
+    c_str_ptr: *const c_char,
+    client_ptr: *const CClient,
+    on_completed_callback: OnCompletedCallback,
+    is_cancellable: bool,
+) -> *mut JoinHandle<()> {
+    let client = unsafe { ffi_ref!(client_ptr) };
+    let input_str = str::from_utf8(unsafe { CStr::from_ptr(c_str_ptr) }.to_bytes())
+        .expect("Input should be a valid string")
+        // Languages may assume that the string is collectable as soon as this method exits
+        // but it's not since the request will be run in the background
+        // so we need to make our own copy.
+        .to_owned();
+
+    let join_handle = client.runtime.spawn(async move {
+        let result = client.client.run_command(input_str.as_str()).await;
+        let str_result = match std::ffi::CString::new(result) {
+            Ok(cstr) => cstr.into_raw(),
+            Err(_) => panic!("failed to return comment result: null encountered"),
+        };
+
+        // run completed function
+        unsafe {
+            on_completed_callback(str_result);
+            let _ = CString::from_raw(str_result);
+        }
+    });
+
+    // We only want to box the join handle the caller has said that they may want to cancel,
+    // essentially promising to us that they will take care of the returned pointer.
+    if is_cancellable {
+        box_ptr!(join_handle)
+    } else {
+        std::ptr::null_mut()
+    }
+}
+
 // Init client, potential leak! You need to call free_mem after this!
 #[no_mangle]
 pub extern "C" fn init(c_str_ptr: *const c_char) -> *mut CClient {
@@ -56,3 +101,15 @@ pub extern "C" fn init(c_str_ptr: *const c_char) -> *mut CClient {
 pub extern "C" fn free_mem(client_ptr: *mut CClient) {
     std::mem::drop(unsafe { Box::from_raw(client_ptr) });
 }
+
+#[no_mangle]
+pub extern "C" fn abort_and_free_handle(join_handle_ptr: *mut tokio::task::JoinHandle<()>) -> () {
+    let join_handle = unsafe { Box::from_raw(join_handle_ptr) };
+    join_handle.abort();
+    std::mem::drop(join_handle);
+}
+
+#[no_mangle]
+pub extern "C" fn free_handle(join_handle_ptr: *mut tokio::task::JoinHandle<()>) -> () {
+    std::mem::drop(unsafe { Box::from_raw(join_handle_ptr) });
+}

crates/bitwarden-c/src/c.rs

@@ -25,5 +25,8 @@ schemars = { workspace = true }
 serde = { version = ">=1.0, <2.0", features = ["derive"] }
 serde_json = ">=1.0.96, <2.0"
 
+[target.'cfg(debug_assertions)'.dependencies]
+tokio = { version = "1.36.0", features = ["time"] }
+
 [lints]
 workspace = true

crates/bitwarden-json/Cargo.toml

@@ -85,6 +85,34 @@ impl Client {
                     client.generator().password(req).into_string()
                 }
             },
+            #[cfg(debug_assertions)]
+            Command::Debug(cmd) => {
+                use bitwarden::Error;
+
+                use crate::command::DebugCommand;
+
+                match cmd {
+                    DebugCommand::CancellationTest { duration_millis } => {
+                        use tokio::time::sleep;
+                        let duration = std::time::Duration::from_millis(duration_millis);
+                        sleep(duration).await;
+                        println!("After wait #1");
+                        sleep(duration).await;
+                        println!("After wait #2");
+                        sleep(duration).await;
+                        println!("After wait #3");
+                        Ok::<i32, Error>(42).into_string()
+                    }
+                    DebugCommand::ErrorTest {} => {
+                        use bitwarden::Error;
+
+                        Err::<i32, Error>(Error::Internal(std::borrow::Cow::Borrowed(
+                            "This is an error.",
+                        )))
+                        .into_string()
+                    }
+                }
+            }
         }
     }
 

crates/bitwarden-json/src/client.rs

@@ -33,6 +33,8 @@ pub enum Command {
     Projects(ProjectsCommand),
     #[cfg(feature = "secrets")]
     Generators(GeneratorsCommand),
+    #[cfg(debug_assertions)]
+    Debug(DebugCommand),
 }
 
 #[cfg(feature = "secrets")]
@@ -142,3 +144,11 @@ pub enum GeneratorsCommand {
     /// Returns: [String]
     GeneratePassword(PasswordGeneratorRequest),
 }
+
+#[cfg(debug_assertions)]
+#[derive(Serialize, Deserialize, JsonSchema, Debug)]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
+pub enum DebugCommand {
+    CancellationTest { duration_millis: u64 },
+    ErrorTest {},
+}

crates/bitwarden-json/src/command.rs

@@ -2,7 +2,7 @@
 
     <PropertyGroup>
         <OutputType>Exe</OutputType>
-        <TargetFramework>net6.0</TargetFramework>
+        <TargetFramework>net8.0</TargetFramework>
         <ImplicitUsings>enable</ImplicitUsings>
         <Nullable>enable</Nullable>
     </PropertyGroup>

languages/csharp/Bitwarden.Sdk.Samples/Bitwarden.Sdk.Samples.csproj

@@ -1,4 +1,4 @@
-using Bitwarden.Sdk;
+using Bitwarden.Sdk;
 
 // Get environment variables
 var identityUrl = Environment.GetEnvironmentVariable("IDENTITY_URL")!;
@@ -15,10 +15,10 @@
 });
 
 // Authenticate
-bitwardenClient.Auth.LoginAccessToken(accessToken, stateFile);
+await bitwardenClient.Auth.LoginAccessTokenAsync(accessToken, stateFile);
 
 // Projects List
-var projectsList = bitwardenClient.Projects.List(organizationId).Data;
+var projectsList = (await bitwardenClient.Projects.ListAsync(organizationId)).Data;
 Console.WriteLine("A list of all projects:");
 foreach (ProjectResponse pr in projectsList)
 {
@@ -30,17 +30,17 @@
 
 // Projects Create, Update, & Get
 Console.WriteLine("Creating and updating a project");
-var projectResponse = bitwardenClient.Projects.Create(organizationId, "NewTestProject");
-projectResponse = bitwardenClient.Projects.Update(organizationId, projectResponse.Id, "NewTestProject Renamed");
-projectResponse = bitwardenClient.Projects.Get(projectResponse.Id);
+var projectResponse = await bitwardenClient.Projects.CreateAsync(organizationId, "NewTestProject");
+projectResponse = await bitwardenClient.Projects.UpdateAsync(organizationId, projectResponse.Id, "NewTestProject Renamed");
+projectResponse = await bitwardenClient.Projects.GetAsync(projectResponse.Id);
 Console.WriteLine("Here is the project we created and updated:");
 Console.WriteLine(projectResponse.Name);
 
 Console.Write("Press enter to continue...");
 Console.ReadLine();
 
 // Secrets list
-var secretsList = bitwardenClient.Secrets.List(organizationId).Data;
+var secretsList = (await bitwardenClient.Secrets.ListAsync(organizationId)).Data;
 Console.WriteLine("A list of all secrets:");
 foreach (SecretIdentifierResponse sr in secretsList)
 {
@@ -52,22 +52,22 @@
 
 // Secrets Create, Update, Get
 Console.WriteLine("Creating and updating a secret");
-var secretResponse = bitwardenClient.Secrets.Create(organizationId, "New Secret", "the secret value", "the secret note", new[] { projectResponse.Id });
-secretResponse = bitwardenClient.Secrets.Update(organizationId, secretResponse.Id, "New Secret Name", "the secret value", "the secret note", new[] { projectResponse.Id });
-secretResponse = bitwardenClient.Secrets.Get(secretResponse.Id);
+var secretResponse = await bitwardenClient.Secrets.CreateAsync(organizationId, "New Secret", "the secret value", "the secret note", new[] { projectResponse.Id });
+secretResponse = await bitwardenClient.Secrets.UpdateAsync(organizationId, secretResponse.Id, "New Secret Name", "the secret value", "the secret note", new[] { projectResponse.Id });
+secretResponse = await bitwardenClient.Secrets.GetAsync(secretResponse.Id);
 Console.WriteLine("Here is the secret we created and updated:");
 Console.WriteLine(secretResponse.Key);
 
 Console.Write("Press enter to continue...");
 Console.ReadLine();
 
 // Secrets GetByIds
-var secretsResponse = bitwardenClient.Secrets.GetByIds(new[] { secretResponse.Id });
+var secretsResponse = await bitwardenClient.Secrets.GetByIdsAsync(new[] { secretResponse.Id });
 
 // Secrets Sync
-var syncResponse = bitwardenClient.Secrets.Sync(organizationId, null);
+var syncResponse = await bitwardenClient.Secrets.SyncAsync(organizationId, null);
 
 // Secrets & Projects Delete
 Console.WriteLine("Deleting our secret and project");
-bitwardenClient.Secrets.Delete(new[] { secretResponse.Id });
-bitwardenClient.Projects.Delete(new[] { projectResponse.Id });
+await bitwardenClient.Secrets.DeleteAsync(new[] { secretResponse.Id });
+await bitwardenClient.Projects.DeleteAsync(new[] { projectResponse.Id });

languages/csharp/Bitwarden.Sdk.Samples/Program.cs

@@ -0,0 +1,29 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+
+    <IsPackable>false</IsPackable>
+    <IsTestProject>true</IsTestProject>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.6.0" />
+    <PackageReference Include="xunit" Version="2.4.2" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.5">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+    <PackageReference Include="coverlet.collector" Version="6.0.0">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Bitwarden.Sdk\Bitwarden.Sdk.csproj" />
+  </ItemGroup>
+
+</Project>

languages/csharp/Bitwarden.Sdk.Tests/Bitwarden.Sdk.Tests.csproj

@@ -0,0 +1 @@
+global using Xunit;

languages/csharp/Bitwarden.Sdk.Tests/GlobalUsings.cs

@@ -0,0 +1,35 @@
+using Bitwarden.Sdk;
+using System.Diagnostics;
+
+namespace Bitwarden.Sdk.Tests;
+
+public class InteropTests
+{
+    [Fact]
+    public async void CancelingTest_ThrowsTaskCanceledException()
+    {
+        var client = new BitwardenClient();
+
+        var cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(250));
+
+        await Assert.ThrowsAsync<TaskCanceledException>(async () => await client.CancellationTestAsync(cts.Token));
+    }
+
+    [Fact]
+    public async void NoCancel_TaskCompletesSuccessfully()
+    {
+        var client = new BitwardenClient();
+
+        var result = await client.CancellationTestAsync(CancellationToken.None);
+        Assert.Equal(42, result);
+    }
+
+    [Fact]
+    public async void Error_ThrowsException()
+    {
+        var client = new BitwardenClient();
+
+        var bitwardenException = await Assert.ThrowsAsync<BitwardenException>(async () => await client.ErrorTestAsync());
+        Assert.Equal("Internal error: This is an error.", bitwardenException.Message);
+    }
+}