Add some common utilities for working w/ aws libraries (#24)

Author: quinnj

Project.toml

@@ -1,6 +1,6 @@
 name = "LibAwsCommon"
 uuid = "c6e421ba-b5f8-4792-a1c4-42948de3ed9d"
-version = "1.2.4"
+version = "1.3.0"
 
 [deps]
 CEnum = "fa961155-64e5-5f13-b03f-caf6b980ea82"

src/LibAwsCommon.jl

@@ -71,4 +71,105 @@ function init(allocator=default_aws_allocator())
     return
 end
 
+# utilities for interacting with AWS library APIs
+
+# like a Ref, but for a field of a struct
+# many AWS APIs take a pointer to an aws struct, so this makes it convenient to to pass
+# a field of a wrapper struct to a library function
+struct FieldRef{T, S}
+    x::T
+    field::Symbol
+
+    function FieldRef(x::T, field::Symbol) where {T}
+        @assert isconcretetype(T) && ismutabletype(T) "only fields of mutable types are supported with FieldRef"
+        S = fieldtype(T, field)
+        @assert isconcretetype(S) && !ismutabletype(S) "field type must be concrete and immutable for FieldRef"
+        return new{T, S}(x, field)
+    end
+end
+
+function Base.unsafe_convert(P::Union{Type{Ptr{S}},Type{Ptr{Cvoid}}}, x::FieldRef{T, S}) where {T, S}
+    return P(pointer_from_objref(x.x) + fieldoffset(T, Base.fieldindex(T, x.field)))
+end
+
+Base.pointer(x::FieldRef{S, T}) where {S, T} = Base.unsafe_convert(Ptr{T}, x)
+
+# wraps a pointer to a struct and allows get/set on fields w/o unsafe_loading the entire struct
+struct StructRef{T}
+    ptr::Ptr{T}
+
+    function StructRef(ptr::Ptr{T}) where {T}
+        @assert isconcretetype(T) "only concrete struct types are supported with StructRef"
+        return new{T}(ptr)
+    end
+end
+
+function Base.getproperty(x::StructRef{T}, k::Symbol) where {T}
+    S = fieldtype(T, k)
+    @assert isconcretetype(S) && !ismutabletype(S) "field type must be concrete and immutable for StructRef"
+    return unsafe_load(Ptr{S}(Ptr{UInt8}(getfield(x, :ptr)) + fieldoffset(T, Base.fieldindex(T, k))))
+end
+
+function Base.setproperty!(x::StructRef{T}, k::Symbol, v) where {T}
+    S = fieldtype(T, k)
+    @assert isconcretetype(S) && !ismutabletype(S) "field type must be concrete and immutable for StructRef"
+    unsafe_store!(Ptr{S}(Ptr{UInt8}(getfield(x, :ptr)) + fieldoffset(T, Base.fieldindex(T, k))), convert(S, v))
+    return v
+end
+
+# simple threadsafe Future impl appropriate for use with the common callback patterns in AWS libs
+mutable struct Future{T}
+    const notify::Threads.Condition
+    @atomic set::Int8 # if 0, result is undefined, 1 means result is T, 2 means result is an exception
+    result::Union{Exception, T} # undefined initially
+    Future{T}() where {T} = new{T}(Threads.Condition(), 0)
+end
+
+Base.pointer(f::Future) = pointer_from_objref(f)
+Future(ptr::Ptr) = unsafe_pointer_to_objref(ptr)::Future
+Future{T}(ptr::Ptr) where {T} = unsafe_pointer_to_objref(ptr)::Future{T}
+
+function Base.wait(f::Future{T}) where {T}
+    set = @atomic f.set
+    set == 1 && return f.result::T
+    set == 2 && throw(f.result::Exception)
+    lock(f.notify) # acquire barrier
+    try
+        set = f.set
+        set == 1 && return f.result::T
+        set == 2 && throw(f.result::Exception)
+        wait(f.notify)
+    finally
+        unlock(f.notify) # release barrier
+    end
+    if f.set == 1
+        return f.result::T
+    else
+        @assert isdefined(f, :result)
+        throw(f.result::Exception)
+    end
+end
+
+capture(e::Exception) = CapturedException(e, Base.backtrace())
+
+function Base.notify(f::Future{T}, x::Union{Exception, T}) where {T}
+    lock(f.notify) # acquire barrier
+    try
+        if f.set == Int8(0)
+            if x isa Exception
+                set = Int8(2)
+                f.result = x
+            else
+                set = Int8(1)
+                f.result = x
+            end
+            @atomic :release f.set = set
+            notify(f.notify)
+        end
+    finally
+        unlock(f.notify)
+    end
+    nothing
+end
+
 end

test/runtests.jl

@@ -1,4 +1,10 @@
 using Test, Aqua, LibAwsCommon
+import LibAwsCommon: FieldRef, StructRef, Future
+
+mutable struct Job
+    name::String
+    wage::Float64
+end
 
 @testset "LibAwsCommon" begin
     @testset "aqua" begin
@@ -18,4 +24,30 @@ using Test, Aqua, LibAwsCommon
             @test isfile(logpath) # might as well check this but we're mainly testing we don't crash
         end
     end
+    @testset "FieldRef/StructRef" begin
+        job = Job("plumber", 50000.0)
+        GC.@preserve job begin
+            @test_throws AssertionError FieldRef(job, :name)
+            wage_field = FieldRef(job, :wage)
+            @test pointer(wage_field) isa Ptr{Float64}
+            @test unsafe_load(pointer(wage_field)) == 50000.0
+            @test_throws AssertionError StructRef(Ptr{Any}(pointer_from_objref(job)))
+            job_ref = StructRef(Ptr{Job}(pointer_from_objref(job)))
+            @test job_ref.wage == 50000.0
+        end
+    end
+    @testset "Future" begin
+        f = Future{Int}()
+        t = Threads.@spawn wait(f)
+        @test !istaskdone(t)
+        notify(f, 10)
+        @test fetch(t) == 10
+        @test wait(f) == 10
+        f2 = Future{Int}()
+        t2 = Threads.@spawn wait(f2)
+        @test !istaskdone(t2)
+        notify(f2, ArgumentError("Error!"))
+        @test_throws TaskFailedException fetch(t2)
+        @test_throws ArgumentError wait(f2)
+    end
 end