public static void handleOrphan(Cluster cluster, ClusterAddressInfo address) {
   Integer orphanCount = 1;
   orphanCount = orphans.putIfAbsent(address, orphanCount);
   orphanCount = (orphanCount == null) ? 1 : orphanCount;
   orphans.put(address, orphanCount + 1);
   EventRecord.caller(
           ClusterState.class,
           EventType.ADDRESS_STATE,
           "Updated orphaned public ip address: "
               + LogUtil.dumpObject(address)
               + " count="
               + orphanCount)
       .debug();
   if (orphanCount > AddressingConfiguration.getInstance().getMaxKillOrphans()) {
     EventRecord.caller(
             ClusterState.class,
             EventType.ADDRESS_STATE,
             "Unassigning orphaned public ip address: "
                 + LogUtil.dumpObject(address)
                 + " count="
                 + orphanCount)
         .warn();
     try {
       final Address addr = Addresses.getInstance().lookup(address.getAddress());
       if (addr.isPending()) {
         try {
           addr.clearPending();
         } catch (Exception ex) {
         }
       }
       try {
         if (addr.isAssigned() && "0.0.0.0".equals(address.getInstanceIp())) {
           addr.unassign().clearPending();
           if (addr.isSystemOwned()) {
             addr.release();
           }
         } else if (addr.isAssigned() && !"0.0.0.0".equals(address.getInstanceIp())) {
           AsyncRequests.newRequest(new UnassignAddressCallback(address))
               .sendSync(cluster.getConfiguration());
           if (addr.isSystemOwned()) {
             addr.release();
           }
         } else if (!addr.isAssigned() && addr.isAllocated() && addr.isSystemOwned()) {
           addr.release();
         }
       } catch (ExecutionException ex) {
         if (!addr.isAssigned() && addr.isAllocated() && addr.isSystemOwned()) {
           addr.release();
         }
       }
     } catch (InterruptedException ex) {
       Exceptions.maybeInterrupted(ex);
     } catch (NoSuchElementException ex) {
     } finally {
       orphans.remove(address);
     }
   }
 }
 public static void handle(String service, MuleMessage responseMessage, BaseMessage request) {
   BaseMessage reply = null;
   if (responseMessage.getExceptionPayload() == null) {
     reply = (BaseMessage) responseMessage.getPayload();
   } else {
     Throwable t = responseMessage.getExceptionPayload().getException();
     t = (t.getCause() == null) ? t : t.getCause();
     reply = new EucalyptusErrorMessageType(service, request, t.getMessage());
   }
   String corrId = reply.getCorrelationId();
   EventRecord.here(
           EuareReplyQueue.class,
           EventType.MSG_REPLY,
           reply.getCorrelationId(),
           reply.getClass().getSimpleName())
       .debug();
   try {
     Context context = Contexts.lookup(corrId);
     Channel channel = context.getChannel();
     Channels.write(channel, reply);
     Contexts.clear(context);
   } catch (NoSuchContextException e) {
     LOG.trace(e, e);
   }
 }
 public static void processFiles() {
   final File libDir = new File(BaseDirectory.LIB.toString());
   for (final File f : libDir.listFiles()) {
     if (f.getName().startsWith("eucalyptus")
         && f.getName().endsWith(".jar")
         && !f.getName().matches(".*-ext-.*")) {
       EventRecord.here(
               ServiceJarDiscovery.class, EventType.BOOTSTRAP_INIT_SERVICE_JAR, f.getName())
           .info();
       try {
         BindingFileSearch.INSTANCE.process(f);
       } catch (final Throwable e) {
         LOG.error(e.getMessage());
         continue;
       }
     }
   }
   for (String pathName : ClassPath.SYSTEM_CLASS_PATH.getClassPath().split(File.pathSeparator)) {
     File pathFile = new File(pathName);
     if (pathFile.isDirectory()) {
       try {
         BindingFileSearch.INSTANCE.process(pathFile);
       } catch (final Throwable e) {
         LOG.error(e.getMessage());
         continue;
       }
       ;
     }
   }
 }
