2523

pending completion

Build # 2523

Build Type

Pull #639

travis-ci

Committed by

web-flow

Commit Message

<a href="https://github.com/4finance/micro-infra-spring/commit/<a class=hub.com/4finance/micro-infra-spring/commit/a9d4d7f857f2c2d9e37615d30d164ba08d9924d4">a9d4d7f85<a href="https://github.com/4finance/micro-infra-spring/commit/a9d4d7f857f2c2d9e37615d30d164ba08d9924d4">&quot;&gt;Revert &amp;quot;Allows to register mapping for stub&quot;

This reverts commit </a><a class="double-link" href="https://github.com/4finance/micro-infra-spring/commit/<a class="double-link" href="https://github.com/4finance/micro-infra-spring/commit/cffc3c351a513f44cf3daa42a791b41b7dd6bf14">cffc3c351</a>">cffc3c351</a><a href="https://github.com/4finance/micro-infra-spring/commit/a9d4d7f857f2c2d9e37615d30d164ba08d9924d4">.

Pull Request Pull Request #639: Revert "Allows to register mapping for stub"

Run Details

2395 of 3197 relevant lines covered (74.91%)

0.75 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

13.46

/micro-deps/micro-deps-spring-config/src/main/java/com/ofg/infrastructure/discovery/SpringCloudZookeeperServiceResolver.java

package com.ofg.infrastructure.discovery;

import com.google.common.base.Function;
import com.google.common.base.Optional;
import com.google.common.base.Throwables;
import com.google.common.collect.Collections2;
import com.google.common.collect.Iterables;
import com.ofg.infrastructure.discovery.util.CollectionUtils;
import org.apache.curator.framework.CuratorFramework;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.cloud.zookeeper.discovery.ZookeeperDiscoveryProperties;
import org.springframework.cloud.zookeeper.discovery.ZookeeperServiceDiscovery;
import org.springframework.cloud.zookeeper.discovery.dependency.ZookeeperDependencies;
import org.springframework.cloud.zookeeper.discovery.dependency.ZookeeperDependency;

import java.net.URI;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import static com.google.common.collect.Collections2.transform;
import static com.ofg.infrastructure.discovery.util.CollectionUtils.flatten;
import static com.ofg.infrastructure.discovery.util.CollectionUtils.toSet;
import static java.util.Collections.singleton;

public class SpringCloudZookeeperServiceResolver implements ServiceResolver {

    private final ZookeeperDependencies zookeeperDependencies;
    private final DiscoveryClient discoveryClient;
    private final CuratorFramework curatorFramework;
    private final ZookeeperServiceDiscovery serviceDiscovery;
    private final ZookeeperDiscoveryProperties zookeeperDiscoveryProperties;

    public SpringCloudZookeeperServiceResolver(ZookeeperDependencies zookeeperDependencies,
                                               DiscoveryClient discoveryClient,
                                               CuratorFramework curatorFramework,
                                               ZookeeperServiceDiscovery serviceDiscovery,
                                               ZookeeperDiscoveryProperties zookeeperDiscoveryProperties) {
        this.zookeeperDependencies = zookeeperDependencies;
        this.discoveryClient = discoveryClient;
        this.curatorFramework = curatorFramework;
        this.serviceDiscovery = serviceDiscovery;
        this.zookeeperDiscoveryProperties = zookeeperDiscoveryProperties;
    }

    @Override
    public ServicePath resolveAlias(ServiceAlias alias) {
        return new ServicePath(zookeeperDependencies.getPathForAlias(alias.getName()));
    }

    @Override
    public Optional<URI> getUri(ServicePath service) {
        return getUriForPath(service);
    }

    private Optional<URI> getUriForPath(ServicePath service) {
        List<ServiceInstance> instances = getInstancesForPath(service);
        if (instances.isEmpty()) {
            return Optional.absent();
        }
        return Optional.of(Iterables.getLast(instances).getUri());
    }

    private List<ServiceInstance> getInstancesForPath(ServicePath service) {
        return discoveryClient.getInstances(service.getPathWithStartingSlash());
    }

    @Override
    public URI fetchUri(ServicePath service) {
        return getUriForPath(service).orNull();
    }

    @Override
    public Set<URI> fetchAllUris(ServicePath service) {
        List<ServiceInstance> instances = getInstancesForPath(service);
        Collection<URI> uris = Collections2.transform(instances, new Function<ServiceInstance, URI>() {
            @Override
            public URI apply(ServiceInstance input) {
                return input.getUri();
            }
        });
        return CollectionUtils.toSet(uris);
    }

