tanker-core 2.30.0 → 2.31.0.beta.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3f4f72b76b69cec6b590fb140b06e8d7ae2a1a80bf5460683ea4adb4fcba8ea6
-  data.tar.gz: d2e0dda686b6d71ae27714c7a1dd904f65e2a78c76622511e52033fc278fd213
+  metadata.gz: 3e052ab81cc7efc4ff4c223486bf8c92500d14120c16362eee5745bb0d990a58
+  data.tar.gz: b9bc2facb9a7f2290cbe4e579c0b900a7b9ad95f853979fc62813f2975d4648f
 SHA512:
-  metadata.gz: 26082b813a8874586abd5e149dc2f60db53b96b3ddaf5d426b21865d6457e23155fa35ea757723127678e3075dddc27dbd883829153e34f8b25ccaf5c6760c43
-  data.tar.gz: 585fff8b0fa829e199747f3bbfe4b9110d5c2171fda2029d628f3ee306789d4991d28c3309912a778851cc614d961345f3d31082d95a8b09b36e76b1dde2b7d3
+  metadata.gz: 5a561e723d259795bec3a01cc1d05efcaee57f42357e1fbd9dfdf8e5301156d214a1e1fa46413e383e503c373d10bb525f33abad80f9327ed54b1d1ba949d14b
+  data.tar.gz: 02c800022efc4505a95393bcc2e1c43a988df20a7966ba34834a948b68c6c50e41e99edbc5432141c36b2fdfac8c3e15d3874eeb967b67672c0653a222d16d67

data/lib/tanker/c_tanker/{c_backends.rb → c_datastore.rb}

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 require 'ffi'
-require 'tanker/core/verification'
-require 'tanker/c_tanker/c_string'
 
 module Tanker
   module CTanker
@@ -15,11 +13,5 @@ module Tanker
              :put_cache_values, :pointer,
              :find_cache_values, :pointer
     end
-
-    class CHttpOptions < FFI::Struct
-      layout :send_request, :pointer,
-             :cancel_request, :pointer,
-             :data, :pointer
-    end
   end
 end

data/lib/tanker/c_tanker/c_http.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'ffi'
+
+module Tanker
+  module CTanker
+    extend FFI::Library
+
+    class CHttpRequest < FFI::Struct
+      layout :method, :string,
+             :url, :string,
+             :instance_id, :string,
+             :authorization, :string,
+             :body, :pointer,
+             :body_size, :int32
+    end
+
+    class CHttpResponse < FFI::Struct
+      def self.new_ok(status_code:, content_type:, body:)
+        new nil, status_code, content_type, body
+      end
+
+      def self.new_error(msg)
+        new msg, nil, nil, nil
+      end
+
+      def initialize(error_msg, status_code, content_type, body)
+        super()
+
+        if error_msg
+          @error_msg = CTanker.new_cstring(error_msg)
+          self[:error_msg] = @error_msg
+        else
+          @content_type = CTanker.new_cstring content_type
+          @body = FFI::MemoryPointer.from_string(body)
+
+          self[:error_msg] = nil
+          self[:content_type] = @content_type
+          self[:body] = @body
+          self[:body_size] = body.bytesize
+          self[:status_code] = status_code
+        end
+      end
+
+      layout :error_msg, :pointer,
+             :content_type, :pointer,
+             :body, :pointer,
+             :body_size, :int64,
+             :status_code, :int32
+    end
+
+    typedef :pointer, :http_request_handle
+
+    callback :http_send_request, [CHttpRequest, :pointer], :http_request_handle
+    callback :http_cancel_request, [CHttpRequest, :http_request_handle, :pointer], :void
+
+    class CHttpOptions < FFI::Struct
+      layout :send_request, :http_send_request,
+             :cancel_request, :http_cancel_request,
+             :data, :pointer
+
+      def initialize(send_request, cancel_request)
+        super()
+
+        self[:send_request] = send_request
+        self[:cancel_request] = cancel_request
+        self[:data] = nil
+      end
+    end
+  end
+end

data/lib/tanker/c_tanker/c_lib.rb

@@ -1,10 +1,24 @@
 # frozen_string_literal: true
 
+require 'ffi'
 require 'ffi/platform'
 