Example #4
0
 @Override
 public void fireEnable(ServiceConfiguration config) throws ServiceRegistrationException {
   if (!config.isVmLocal()) {
     for (Host h : Hosts.list()) {
       if (h.getHostAddresses().contains(config.getInetAddress())) {
         EventRecord.here(
                 EucalyptusBuilder.class, EventType.COMPONENT_SERVICE_ENABLED, config.toString())
             .info();
         return;
       }
     }
     throw Faults.failure(
         config,
         Exceptions.error(
             "There is no host in the system (yet) for the given cloud controller configuration: "
                 + config.getFullName()
                 + ".\nHosts are: "
                 + Hosts.list()));
   } else if (config.isVmLocal() && !Hosts.isCoordinator()) {
     throw Faults.failure(
         config,
         Exceptions.error(
             "This cloud controller "
                 + config.getFullName()
                 + " is not currently the coordinator "
                 + Hosts.list()));
   }
 }
Example #5
0
 private boolean transition(
     State expectedState,
     State newState,
     boolean expectedMark,
     boolean newMark,
     SplitTransition transition) {
   this.transition = transition;
   if (!this.atomicState.compareAndSet(expectedState, newState, expectedMark, newMark)) {
     throw new IllegalStateException(
         String.format(
             "Cannot mark address as %s[%s.%s->%s.%s] when it is %s.%s: %s",
             transition.getName(),
             expectedState,
             expectedMark,
             newState,
             newMark,
             this.atomicState.getReference(),
             this.atomicState.isMarked(),
             this.toString()));
   }
   EventRecord.caller(this.getClass(), EventType.ADDRESS_STATE, "TOP", this.toString()).info();
   try {
     this.transition.top();
   } catch (RuntimeException ex) {
     LOG.error(ex);
     Logs.extreme().error(ex, ex);
     throw ex;
   }
   return true;
 }
 @Override
 public void fireCheck(ServiceConfiguration config) throws ServiceRegistrationException {
   EventRecord.here(
           ServiceBuilder.class,
           EventType.COMPONENT_SERVICE_CHECK,
           config.getFullName().toString(),
           config.toString())
       .exhaust();
 }
Example #7
0
 public <T extends ServiceConfiguration> T remove(final T config) {
   final EntityTransaction db = Entities.get(config.getClass());
   try {
     final T searchConfig = (T) config.getClass().newInstance();
     searchConfig.setName(config.getName());
     final T exists = Entities.uniqueResult(searchConfig);
     Entities.delete(exists);
     db.commit();
     EventRecord.here(
             ServiceConfigurations.class,
             EventClass.COMPONENT,
             EventType.COMPONENT_DEREGISTERED,
             config.toString())
         .info();
   } catch (final NoSuchElementException ex) {
     db.rollback();
   } catch (final PersistenceException ex) {
     LOG.debug(ex);
     EventRecord.here(
             ServiceConfigurations.class,
             EventClass.COMPONENT,
             EventType.COMPONENT_DEREGISTERED,
             "FAILED",
             config.toString())
         .error();
     db.rollback();
     throw ex;
   } catch (final Throwable ex) {
     LOG.debug(ex);
     EventRecord.here(
             ServiceConfigurations.class,
             EventClass.COMPONENT,
             EventType.COMPONENT_DEREGISTERED,
             "FAILED",
             config.toString())
         .error();
     db.rollback();
     throw new PersistenceException(
         "Service configuration removal failed for: " + LogUtil.dumpObject(config), ex);
   }
   return config;
 }
Example #8
0
 public static void write(final String fileName, final Object securityToken) {
   PEMWriter privOut = null;
   try {
     privOut = new PEMWriter(new FileWriter(fileName));
     EventRecord.caller(PEMFiles.class, EventType.CERTIFICATE_WRITE, fileName).info();
     privOut.writeObject(securityToken);
     privOut.close();
   } catch (final IOException e) {
     LOG.error(e, e);
   }
 }
