Wrappers Python: Implement V2 initial API

1 files changed, 92 insertions, 440 deletions

diff --git a/wrappers/python/eduvpn_common/main.py b/wrappers/python/eduvpn_common/main.py
index 74ff52d..f22e4d3 100644
--- a/wrappers/python/eduvpn_common/main.py
+++ b/wrappers/python/eduvpn_common/main.py
@@ -1,36 +1,19 @@
-import threading
-from ctypes import POINTER, cast, c_void_p, c_int, pointer
-from typing import Any, Callable, Dict, Iterator, List, Optional, Tuple
-
-from eduvpn_common.discovery import (
-    DiscoOrganizations,
-    DiscoServers,
-    get_disco_organizations,
-    get_disco_servers,
-)
-from eduvpn_common.event import EventHandler
+from typing import Any, Callable, Iterator, Optional
+
 from eduvpn_common.loader import initialize_functions, load_lib
-from eduvpn_common.server import (
-    Profiles,
-    Config,
-    Token,
-    encode_tokens,
-    get_config,
-    Server,
-    get_tokens,
-    get_transition_server,
-    get_servers,
-)
-from eduvpn_common.state import State, StateType
-from eduvpn_common.types import (
-    VPNStateChange,
-    ReadRxBytes,
-    UpdateToken,
-    decode_res,
-    encode_args,
-    get_data_error,
-    get_bool,
-)
+from eduvpn_common.types import (ReadRxBytes, VPNStateChange, decode_res,
+                                  encode_args, get_bool, get_data_error)
+
+
+class WrappedError(Exception):
+    pass
+
+
+def forwardError(error: bytes | str):
+    # TODO: HACK, remove this
+    if isinstance(error, str):
+        raise WrappedError(error)
+    raise WrappedError(error.decode("utf-8"))
 
 
 class EduVPN(object):
@@ -40,52 +23,18 @@ class EduVPN(object):
     :param name: str: The name of the client. For commonly used names, see https://git.sr.ht/~fkooman/vpn-user-portal/tree/v3/item/src/OAuth/ClientDb.php. E.g. org.eduvpn.app.linux, if this name has "letsconnect" in it, then it is a Let's Connect! variant
     :param version: str: The version number of the client as a string, max 10 characters
     :param config_directory: str: The directory (absolute/relative) where to store the files
-    :param language: str: The language of the client, e.g. en
 
     """
 
-    def __init__(self, name: str, version: str, config_directory: str, language: str):
+    def __init__(self, name: str, version: str, config_directory: str):
         self.name = name
         self.version = version
         self.config_directory = config_directory
-        self.language = language
 
         # Load the library
         self.lib = load_lib()
         initialize_functions(self.lib)
 
-        self.event_handler = EventHandler(self.lib)
-        self.token_callback = None
-
-        # Callbacks that need to wait for specific events
-
-        # The ask profile callback needs to wait for the UI thread to select a profile
-        # This is stored in the profile_event
-        self.profile_event: Optional[threading.Event] = None
-        self.location_event: Optional[threading.Event] = None
-
-        @self.event.on(State.ASK_PROFILE, StateType.WAIT)
-        def wait_profile_event(old_state: int, profiles: Profiles):
-            """This functions waits until the ask location thread event is finished
-
-            :param old_state: int: The old state of the profiles event
-            :param profiles: Profiles: The profiles
-
-            """
-            if self.profile_event:
-                self.profile_event.wait()
-
-        @self.event.on(State.ASK_LOCATION, StateType.WAIT)
-        def wait_location_event(old_state: int, locations: List[str]):
-            """This functions waits until the location thread event is finished
-
-            :param old_state: int: The old state of the location event
-            :param locations: List[str]: The locations
-
-            """
-            if self.location_event:
-                self.location_event.wait()
-
     def go_function(
         self, func: Any, *args: Iterator, decode_func: Optional[Callable] = None
     ) -> Any:
@@ -99,8 +48,8 @@ class EduVPN(object):
         :meta private:
         """
         # The functions all have at least one arg type which is the name of the client
