Java tutorial
/* * Copyright (c) 2015 Spotify AB. * * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. */ package com.spotify.heroic.cluster; import static com.spotify.heroic.common.Optionals.pickOptional; import static java.util.Optional.empty; import static java.util.Optional.of; import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonProperty; import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableMap; import com.google.common.collect.ImmutableSet; import com.spotify.heroic.common.ServiceInfo; import com.spotify.heroic.dagger.PrimaryComponent; import com.spotify.heroic.lifecycle.LifeCycle; import com.spotify.heroic.lifecycle.LifeCycleManager; import com.spotify.heroic.metadata.MetadataComponent; import com.spotify.heroic.metric.MetricComponent; import com.spotify.heroic.statistics.HeroicReporter; import com.spotify.heroic.statistics.QueryReporter; import com.spotify.heroic.suggest.SuggestComponent; import dagger.Module; import dagger.Provides; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Optional; import java.util.Set; import java.util.UUID; import javax.inject.Named; import lombok.AccessLevel; import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor; import org.apache.commons.lang3.tuple.Pair; /** * @author udoprog */ @Data @Module public class ClusterManagerModule { public static final boolean DEFAULT_USE_LOCAL = true; private final UUID id; private final Map<String, String> tags; private final boolean useLocal; private final ClusterDiscoveryModule discovery; private final List<RpcProtocolModule> protocols; private final Set<Map<String, String>> topology; private final Optional<NodeMetadataFactory> metadataFactory; @Provides @ClusterScope @Named("local") public ClusterNode localClusterNode(LocalClusterNode local) { return local; } @Provides @ClusterScope public NodeMetadata localMetadata(final ServiceInfo service) { return new NodeMetadata(0, id, tags, service); } @Provides @ClusterScope public NodeMetadataProvider metadataProvider(final NodeMetadata localMetadata) { return metadataFactory.map(fn -> fn.buildProvider(localMetadata)) .orElseGet(() -> NodeMetadataProvider.staticProvider(localMetadata)); } @Provides @ClusterScope @Named("useLocal") public Boolean useLocal() { return useLocal; } @Provides @ClusterScope @Named("topology") public Set<Map<String, String>> topology() { return topology; } @Provides @ClusterScope public QueryReporter queryReporter(HeroicReporter heroicReporter) { return heroicReporter.newQueryReporter(); } @Provides @ClusterScope public List<Pair<String, RpcProtocolComponent>> protocolComponents(final NodeMetadataProvider metadataProvider, @Named("local") final ClusterNode localClusterNode, final PrimaryComponent primary, final MetricComponent metric, final MetadataComponent metadata, final SuggestComponent suggest) { final ImmutableList.Builder<Pair<String, RpcProtocolComponent>> protocolComponents = ImmutableList .builder(); /* build up a local component which defines all dependencies for a child component */ final RpcProtocolModule.Dependencies dependencies = DaggerRpcProtocolModule_Dependencies.builder() .primaryComponent(primary).metricComponent(metric).metadataComponent(metadata) .suggestComponent(suggest).provided(new RpcProtocolModule.Provided() { @Override public NodeMetadataProvider metadataProvider() { return metadataProvider; } @Override public ClusterNode localClusterNode() { return localClusterNode; } }).build(); for (final RpcProtocolModule m : protocols) { protocolComponents.add(Pair.of(m.scheme(), m.module(dependencies))); } return protocolComponents.build(); } @Provides @ClusterScope public Map<String, RpcProtocol> protocols(List<Pair<String, RpcProtocolComponent>> protocols) { final Map<String, RpcProtocol> map = new HashMap<>(); for (final Pair<String, RpcProtocolComponent> m : protocols) { map.put(m.getLeft(), m.getRight().rpcProtocol()); } return map; } @Provides @ClusterScope @Named("cluster") LifeCycle clusterLife(LifeCycleManager manager, CoreClusterManager cluster, List<Pair<String, RpcProtocolComponent>> protocols) { final List<LifeCycle> life = new ArrayList<>(); life.add(manager.build(cluster)); protocols.stream().map(p -> p.getRight().life()).forEach(life::add); return LifeCycle.combined(life); } public static Builder builder() { return new Builder(); } @AllArgsConstructor(access = AccessLevel.PRIVATE) @NoArgsConstructor(access = AccessLevel.PRIVATE) public static class Builder { private Optional<UUID> id = empty(); private Optional<Map<String, String>> tags = empty(); private Optional<Boolean> useLocal = empty(); private Optional<ClusterDiscoveryModule> discovery = empty(); private Optional<List<RpcProtocolModule>> protocols = empty(); private Optional<Set<Map<String, String>>> topology = empty(); private Optional<NodeMetadataFactory> metadataFactory = empty(); @JsonCreator public Builder(@JsonProperty("id") Optional<UUID> id, @JsonProperty("tags") Optional<Map<String, String>> tags, @JsonProperty("useLocal") Optional<Boolean> useLocal, @JsonProperty("discovery") Optional<ClusterDiscoveryModule> discovery, @JsonProperty("protocols") Optional<List<RpcProtocolModule>> protocols, @JsonProperty("topology") Optional<Set<Map<String, String>>> topology) { this.id = id; this.tags = tags; this.useLocal = useLocal; this.discovery = discovery; this.protocols = protocols; this.topology = topology; } public Builder id(UUID id) { this.id = of(id); return this; } public Builder tags(Map<String, String> tags) { this.tags = of(tags); return this; } public Builder useLocal(Boolean useLocal) { this.useLocal = of(useLocal); return this; } public Builder discovery(ClusterDiscoveryModule discovery) { this.discovery = of(discovery); return this; } public Builder protocols(List<RpcProtocolModule> protocols) { this.protocols = of(protocols); return this; } public Builder topology(Set<Map<String, String>> topology) { this.topology = of(topology); return this; } /** * Set the metadata factory. * * Only used for testing purposes. * * @param metadataFactory factory to use * @return this builder */ public Builder metadataFactory(NodeMetadataFactory metadataFactory) { this.metadataFactory = of(metadataFactory); return this; } public Builder merge(Builder o) { // @formatter:off return new Builder(pickOptional(id, o.id), pickOptional(tags, o.tags), pickOptional(useLocal, o.useLocal), pickOptional(discovery, o.discovery), pickOptional(protocols, o.protocols), pickOptional(topology, o.topology), pickOptional(metadataFactory, o.metadataFactory)); // @formatter:on } public ClusterManagerModule build() { // @formatter:off return new ClusterManagerModule(id.orElseGet(UUID::randomUUID), tags.orElseGet(ImmutableMap::of), useLocal.orElse(DEFAULT_USE_LOCAL), discovery.orElseGet(ClusterDiscoveryModule::nullModule), protocols.orElseGet(ImmutableList::of), topology.orElseGet(ImmutableSet::of), metadataFactory); // @formatter:on } } }