Example #9
0
 public <T extends ServiceConfiguration> T store(T config) {
   final EntityTransaction db = Entities.get(config.getClass());
   try {
     config = Entities.persist(config);
     db.commit();
     EventRecord.here(
             ServiceConfigurations.class,
             EventClass.COMPONENT,
             EventType.COMPONENT_REGISTERED,
             config.toString())
         .info();
   } catch (final PersistenceException ex) {
     LOG.debug(ex);
     EventRecord.here(
             ServiceConfigurations.class,
             EventClass.COMPONENT,
             EventType.COMPONENT_REGISTERED,
             "FAILED",
             config.toString())
         .error();
     db.rollback();
     throw ex;
   } catch (final Throwable ex) {
     LOG.debug(ex);
     EventRecord.here(
             ServiceConfigurations.class,
             EventClass.COMPONENT,
             EventType.COMPONENT_REGISTERED,
             "FAILED",
             config.toString())
         .error();
     db.rollback();
     throw new PersistenceException(
         "Service configuration storing failed for: " + LogUtil.dumpObject(config), ex);
   }
   return config;
 }
 @Override
 public boolean apply(Allocation allocInfo) {
   if (EventRecord.isTraceEnabled(AdmissionControl.class)) {
     EventRecord.here(
             AdmissionControl.class, EventType.VM_RESERVED, LogUtil.dumpObject(allocInfo))
         .trace();
   }
   List<ResourceAllocator> finished = Lists.newArrayList();
   EntityTransaction db = Entities.get(NetworkGroup.class);
   try {
     for (ResourceAllocator allocator : allocators) {
       runAllocatorSafely(allocInfo, allocator);
       finished.add(allocator);
     }
     db.commit();
     return true;
   } catch (Exception ex) {
     Logs.exhaust().error(ex, ex);
     rollbackAllocations(allocInfo, finished, ex);
     db.rollback();
     throw Exceptions.toUndeclared(
         new NotEnoughResourcesException(Exceptions.getCauseMessage(ex), ex));
   }
 }
Example #11
0
 public Address clearPending() {
   if (!this.atomicState.isMarked()) {
     throw new IllegalStateException("Trying to clear an address which is not currently pending.");
   } else {
     EventRecord.caller(this.getClass(), EventType.ADDRESS_STATE, "BOTTOM", this.toString())
         .info();
     try {
       this.transition.bottom();
     } catch (RuntimeException ex) {
       LOG.error(ex);
       Logs.extreme().error(ex, ex);
     } finally {
       this.transition = this.QUIESCENT;
       this.atomicState.set(this.atomicState.getReference(), false);
     }
   }
   return this;
 }
 @Override
 public void fire(AssignAddressResponseType msg) {
   try {
     if (!this.checkVmState()) {
       this.clearState();
     } else {
       this.address.clearPending();
       EventRecord.here(
               AssignAddressCallback.class,
               EventType.ADDRESS_ASSIGNED,
               Address.State.assigned.toString(),
               this.address.toString())
           .info();
     }
   } catch (Exception e) {
     LOG.debug(e, e);
     this.clearState();
   }
 }
 public void handle(BaseMessage responseMessage) {
   EventRecord.here(
           EuareReplyQueue.class,
           EventType.MSG_REPLY,
           responseMessage.getCorrelationId(),
           responseMessage.getClass().getSimpleName())
       .debug();
   LOG.debug("HERE: " + responseMessage);
   String corrId = responseMessage.getCorrelationId();
   try {
     Context context = Contexts.lookup(corrId);
     Channel channel = context.getChannel();
     Channels.write(channel, responseMessage);
     Contexts.clear(context);
   } catch (NoSuchContextException e) {
     LOG.warn("Received a reply for absent client:  No channel to write response message.", e);
     LOG.debug(responseMessage);
   }
 }
 @SuppressWarnings("ThrowableResultOfMethodCallIgnored")
 public void handle(final ExceptionMessage exMsg) {
   EventRecord.here(getClass(), EventType.MSG_REPLY, exMsg.getPayload().getClass().getSimpleName())
       .debug();
   LOG.trace("Caught exception while servicing: " + exMsg.getPayload());
   final Throwable exception = exMsg.getException();
   if (exception instanceof MessagingException
       && exception.getCause() instanceof EucalyptusCloudException) {
     try {
       final EucalyptusCloudException cloudException =
           (EucalyptusCloudException) exception.getCause();
       final BaseMessage payload = parsePayload(exMsg.getPayload());
       final HttpResponseStatus status;
       final Role role;
       final String code;
       if (cloudException instanceof EucalyptusWebServiceException) {
         final EucalyptusWebServiceException webServiceException =
             (EucalyptusWebServiceException) cloudException;
         role = webServiceException.getRole();
         code = webServiceException.getCode();
       } else {
         role = Role.Receiver;
         code = defaultCode;
       }
       final QueryBindingInfo info =
           Ats.inClassHierarchy(cloudException.getClass()).get(QueryBindingInfo.class);
       status =
           info == null
               ? HttpResponseStatus.INTERNAL_SERVER_ERROR
               : new HttpResponseStatus(info.statusCode(), code);
       final BaseMessage errorResp =
           buildErrorResponse(payload.getCorrelationId(), role, code, cloudException.getMessage());
       Contexts.response(new BaseMessageSupplier(errorResp, status));
     } catch (final PayloadParseException e) {
       LOG.error("Failed to parse payload ", e.getCause());
     }
   } else {
     LOG.error("Unable to handle exception", exception);
     final BaseMessage errorResp = buildFatalResponse(exception);
     Contexts.response(
         new BaseMessageSupplier(errorResp, HttpResponseStatus.INTERNAL_SERVER_ERROR));
   }
 }
