Read the retry exception lists from the BDS props.
171184
private void initialize(Chunk chunk)
    {
        final String mName = "initialize";

        if(logger.isLoggable(Level.FINER)) 
            logger.entering(className, mName);

        try
        {
            if (chunk.getRetryLimit() != null){
                _retryLimit = Integer.parseInt(chunk.getRetryLimit());
                if (_retryLimit < 0) {
                    throw new IllegalArgumentException("The retry-limit attribute on a chunk cannot be a negative value");
                }

            }
        }
        catch (NumberFormatException nfe)
        {
            throw new RuntimeException("NumberFormatException reading " + RETRY_COUNT, nfe);
        }

        // Read the include/exclude exceptions.
        _retryIncludeExceptions = new HashSet<String>();
        _retryExcludeExceptions = new HashSet<String>();
        _retryNoRBIncludeExceptions = new HashSet<String>();
        _retryNoRBExcludeExceptions = new HashSet<String>();

        if (chunk.getRetryableExceptionClasses() != null) {
            if (chunk.getRetryableExceptionClasses().getIncludeList() != null) {
                List<ExceptionClassFilter.Include> includes = chunk.getRetryableExceptionClasses().getIncludeList();
                for (ExceptionClassFilter.Include include : includes) {
                    _retryIncludeExceptions.add(include.getClazz().trim());
                    logger.finer("RETRYHANDLE: include: " + include.getClazz().trim());
                }

                if (_retryIncludeExceptions.size() == 0) {
                    logger.finer("RETRYHANDLE: include element not present");

                }
            }
            if (chunk.getRetryableExceptionClasses().getExcludeList() != null) {
                List<ExceptionClassFilter.Exclude> excludes = chunk.getRetryableExceptionClasses().getExcludeList();
                for (ExceptionClassFilter.Exclude exclude : excludes) {
                    _retryExcludeExceptions.add(exclude.getClazz().trim());
                    logger.finer("SKIPHANDLE: exclude: " + exclude.getClazz().trim());
                }

                if (_retryExcludeExceptions.size() == 0) {
                    logger.finer("SKIPHANDLE: exclude element not present");

                }
            }
        }

        if (chunk.getNoRollbackExceptionClasses() != null) {
            if (chunk.getNoRollbackExceptionClasses().getIncludeList() != null) {
                List<ExceptionClassFilter.Include> includes = chunk.getNoRollbackExceptionClasses().getIncludeList();
                for (ExceptionClassFilter.Include include : includes) {
                    _retryNoRBIncludeExceptions.add(include.getClazz().trim());
                    logger.finer("RETRYHANDLE: include: " + include.getClazz().trim());
                }

                if (_retryNoRBIncludeExceptions.size() == 0) {
                    logger.finer("RETRYHANDLE: include element not present");

                }
            }
            if (chunk.getNoRollbackExceptionClasses().getExcludeList() != null) {
                List<ExceptionClassFilter.Exclude> excludes = chunk.getNoRollbackExceptionClasses().getExcludeList();
                for (ExceptionClassFilter.Exclude exclude : excludes) {
                    _retryNoRBExcludeExceptions.add(exclude.getClazz().trim());
                    logger.finer("SKIPHANDLE: exclude: " + exclude.getClazz().trim());
                }

                if (_retryNoRBExcludeExceptions.size() == 0) {
                    logger.finer("SKIPHANDLE: exclude element not present");

                }
            }
        }
        
        // Create the ExceptionMatcher Object
        excMatcher = new ExceptionMatcher(_retryIncludeExceptions, _retryExcludeExceptions);
        noRBexcMatcher = new ExceptionMatcher(_retryNoRBIncludeExceptions, _retryNoRBExcludeExceptions);


        if (logger.isLoggable(Level.FINE)) {
            logger.logp(Level.FINE, className, mName, "added include exception " + _retryIncludeExceptions 
                    + "; added exclude exception " + _retryExcludeExceptions);
            logger.logp(Level.FINE, className, mName, "added include no rollback exception " + _retryNoRBIncludeExceptions
                    + "; added exclude no rollback exception " + _retryNoRBExcludeExceptions);
        }
            
        if(logger.isLoggable(Level.FINER)) {
          logger.exiting(className, mName, this.toString());
        }
      }
1208636
def errors(self):
        
        ret_errs = list()
        errors = self.get('error').get('errors', None) or list()
        assert isinstance(errors, list)
        for err in errors:
            when = parse_datetime(err.get('when', None))
            msg = err.get('message', '')
            e = ErrorEvent(when, msg)
            ret_errs.append(e)
        return ret_errs
401017
def get_error_codes(cls) -> Iterable[str]:
        """"""
        for group in cls.groups:
            for error in group.errors:
                yield error.code
505814
public List<ErrorPageType<WebAppDescriptor>> getAllErrorPage()
   {
      List<ErrorPageType<WebAppDescriptor>> list = new ArrayList<ErrorPageType<WebAppDescriptor>>();
      List<Node> nodeList = model.get("error-page");
      for(Node node: nodeList)
      {
         ErrorPageType<WebAppDescriptor>  type = new ErrorPageTypeImpl<WebAppDescriptor>(this, "error-page", model, node);
         list.add(type);
      }
      return list;
   }
