org.jclouds.ohai.functions.NestSlashKeys.java Source code

Introduction

Here is the source code for org.jclouds.ohai.functions.NestSlashKeys.java

Source

/*
 * 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 org.jclouds.ohai.functions;

import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkNotNull;

import java.lang.reflect.Type;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import javax.inject.Inject;
import javax.inject.Singleton;

import org.jclouds.domain.JsonBall;
import org.jclouds.json.Json;

import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Function;
import com.google.common.base.Predicate;
import com.google.common.base.Splitter;
import com.google.common.base.Supplier;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.collect.Multimap;
import com.google.common.collect.Sets;
import com.google.inject.TypeLiteral;

@Singleton
public class NestSlashKeys implements Function<Multimap<String, Supplier<JsonBall>>, Map<String, JsonBall>> {

    private final Json json;

    @Inject
    NestSlashKeys(Json json) {
        this.json = checkNotNull(json, "json");
    }

    @Override
    public Map<String, JsonBall> apply(Multimap<String, Supplier<JsonBall>> from) {

        Map<String, JsonBall> autoAttrs = mergeSameKeys(from);

        Map<String, JsonBall> modifiableFlatMap = Maps
                .newLinkedHashMap(Maps.filterKeys(autoAttrs, new Predicate<String>() {

                    @Override
                    public boolean apply(String input) {
                        return input.indexOf('/') == -1;
                    }

                }));
        Map<String, JsonBall> withSlashesMap = Maps.difference(autoAttrs, modifiableFlatMap).entriesOnlyOnLeft();
        for (Entry<String, JsonBall> entry : withSlashesMap.entrySet()) {
            List<String> keyParts = Lists.newArrayList(Splitter.on('/').split(entry.getKey()));
            JsonBall toInsert = entry.getValue();
            try {
                putUnderContext(keyParts, toInsert, modifiableFlatMap);
            } catch (IllegalArgumentException e) {
                throw new IllegalArgumentException("error inserting value in entry: " + entry.getKey(), e);
            }
        }
        return modifiableFlatMap;
    }

    private Map<String, JsonBall> mergeSameKeys(Multimap<String, Supplier<JsonBall>> from) {
        Map<String, JsonBall> merged = Maps.newLinkedHashMap();
        for (Entry<String, Supplier<JsonBall>> entry : from.entries()) {
            if (merged.containsKey(entry.getKey())) {
                mergeAsPeer(entry.getKey(), entry.getValue().get(), merged);
            } else {
                merged.put(entry.getKey(), entry.getValue().get());
            }
        }
        return merged;
    }

    @VisibleForTesting
    void mergeAsPeer(String key, JsonBall value, Map<String, JsonBall> insertionContext) {
        Map<String, JsonBall> immutableValueContext = json.fromJson(insertionContext.get(key).toString(),
                mapLiteral);
        Map<String, JsonBall> valueContext = Maps.newLinkedHashMap(immutableValueContext);
        Map<String, JsonBall> toPut = json.<Map<String, JsonBall>>fromJson(value.toString(), mapLiteral);
        Set<String> uniques = Sets.difference(toPut.keySet(), valueContext.keySet());
        for (String k : uniques) {
            valueContext.put(k, toPut.get(k));
        }
        Set<String> conflicts = Sets.difference(toPut.keySet(), uniques);
        for (String k : conflicts) {
            JsonBall v = toPut.get(k);
            if (v.toString().matches("^\\{.*\\}$")) {
                mergeAsPeer(k, v, valueContext);
            } else {
                // replace
                valueContext.put(k, v);
            }
        }
        insertionContext.put(key, new JsonBall(json.toJson(valueContext, mapLiteral)));
    }

    /**
     * @param keyParts
     * @param toInsert
     * @param destination
     * @throws IllegalArgumentException
     *            <p/>
     *            if destination.get(keyParts(0)) is not a map *
     *            <p/>
     *            keyParts is zero length
     */
    void putUnderContext(List<String> keyParts, JsonBall toInsert, Map<String, JsonBall> destination) {
        checkNotNull(keyParts, "keyParts");
        checkArgument(keyParts.size() >= 1, "keyParts must contain at least one element");

        checkNotNull(toInsert, "toInsert");
        checkNotNull(destination, "destination");

        String rootKey = keyParts.remove(0);
        String rootValue = destination.containsKey(rootKey) ? destination.get(rootKey).toString() : "{}";

        checkArgument(rootValue.matches("^\\{.*\\}$"), "value must be a hash: %s", rootValue);
        Map<String, JsonBall> immutableInsertionContext = json.fromJson(rootValue, mapLiteral);
        Map<String, JsonBall> insertionContext = Maps.newLinkedHashMap(immutableInsertionContext);
        if (keyParts.size() == 1) {
            if (!insertionContext.containsKey(keyParts.get(0))) {
                insertionContext.put(keyParts.get(0), toInsert);
            } else {
                String key = keyParts.get(0);
                mergeAsPeer(key, toInsert, insertionContext);
            }
        } else {
            putUnderContext(keyParts, toInsert, insertionContext);
        }
        destination.put(rootKey, new JsonBall(json.toJson(insertionContext, mapLiteral)));
    }

    final Type mapLiteral = new TypeLiteral<Map<String, JsonBall>>() {
    }.getType();
    final Type listLiteral = new TypeLiteral<List<JsonBall>>() {
    }.getType();
}