Example #15
0
 static FilteredPipeline find(final HttpRequest request)
     throws DuplicatePipelineException, NoAcceptingPipelineException {
   final FilteredPipeline candidate = findAccepting(request);
   if (candidate == null) {
     if (Logs.isExtrrreeeme()) {
       if (request instanceof MappingHttpMessage) {
         ((MappingHttpMessage) request).logMessage();
         for (final FilteredPipeline p : pipelines) {
           LOG.debug("PIPELINE: " + p);
         }
         for (final FilteredPipeline p : internalPipelines) {
           LOG.debug("PIPELINE: " + p);
         }
       }
     }
     throw new NoAcceptingPipelineException();
   }
   if (Logs.isExtrrreeeme()) {
     EventRecord.here(Pipelines.class, EventType.PIPELINE_UNROLL, candidate.toString()).extreme();
   }
   return candidate;
 }
 private void clearState() {
   EventRecord.here(
           AssignAddressCallback.class,
           EventType.ADDRESS_ASSIGNING,
           Transition.assigning.toString(),
           "FAILED",
           this.address.toString())
       .debug();
   if (this.address.isPending()) {
     try {
       this.address.clearPending();
     } catch (Exception ex) {
     }
   }
   if (this.address.isSystemOwned()) {
     Addresses.release(this.address);
   } else if (this.address.isAssigned() && this.vm != null) {
     AddressingDispatcher.dispatch(
         AsyncRequests.newRequest(this.address.unassign().getCallback()), vm.getPartition());
   } else if (this.address.isAssigned() && this.vm == null) {
     this.address.unassign().clearPending();
   }
 }
 public void handle(ExceptionMessage exMsg) {
   EventRecord.here(
           EuareReplyQueue.class,
           EventType.MSG_REPLY,
           exMsg.getPayload().getClass().getSimpleName())
       .debug();
   LOG.trace("Caught exception while servicing: " + exMsg.getPayload());
   Throwable exception = exMsg.getException();
   if (exception instanceof MessagingException
       && exception.getCause() instanceof EucalyptusCloudException) {
     HttpResponseStatus status = HttpResponseStatus.INTERNAL_SERVER_ERROR;
     String errorName = EuareException.INTERNAL_FAILURE;
     if (exception.getCause() instanceof EuareException) {
       EuareException euareException = (EuareException) exception.getCause();
       status = euareException.getStatus();
       errorName = euareException.getError();
     }
     ErrorResponseType errorResp = new ErrorResponseType();
     BaseMessage payload = null;
     try {
       payload = parsePayload(((MessagingException) exception).getUmoMessage().getPayload());
     } catch (Exception e) {
       LOG.error("Failed to parse payload ", e);
     }
     if (payload != null) {
       errorResp.setHttpStatus(status);
       errorResp.setCorrelationId(payload.getCorrelationId());
       errorResp.setRequestId(payload.getCorrelationId());
       ErrorType error = new ErrorType();
       error.setType("Sender");
       error.setCode(errorName);
       error.setMessage(exception.getCause().getMessage());
       errorResp.getErrorList().add(error);
       this.handle(errorResp);
     }
   }
 }