-module Tanker::CTanker
-  def self.get_path(name)
-    File.expand_path "../../../vendor/tanker/#{FFI::Platform::OS}-#{FFI::Platform::ARCH}/"\
-                     "#{FFI::Platform::LIBPREFIX}#{name}.#{FFI::Platform::LIBSUFFIX}", __dir__
+module FFI::Library
+  # Marking a function blocking releases the global Ruby lock.
+  # This is required for every function that could invoke a callback (including log handler) in another thread
+  def blocking_attach_function(func, args, returns = nil)
+    attach_function func, args, returns, blocking: true
+  end
+end
+
+module Tanker
+  module CTanker
+    def self.get_path(name)
+      File.expand_path "../../../vendor/tanker/#{FFI::Platform::OS}-#{FFI::Platform::ARCH}/"\
+                       "#{FFI::Platform::LIBPREFIX}#{name}.#{FFI::Platform::LIBSUFFIX}", __dir__
+    end
+
+    extend FFI::Library
+    ffi_lib get_path('ctanker')
   end
 end

data/lib/tanker/c_tanker.rb

@@ -1,30 +1,19 @@
 # frozen_string_literal: true
 
 require 'ffi'
+require_relative 'c_tanker/c_lib'
 require_relative 'core/options'
 require_relative 'sharing_options'
 require_relative 'encryption_options'
 require_relative 'verification_options'
-require_relative 'c_tanker/c_lib'
 require_relative 'c_tanker/c_future'
 require_relative 'c_tanker/c_verification'
 require_relative 'c_tanker/c_verification_method'
 require_relative 'c_tanker/c_log_record'
 require_relative 'c_tanker/c_device_info'
 
-module FFI::Library
-  # Marking a function blocking releases the global Ruby lock.
-  # This is required for every function that could invoke a callback (including log handler) in another thread
-  def blocking_attach_function(func, args, returns = nil)
-    attach_function func, args, returns, blocking: true
-  end
-end
-
 module Tanker
   module CTanker
-    extend FFI::Library
-    ffi_lib get_path('ctanker')
-
     typedef :pointer, :session_pointer
     typedef :pointer, :enc_sess_pointer
     typedef :pointer, :stream_pointer
@@ -99,6 +88,8 @@ module Tanker
 
     blocking_attach_function :tanker_set_log_handler, [:log_handler_callback], :void
 
+    blocking_attach_function :tanker_http_handle_response, [CHttpRequest, CHttpResponse], :void
+
     blocking_attach_function :tanker_prehash_password, [:string], CFuture
 
     blocking_attach_function :tanker_free_buffer, [:pointer], :void