    @Override
    public Set<ServicePath> fetchMyDependencies() {
        Map<String, ZookeeperDependency> dependencies = zookeeperDependencies.getDependencies();
        Set<ServicePath> servicePaths = new HashSet<>();
        for (Map.Entry<String, ZookeeperDependency> zookeeperDependencyEntry : dependencies.entrySet()) {
            servicePaths.add(new ServicePath(zookeeperDependencyEntry.getValue().getPath()));
        }
        return servicePaths;
    }

    @Override
    public Set<ServicePath> fetchAllDependencies() {
        return findLeavesOf(zookeeperDiscoveryProperties.getRoot());
    }

    private Set<ServicePath> findLeavesOf(final String root) {
        if (isServiceName(root)) {
            return singleton(new ServicePath(stripBasePath(root)));
        }

        List<String> children = new ArrayList<String>();
        try {
            String path = root;
            if (!path.startsWith("/")) {
                path = "/" + path;
            }
            children = curatorFramework.getChildren().forPath(path);
        } catch (Exception e) {
            Throwables.propagate(e);
        }
        return toSet(flatten(transform(children, new Function<String, Set<ServicePath>>() {
            @Override
            public Set<ServicePath> apply(String input) {
                return findLeavesOf(root + "/" + input);
            }

        }), ServicePath.class));
    }

    private boolean isServiceName(String path) {
        final String potentialServiceName = path.substring(zookeeperDiscoveryProperties.getRoot().length());
        try {
            return !serviceDiscovery.getServiceDiscoveryRef().get().queryForInstances(potentialServiceName).isEmpty();
        } catch (Exception ignored) {
            //ignored, not a service
            return false;
        }
    }

    private String stripBasePath(String path) {
        return path.substring(zookeeperDiscoveryProperties.getRoot().length() + 1);
    }

    @Override
    public Optional<URI> getUri(ServiceAlias serviceAlias) {
        return getUriForAlias(serviceAlias);
    }

    @Override
    public URI fetchUri(ServiceAlias serviceAlias) {
        return getUriForAlias(serviceAlias).orNull();
    }

    private Optional<URI> getUriForAlias(ServiceAlias service) {
        List<ServiceInstance> instances = getInstancesForAlias(service);
        if (instances.isEmpty()) {
            return Optional.absent();
        }
        return Optional.of(Iterables.getLast(instances).getUri());
    }

    private List<ServiceInstance> getInstancesForAlias(ServiceAlias service) {
        return discoveryClient.getInstances(zookeeperDependencies.getPathForAlias(service.getName()));
    }

    @Override
    public void start() {

    }

    @Override
    public void close() {

    }
}