Example #18
0
  public DetachVolumeResponseType detach(DetachVolumeType request) throws EucalyptusCloudException {
    DetachVolumeResponseType reply = (DetachVolumeResponseType) request.getReply();
    Context ctx = Contexts.lookup();

    Volume vol;
    try {
      vol = Volumes.lookup(ctx.getUserFullName().asAccountFullName(), request.getVolumeId());
    } catch (Exception ex1) {
      throw new EucalyptusCloudException("Volume does not exist: " + request.getVolumeId());
    }
    if (!RestrictedTypes.filterPrivileged().apply(vol)) {
      throw new EucalyptusCloudException(
          "Not authorized to detach volume "
              + request.getVolumeId()
              + " by "
              + ctx.getUser().getName());
    }

    VmInstance vm = null;
    AttachedVolume volume = null;
    try {
      VmVolumeAttachment vmVolAttach = VmInstances.lookupVolumeAttachment(request.getVolumeId());
      volume = VmVolumeAttachment.asAttachedVolume(vmVolAttach.getVmInstance()).apply(vmVolAttach);
      vm = vmVolAttach.getVmInstance();
    } catch (NoSuchElementException ex) {
      /** no such attachment * */
    }
    if (volume == null) {
      throw new EucalyptusCloudException("Volume is not attached: " + request.getVolumeId());
    }
    if (!RestrictedTypes.filterPrivileged().apply(vm)) {
      throw new EucalyptusCloudException(
          "Not authorized to detach volume from instance "
              + request.getInstanceId()
              + " by "
              + ctx.getUser().getName());
    }
    if (!vm.getInstanceId().equals(request.getInstanceId())
        && request.getInstanceId() != null
        && !request.getInstanceId().equals("")) {
      throw new EucalyptusCloudException(
          "Volume is not attached to instance: " + request.getInstanceId());
    }
    if (request.getDevice() != null
        && !request.getDevice().equals("")
        && !volume.getDevice().equals(request.getDevice())) {
      throw new EucalyptusCloudException(
          "Volume is not attached to device: " + request.getDevice());
    }

    Cluster cluster = null;
    ServiceConfiguration ccConfig = null;
    try {
      ccConfig = Topology.lookup(ClusterController.class, vm.lookupPartition());
      cluster = Clusters.lookup(ccConfig);
    } catch (NoSuchElementException e) {
      LOG.debug(e, e);
      throw new EucalyptusCloudException(
          "Cluster does not exist in partition: " + vm.getPartition());
    }
    ServiceConfiguration scVm;
    try {
      scVm = Topology.lookup(Storage.class, vm.lookupPartition());
    } catch (Exception ex) {
      LOG.error(ex, ex);
      throw new EucalyptusCloudException(
          "Failed to lookup SC for partition: " + vm.getPartition(), ex);
    }
    request.setVolumeId(volume.getVolumeId());
    request.setRemoteDevice(volume.getRemoteDevice());
    request.setDevice(volume.getDevice().replaceAll("unknown,requested:", ""));
    request.setInstanceId(vm.getInstanceId());
    VolumeDetachCallback ncDetach = new VolumeDetachCallback(request);
    try {
      AsyncRequests.sendSync(scVm, new DetachStorageVolumeType(volume.getVolumeId()));
    } catch (Exception e) {
      LOG.debug(e);
      Logs.extreme().debug(e, e);
      // GRZE: attach is idempotent, failure here is ok.      throw new EucalyptusCloudException(
      // e.getMessage( ) );
    }
    AsyncRequests.newRequest(ncDetach).dispatch(cluster.getConfiguration());
    EventRecord.here(VolumeManager.class, EventClass.VOLUME, EventType.VOLUME_DETACH)
        .withDetails(vm.getOwner().toString(), volume.getVolumeId(), "instance", vm.getInstanceId())
        .withDetails("cluster", ccConfig.getFullName().toString())
        .info();
    volume.setStatus("detaching");
    reply.setDetachedVolume(volume);
    return reply;
  }
