Resumes a NSR that failed while executing a script in a VNFR. The id in the URL specifies the
Network Service Record that will be resumed..

@param idNsr the ID of the NetworkServiceRecord
@throws SDKException if the request fails
342936
@Help(
    help =
        "Resumes a NSR that failed while executing a script in a VNFR. The id in the URL specifies the Network Service Record that will be resumed."
  )
  public void resume(final String idNsr) throws SDKException {
    String url = idNsr + "/resume";
    requestPost(url);
  }
381773
@Override
    public void resumeConsumer(int suspendFlag)
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "resumeConsumer", this);

        // Use this flag to identify whether a new thread must be spun off to look for more
        // messages
        boolean spinOffNewThread = false;
        try
        {
            // Take the lock
            this.lock();

            if (_consumerSuspended)
            {
                boolean setStillSuspended = false;

                // If we're resuming due to the ConsumerSet being resumed then we need to
                // re-check the set's state due to us not holding the set's activeMessageCount
                // lock at this time (due to the hierarchy). And if we find that the set is
                // actually suspended (due to someone else in the set getting in and adding
                // another message then we just ignore this resume as there'll be another one
                // along when the count drops back below the limit again.
                if (suspendFlag == DispatchableConsumerPoint.SUSPEND_FLAG_SET_ACTIVE_MSGS)
                    setStillSuspended = _consumerKey.isConsumerSetSuspended();

                if (!setStillSuspended)
                {
                    // clear the bit provided in the _suspendFlags
                    _suspendFlags &= ~suspendFlag;

                    if (_suspendFlags == 0) // No flags set so resume the consumer
                    {
                        _consumerSuspended = false;

                        // If the consumer is still active (started) we need
                        // to kickstart the consumer back into life to check for more
                        // messages
                        if (!_stopped && !_closing)
                        {
                            if (_asynchConsumerRegistered)
                            {
                                if (!_asynchConsumer.isAsynchConsumerRunning())
                                {
                                    // We'll have to take the full lock hierarchy and
                                    // possibly spin off another thread to start looking for more messages
                                    // (just like start())
                                    spinOffNewThread = true;
                                }
                            }
                            else
                            {
                                // Wake up any synchronous receivers
                                _waiter.signal();
                            }
                        }
                    }
                }
            }
        } finally
        {
            this.unlock();
        }

        // start a new thread to run the callback if we determined that it was necessary   
        if (spinOffNewThread)
        {
            try
            {
                _messageProcessor.startNewThread(new AsynchThread(this, false));
            } catch (InterruptedException e)
            {
                FFDCFilter.processException(
                                            e,
                                            "com.ibm.ws.sib.processor.impl.JSLocalConsumerPoint.resumeConsumer",
                                            "1:4978:1.22.5.1",
                                            this);

                SibTr.exception(tc, e);

                if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                    SibTr.exit(tc, "resumeConsumer", e);
            }
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "resumeConsumer");
    }
1047207
public void resume() {
        this.paused = false;
        ServerActivityCallback listener = listenerUpdater.get(this);
        if (listener != null) {
            listenerUpdater.compareAndSet(this, listener, null);
        }
    }
1291415
function(err) {
          logger.entry('Client._tryService.connError', _id);

          err = lookupError(err);
          logger.log('data', _id, 'failed to connect to: ' + logUrl +
                     ' due to error: ' + util.inspect(err));

          // This service failed to connect. Try the next one.
          // XXX: wrap in shouldReconnect ?
          tryNextService(err);

          logger.exit('Client._tryService.connError', _id, null);
        }
460548
public void restart(FailureHandler failureHandler) {
		if (!this.enabled) {
			this.logger.debug("Application restart is disabled");
			return;
		}
		this.logger.debug("Restarting application");
		getLeakSafeThread().call(() -> {
			Restarter.this.stop();
			Restarter.this.start(failureHandler);
			return null;
		});
	}
