Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package com.hubspot.mesos;
  
  import java.util.List;
  import java.util.Random;
  
 
 
 public class MesosUtils {
 
   public static final String CPUS = "cpus";
   public static final String MEMORY = "mem";
   public static final String PORTS = "ports";
 
   private MesosUtils() { }
 
   private static double getScalar(Resource r) {
     return r.getScalar().getValue();
   }
 
   private static double getScalar(List<ResourceresourcesString name) {
     for (Resource r : resources) {
       if (r.hasName() && r.getName().equals(name) && r.hasScalar()) {
         return getScalar(r);
       }
     }
 
     return 0;
   }
 
   private static Ranges getRanges(List<ResourceresourcesString name) {
     for (Resource r : resources) {
       if (r.hasName() && r.getName().equals(name) && r.hasRanges()) {
         return r.getRanges();
       }
     }
 
     return null;
   }
 
   private static Ranges getRanges(TaskInfo taskInfoString name) {
     return getRanges(taskInfo.getResourcesList(), name);
   }
 
   private static int getNumRanges(List<ResourceresourcesString name) {
     int totalRanges = 0;
 
     Ranges ranges = getRanges(resourcesname);
 
     if (ranges == null) {
       return 0;
     }
 
     for (Range range : ranges.getRangeList()) {
       long num = range.getEnd() - range.getBegin();
       totalRanges += num;
     }
 
     return totalRanges;
   }
 
   public static Resource getCpuResource(double cpus) {
     return newScalar(cpus);
   }
 
   public static Resource getMemoryResource(double memory) {
     return newScalar(memory);
   }
 
   public static long[] getPorts(Resource portsResourceint numPorts) {
     long[] ports = new long[numPorts];
     int idx = 0;
 
     for (Range r : portsResource.getRanges().getRangeList()) {
       for (long port = r.getBegin(); port <= r.getEnd(); port++) {
         ports[idx++] = port;
 
         if (idx >= numPorts) {
           return ports;
         }
       }
    }
    return ports;
  }
  public static List<LonggetAllPorts(TaskInfo taskInfo) {
    final List<Longports = Lists.newArrayList();
    final Ranges ranges = getRanges(taskInfo);
    if (ranges != null) {
      for (Range range : ranges.getRangeList()) {
        for (long port = range.getBegin(); port < range.getEnd(); port++) {
          ports.add(port);
        }
      }
    }
    return ports;
  }
  public static Resource getPortsResource(int numPortsOffer offer) {
    return getPortsResource(numPortsoffer.getResourcesList());
  }
  public static Resource getPortsResource(int numPortsList<Resourceresources) {
    Ranges ranges = getRanges(resources);
    Preconditions.checkState(ranges != null"Ports %s should have existed in resources %s"resources);
    Ranges.Builder rangesBldr = Ranges.newBuilder();
    int portsSoFar = 0;
    List<RangeofferRangeList = Lists.newArrayList(ranges.getRangeList());
    Random random = new Random();
    Collections.shuffle(offerRangeListrandom);
    for (Range range : offerRangeList) {
      long rangeStartSelection = Math.max(range.getBegin(), range.getEnd() - (numPorts - portsSoFar + 1));
      if (rangeStartSelection != range.getBegin()) {
        int rangeDelta = (int) (rangeStartSelection - range.getBegin()) + 1;
        rangeStartSelection = random.nextInt(rangeDelta) + range.getBegin();
      }
      long rangeEndSelection = Math.min(range.getEnd(), rangeStartSelection + (numPorts - portsSoFar - 1));
      rangesBldr.addRange(Range.newBuilder()
          .setBegin(rangeStartSelection)
          .setEnd(rangeEndSelection));
      portsSoFar += (rangeEndSelection - rangeStartSelection) + 1;
      if (portsSoFar == numPorts) {
        break;
      }
    }
    return Resource.newBuilder()
        .setType(.)
        .setName()
        .setRanges(rangesBldr)
        .build();
  }
  private static Resource newScalar(String namedouble value) {
    return Resource.newBuilder().setName(name).setType(..).setScalar(Value.Scalar.newBuilder().setValue(value).build()).build();
  }
  public static double getNumCpus(Offer offer) {
    return getNumCpus(offer.getResourcesList());
  }
  public static double getMemory(Offer offer) {
    return getMemory(offer.getResourcesList());
  }
  public static double getNumCpus(List<Resourceresources) {
    return getScalar(resources);
  }
  public static double getMemory(List<Resourceresources) {
    return getScalar(resources);
  }
  public static int getNumPorts(List<Resourceresources) {
    return getNumRanges(resources);
  }
  public static int getNumPorts(Offer offer) {
    return getNumPorts(offer.getResourcesList());
  }
  public static boolean doesOfferMatchResources(Resources resourcesList<ResourceofferResources) {
    double numCpus = getNumCpus(offerResources);
    if (numCpus < resources.getCpus()) {
      return false;
    }
    double memory = getMemory(offerResources);
    if (memory < resources.getMemoryMb()) {
      return false;
    }
    int numPorts = getNumPorts(offerResources);
    if (numPorts < resources.getNumPorts()) {
      return false;
    }
    return true;
  }
  public static boolean isTaskDone(TaskState state) {
    return state == . || state == . || state == . || state == .;
  }
  public static String getMasterHostAndPort(MasterInfo masterInfo) {
    byte[] fromIp = ByteBuffer.allocate(4).putInt(masterInfo.getIp()).array();
    try {
      return String.format("%s:%s", InetAddresses.fromLittleEndianByteArray(fromIp).getHostAddress(), masterInfo.getPort());
    } catch (UnknownHostException e) {
      throw Throwables.propagate(e);
    }
  }
  private static Optional<ResourcegetMatchingResource(Resource toMatchList<Resourceresources) {
    for (Resource resource : resources) {
      if (toMatch.getName().equals(resource.getName())) {
        return Optional.of(resource);
      }
    }
    return Optional.absent();
  }
  private static final Comparator<RangeRANGE_COMPARATOR = new Comparator<Range>() {
    @Override
    public int compare(Range o1Range o2) {
      return Longs.compare(o1.getBegin(), o2.getBegin());
    }
  };
  private static Ranges subtractRanges(Ranges rangesRanges toSubtract) {
    Ranges.Builder newRanges = Ranges.newBuilder();
    List<RangesortedRanges = Lists.newArrayList(ranges.getRangeList());
    Collections.sort(sortedRanges);
    List<RangesubtractRanges = Lists.newArrayList(toSubtract.getRangeList());
    Collections.sort(subtractRanges);
    int s = 0;
    for (Range range : ranges.getRangeList()) {
      Range.Builder currentRange = range.toBuilder();
      for (int i = si < subtractRanges.size(); i++) {
        Range matchedRange = subtractRanges.get(i);
        if (matchedRange.getBegin() < currentRange.getBegin() || matchedRange.getEnd() > currentRange.getEnd()) {
          s = i;
          break;
        }
        currentRange.setEnd(matchedRange.getBegin() - 1);
        if (currentRange.getEnd() >= currentRange.getBegin()) {
          newRanges.addRange(currentRange.build());
        }
        currentRange = Range.newBuilder();
        currentRange.setBegin(matchedRange.getEnd() + 1);
        currentRange.setEnd(range.getEnd());
      }
      if (currentRange.getEnd() >= currentRange.getBegin()) {
        newRanges.addRange(currentRange.build());
      }
    }
    return newRanges.build();
  }
  public static List<ResourcesubtractResources(List<ResourceresourcesList<Resourcesubtract) {
    List<Resourceremaining = Lists.newArrayListWithCapacity(resources.size());
    for (Resource resource : resources) {
      Optional<Resourcematched = getMatchingResource(resourcesubtract);
      if (!matched.isPresent()) {
        remaining.add(resource.toBuilder().clone().build());
      } else {
        Resource.Builder resourceBuilder = resource.toBuilder().clone();
        if (resource.hasScalar()) {
          resourceBuilder.setScalar(resource.toBuilder().getScalarBuilder().setValue(resource.getScalar().getValue() - matched.get().getScalar().getValue()).build());
        } else if (resource.hasRanges()) {
          resourceBuilder.setRanges(subtractRanges(resource.getRanges(), matched.get().getRanges()));
        } else {
          throw new IllegalStateException(String.format("Can't subtract non-scalar or range resources %s"resource));
        }
        remaining.add(resourceBuilder.build());
      }
    }
    return remaining;
  }
New to GrepCode? Check out our FAQ X