data/lib/tanker/core/http.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require 'faraday'
+
+module Tanker
+  module Http
+    class HttpRequest
+      @@mutex = Mutex.new # rubocop:disable Style/ClassVars I have no idea why you don't like class vars
+      @@current_request_id = 0 # rubocop:disable Style/ClassVars
+      # Hash(id => request)
+      @@running_requests = {} # rubocop:disable Style/ClassVars
+
+      attr_reader :id
+      attr_reader :method
+      attr_reader :url
+      attr_reader :instance_id
+      attr_reader :authorization
+      attr_reader :body
+      attr_reader :crequest
+
+      def self.method_str_to_symbol(method)
+        case method
+        when 'GET' then :get
+        when 'POST' then :post
+        when 'PATCH' then :patch
+        when 'PUT' then :put
+        when 'DELETE' then :delete
+        else raise "unknown HTTP method #{method}"
+        end
+      end
+
+      def initialize(crequest:)
+        @@mutex.synchronize do
+          @@current_request_id += 1 # rubocop:disable Style/ClassVars
+          @id = @@current_request_id
+          @@running_requests[@id] = self
+        end
+
+        @method = self.class.method_str_to_symbol crequest[:method]
+        @url = crequest[:url]
+        @instance_id = crequest[:instance_id]
+        @authorization = crequest[:authorization]
+        @body = crequest[:body].read_string_length(crequest[:body_size])
+
+        # Keep the crequest because we need its address to answer to Tanker
+        @crequest = crequest
+      end
+
+      # Since Ruby's HTTP libraries are not asynchronous, they do not support cancelation either.
+      # When a request is canceled, we let it run until the end, and then we discard its result.
+      def self.cancel(id)
+        @@mutex.synchronize do
+          @@running_requests.delete id
+        end
+      end
+
+      def complete_if_not_canceled(&block)
+        @@mutex.synchronize do
+          unless @@running_requests.delete @id
+            # Request has been canceled, don't call Tanker back
+            return
+          end
+
+          block.call
+        end
+      end
+    end
+
+    module ThreadPool
+      THREAD_POOL_SIZE = 4
+
+      def self.thread_loop
+        loop do
+          work = @queue.pop
+          work.call
+        end
+      end
+
+      def self.push(proc)
+        @queue << proc
+      end
+
+      # Queue is a concurrent queue in Ruby
+      @queue = Queue.new
+      @http_thread_pool = THREAD_POOL_SIZE.times do
+        Thread.new do
+          thread_loop
+        end
+      end
+    end
+
+    class Client
+      attr_reader :tanker_http_options
+
+      def initialize(sdk_type, sdk_version, faraday_adapter)
+        @sdk_type = sdk_type
+        @sdk_version = sdk_version
+        @conn = Faraday.new do |conn|
+          conn.adapter faraday_adapter || Faraday.default_adapter
+        end
+
+        # This could be a proc, but for some reason, ffi gives the wrong type
+        # for crequest if we don't specify it explicitly here
+        @c_send_request = FFI::Function.new(:pointer, [CTanker::CHttpRequest.by_ref, :pointer]) do |crequest, cdata|
+          next send_request crequest, cdata
+        rescue Exception => e # rubocop:disable Lint/RescueException I do want to rescue all exceptions
+          cresponse = CTanker::CHttpResponse.new_error e.message
+          CTanker.tanker_http_handle_response(crequest, cresponse)
+        end
+        @c_cancel_request = proc do |crequest, request_id, cdata|
+          cancel_request crequest, request_id, cdata
+        rescue Exception => e # rubocop:disable Lint/RescueException I do want to rescue all exceptions
+          # This is not recoverable and won't be logged by FFI, let's do our best and log it here just before we crash
+          puts "fatal error when canceling HTTP request:\n#{e.full_message}"
+          raise
+        end
+
+        @tanker_http_options = CTanker::CHttpOptions.new @c_send_request, @c_cancel_request
+      end
+
+      def process_request(request)
+        fresponse = Faraday.run_request(request.method, request.url, request.body, {
+          'X-Tanker-SdkType' => @sdk_type,
+          'X-Tanker-SdkVersion' => @sdk_version,
+          'Authorization' => request.authorization,
+          'X-Tanker-Instanceid' => request.instance_id,
+          # net-http really wants a Content-Type
+          'Content-Type' => 'application/data'
+        }.compact)
+
+        request.complete_if_not_canceled do
+          cresponse = CTanker::CHttpResponse.new_ok status_code: fresponse.status,
+                                                    content_type: fresponse.headers['content-type'],
+                                                    body: fresponse.body
+          CTanker.tanker_http_handle_response(request.crequest, cresponse)
+        end
+      rescue Exception => e # rubocop:disable Lint/RescueException I do want to rescue all exceptions
+        # NOTE: when debugging, you might want to uncomment this to print a full backtrace
+        # puts "HTTP request error:\n#{e.full_message}"
+        cresponse = CTanker::CHttpResponse.new_error e.message
+        CTanker.tanker_http_handle_response(request.crequest, cresponse)
+      end
+
+      def send_request(crequest, _cdata)
+        request = HttpRequest.new crequest: crequest
+        ThreadPool.push(proc do
+          process_request request
+        end)
+        FFI::Pointer.new :void, request.id
+      end
+
+      def cancel_request(_crequest, prequest_id, _cdata)
+        request_id = prequest_id.to_i
+        HttpRequest.cancel(request_id)
+      end
+    end
+  end
+
+  private_constant :Http
+end

data/lib/tanker/core/init.rb

@@ -31,6 +31,9 @@ module Tanker
       # Do not spam the console of our users.
       self.class.set_log_handler { |_| } unless self.class.test_and_set_log_handler == 1 # rubocop:disable Lint/EmptyBlock
 
+      @http_client = Http::Client.new options.sdk_type, VERSION, options.faraday_adapter
+      options[:http_options] = @http_client.tanker_http_options
+
       @ctanker = CTanker.tanker_create(options).get
       @freed = false
       ctanker_addr = @ctanker.address

data/lib/tanker/core/options.rb