568588
public void resume(UOWHandle handle) throws CSIException {
        final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
        if (isTraceOn && tc.isEntryEnabled())
            Tr.entry(tc, "resume : " + handle);

        //A null handle indicates that during the execution of the corresponding suspend,
        //there wasn't a Tx to suspend, so do nothing.
        if (handle != null) {
            //Cast the handle to a UOWHandleImpl in order to get the instance
            //variables from it.
            UOWHandleImpl handleImpl = (UOWHandleImpl) handle;

            try {
                //From the handle we can determine if it is a local tx.  If so resume the local
                // tx, otherwise we have a global tx.
                if (handleImpl.suspendedLocalTx != null) {
                    //Get the LocalTransactionCoordinator from the handle, and resume the local
                    //Tx associated with it.
                    resumeLocalTx(handleImpl.suspendedLocalTx);
                }
                else {
                    //Get the suspended global tx from the handle, and resume the global
                    //tx associated with it.
                    resumeGlobalTx(handleImpl.suspendedGlobalTx, TIMEOUT_CLOCK_START);
                }
            } catch (Throwable t) {
                FFDCFilter.processException(t, CLASS_NAME + ".resume", "1491", this);
                if (isTraceOn && tc.isEntryEnabled())
                    Tr.exit(tc, "resume", "Error resuming tx in TransactionControlImpl: " + t);
                throw new CSIException("Error resuming tx in TransactionControlImpl.", t);
            }
        }

        if (isTraceOn && tc.isEntryEnabled())
            Tr.exit(tc, "resume");
    }
777062
@Override
    protected void resumeFaxJobImpl(FaxJob faxJob)
    {
        String name=VBSFaxClientSpi.VBS_WIN_XP_RESUME_SCRIPT;
        if(this.useWin2kAPI)
        {
            name=VBSFaxClientSpi.VBS_WIN_2K_RESUME_SCRIPT;
        }

        //invoke script
        this.invokeExistingFaxJobAction(name,faxJob,FaxActionType.RESUME_FAX_JOB);
    }
507522
@Help(
    help = "Get all the PhysicalNetworkFunctionRecords of a specific NetworkServiceRecord with id"
  )
  public List<PhysicalNetworkFunctionRecord> getPhysicalNetworkFunctionRecords(final String idNsr)
      throws SDKException {
    String url = idNsr + "/pnfrecords";
    return Arrays.asList(
        (PhysicalNetworkFunctionRecord[]) requestGetAll(url, PhysicalNetworkFunctionRecord.class));
  }
70337
@Help(
    help =
        "Create the VirtualNetworkFunctionRecord Dependency of a NetworkServiceRecord with specific id"
  )
  public VNFRecordDependency postVNFDependency(
      final String idNsr, final VNFRecordDependency vnfRecordDependency) throws SDKException {
    String url = idNsr + "/vnfdependencies" + "/";
    return (VNFRecordDependency) requestPost(url, vnfRecordDependency);
  }
719094
private void doResume(long id) {
    if (paused) {
      log.debug(String.format("%s - Resumed connection to %s", this, context.target()));
      paused = false;
      checkDrain();
    }
  }
1047003
public void useNewRESTService(String address) throws Exception {
        List<Object> providers = createJAXRSProviders();

        org.customer.service.CustomerService customerService = JAXRSClientFactory
            .createFromModel(address, 
                             org.customer.service.CustomerService.class,
                             "classpath:/model/CustomerService-jaxrs.xml", 
                             providers, 
                             null);

        System.out.println("Using new RESTful CustomerService with new client");

        customer.v2.Customer customer = createNewCustomer("Smith New REST");
        customerService.updateCustomer(customer);

        customer = customerService.getCustomerByName("Smith New REST");
        printNewCustomerDetails(customer);
    }
