polywrap_resolvers 0.1.11

Uri resolvers to achieve uri resolution in Polywrap Client
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

use std::sync::{Arc, Mutex};

use polywrap_core::error::Error;

use polywrap_core::{invoker::Invoker, uri::Uri};

use polywrap_core::resolution::{
    uri_resolution_context::{UriPackageOrWrapper, UriResolutionContext, UriResolutionStep},
    uri_resolver::UriResolver,
};

pub trait UriResolverAggregatorBase: UriResolver + core::fmt::Debug {
    fn get_resolver_name(&self) -> Option<String>;
    fn get_uri_resolvers(
        &self,
        uri: &Uri,
        client: &dyn Invoker,
        resolution_context: Arc<Mutex<UriResolutionContext>>,
    ) -> Result<Vec<Arc<dyn UriResolver>>, Error>;
    fn get_step_description(
        &self,
        uri: &Uri,
        result: &Result<UriPackageOrWrapper, Error>,
    ) -> String;
    fn try_resolve_uri_with_resolvers(
        &self,
        uri: &Uri,
        invoker: Arc<dyn Invoker>,
        resolvers: Vec<Arc<dyn UriResolver>>,
        resolution_context: Arc<Mutex<UriResolutionContext>>,
    ) -> Result<UriPackageOrWrapper, Error> {
        let sub_context = resolution_context
            .lock()
            .unwrap()
            .create_sub_history_context();
        let sub_context = Arc::new(Mutex::new(sub_context));
        for resolver in resolvers.into_iter() {
            let result = resolver.try_resolve_uri(uri, invoker.clone(), sub_context.clone());
            let track_and_return = if let Ok(UriPackageOrWrapper::Uri(result_uri)) = &result {
                uri.to_string() != result_uri.to_string()
            } else {
                true
            };

            if track_and_return {
                resolution_context
                    .lock()
                    .unwrap()
                    .track_step(UriResolutionStep {
                        source_uri: uri.clone(),
                        result: result.clone(),
                        sub_history: Some(sub_context.lock().unwrap().get_history().clone()),
                        description: Some(self.get_step_description(uri, &result)),
                    });

                return result;
            }
        }

        let result = Ok(UriPackageOrWrapper::Uri(uri.clone()));

        resolution_context
            .lock()
            .unwrap()
            .track_step(UriResolutionStep {
                source_uri: uri.clone(),
                result: result.clone(),
                sub_history: Some(sub_context.lock().unwrap().get_history().clone()),
                description: Some(self.get_step_description(uri, &result)),
            });

        result
    }
}