-        args_gen = encode_args(list(args), func.argtypes[1:])
-        res = func(self.name.encode("utf-8"), *(args_gen))
+        args_gen = encode_args(list(args), func.argtypes)
+        res = func(*(args_gen))
         if decode_func is None:
             return decode_res(func.restype)(self.lib, res)
         else:
@@ -111,348 +60,143 @@ class EduVPN(object):
         cancel_oauth_err = self.go_function(self.lib.CancelOAuth)
 
         if cancel_oauth_err:
-            raise cancel_oauth_err
+            forwardError(cancel_oauth_err)
 
     def deregister(self) -> None:
         """Deregister the Go shared library.
         This removes the object from internal bookkeeping and saves the configuration
         """
         self.go_function(self.lib.Deregister)
-        remove_as_global_object(self)
+        global callback_object
+        callback_object = None
 
-    def register(self, debug: bool = False) -> None:
+    def register(self, handler: Optional[Callable] = None, debug: bool = False) -> None:
         """Register the Go shared library.
         This makes sure the FSM is initialized and that we can call Go functions
 
         :param debug: bool:  (Default value = False): Whether or not we want to enable debug logging
 
         """
-        if not add_as_global_object(self):
+        global callback_object
+        if callback_object is not None:
             raise Exception("Already registered")
-
+        callback_object = handler
         register_err = self.go_function(
             self.lib.Register,
+            self.name,
             self.version,
             self.config_directory,
-            self.language,
             state_callback,
             debug,
         )
 
         if register_err:
-            raise register_err
-
-    def set_token_updater(self, updater: Callable):
-        self.token_callback = updater
-        updater_err = self.go_function(
-            self.lib.SetTokenUpdater,
-            token_callback,
-        )
-
-        if updater_err:
-            raise updater_err
-
-    def get_disco_servers(self) -> Optional[DiscoServers]:
-        """Get the discovery servers
-
-        :raises WrappedError: An error by the Go library
-
-        :return: The disco Servers if any
-        :rtype: Optional[DiscoServers]
-        """
-        servers, _ = self.go_function(
-            self.lib.GetDiscoServers,
-            decode_func=lambda lib, x: get_data_error(lib, x, get_disco_servers),
-        )
-
-        return servers
-
-    def get_disco_organizations(self) -> Optional[DiscoOrganizations]:
-        """Get the discovery organizations
-
-        :raises WrappedError: An error by the Go library
-
-        :return: The discovery Organizations if any
-        :rtype: Optional[DiscoOrganizations]
-        """
-        organizations, _ = self.go_function(
-            self.lib.GetDiscoOrganizations,
-            decode_func=lambda lib, x: get_data_error(lib, x, get_disco_organizations),
-        )
-
-        return organizations
-
-    def add_institute_access(self, url: str) -> None:
-        """Add an institute access server
-
-        :param url: str: The URL for the institute access server. Use the exact base_url as returned by Discovery
-
-        :raises WrappedError: An error by the Go library
-        """
-        add_err = self.go_function(self.lib.AddInstituteAccess, url)
-
-        if add_err:
-            raise add_err
-
-    def add_secure_internet_home(self, org_id: str) -> None:
-        """Add a secure internet server
-
-        :param org_id: str: The organization ID of the secure internet server. Use the exact organization as returned by Discovery
-
-        :raises WrappedError: An error by the Go library
-        """
-        self.location_event = threading.Event()
-        add_err = self.go_function(self.lib.AddSecureInternetHomeServer, org_id)
-
-        if add_err:
-            raise add_err
+            forwardError(register_err)
 
-    def add_custom_server(self, url: str) -> None:
-        """Add a custom server
+    def add_server(self, _type: str, _id: str) -> None:
+        """Add a server
 