754993
@Help(
    help =
        "Delete the VirtualNetworkFunctionRecord Dependency of a NetworkServiceRecord with specific id"
  )
  public void deleteVNFDependency(final String idNsr, final String idVnfrDep) throws SDKException {
    String url = idNsr + "/vnfdependencies" + "/" + idVnfrDep;
    requestDelete(url);
  }
1367687
def _resume_with_session_id(
            self,
            server_info: ServerConnectivityInfo,
            ssl_version_to_use: OpenSslVersionEnum
    ) -> bool:
        
        session1 = self._resume_ssl_session(server_info, ssl_version_to_use)
        try:
            # Recover the session ID
            session1_id = self._extract_session_id(session1)
        except IndexError:
            # Session ID not assigned
            return False

        if session1_id == '':
            # Session ID empty
            return False

        # Try to resume that SSL session
        session2 = self._resume_ssl_session(server_info, ssl_version_to_use, session1)
        try:
            # Recover the session ID
            session2_id = self._extract_session_id(session2)
        except IndexError:
            # Session ID not assigned
            return False

        # Finally, compare the two Session IDs
        if session1_id != session2_id:
            # Session ID assigned but not accepted
            return False

        return True
1232086
public InetSocketAddress remoteLookup(final Identifier id) throws Exception {
    // the lookup is not thread-safe, because concurrent replies may
    // be read by the wrong thread.
    // TODO: better fix uses a map of id's after REEF-198
    synchronized (this) {

      LOG.log(Level.INFO, "Looking up {0} on NameServer {1}", new Object[]{id, serverSocketAddr});

      final List<Identifier> ids = Arrays.asList(id);
      final Link<NamingMessage> link = transport.open(serverSocketAddr, codec,
          new LoggingLinkListener<NamingMessage>());
      link.write(new NamingLookupRequest(ids));

      final NamingLookupResponse resp;
      for (;;) {
        try {
          resp = replyQueue.poll(timeout, TimeUnit.MILLISECONDS);
          break;
        } catch (final InterruptedException e) {
          LOG.log(Level.INFO, "Lookup interrupted", e);
          throw new NamingException(e);
        }
      }

      final List<NameAssignment> list = resp == null ? Collections.<NameAssignment>emptyList()
          : resp.getNameAssignments();
      if (list.isEmpty()) {
        throw new NamingException("Cannot find " + id + " from the name server");
      } else {
        return list.get(0).getAddress();
      }
    }
  }
833374
private void resume() throws RepositoryException
   {
      WorkspaceResumer workspaceResumer = getWorkspaceResumer();
      if (workspaceResumer != null)
      {
         workspaceResumer.onResume();
      }

      // components should be resumed in reverse order
      List<Suspendable> components = getComponentInstancesOfType(Suspendable.class);
      Comparator<Suspendable> c = new Comparator<Suspendable>()
      {
         public int compare(Suspendable s1, Suspendable s2)
         {
            return s1.getPriority() - s2.getPriority();
         };
      };
      Collections.sort(components, c);

      for (Suspendable component : components)
      {
         try
         {
            if (component.isSuspended())
            {
               component.resume();
            }
         }
         catch (ResumeException e)
         {
            throw new RepositoryException("Can't set component online", e);
         }
      }
   }
682975
@Help(
    help =
        "Create the VirtualNetworkFunctionDescriptor dependency of a NetworkServiceDescriptor with specific id"
  )
  public VNFDependency createVNFDependency(final String idNSD, final VNFDependency vnfDependency)
      throws SDKException {
    String url = idNSD + "/vnfdependencies" + "/";
    return (VNFDependency) requestPost(url, vnfDependency);
  }
656855
protected void resumeFaxJob(HylaFaxJob faxJob,HylaFAXClient client) throws Exception
    {
        //get job
        Job job=faxJob.getHylaFaxJob();
        
        //get job ID
        long faxJobID=job.getId();
        
        //resume job
        client.retry(faxJobID);
    }