70442
static DnsException translateAndThrow(RetryHelperException ex) {
    BaseServiceException.translate(ex);
    throw new DnsException(UNKNOWN_CODE, ex.getMessage(), ex.getCause());
  }
706763
public java.util.List<ResourceKey> getFailedItems() {
        if (failedItems == null) {
            failedItems = new com.amazonaws.internal.SdkInternalList<ResourceKey>();
        }
        return failedItems;
    }
1071933
def retry(self, retries=3, backoff_factor=0.3, status_forcelist=(500, 502, 504)):
        
        retries = Retry(
            total=retries,
            read=retries,
            connect=retries,
            backoff_factor=backoff_factor,
            status_forcelist=status_forcelist,
        )
        # mount all https requests
        self.mount('https://', adapters.HTTPAdapter(max_retries=retries))
470897
@Override
    public final List<DataSlice> readDataFromPersistence() throws SevereMessageStoreException
    {
        List<DataSlice> dataSlices;
        // lazy restoration only needed if the item was stored.  There is
        // no point trying to restore if there is no data.
        PersistentMessageStore pm = getMessageStoreImpl().getPersistentMessageStore();
        try
        {
            dataSlices = pm.readDataOnly(getTuple());
        } catch (PersistenceException pe)
        {
            com.ibm.ws.ffdc.FFDCFilter.processException(pe, "com.ibm.ws.sib.msgstore.cache.links.AbstractItemLink.readDataFromPersistence", "1:3271:1.241", this);
            throw new SevereMessageStoreException(pe);
        }

        return dataSlices;
    }
151801
def get_jids(returner):
    '''
    
    '''
    returners = salt.loader.returners(__opts__, __salt__)
    return returners['{0}.get_jids'.format(returner)]()
1370909
def read_bplist(data, start, length):
    """"""
    # TODO: pylint doesn't find FMT_BINARY, why?
    # pylint: disable=no-member
    return plistlib.loads(data[start:start+length],
                          fmt=plistlib.FMT_BINARY)
182698
def decodeIlxResp(resp):
    
    lines = [_ for _ in resp.text.split('\n') if _]  # strip empties

    if 'successfull' in lines[0]:
        return [(_.split('"')[1],
                 ilxIdFix(_.split(': ')[-1]))
                for _ in lines[1:]]
    elif 'errors' in lines[0]:
        return [(_.split('"')[1],
                 ilxIdFix(_.split('(')[1].split(')')[0]))
                for _ in lines[1:]]
65738
private int find(Vector prop_list,String prop_name) throws DevFailed
	{
		int i;
		int nb_prop = prop_list.size();
		
		for (i = 0;i < nb_prop;i++)
		{
			if (((AttrProperty)(prop_list.elementAt(i))).get_name().equals(prop_name) == true)
				break;
		}
		
		if (i == nb_prop)
		{
			StringBuffer o = new StringBuffer("Property ");
			o.append(prop_name);
			o.append(" not found");
			
			Except.throw_exception("API_AttrWrongDefined",o.toString(),
					       "Attribute.find");
		}
		
		return i;
	}
14527
public static boolean isRetryableServiceException(SdkBaseException exception) {
        return isAse(exception) && RETRYABLE_STATUS_CODES.contains(toAse(exception).getStatusCode());
    }
944622
def failed_hosts(self):
        """"""
        return {h: r for h, r in self.items() if r.failed}
982070
public java.util.List<Failure> getFailures() {
        if (failures == null) {
            failures = new com.amazonaws.internal.SdkInternalList<Failure>();
        }
        return failures;
    }
1045976
def failed_hosts(self) -> Dict[str, "MultiResult"]:
        
        return {k: v for k, v in self.result.items() if v.failed}
714847
def decode_osgi_props(input_props):
    # type: (Dict[str, Any]) -> Dict[str, Any]
    
    result_props = {}
    intfs = decode_list(input_props, OBJECTCLASS)
    result_props[OBJECTCLASS] = intfs
    for intf in intfs:
        package_key = ENDPOINT_PACKAGE_VERSION_ + package_name(intf)
        intfversionstr = input_props.get(package_key, None)
        if intfversionstr:
            result_props[package_key] = intfversionstr
    result_props[ENDPOINT_ID] = input_props[ENDPOINT_ID]
    result_props[ENDPOINT_SERVICE_ID] = input_props[ENDPOINT_SERVICE_ID]
    result_props[ENDPOINT_FRAMEWORK_UUID] = input_props[ENDPOINT_FRAMEWORK_UUID]
    imp_configs = decode_list(input_props, SERVICE_IMPORTED_CONFIGS)
    if imp_configs:
        result_props[SERVICE_IMPORTED_CONFIGS] = imp_configs
    intents = decode_list(input_props, SERVICE_INTENTS)
    if intents:
        result_props[SERVICE_INTENTS] = intents
    remote_configs = decode_list(input_props, REMOTE_CONFIGS_SUPPORTED)
    if remote_configs:
        result_props[REMOTE_CONFIGS_SUPPORTED] = remote_configs
    remote_intents = decode_list(input_props, REMOTE_INTENTS_SUPPORTED)
    if remote_intents:
        result_props[REMOTE_INTENTS_SUPPORTED] = remote_intents
    return result_props