-        :param url: str: The base URL of the server
+        :param _type: str: The type of server: "institute_access", "secure_internet" or "custom_server"
+        :param _id: str: The identifier of the server, e.g. "https://vpn.example.com/"
 
         :raises WrappedError: An error by the Go library
         """
-        add_err = self.go_function(self.lib.AddCustomServer, url)
+        add_err = self.go_function(self.lib.AddServer, _type, _id)
 
         if add_err:
-            raise add_err
+            forwardError(add_err)
 
-    def remove_secure_internet(self) -> None:
-        """Remove the secure internet server
+    def get_expiry_times(self) -> Optional[str]:
+        expiry, expiry_err = self.go_function(self.lib.ExpiryTimes)
+        if expiry_err:
+            forwardError(expiry_err)
+        return expiry
 
-        :raises WrappedError: An error by the Go library
-        """
-        remove_err = self.go_function(self.lib.RemoveSecureInternet)
-
-        if remove_err:
-            raise remove_err
+    def get_current_server(self) -> Optional[str]:
+        server, server_err = self.go_function(self.lib.CurrentServer)
+        if server_err:
+            forwardError(server_err)
+        return server
 
-    def remove_institute_access(self, url: str) -> None:
-        """Remove an institute access server
+    def get_secure_locations(self) -> Optional[str]:
+        locs, locs_err = self.go_function(self.lib.SecureLocationList)
+        if locs_err:
+            forwardError(locs_err)
+        return locs
 
-        :param url: str: The URL for the institute access server. Use the exact base_url as returned by Discovery
+    def get_disco_organizations(self) -> Optional[str]:
+        orgs, _ = self.go_function(self.lib.DiscoOrganizations)
+        # TODO: Log error
+        return orgs
 
-        :raises WrappedError: An error by the Go library
-        """
-        remove_err = self.go_function(self.lib.RemoveInstituteAccess, url)
+    def get_disco_servers(self) -> Optional[str]:
+        servers, _ = self.go_function(self.lib.DiscoServers)
+        # TODO: Log error
+        return servers
 
-        if remove_err:
-            raise remove_err
+    def get_servers(self) -> Optional[str]:
+        servers, servers_err = self.go_function(self.lib.ServerList)
+        if servers_err:
+            forwardError(servers_err)
+        return servers
 
-    def remove_custom_server(self, url: str) -> None:
-        """Remove a custom server
+    def remove_server(self, _type: str, _id: str) -> None:
+        """Remove a server
 
-        :param url: str: The base URL of the server
+        :param _type: str: The type of server: "institute_access", "secure_internet" or "custom_server"
+        :param _id: str: The identifier of the server, e.g. "https://vpn.example.com/"
 
         :raises WrappedError: An error by the Go library
         """
-        remove_err = self.go_function(self.lib.RemoveCustomServer, url)
+        remove_err = self.go_function(self.lib.RemoveServer, _type, _id)
 
         if remove_err:
-            raise remove_err
+            forwardError(remove_err)
 
     def get_config(
-        self,
-        identifier: str,
-        func: Any,
-        prefer_tcp: bool = False,
-        tokens: Optional[Token] = None,
-    ) -> Optional[Config]:
+        self, _type: str, identifier: str, prefer_tcp: bool = False, tokens: str = "{}"
+    ) -> Optional[str]:
         """Get an OpenVPN/WireGuard configuration from the server
 
+        :param _type: str: The type of server: "institute_access", "secure_internet" or "custom_server"
         :param identifier: str: The identifier of the server, e.g. URL or ORG ID
-        :param func: Any: The Go function to call
         :param prefer_tcp: bool:  (Default value = False): Whether or not to prefer TCP
-        :param tokens: Optional[Token]  (Default value = None): The OAuth tokens if available
+        :param tokens: str  (Defualt value = ""): The OAuth tokens if available
 
         :meta private:
 
         :raises WrappedError: An error by the Go library
 
-        :return: The configuration and configuration type ('openvpn' or 'wireguard')
-        :rtype: Config
+        :return: The configuration and configuration type ('openvpn' or 'wireguard') as a JSON string
+        :rtype: str
         """
         # Because it could be the case that a profile callback is started, store a threading event
         # In the constructor, we have defined a wait event for Ask_Profile, this waits for this event to be set
         # The event is set in self.set_profile