@@ -2,7 +2,8 @@
 
 require 'ffi'
 require 'tanker/c_tanker/c_string'
-require 'tanker/c_tanker/c_backends'
+require 'tanker/c_tanker/c_datastore'
+require 'tanker/c_tanker/c_http'
 
 module Tanker
   # Options that can be given when opening a Tanker session
@@ -20,22 +21,27 @@ module Tanker
     SDK_TYPE = 'client-ruby'
     SDK_VERSION = CTanker.new_cstring Core::VERSION
 
-    def initialize(app_id:, url: nil, sdk_type: SDK_TYPE, persistent_path: nil, cache_path: nil)
+    attr_reader :sdk_type
+    attr_reader :faraday_adapter
+
+    def initialize(app_id:, url: nil, sdk_type: SDK_TYPE, persistent_path: nil, cache_path: nil, faraday_adapter: nil) # rubocop:disable Metrics/ParameterLists
       super()
 
       # NOTE: Instance variables are required to keep the CStrings alive
-      @app_id = CTanker.new_cstring app_id
-      @url = CTanker.new_cstring url
-      @persistent_path = CTanker.new_cstring persistent_path
-      @cache_path = CTanker.new_cstring cache_path
-      @sdk_type = CTanker.new_cstring sdk_type
+      @c_app_id = CTanker.new_cstring app_id
+      @c_url = CTanker.new_cstring url
+      @c_persistent_path = CTanker.new_cstring persistent_path
+      @c_cache_path = CTanker.new_cstring cache_path
+      @sdk_type = sdk_type
+      @c_sdk_type = CTanker.new_cstring sdk_type
+      @faraday_adapter = faraday_adapter
 
       self[:version] = 4
-      self[:app_id] = @app_id
-      self[:url] = @url
-      self[:persistent_path] = @persistent_path
-      self[:cache_path] = @cache_path
-      self[:sdk_type] = @sdk_type
+      self[:app_id] = @c_app_id
+      self[:url] = @c_url
+      self[:persistent_path] = @c_persistent_path
+      self[:cache_path] = @c_cache_path
+      self[:sdk_type] = @c_sdk_type
       self[:sdk_version] = SDK_VERSION
     end
   end

data/lib/tanker/core/session.rb

@@ -41,7 +41,7 @@ module Tanker
 
       method_base_addr = method_list_ptr.read_pointer
       method_list = count.times.map do |i|
-        method_ptr = method_base_addr + i * CTanker::CVerificationMethod.size
+        method_ptr = method_base_addr + (i * CTanker::CVerificationMethod.size)
         CTanker::CVerificationMethod.new(method_ptr).to_verification_method
       end
       CTanker.tanker_free_verification_method_list method_list_ptr
@@ -58,7 +58,7 @@ module Tanker
 
       method_base_addr = device_list_ptr.read_pointer
       device_info_list = count.times.map do |i|
-        method_ptr = method_base_addr + i * CTanker::CDeviceInfo.size
+        method_ptr = method_base_addr + (i * CTanker::CDeviceInfo.size)
         CTanker::CDeviceInfo.new(method_ptr)
       end
       CTanker.tanker_free_device_list device_list_ptr

data/lib/tanker/core/stream.rb

@@ -166,7 +166,7 @@ module Tanker
         buffer.put_bytes(0, rbbuf)
         CTanker.tanker_stream_read_operation_finish(operation, rbbuf.size)
       end
-    rescue StandardError => e
+    rescue Exception => e # rubocop:disable Lint/RescueException I do want to rescue all exceptions
       @mutex.synchronize do
         return if @closed
 
@@ -227,7 +227,7 @@ module Tanker
 
           @write.write(ffibuf.read_string(nb_read))
         end
-      rescue StandardError => e
+      rescue Exception => e # rubocop:disable Lint/RescueException I do want to rescue all exceptions
         @error = @substream.error || e
       ensure
         @write.close

data/lib/tanker/core/version.rb

@@ -2,7 +2,7 @@
 
 module Tanker
   class Core
-    VERSION = '2.30.0'
+    VERSION = '2.31.0.beta.1'
 
     def self.native_version
       CTanker.tanker_version_string

data/lib/tanker/core.rb

@@ -5,6 +5,7 @@ require 'set'
 require_relative 'core/version'
 require_relative 'c_tanker'
 require_relative 'error'
+require_relative 'core/http'
 require_relative 'core/session'
 require_relative 'core/verification'
 require_relative 'core/encryption'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tanker-core
 version: !ruby/object:Gem::Version
-  version: 2.30.0
+  version: 2.31.0.beta.1
 platform: ruby
 authors:
 - Tanker team
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-05-03 00:00:00.000000000 Z
+date: 2022-05-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -134,15 +134,11 @@ files:
 - LICENSE
 - README.rst
 - lib/tanker-core.rb
-- lib/tanker/admin.rb
-- lib/tanker/admin/app.rb
-- lib/tanker/admin/c_admin.rb
-- lib/tanker/admin/c_admin/c_app_descriptor.rb
-- lib/tanker/admin/c_admin/c_app_update_options.rb
 - lib/tanker/c_tanker.rb
-- lib/tanker/c_tanker/c_backends.rb
+- lib/tanker/c_tanker/c_datastore.rb
 - lib/tanker/c_tanker/c_device_info.rb
 - lib/tanker/c_tanker/c_future.rb
+- lib/tanker/c_tanker/c_http.rb
 - lib/tanker/c_tanker/c_lib.rb
 - lib/tanker/c_tanker/c_log_record.rb
 - lib/tanker/c_tanker/c_string.rb
@@ -154,6 +150,7 @@ files:
 - lib/tanker/core/encryption.rb
 - lib/tanker/core/encryption_session.rb
 - lib/tanker/core/group.rb
+- lib/tanker/core/http.rb
 - lib/tanker/core/init.rb
 - lib/tanker/core/log_record.rb
 - lib/tanker/core/options.rb
@@ -176,6 +173,7 @@ licenses:
 metadata:
   homepage_uri: https://tanker.io
   source_code_uri: https://github.com/TankerHQ/sdk-ruby
+  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -187,9 +185,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.6.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.3.7
 signing_key:

data/lib/tanker/admin/app.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module Tanker
-  class Admin
-    # Information from the Admin SDK concerning a Tanker application
-    class App
-      attr_reader :url, :id, :auth_token, :private_key
-
-      def initialize(trustchain_url:, id:, auth_token:, private_key:)
-        @trustchain_url = trustchain_url
-        @id = id
-        @auth_token = auth_token
-        @private_key = private_key
-      end
-
-      def get_email_verification_code(email)
-        CAdmin.tanker_get_email_verification_code(@trustchain_url, @id, @auth_token, email).get_string
-      end
-
-      def get_sms_verification_code(phone_number)
-        CAdmin.tanker_get_sms_verification_code(@trustchain_url, @id, @auth_token, phone_number).get_string
-      end
-    end
-  end
-end

data/lib/tanker/admin/c_admin/c_app_descriptor.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-require 'ffi'
-
-module Tanker
-  class Admin
-    class CAdmin::CAppDescriptor < FFI::ManagedStruct
-      layout :name, :string,
-             :id, :string,
-             :auth_token, :string,
-             :private_key, :string,
-             :public_key, :string
-
-      def get_email_verification_code(email)
-        CTanker.tanker_get_email_verification_code(email).get
-      end
-
-      def get_sms_verification_code(phone_number)
-        CTanker.tanker_get_sms_verification_code(phone_number).get
-      end
-
-      def self.release(ptr)
-        CAdmin.tanker_admin_app_descriptor_free ptr
-      end
-    end
-  end
-end

data/lib/tanker/admin/c_admin/c_app_update_options.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-require 'ffi'
-require 'tanker/c_tanker/c_string'
-
-module Tanker
-  class Admin
-    class AppUpdateOptions < FFI::Struct
-      def initialize(oidc_client_id: nil, oidc_client_provider: nil,
-                     preverified_verification: nil, user_enrollment: nil)
-        super()
-        self[:version] = 4
-        unless oidc_client_id.nil?
-          @oidc_client_id = CTanker.new_cstring oidc_client_id
-          self[:oidc_client_id] = @oidc_client_id
-        end
-        unless oidc_client_provider.nil?
-          @oidc_client_provider = CTanker.new_cstring oidc_client_provider
-          self[:oidc_client_provider] = @oidc_client_provider
-        end
-        unless preverified_verification.nil?
-          boolptr = FFI::MemoryPointer.new(:bool, 1)
-          boolptr.put(:bool, 0, preverified_verification)
-          @preverified_verification = boolptr
-          self[:preverified_verification] = @preverified_verification
-        end
-        unless user_enrollment.nil? # rubocop:disable Style/GuardClause no different than the other parameters
-          boolptr = FFI::MemoryPointer.new(:bool, 1)
-          boolptr.put(:bool, 0, user_enrollment)
-          @user_enrollment = boolptr
-          self[:user_enrollment] = @user_enrollment
-        end
-      end
-
-      layout :version, :uint8,
-             :oidc_client_id, :pointer,
-             :oidc_client_provider, :pointer,
-             :preverified_verification, :pointer,
-             :user_enrollment, :pointer
-    end
-  end
-end

