Handles the download failure callback from Node
@param {string} message - reason of download failure
544835
function handleDownloadFailure(message) {
        console.log("AutoUpdate : Download of latest installer failed in Attempt " +
            (MAX_DOWNLOAD_ATTEMPTS - downloadAttemptsRemaining) + ".\n Reason : " + message);

        if (downloadAttemptsRemaining) {

            // Retry the downloading
            attemptToDownload();
        } else {

            // Download could not completed, all attempts exhausted
            enableCheckForUpdateEntry(true);
            UpdateStatus.cleanUpdateStatus();

            var descriptionMessage = "",
                analyticsDescriptionMessage = "";
            if (message === _nodeErrorMessages.DOWNLOAD_ERROR) {
                descriptionMessage = Strings.DOWNLOAD_ERROR;
                analyticsDescriptionMessage = "Error occurred while downloading.";
            } else if (message === _nodeErrorMessages.NETWORK_SLOW_OR_DISCONNECTED) {
                descriptionMessage = Strings.NETWORK_SLOW_OR_DISCONNECTED;
                analyticsDescriptionMessage = "Network is Disconnected or too slow.";
            }
            HealthLogger.sendAnalyticsData(
                autoUpdateEventNames.AUTOUPDATE_DOWNLOAD_FAILED,
                "autoUpdate",
                "download",
                "fail",
                analyticsDescriptionMessage
            );
            UpdateInfoBar.showUpdateBar({
                type: "error",
                title: Strings.DOWNLOAD_FAILED,
                description: descriptionMessage
            });

            setUpdateStateInJSON("autoUpdateInProgress", false);
        }

    }
777275
function() {
      FS.readFile(path, options.encoding, function(err, text) {
        if (err) {
          // Forward the error
          return callback(err);
        }
        // Success
        callback(null, text.toString());
      });
    }
1369161
function ErrorBadRequest (message) {

  Error.call(this);

  // Add Information
  this.name    = 'ErrorBadRequest';
  this.type    = 'client';
  this.status  = 400;
  if (message) {
    this.message = message;
  }

}
370722
protected void notifyFailure (int oid, String message)
    {
        // let the penders know that the object is not available
        PendingRequest<?> req = _penders.remove(oid);
        if (req == null) {
            log.warning("Failed to get object, but no one cares?!", "oid", oid);
            return;
        }

        for (int ii = 0; ii < req.targets.size(); ii++) {
            req.targets.get(ii).requestFailed(oid, new ObjectAccessException(message));
        }
    }
487207
function InternalServerError(message, cause) {
    InternalServerError.super_.call(this, message, StatusCode.INTERNAL_SERVER_ERROR, cause);
}
16350
function Message({backendError, translations, onCheckAgain}) {
  const {backendIsNotAvailable, checkAgain} = translations;

  const errorMessage = backendError.message ||
    (backendError.toString ? backendError.toString() : null);

  return (
    <div data-test="ring-backend-down-notification">
      <Group>
        <span className={styles.title}>{backendIsNotAvailable}</span>
        <Link onClick={onCheckAgain} data-test="check-again">{checkAgain}</Link>
      </Group>
      <div className={styles.error}>{errorMessage}</div>
    </div>
  );
}
1184938
function (error, response) {
            // Destroy the client - frees up resources so that the application
            // stops running
            client.destroy()
            // Display the contents of an error, if one occurred
            if (error) {
              console.log('Request error: ' + error.message)
              // The 'code' property, if set, typically has a string
              // representation of the error code.
              if (error.code) {
                console.log('Request error code: ' + error.code)
              // If no string representation is available for the error code
              // but the error is a DXL 'RequestError', a numeric error
              // code should be available in the
              // 'dxlErrorResponse.errorCode' property.
              } else if (error.dxlErrorResponse) {
                console.log('Request error code: ' +
                  error.dxlErrorResponse.errorCode)
              }
            // No error occurred, so extract information from the response. The
            // toString() call converts the payload from a binary Buffer into a
            // string, decoded using UTF-8 character encoding.
            } else {
              console.log('Client received response payload: ' +
                response.payload.toString())
            }
          }
612545
function connectionError(response, message, body) {
  var content = errorContent(ErrorType.connection, message, body);
  send(response, content, StatusCode.badGateway);
}
452116
function(message, rule) {
        "use strict";
        this.messages.push({
            type    : "error",
            rollup  : true,
            message : message,
            rule    : rule
        });
    }
16511
function(message) {

    // If an error already has been thrown, exit
    if (errorTarget) return message

    utils.doCallback('errorTriggered', message);
    utils.logError(message)

    // If no target DOM element exists, only do the logging
    if (!rootTarget) return message

    var messageProcessed = message
    var contextProcessed = null

    if (utils.isArray(message)) {
      messageProcessed = message[0]
      if (message[1].data) {
        contextProcessed = stringify(message[1].data.errors || message[1].data.error || message[1].data)
      } else {
        contextProcessed = stringify(message[1])
      }
    }

    var template = require('./templates/error.html');
    errorTarget = $(template.render({
      errorWarningIcon: require('!svg-inline!./assets/error-warning-icon.svg'),
      message: messageProcessed,
      context: contextProcessed
    }));

    rootTarget.append(errorTarget);

    return message

  }
1092476
async def on_raw_error(self, message):
        
        error = protocol.ServerError(' '.join(message.params))
        await self.on_data_error(error)
532912
function (err, params) {
                if (!err) {
                  callback && callback(null, params);
                }
                else {
                  callback && callback(err.message || err);
                }
              }
981844
@Override
    public void sendFailure(String message) {
        System.out.print("Warning: " + message);
        System.exit(1);
    }
1260815
function NotFoundError(message) {
  Error.call(this);
  Error.captureStackTrace(this, this.constructor);

  this.status = 404;
  this.message = 'Not Found: ' + message;
  this.name = this.constructor.name;
}
305683
protected String handleError(final String message) {
        notifier().error(formatMessage(message));
        return formatMessage(message);
    }
1201888
def _wrap_callback_errors(callback, message):
    
    try:
        callback(message)
    except Exception:
        # Note: the likelihood of this failing is extremely low. This just adds
        # a message to a queue, so if this doesn't work the world is in an
        # unrecoverable state and this thread should just bail.
        _LOGGER.exception(
            "Top-level exception occurred in callback while processing a " "message"
        )
        message.nack()
802207
protected String handleError(final String message, final Throwable cause) {
        notifier().error(formatMessage(message), cause);
        return formatMessage(message);
    }