-        self.profile_event = threading.Event()
-
         config, config_err = self.go_function(
-            func,
+            self.lib.GetConfig,
+            _type,
             identifier,
             prefer_tcp,
-            encode_tokens(tokens),
-            decode_func=lambda lib, x: get_data_error(lib, x, get_config),
+            tokens,
         )
 
-        self.profile_event = None
-        self.location_event = None
-
         if config_err:
-            raise config_err
+            forwardError(config_err)
 
         return config
 
-    def get_config_custom_server(
-        self, url: str, prefer_tcp: bool = False, tokens: Optional[Token] = None
-    ) -> Optional[Config]:
-        """Get an OpenVPN/WireGuard configuration from a custom server
-
-        :param url: str: The URL of the custom server
-        :param prefer_tcp: bool:  (Default value = False): Whether or not to prefer TCP
-        :param tokens: Optional[Token]  (Default value = None): The OAuth tokens if available
-
-        :raises WrappedError: An error by the Go library
-
-        :return: The configuration and configuration type ('openvpn' or 'wireguard')
-        :rtype: Config
-        """
-        return self.get_config(url, self.lib.GetConfigCustomServer, prefer_tcp, tokens)
-
-    def get_config_institute_access(
-        self, url: str, prefer_tcp: bool = False, tokens: Optional[Token] = None
-    ) -> Optional[Config]:
-        """Get an OpenVPN/WireGuard configuration from an institute access server
-
-        :param url: str: The URL of the institute access server. Use the one from Discovery
-        :param prefer_tcp: bool:  (Default value = False): Whether or not to prefer TCP
-        :param tokens: Optional[Token]  (Default value = None): The OAuth tokens if available
-
-        :raises WrappedError: An error by the Go library
-
-        :return: The configuration and configuration type ('openvpn' or 'wireguard')
-        :rtype: Config
-        """
-        return self.get_config(
-            url, self.lib.GetConfigInstituteAccess, prefer_tcp, tokens
-        )
-
-    def get_config_secure_internet(
-        self, org_id: str, prefer_tcp: bool = False, tokens: Optional[Token] = None
-    ) -> Optional[Config]:
-        """Get an OpenVPN/WireGuard configuration from a secure internet server
-
-        :param org_id: str: The organization ID of the secure internet server. Use the one from Discovery
-        :param prefer_tcp: bool:  (Default value = False): Whether or not to prefer TCP
-        :param tokens: Optional[Token]  (Default value = None): The OAuth tokens if available
-
-        :raises WrappedError: An error by the Go library
-
-        :return: The configuration and configuration type ('openvpn' or 'wireguard')
-        :rtype: Config
-        """
-        return self.get_config(
-            org_id, self.lib.GetConfigSecureInternet, prefer_tcp, tokens
-        )
-
-    def go_back(self) -> None:
-        """Go back in the FSM"""
-        # Ignore the error
-        self.go_function(self.lib.GoBack)
-
-    def set_connected(self) -> None:
-        """Set the FSM to connected
-
-        :raises WrappedError: An error by the Go library
-        """
-        connect_err = self.go_function(self.lib.SetConnected)
-
-        if connect_err:
-            raise connect_err
-
-    def set_disconnecting(self) -> None:
-        """Set the FSM to disconnecting
-
-        :raises WrappedError: An error by the Go library
-        """
-        disconnecting_err = self.go_function(self.lib.SetDisconnecting)
-
-        if disconnecting_err:
-            raise disconnecting_err
-
-    def set_connecting(self) -> None:
-        """Set the FSM to connecting
-
-        :raises WrappedError: An error by the Go library
-        """
-        connecting_err = self.go_function(self.lib.SetConnecting)
-
-        if connecting_err:
-            raise connecting_err
-
-    def cleanup(self, tokens: Optional[Token] = None) -> None:
+    def cleanup(self, tokens: str = "") -> None:
         """Cleanup the vpn connection
 
-        :param tokens: Optional[Token]  (Default value = None): The OAuth tokens if available
+        :param tokens: str  (Default value = ""): The OAuth tokens if available
 
         :raises WrappedError: An error by the Go library
         """