1	package com.ofg.infrastructure.discovery;
2
3	import com.google.common.base.Function;
4	import com.google.common.base.Optional;
5	import com.google.common.base.Throwables;
6	import com.google.common.collect.Collections2;
7	import com.google.common.collect.Iterables;
8	import com.ofg.infrastructure.discovery.util.CollectionUtils;
9	import org.apache.curator.framework.CuratorFramework;
10	import org.springframework.cloud.client.ServiceInstance;
11	import org.springframework.cloud.client.discovery.DiscoveryClient;
12	import org.springframework.cloud.zookeeper.discovery.ZookeeperDiscoveryProperties;
13	import org.springframework.cloud.zookeeper.discovery.ZookeeperServiceDiscovery;
14	import org.springframework.cloud.zookeeper.discovery.dependency.ZookeeperDependencies;
15	import org.springframework.cloud.zookeeper.discovery.dependency.ZookeeperDependency;
16
17	import java.net.URI;
18	import java.util.ArrayList;
19	import java.util.Collection;
20	import java.util.HashSet;
21	import java.util.List;
22	import java.util.Map;
23	import java.util.Set;
24
25	import static com.google.common.collect.Collections2.transform;
26	import static com.ofg.infrastructure.discovery.util.CollectionUtils.flatten;
27	import static com.ofg.infrastructure.discovery.util.CollectionUtils.toSet;
28	import static java.util.Collections.singleton;
29
30	public class SpringCloudZookeeperServiceResolver implements ServiceResolver {
31
32	private final ZookeeperDependencies zookeeperDependencies;
33	private final DiscoveryClient discoveryClient;
34	private final CuratorFramework curatorFramework;
35	private final ZookeeperServiceDiscovery serviceDiscovery;
36	private final ZookeeperDiscoveryProperties zookeeperDiscoveryProperties;
37
38	public SpringCloudZookeeperServiceResolver(ZookeeperDependencies zookeeperDependencies,
39	DiscoveryClient discoveryClient,
40	CuratorFramework curatorFramework,
41	ZookeeperServiceDiscovery serviceDiscovery,
42	ZookeeperDiscoveryProperties zookeeperDiscoveryProperties) {	1✔
43	this.zookeeperDependencies = zookeeperDependencies;	1✔
44	this.discoveryClient = discoveryClient;	1✔
45	this.curatorFramework = curatorFramework;	1✔
46	this.serviceDiscovery = serviceDiscovery;	1✔
47	this.zookeeperDiscoveryProperties = zookeeperDiscoveryProperties;	1✔
48	}	1✔
49
50	@Override
51	public ServicePath resolveAlias(ServiceAlias alias) {
52	return new ServicePath(zookeeperDependencies.getPathForAlias(alias.getName()));	×
53	}
54
55	@Override
56	public Optional<URI> getUri(ServicePath service) {
57	return getUriForPath(service);	×
58	}
59
60	private Optional<URI> getUriForPath(ServicePath service) {
61	List<ServiceInstance> instances = getInstancesForPath(service);	×
62	if (instances.isEmpty()) {	×
63	return Optional.absent();	×
64	}
65	return Optional.of(Iterables.getLast(instances).getUri());	×
66	}
67
68	private List<ServiceInstance> getInstancesForPath(ServicePath service) {
69	return discoveryClient.getInstances(service.getPathWithStartingSlash());	×
70	}
71
72	@Override
73	public URI fetchUri(ServicePath service) {
74	return getUriForPath(service).orNull();	×
75	}
76
77	@Override
78	public Set<URI> fetchAllUris(ServicePath service) {
79	List<ServiceInstance> instances = getInstancesForPath(service);	×
80	Collection<URI> uris = Collections2.transform(instances, new Function<ServiceInstance, URI>() {	×
81	@Override
82	public URI apply(ServiceInstance input) {
83	return input.getUri();	×
84	}
85	});
86	return CollectionUtils.toSet(uris);	×
87	}
88
89	@Override
90	public Set<ServicePath> fetchMyDependencies() {
91	Map<String, ZookeeperDependency> dependencies = zookeeperDependencies.getDependencies();	×
92	Set<ServicePath> servicePaths = new HashSet<>();	×
93	for (Map.Entry<String, ZookeeperDependency> zookeeperDependencyEntry : dependencies.entrySet()) {	×
94	servicePaths.add(new ServicePath(zookeeperDependencyEntry.getValue().getPath()));	×
95	}	×
96	return servicePaths;	×
97	}
98
99	@Override
100	public Set<ServicePath> fetchAllDependencies() {
101	return findLeavesOf(zookeeperDiscoveryProperties.getRoot());	×
102	}
103
104	private Set<ServicePath> findLeavesOf(final String root) {
105	if (isServiceName(root)) {	×
106	return singleton(new ServicePath(stripBasePath(root)));	×
107	}
108
109	List<String> children = new ArrayList<String>();	×
110	try {
111	String path = root;	×
112	if (!path.startsWith("/")) {	×
113	path = "/" + path;	×
114	}
115	children = curatorFramework.getChildren().forPath(path);	×
116	} catch (Exception e) {	×
117	Throwables.propagate(e);	×
118	}	×
119	return toSet(flatten(transform(children, new Function<String, Set<ServicePath>>() {	×
120	@Override
121	public Set<ServicePath> apply(String input) {
122	return findLeavesOf(root + "/" + input);	×
123	}
124
125	}), ServicePath.class));
126	}
127
128	private boolean isServiceName(String path) {
129	final String potentialServiceName = path.substring(zookeeperDiscoveryProperties.getRoot().length());	×
130	try {
131	return !serviceDiscovery.getServiceDiscoveryRef().get().queryForInstances(potentialServiceName).isEmpty();	×
132	} catch (Exception ignored) {	×
133	//ignored, not a service
134	return false;	×
135	}
136	}
137
138	private String stripBasePath(String path) {
139	return path.substring(zookeeperDiscoveryProperties.getRoot().length() + 1);	×
140	}
141
142	@Override
143	public Optional<URI> getUri(ServiceAlias serviceAlias) {
144	return getUriForAlias(serviceAlias);	×
145	}
146
147	@Override
148	public URI fetchUri(ServiceAlias serviceAlias) {
149	return getUriForAlias(serviceAlias).orNull();	×
150	}
151
152	private Optional<URI> getUriForAlias(ServiceAlias service) {
153	List<ServiceInstance> instances = getInstancesForAlias(service);	×
154	if (instances.isEmpty()) {	×
155	return Optional.absent();	×
156	}
157	return Optional.of(Iterables.getLast(instances).getUri());	×
158	}
159
160	private List<ServiceInstance> getInstancesForAlias(ServiceAlias service) {
161	return discoveryClient.getInstances(zookeeperDependencies.getPathForAlias(service.getName()));	×
162	}
163
164	@Override
165	public void start() {
166
167	}	×
168
169	@Override
170	public void close() {
171
172	}	×
173	}

4finance / micro-infra-spring / 2523

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous