borepin/FabAccessAPI/Connection.cs

//using Capnp.Rpc;
//using FabAccessAPI.Schema;
//using System;
//using System.Collections.Generic;
//using System.Linq;
//using System.Threading;
//using System.Threading.Tasks;

//namespace FabAccessAPI {
//    public class Connection {
//        #region private variables
//        private readonly TcpRpcClient? _rpcClient = null;
//        private readonly IBootstrap? _bootstrapCap = null;
//        private Auth? _auth = null;
//        private Machines? _machines = null;
//        #endregion
        
//        public TcpRpcClient? RpcClient => _rpcClient;
        
//        #region Log
//        private static readonly log4net.ILog _Log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
//        #endregion
        
//        /// <summary>
//        /// 
//        /// </summary>
//        /// <param name="rpcClient">Should be an already configured and connected TcpRpcClient</param>
//        public Connection(TcpRpcClient rpcClient) {
//            _rpcClient = rpcClient;
//            _bootstrapCap = _rpcClient.GetMain<IBootstrap>();
//            _Log.Debug($"Done bootstraping API connection.");
//        }

//        /// <summary>
//        /// Authenticate this connection.
//        /// Calling this more then once is UB
//        /// </summary>
//        /// <param name="mech">The desired authentication mechanism</param>
//        /// <param name="kvs">Key-Value data specific to the mechanism</param>
//        /// <returns></returns>
//        public async Task Auth(string mech, Dictionary<string, object> kvs, CancellationToken cancellationToken_ = default) {
//            // _bootstrapCap = await _bootstrapCap.Unwrap();
//            var authCap = await _bootstrapCap.Auth(cancellationToken_);
//            _auth = new Auth(authCap);
//            var mechs = await _auth.GetMechanisms();
//            _Log.Debug($"The Server supports the following auth mechs: {string.Join(", ", mechs)}");

//            if (!mechs.Contains(mech)) {
//                throw new UnsupportedMechanismException();
//            }

//            await _auth.Authenticate(mech, kvs);
//        }

//        /// <summary>
//        /// Get a wrapped capability to interact with machines
//        /// </summary>
//        /// <returns>A wrapped capability to interact with machines</returns>
//        public async Task<Machines> AccessMachines() {
//            _machines ??= new Machines(await _bootstrapCap.Machines());
//            return _machines;
//        }
//    }
//}