Example #19
0
  public AttachVolumeResponseType AttachVolume(AttachVolumeType request)
      throws EucalyptusCloudException {
    AttachVolumeResponseType reply = (AttachVolumeResponseType) request.getReply();
    final String deviceName = request.getDevice();
    final String volumeId = request.getVolumeId();
    final Context ctx = Contexts.lookup();

    if (request.getDevice() == null
        || request.getDevice().endsWith("sda")
        || request.getDevice().endsWith("sdb")) {
      throw new EucalyptusCloudException("Invalid device name specified: " + request.getDevice());
    }
    VmInstance vm = null;
    try {
      vm = RestrictedTypes.doPrivileged(request.getInstanceId(), VmInstance.class);
    } catch (NoSuchElementException ex) {
      LOG.debug(ex, ex);
      throw new EucalyptusCloudException("Instance does not exist: " + request.getInstanceId(), ex);
    } catch (Exception ex) {
      LOG.debug(ex, ex);
      throw new EucalyptusCloudException(ex.getMessage(), ex);
    }
    AccountFullName ownerFullName = ctx.getUserFullName().asAccountFullName();
    Volume volume = Volumes.lookup(ownerFullName, volumeId);
    if (!RestrictedTypes.filterPrivileged().apply(volume)) {
      throw new EucalyptusCloudException(
          "Not authorized to attach volume "
              + request.getVolumeId()
              + " by "
              + ctx.getUser().getName());
    }
    try {
      vm.lookupVolumeAttachmentByDevice(deviceName);
      throw new EucalyptusCloudException(
          "Already have a device attached to: " + request.getDevice());
    } catch (NoSuchElementException ex1) {
      /** no attachment * */
    }
    try {
      VmInstances.lookupVolumeAttachment(volumeId);
      throw new EucalyptusCloudException("Volume already attached: " + request.getVolumeId());
    } catch (NoSuchElementException ex1) {
      /** no attachment * */
    }

    Partition volPartition = Partitions.lookupByName(volume.getPartition());
    ServiceConfiguration sc = Topology.lookup(Storage.class, volPartition);
    ServiceConfiguration scVm = Topology.lookup(Storage.class, vm.lookupPartition());
    if (!sc.equals(scVm)) {
      throw new EucalyptusCloudException(
          "Can only attach volumes in the same zone: " + request.getVolumeId());
    }
    ServiceConfiguration ccConfig = Topology.lookup(ClusterController.class, vm.lookupPartition());
    AttachStorageVolumeResponseType scAttachResponse;
    try {
      AttachStorageVolumeType req =
          new AttachStorageVolumeType(Nodes.lookupIqn(vm), volume.getDisplayName());
      scAttachResponse = AsyncRequests.sendSync(sc, req);
    } catch (Exception e) {
      LOG.debug(e, e);
      throw new EucalyptusCloudException(e.getMessage(), e);
    }
    request.setRemoteDevice(scAttachResponse.getRemoteDeviceString());

    AttachedVolume attachVol =
        new AttachedVolume(
            volume.getDisplayName(),
            vm.getInstanceId(),
            request.getDevice(),
            request.getRemoteDevice());
    vm.addTransientVolume(deviceName, scAttachResponse.getRemoteDeviceString(), volume);
    AsyncRequests.newRequest(new VolumeAttachCallback(request)).dispatch(ccConfig);

    EventRecord.here(VolumeManager.class, EventClass.VOLUME, EventType.VOLUME_ATTACH)
        .withDetails(
            volume.getOwner().toString(), volume.getDisplayName(), "instance", vm.getInstanceId())
        .withDetails("partition", vm.getPartition().toString())
        .info();
    reply.setAttachedVolume(attachVol);
    return reply;
  }