Create file node

        Valid replies:
            reply_entry
            reply_err
184967
def mknod(self, req, parent, name, mode, rdev):
        
        self.reply_err(req, errno.EROFS)
1220949
function onErrorHandle($errno, $errstr, $errfile, $errline)
    {
        $error = array(
            'message' => $errstr,
            'file' => $errfile,
            'line' => $errline,
        );
        $this->errorResponse($error);
    }
526633
def write(self, req, ino, buf, off, fi):
        
        self.reply_err(req, errno.EROFS)
803545
def listxattr(self, req, ino, size):
        
        self.reply_err(req, errno.ENOSYS)
724437
function addOnErrorHook () {

		window.addEventListener("error", function(error) {
			error.preventDefault();
			var oErrorOutput = document.createElement("span");
			oErrorOutput.innerText = error.message; // use save API
			oErrorOutput.style.cssText = "position:absolute; top:1rem; left:1rem";
			if (!document.body) {
				document.write("<span></span>"); // add content via document.write to ensure document.body is created;
			}
			document.body.appendChild(oErrorOutput);
		});
	}
81758
function cbk(err, fields, files, resolve) {
    let fileList;

    if (err) {
      debug('upload file error:' + err);
    } else {
      try {
        fileList = createFilenameHash(config.uploadDir, files);
        debug('upload file success！');
      } catch (err) {
        fileList = files;
        debug('create filename hash:' + err);
      }
    }

    resolve(fileList);
  }
710436
def _new_mock_response(self, response, file_path):
        ''''''
        mock_response = copy.copy(response)

        mock_response.body = Body(open(file_path, 'rb'))
        mock_response.fields = NameValueRecord()

        for name, value in response.fields.get_all():
            mock_response.fields.add(name, value)

        mock_response.fields['Content-Type'] = 'text/html; charset="utf-8"'

        return mock_response
891474
def access(self, req, ino, mask):
        
        self.reply_err(req, errno.ENOSYS)
1322043
async function reply(node, data, config) {

    // Assume we send the message to the current user address
    let address = botmgr.getUserAddress(data)
    if (!address || address.carrier !== CARRIER) return false;

    try {

        // Assume we send the message to the current user address
        let address = botmgr.getUserAddress(data)
        if (!address || address.carrier !== CARRIER) return false;

        // Building the message
        let message = getMessage(data.reply, botmgr.getConvId(data));
        node.warn(message)
        if (!message) return false;
        
        // Write the message 
        let req = {
            uri: "https://graph.facebook.com/v2.6/me/messages?access_token=" + config.pageToken,
            method: 'POST',
            body: message,
            json: true
        }

        /*
        if (message.filedata) {
            req.form = message;
        }
        else {
            req.body= message;
            req.json= true;
        }*/

        try {
            let res = await request(req);
        }
        catch(err) {
            node.warn({error: err});
            return false;
        }

        // Trap the event in order to continue
        helper.fireAsyncCallback(data);

    } catch(ex){ console.log(ex) }
}
741759
def send_comment(results)
      dir = "#{Dir.pwd}/"
      results['messages'].each do |r|
        filename = results['filePath'].gsub(dir, '')
        method = r['severity'] > 1 ? 'fail' : 'warn'
        send(method, r['message'], file: filename, line: r['line'])
      end
    end
749547
def lookup(self, req, parent, name):
        
        self.reply_err(req, errno.ENOENT)
941421
def symlink(self, req, link, parent, name):
        
        self.reply_err(req, errno.EROFS)
773066
function reply(req, res, opts) {
  opts = opts || {};

  return function(statusCode, body) {
    var call = { args: [].slice.call(arguments) };

    // handle single argument replies
    if (typeof statusCode === 'string') {
      body = { message: statusCode };
      statusCode = 200;
    } else if (statusCode instanceof Error) {
      body = statusCode;
      statusCode = 500;
    }

    // handle error objects in replies
    if (body instanceof Error) {
      if (typeof body.statusCode === 'number') {
        statusCode = body.statusCode;
      }
      if (body.expose) {
        body = body.toJSON ? body.toJSON() : { message: body.message };
      } else {
        body = undefined;
      }
    }

    // default message
    if (body === undefined) {
      body = { message: http.STATUS_CODES[statusCode] || 'unknown response' };
    }

    call.statusCode = statusCode;
    call.body = body;

    // allow user to override body before sending
    if (req.sf.responseMessage) {
      call = req.sf.responseMessage(call);

      if (!call) {
        debug('responseMessage handled reply');
        return;
      }

      statusCode = call.statusCode;
      body = call.body;
    }

    var length = 0;
    var type;

    if (body !== undefined) {
      if (Buffer.isBuffer(body)) {
        length = body.length;
      } else if (res.sf && res.sf.produce) {
        type = res.sf.produce.mime;
        body = res.sf.produce.encoder(body);
        length = Buffer.byteLength(body, CHARSET);
      } else {
        type = 'application/json';
        body = encoder[type](body);
        length = Buffer.byteLength(body, CHARSET);
      }
    }

    var noContent = statusCode === 204 || statusCode === 304;

    if (!noContent && !res.headersSent) {
      if (type && !res.getHeader('content-type') ||
        res.getHeader('content-type') !== type) {
        res.setHeader('content-type', type + '; charset=' + CHARSET);
      }

      if (!res.getHeader('content-length') ||
        res.getHeader('content-length') !== length) {
        res.setHeader('content-length', length);
      }

      // add etag header if not already set
      if (opts.etag && body && body.length && !res.getHeader('etag') &&
          req.method === 'GET' && Math.floor(statusCode / 100) === 2) {
        var etag = crypto.createHash('md5').update(body).digest('hex');
        res.setHeader('etag', etag);
      }

      // if cache is fresh set status code to 304
      if (fresh(req.headers, res._headers)) {
        statusCode = 304;
        noContent = true;
      }

      if (noContent) {
        res.removeHeader('content-type');
        res.removeHeader('content-length');
        res.removeHeader('transfer-encoding');
      }
    }

    if (noContent) body = '';

    res.statusCode = statusCode;

    return res.end(req.method === 'HEAD' ? null : body);
  };
}
755165
def setxattr(self, req, ino, name, value, flags):
        
        self.reply_err(req, errno.ENOSYS)
984069
def create_reply(reply, message=None, render=False):
    
    r = None
    if not reply:
        r = EmptyReply()
    elif isinstance(reply, BaseReply):
        r = reply
        if message:
            r.source = message.target
            r.target = message.source
    elif isinstance(reply, six.string_types):
        r = TextReply(
            message=message,
            content=reply
        )
    elif isinstance(reply, (tuple, list)):
        if len(reply) > 10:
            raise AttributeError("Can't add more than 10 articles"
                                 " in an ArticlesReply")
        r = ArticlesReply(
            message=message,
            articles=reply
        )
    if r and render:
        return r.render()
    return r
206333
function err(...messages) {
  console.error(...messages);
  const p = document.createElement('p');
  p.innerText = messages.join(' ');
  p.style = 'color: red';
  logElement.appendChild(p);
}
386775
private void replyError() {
    Error error = Preconditions.checkNotNull(mContext.getError());
    if (error.isNotifyClient()) {
      mResponseObserver.onError(error.getCause().toGrpcStatusException());
    }
  }