org.jclouds.googlecomputeengine.compute.functions.InstanceInZoneToNodeMetadata Maven / Gradle / Ivy

Go to download
/*
 * 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.googlecomputeengine.compute.functions;

import static com.google.common.base.Preconditions.checkNotNull;
import static org.jclouds.compute.util.ComputeServiceUtils.groupFromMapOrName;
import static org.jclouds.googlecomputeengine.GoogleComputeEngineConstants.GCE_IMAGE_METADATA_KEY;

import java.net.URI;
import java.util.Map;
import java.util.Set;

import javax.inject.Inject;

import org.jclouds.collect.Memoized;
import org.jclouds.compute.domain.Hardware;
import org.jclouds.compute.domain.Image;
import org.jclouds.compute.domain.NodeMetadata;
import org.jclouds.compute.domain.NodeMetadataBuilder;
import org.jclouds.compute.functions.GroupNamingConvention;
import org.jclouds.domain.Location;
import org.jclouds.googlecomputeengine.GoogleComputeEngineApi;
import org.jclouds.googlecomputeengine.config.UserProject;
import org.jclouds.googlecomputeengine.domain.Instance;
import org.jclouds.googlecomputeengine.domain.InstanceInZone;
import org.jclouds.googlecomputeengine.domain.SlashEncodedIds;

import com.google.common.base.Function;
import com.google.common.base.Predicates;
import com.google.common.base.Supplier;
import com.google.common.collect.FluentIterable;
import com.google.common.collect.ImmutableSet;

/**
 * Transforms a google compute domain Instance into a generic NodeMetatada object.
 *
 * @author David Alves
 */
public class InstanceInZoneToNodeMetadata implements Function {

   private final Map toPortableNodeStatus;
   private final GroupNamingConvention nodeNamingConvention;
   private final Supplier> images;
   private final Supplier> hardwares;
   private final Supplier> locations;
   private final FirewallTagNamingConvention.Factory firewallTagNamingConvention;
   private final GoogleComputeEngineApi api;
   private final Supplier userProject;

   @Inject
   public InstanceInZoneToNodeMetadata(Map toPortableNodeStatus,
                                 GroupNamingConvention.Factory namingConvention,
                                 @Memoized Supplier> images,
                                 @Memoized Supplier> hardwares,
                                 @Memoized Supplier> locations,
                                 FirewallTagNamingConvention.Factory firewallTagNamingConvention,
                                 GoogleComputeEngineApi api,
                                 @UserProject Supplier userProject) {
      this.toPortableNodeStatus = toPortableNodeStatus;
      this.nodeNamingConvention = namingConvention.createWithoutPrefix();
      this.images = images;
      this.hardwares = hardwares;
      this.locations = locations;
      this.firewallTagNamingConvention = checkNotNull(firewallTagNamingConvention, "firewallTagNamingConvention");
      this.api = checkNotNull(api, "api");
      this.userProject = checkNotNull(userProject, "userProject");
   }

   @Override
   public NodeMetadata apply(InstanceInZone instanceInZone) {
      Instance input = instanceInZone.getInstance();

      String group = groupFromMapOrName(input.getMetadata().getItems(),
                                               input.getName(), nodeNamingConvention);
      FluentIterable tags = FluentIterable.from(input.getTags().getItems())
                                            .filter(Predicates.not(firewallTagNamingConvention.get(group).isFirewallTag()));

      NodeMetadataBuilder builder = new NodeMetadataBuilder();

      builder.id(SlashEncodedIds.fromTwoIds(checkNotNull(locations.get().get(input.getZone()),
                                                                "location for %s", input.getZone())
                                                    .getId(), input.getName()).slashEncode())
              .name(input.getName())
              .providerId(input.getId())
              .hostname(input.getName())
              .location(checkNotNull(locations.get().get(input.getZone()), "location for %s", input.getZone()))
              .hardware(checkNotNull(hardwares.get().get(input.getMachineType()), "hardware type for %s",
                                            input.getMachineType().toString()))
              .status(toPortableNodeStatus.get(input.getStatus()))
              .tags(tags)
              .uri(input.getSelfLink())
              .userMetadata(input.getMetadata().getItems())
              .group(group)
              .privateAddresses(collectPrivateAddresses(input))
              .publicAddresses(collectPublicAddresses(input));

      if (input.getMetadata().getItems().containsKey(GCE_IMAGE_METADATA_KEY)) {
         try {
            URI imageUri = URI.create(input.getMetadata().getItems()
                                              .get(GCE_IMAGE_METADATA_KEY));

            Map imagesMap = images.get();

            Image image = checkNotNull(imagesMap.get(imageUri),
                                       "no image for %s. images: %s", imageUri,
                                       imagesMap.values());
            builder.imageId(image.getId());
         } catch (IllegalArgumentException e) {
            // Swallow any exception here - it just means we don't actually have a valid image URI, so we skip it.
         }
      }

      return builder.build();
   }

   private Set collectPrivateAddresses(Instance input) {
      ImmutableSet.Builder privateAddressesBuilder = ImmutableSet.builder();
      for (Instance.NetworkInterface networkInterface : input.getNetworkInterfaces()) {
         if (networkInterface.getNetworkIP().isPresent()) {
            privateAddressesBuilder.add(networkInterface.getNetworkIP().get());
         }
      }
      return privateAddressesBuilder.build();
   }

   private Set collectPublicAddresses(Instance input) {
      ImmutableSet.Builder publicAddressesBuilder = ImmutableSet.builder();
      for (Instance.NetworkInterface networkInterface : input.getNetworkInterfaces()) {
         for (Instance.NetworkInterface.AccessConfig accessConfig : networkInterface.getAccessConfigs()) {
            if (accessConfig.getNatIP().isPresent()) {
               publicAddressesBuilder.add(accessConfig.getNatIP().get());
            }
         }
      }
      return publicAddressesBuilder.build();
   }
}