data/lib/tanker/admin/c_admin.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-require 'ffi'
-require 'tanker/c_tanker/c_future'
-require 'tanker/c_tanker/c_lib'
-require_relative 'c_admin/c_app_update_options'
-
-module Tanker
-  class Admin
-    module CAdmin
-      extend FFI::Library
-
-      ffi_lib Tanker::CTanker.get_path('tanker_admin-c')
-      typedef :pointer, :admin_pointer
-
-      # NOTE: We use those CFutures with the tanker_future_* functions exposed by CTanker,
-      # this is safe because we only do simple synchronous blocking calls, without using tanker_future_then.
-
-      attach_function :tanker_admin_connect, [:string, :string, :string], CTanker::CFuture
-      attach_function :tanker_admin_create_app, [:admin_pointer, :string], CTanker::CFuture
-      attach_function :tanker_admin_delete_app, [:admin_pointer, :string], CTanker::CFuture
-      attach_function :tanker_admin_destroy, [:admin_pointer], CTanker::CFuture
-      attach_function :tanker_admin_app_descriptor_free, [:pointer], :void
-      attach_function :tanker_admin_app_update, [:admin_pointer, :string,
-                                                 Tanker::Admin::AppUpdateOptions], CTanker::CFuture
-      attach_function :tanker_get_email_verification_code, [:string, :string, :string, :string], CTanker::CFuture
-      attach_function :tanker_get_sms_verification_code, [:string, :string, :string, :string], CTanker::CFuture
-    end
-
-    private_constant :CAdmin
-  end
-end

data/lib/tanker/admin.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-require 'ffi'
-require_relative 'admin/c_admin'
-require_relative 'admin/c_admin/c_app_descriptor'
-require_relative 'admin/c_admin/c_app_update_options'
-require_relative 'admin/app'
-
-module Tanker
-  class Admin
-    def initialize(app_management_token:, app_management_url:, api_url:, environment_name:, trustchain_url:)
-      @app_management_token = app_management_token
-      @app_management_url = app_management_url
-      @api_url = api_url
-      @environment_name = environment_name
-      @trustchain_url = trustchain_url
-    end
-
-    # Authenticate to the Tanker admin server API
-    # This must be called before doing any other operation
-    def connect
-      @cadmin = CAdmin.tanker_admin_connect(@app_management_url, @app_management_token, @environment_name).get
-      cadmin_addr = @cadmin.address
-      ObjectSpace.define_finalizer(@cadmin) do |_|
-        CAdmin.tanker_admin_destroy(FFI::Pointer.new(:void, cadmin_addr)).get
-      end
-    end
-
-    def create_app(name)
-      assert_connected
-      descriptor_ptr = CAdmin.tanker_admin_create_app(@cadmin, name).get
-      descriptor = CAdmin::CAppDescriptor.new(descriptor_ptr)
-      App.new(
-        trustchain_url: @trustchain_url,
-        id: descriptor[:id],
-        auth_token: descriptor[:auth_token],
-        private_key: descriptor[:private_key]
-      )
-    end
-
-    def delete_app(app_id)
-      assert_connected
-      CAdmin.tanker_admin_delete_app(@cadmin, app_id).get
-    end
-
-    def app_update(app_id, app_update_options)
-      assert_connected
-      CAdmin.tanker_admin_app_update(@cadmin, app_id, app_update_options).get
-    end
-
-    private
-
-    def assert_connected
-      raise 'You need to connect() before using the admin API!' if @cadmin.nil?
-    end
-  end
-
-  private_constant :Admin
-end