zeldon/mineping
1
0
Fork 0
mirror of https://github.com/minescope/mineping.git synced 2025-07-15 13:54:40 +03:00
Code Issues Packages Projects Releases Wiki Activity

refactoring and comments

Browse Source 
fix(cli.js): refactor help and error handling logic for better readability and maintainability
feat(cli.js): add support for custom port and timeout options
fix(parallel.js): update list of hosts to ping
fix(bedrock.js): add comments and improve error handling in ping function
fix(java.js): add comments and improve error handling in ping function
fix(varint.js): add comments to functions and improve readability
fix(index.d.ts): export all functions from java.js and bedrock.js
fix(lib/bedrock.d.ts): update source link
fix(lib/java.d.ts): update source link
This commit is contained in:
Timofey Gelazoniya
2023-10-22 21:32:00 +03:00
parent 915edbec9c
commit 910184bf5f
8 changed files with 148 additions and 59 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
lib/bedrock.js
View File

@ -131,12 +131,15 @@ const UNCONNECTED_PONG = (buffer) => {
const ping = (host, port = 19132, cb, timeout = 5000) => {
const socket = dgram.createSocket('udp4');
// Set manual timeout interval.
// This ensures the connection will NEVER hang regardless of internal state
const timeoutTask = setTimeout(() => {
socket.emit('error', new Error('Socket timeout'));
}, timeout);
const closeSocket = () => {
socket.close(); clearTimeout(timeoutTask);
socket.close();
clearTimeout(timeoutTask);
};
// Generic error handler
@ -144,6 +147,10 @@ const ping = (host, port = 19132, cb, timeout = 5000) => {
// This is mostly dangerous since it can swallow errors
let didFireError = false;
/**
* Handle any error that occurs during the ping process.
* @param {Error} err The error that occurred.
*/
const handleError = (err) => {
closeSocket();
@ -191,15 +198,15 @@ const ping = (host, port = 19132, cb, timeout = 5000) => {
}
});
socket.on('error', (err) => handleError(err));
socket.on('error', handleError);
};
/**
* Asynchronously ping Minecraft Bedrock server.
* The optional `options` argument can be an object with a `ping` (default is `19132`) or/and `timeout` (default is `5000`) property.
* @param {string} host The Bedrock server address.
* @param {import('../types/lib/bedrock.js').PingOptions} options The configuration for pinging Minecraft Bedrock server.
* @returns {Promise<import('../types/lib/bedrock.js').BedrockPingResponse>}
* @param {import('../types/index.js').PingOptions} options The configuration for pinging Minecraft Bedrock server.
* @returns {Promise<import('../types/index.js').BedrockPingResponse>}
*/
export const pingBedrock = (host, options = {}) => {
if (!host) throw new Error('Host argument is not provided');

25
lib/java.js
View File

@ -10,6 +10,13 @@ import varint from './varint.js';
const PROTOCOL_VERSION = 0;
/**
* Ping a Minecraft Java server.
* @param {string} host The host of the Java server.
* @param {number} [port=25565] The port of the Java server.
* @param {function} cb The callback function to handle the ping response.
* @param {number} [timeout=5000] The timeout duration in milliseconds.
*/
function ping(host, port = 25565, cb, timeout = 5000) {
const socket = net.createConnection(({ host, port }));
@ -29,6 +36,10 @@ function ping(host, port = 25565, cb, timeout = 5000) {
// This is mostly dangerous since it can swallow errors
let didFireError = false;
/**
* Handle any error that occurs during the ping process.
* @param {Error} err The error that occurred.
*/
const handleError = (err) => {
closeSocket();
@ -65,6 +76,7 @@ function ping(host, port = 25565, cb, timeout = 5000) {
socket.on('data', (data) => {
incomingBuffer = Buffer.concat([incomingBuffer, data]);
// Wait until incomingBuffer is at least 5 bytes long to ensure it has captured the first VarInt value
// This value is used to determine the full read length of the response
// "VarInts are never longer than 5 bytes"
@ -84,16 +96,15 @@ function ping(host, port = 25565, cb, timeout = 5000) {
const packetId = varint.decodeInt(incomingBuffer, varint.decodeLength(packetLength));
if (packetId === 0) {
const data = incomingBuffer.slice(varint.decodeLength(packetLength) + varint.decodeLength(packetId));
const data = incomingBuffer.subarray(varint.decodeLength(packetLength) + varint.decodeLength(packetId));
const responseLength = varint.decodeInt(data, 0);
const response = data.slice(varint.decodeLength(responseLength), varint.decodeLength(responseLength) + responseLength);
const response = data.subarray(varint.decodeLength(responseLength), varint.decodeLength(responseLength) + responseLength);
try {
const message = JSON.parse(response);
cb(null, message);
// Close the socket and clear the timeout task
closeSocket();
cb(message, null);
} catch (err) {
handleError(err);
}
@ -107,12 +118,10 @@ function ping(host, port = 25565, cb, timeout = 5000) {
/**
* Asynchronously ping Minecraft Java server.
*
* The optional `options` argument can be an object with a `ping` (default is `25565`) or/and `timeout` (default is `5000`) property.
*
* @param {string} host The Java server address.
* @param {import('../types/index.js').PingOptions} options The configuration for pinging Minecraft Java server.
* @returns {Promise<import('../types/lib/java.js').JavaPingResponse>}
* @returns {Promise<import('../types/index.js').JavaPingResponse>}
*/
export function pingJava(host, options = {}) {
if (!host) throw new Error('Host argument is not provided');
@ -120,7 +129,7 @@ export function pingJava(host, options = {}) {
const { port = 25565, timeout = 5000 } = options;
return new Promise((resolve, reject) => {
ping(host, port, (err, res) => {
ping(host, port, (res, err) => {
err ? reject(err) : resolve(res);
}, timeout);
});

55
lib/varint.js
View File

@ -1,6 +1,14 @@
// https://wiki.vg/Data_types
/**
* A utility object for encoding and decoding varints.
*/
const varint = {
/**
* Encodes an integer value into a varint byte buffer.
* @param {number} val - The integer value to encode.
* @returns {Buffer}
*/
encodeInt: (val) => {
// "constInts are never longer than 5 bytes"
// https://wiki.vg/Data_types#constInt_and_constLong
@ -8,26 +16,43 @@ const varint = {
let written = 0;
while (true) {
if ((val & 0xFFFFFF80) === 0) {
buf.writeUInt8(val, written++);
const byte = val & 0x7F;
val >>>= 7;
if (val === 0) {
buf.writeUInt8(byte, written++);
break;
} else {
buf.writeUInt8(val & 0x7F | 0x80, written++);
val >>>= 7;
}
buf.writeUInt8(byte | 0x80, written++);
}
return buf.slice(0, written);
},
/**
* Encodes a string value into a UTF-8 byte buffer.
* @param {string} val - The string value to encode.
* @returns {Buffer}
*/
encodeString: (val) => {
return Buffer.from(val, 'utf-8');
},
/**
* Encodes an unsigned short value into a byte buffer.
* @param {number} val - The unsigned short value to encode.
* @returns {Buffer}
*/
encodeUShort: (val) => {
return Buffer.from([val >> 8, val & 0xFF]);
},
/**
* Concatenates multiple byte buffers into a single byte buffer.
* @param {Buffer[]} chunks - An array of byte buffers to concatenate.
* @returns {Buffer}
*/
concat: (chunks) => {
let length = 0;
@ -43,16 +68,22 @@ const varint = {
return Buffer.concat(buffer);
},
/**
* Decodes a varint integer value from a byte buffer.
* @param {Buffer} buffer - The byte buffer to decode from.
* @param {number} offset - The offset in the buffer to start decoding from.
* @returns {number}
*/
decodeInt: (buffer, offset) => {
let val = 0;
let count = 0;
while (true) {
const b = buffer.readUInt8(offset++);
const byte = buffer.readUInt8(offset++);
val |= (b & 0x7F) << count++ * 7;
val |= (byte & 0x7F) << count++ * 7;
if ((b & 0x80) != 128) {
if ((byte & 0x80) !== 0x80) {
break;
}
}
@ -60,8 +91,13 @@ const varint = {
return val;
},
// The number of bytes that the last .decodeInt() call had to use to decode.
/**
* Calculates the number of bytes required to decode a varint integer value.
* @param {number} val - The varint integer value.
* @returns {5 | 7 | 8 | 1 | 2 | 3 | 4 | 6 | 9 | 10}
*/
decodeLength: (val) => {
// Constants representing the powers of 2 used for comparison
const N1 = Math.pow(2, 7);
const N2 = Math.pow(2, 14);
const N3 = Math.pow(2, 21);
@ -72,6 +108,7 @@ const varint = {
const N8 = Math.pow(2, 56);
const N9 = Math.pow(2, 63);
// Return the number of bytes required based on the value
return (
val < N1 ? 1
: val < N2 ? 2