-        cleanup_err = self.go_function(self.lib.Cleanup, encode_tokens(tokens))
+        cleanup_err = self.go_function(self.lib.Cleanup, tokens)
 
         if cleanup_err:
-            raise cleanup_err
-
-    def set_disconnected(
-        self,
-    ) -> None:
-        """Set the FSM to disconnected
-
-        :param cleanup: bool:  (Default value = True): Whether or not to call /disconnect to the server. This invalidates the OpenVPN/WireGuard configuration
-        :param tokens: Optional[Token]  (Default value = None): The OAuth tokens if available
-
-        :raises WrappedError: An error by the Go library
-        """
-        disconnect_err = self.go_function(self.lib.SetDisconnected)
-
-        if disconnect_err:
-            raise disconnect_err
-
-    def set_search_server(self) -> None:
-        """Set the FSM to search server
-
-        :raises WrappedError: An error by the Go library
-        """
-        search_err = self.go_function(self.lib.SetSearchServer)
-
-        if search_err:
-            raise search_err
-
-    def remove_class_callbacks(self, cls: Any) -> None:
-        """Remove class callbacks
-
-        :param cls: Any: The class to remove callbacks for
-
-        """
-        self.event_handler.change_class_callbacks(cls, add=False)
-
-    def register_class_callbacks(self, cls: Any) -> None:
-        """Register class callbacks
-
-        :param cls: Any: The class to register callbacks for
-
-        """
-        self.event_handler.change_class_callbacks(cls)
-
-    @property
-    def event(self) -> EventHandler:
-        """The property that gets the event handler
-
-        :return: The event handler
-        :rtype: EventHandler
-        """
-        return self.event_handler
-
-    def callback(self, old_state: State, new_state: State, data: Any) -> bool:
-        """Run an event callback
-
-        :param old_state: State: The previous state
-        :param new_state: State: The new state
-        :param data: Any: The data to pass to the event
-
-        """
-        return self.event.run(old_state, new_state, data)
+            forwardError(cleanup_err)
 
     def token_calback(self, srv: Server, tok: Token):
         if self.token_callback is None:
@@ -471,23 +215,8 @@ class EduVPN(object):
 
         # If there is a profile event, set it so that the wait callback finishes
         # And so that the Go code can move to the next state
-        if self.profile_event:
-            self.profile_event.set()
-
         if profile_err:
-            raise profile_err
-
-    def change_secure_location(self) -> None:
-        """Change the secure location. This calls the necessary events
-
-        :raises WrappedError: An error by the Go library
-        """
-        # Set the location by country code
-        self.location_event = threading.Event()
-        location_err = self.go_function(self.lib.ChangeSecureLocation)
-
-        if location_err:
-            raise location_err
+            forwardError(profile_err)
 
     def set_secure_location(self, country_code: str) -> None:
         """Set the secure location
@@ -501,11 +230,8 @@ class EduVPN(object):
 
         # If there is a location event, set it so that the wait callback finishes
         # And so that the Go code can move to the next state
-        if self.location_event:
-            self.location_event.set()
-
         if location_err:
-            raise location_err
+            forwardError(location_err)
 
     def renew_session(self) -> None:
         """Renew the session. This invalidates the tokens and runs the necessary callbacks to log back in
@@ -515,7 +241,7 @@ class EduVPN(object):
         renew_err = self.go_function(self.lib.RenewSession)
 
         if renew_err:
-            raise renew_err
+            forwardError(renew_err)
 
     def set_support_wireguard(self, support: bool) -> None:
         """Indicates whether or not the OS supports WireGuard connections.
@@ -527,7 +253,7 @@ class EduVPN(object):
         support_err = self.go_function(self.lib.SetSupportWireguard, support)
 
         if support_err:
-            raise support_err
+            forwardError(support_err)
 
     def should_renew_button(self) -> bool:
         """Whether or not the UI should show the renew button
@@ -537,48 +263,6 @@ class EduVPN(object):
         """
         return self.go_function(self.lib.ShouldRenewButton)
 
-    def in_fsm_state(self, state_id: State) -> bool:
-        """Check whether or not the FSM is in the provided state
-
-        :param state_id: State: The state to check for
-
-        :return: Whether or not the FSM is in the provided state
-        :rtype: bool
-        """
-        return self.go_function(self.lib.InFSMState, state_id)
-
-    def get_current_server(self) -> Optional[Server]:
-        """Get the current server
-
-        :return: The current servers if there is any
-        :rtype: Optional[List[Servers]]
-        """
-        server, server_err = self.go_function(
-            self.lib.GetCurrentServer,
-            decode_func=lambda lib, x: get_data_error(lib, x, get_transition_server),
-        )
-
-        if server_err:
-            raise server_err
-
-        return server
-
-    def get_saved_servers(self) -> Optional[List[Server]]:
-        """Get a list of saved servers
-
-        :return: The list of Servers if there are any
-        :rtype: Optional[List[Servers]]
-        """
-        servers, servers_err = self.go_function(
-            self.lib.GetSavedServers,
-            decode_func=lambda lib, x: get_data_error(lib, x, get_servers),
-        )
-
-        if servers_err:
-            raise servers_err
-
-        return servers
-
     def start_failover(
         self, gateway: str, wg_mtu: int, readrxbytes: ReadRxBytes
     ) -> bool:
@@ -590,16 +274,16 @@ class EduVPN(object):
             decode_func=lambda lib, x: get_data_error(lib, x, get_bool),
         )
         if dropped_err:
-            raise dropped_err
+            forwardError(dropped_err)
         return dropped
 
     def cancel_failover(self):
         cancel_err = self.go_function(self.lib.CancelFailover)
         if cancel_err:
-            raise cancel_err
+            forwardError(cancel_err)
 
 
-eduvpn_objects: Dict[str, EduVPN] = {}
+callback_object: Optional[Callable] = None
 
 
 @UpdateToken
@@ -616,50 +300,18 @@ def token_callback(name: bytes, srv, tok):
 
 
 @VPNStateChange
-def state_callback(name: bytes, old_state: int, new_state: int, data: Any) -> int:
+def state_callback(old_state: int, new_state: int, data: str) -> int:
     """The internal callback that is passed to the Go library
 
-    :param name: bytes: The name of the client
     :param old_state: int: The old state
     :param new_state: int: The new state
-    :param data: Any: The data that still needs to be converted
+    :param data: str: The data that still needs to be converted by parsing the JSON
 
     :meta private:
     """
-    name_decoded = name.decode()
-    if name_decoded not in eduvpn_objects:
+    if callback_object is None:
         return 0
-    handled = eduvpn_objects[name_decoded].callback(
-        State(old_state), State(new_state), data
-    )
+    handled = callback_object(old_state, new_state, data.decode("utf-8"))
     if handled:
         return 1
     return 0
-
-
-def add_as_global_object(eduvpn: EduVPN) -> bool:
-    """Add the provided parameter to the global objects lists so we can call the callback
-
-    :param eduvpn: EduVPN: The class to add
-
-    :meta private:
-
-    :return: Whether or not the object was added
-    :rtype: bool
-    """
-    global eduvpn_objects
-    if eduvpn.name not in eduvpn_objects:
-        eduvpn_objects[eduvpn.name] = eduvpn
-        return True
-    return False
-
-
-def remove_as_global_object(eduvpn: EduVPN) -> None:
-    """Remove the provided parameter from the global objects list
-
-    :param eduvpn: EduVPN: The class to remove
-
-    :meta private:
-    """
-    global eduvpn_objects
-    eduvpn_objects.pop(eduvpn.name, None)