Aidar/SHiNE-server
SHA256
2
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

30 12 25

Browse Source 
Ну типо переделал Всё под короткую таблицу солана юзерс, но теперь не надо поправить баги
This commit is contained in:
AidarKC 2025-12-30 12:39:55 +03:00
parent b6b50557a7
commit 34e8640e78
11 changed files with 439 additions and 182 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
shine-server-db/src/main/java/shine/db/DatabaseInitializer.java
View File

@ -81,10 +81,7 @@ public class DatabaseInitializer {
st.executeUpdate("""
CREATE TABLE IF NOT EXISTS solana_users (
login TEXT NOT NULL PRIMARY KEY,
bchName TEXT NOT NULL,
loginKey TEXT,
deviceKey TEXT,
bchLimit INTEGER
deviceKey TEXT NOT NULL
);
""");
@ -157,7 +154,7 @@ public class DatabaseInitializer {
CREATE TABLE IF NOT EXISTS blockchain_state (
blockchainName TEXT NOT NULL PRIMARY KEY,
login TEXT NOT NULL,
public_key_base64 TEXT NOT NULL,
blockchainKey TEXT NOT NULL,
size_limit INTEGER NOT NULL,
file_size_bytes INTEGER NOT NULL,
@ -181,7 +178,9 @@ public class DatabaseInitializer {
line6_last_number INTEGER NOT NULL,
line6_last_hash TEXT NOT NULL,
line7_last_number INTEGER NOT NULL,
line7_last_hash TEXT NOT NULL
line7_last_hash TEXT NOT NULL,
FOREIGN KEY (login) REFERENCES solana_users(login)
);
""");
@ -216,7 +215,8 @@ public class DatabaseInitializer {
toBlockGlobalNumber INTEGER,
toBlockHashe TEXT,
FOREIGN KEY (login) REFERENCES solana_users(login)
FOREIGN KEY (login) REFERENCES solana_users(login),
FOREIGN KEY (bchName) REFERENCES blockchain_state(blockchainName)
);
""");

53
shine-server-db/src/main/java/shine/db/dao/BlockchainStateDAO.java
View File

@ -34,7 +34,7 @@ public final class BlockchainStateDAO {
SELECT
blockchainName,
login,
public_key_base64,
blockchainKey,
size_limit,
file_size_bytes,
last_global_number,
@ -81,7 +81,7 @@ public final class BlockchainStateDAO {
INSERT INTO blockchain_state (
blockchainName,
login,
public_key_base64,
blockchainKey,
size_limit,
file_size_bytes,
last_global_number,
@ -109,7 +109,7 @@ public final class BlockchainStateDAO {
ON CONFLICT(blockchainName)
DO UPDATE SET
login = excluded.login,
public_key_base64 = excluded.public_key_base64,
blockchainKey = excluded.blockchainKey,
size_limit = excluded.size_limit,
file_size_bytes = excluded.file_size_bytes,
last_global_number = excluded.last_global_number,
@ -138,7 +138,7 @@ public final class BlockchainStateDAO {
ps.setString(i++, e.getBlockchainName());
ps.setString(i++, nn(e.getLogin()));
ps.setString(i++, nn(e.getPublicKeyBase64()));
ps.setString(i++, nn(e.getBlockchainKey()));
ps.setLong(i++, e.getSizeLimit());
ps.setLong(i++, e.getFileSizeBytes());
@ -156,12 +156,55 @@ public final class BlockchainStateDAO {
}
}
/**
* Атомарно увеличить file_size_bytes на deltaBytes, но только если НЕ превысим size_limit.
*
* Возвращает:
* - true если обновили (лимит не превышен)
* - false если лимит превышается или blockchainName не найден
*
* ВАЖНО: это именно тот механизм, который надо дергать при добавлении блока.
*/
public boolean tryIncreaseFileSizeWithinLimit(Connection c, String blockchainName, long deltaBytes, long nowMs) throws SQLException {
String sql = """
UPDATE blockchain_state
SET
file_size_bytes = file_size_bytes + ?,
updated_at_ms = ?
WHERE
blockchainName = ?
AND (file_size_bytes + ?) <= size_limit
""";
try (PreparedStatement ps = c.prepareStatement(sql)) {
ps.setLong(1, deltaBytes);
ps.setLong(2, nowMs);
ps.setString(3, blockchainName);
ps.setLong(4, deltaBytes);
int updated = ps.executeUpdate();
return updated > 0;
}
}
/** Удобная проверка для HEADER: запись должна быть и last_global_number должен быть -1. */
public BlockchainStateEntry requireExistingAtGenesis(Connection c, String blockchainName) throws SQLException {
BlockchainStateEntry st = getByBlockchainName(c, blockchainName);
if (st == null) {
throw new IllegalStateException("Blockchain state not found for blockchainName=" + blockchainName);
}
if (st.getLastGlobalNumber() != -1) {
throw new IllegalStateException("Blockchain state is not at genesis (-1). blockchainName=" + blockchainName +
" last_global_number=" + st.getLastGlobalNumber());
}
return st;
}
private BlockchainStateEntry mapRow(ResultSet rs) throws SQLException {
BlockchainStateEntry e = new BlockchainStateEntry();
e.setBlockchainName(rs.getString("blockchainName"));
e.setLogin(rs.getString("login"));
e.setPublicKeyBase64(rs.getString("public_key_base64"));
e.setBlockchainKey(rs.getString("blockchainKey"));
// size_limit теперь long
e.setSizeLimit(rs.getLong("size_limit"));

53
shine-server-db/src/main/java/shine/db/dao/SolanaBlockchainsDAO.java Normal file
View File

@ -0,0 +1,53 @@
package shine.db.dao;
import shine.db.SqliteDbController;
import shine.db.entities.BlockchainStateEntry;
import java.sql.*;
/**
* SolanaBlockchainsDAO — таблица блокчейнов пользователя.
*
* Сейчас физически это blockchain_state, потому что:
* - у одного login может быть несколько blockchainName
* - у каждого blockchainName свой blockchainKey и size_limit
*
* Правило:
* - методы с Connection НЕ закрывают соединение
* - методы без Connection сами открывают и закрывают соединение
*/
public final class SolanaBlockchainsDAO {
private static volatile SolanaBlockchainsDAO instance;
private final SqliteDbController db = SqliteDbController.getInstance();
private final BlockchainStateDAO stateDao = BlockchainStateDAO.getInstance();
private SolanaBlockchainsDAO() {}
public static SolanaBlockchainsDAO getInstance() {
if (instance == null) {
synchronized (SolanaBlockchainsDAO.class) {
if (instance == null) instance = new SolanaBlockchainsDAO();
}
}
return instance;
}
public BlockchainStateEntry getByBlockchainName(String blockchainName) throws SQLException {
return stateDao.getByBlockchainName(blockchainName);
}
public BlockchainStateEntry getByBlockchainName(Connection c, String blockchainName) throws SQLException {
return stateDao.getByBlockchainName(c, blockchainName);
}
/** Для HEADER: проверка, что blockchain_state существует и last_global_number=-1. */
public BlockchainStateEntry requireExistingAtGenesis(Connection c, String blockchainName) throws SQLException {
return stateDao.requireExistingAtGenesis(c, blockchainName);
}
/** Для добавления блока: атомарная проверка лимита + увеличение размера файла. */
public boolean tryIncreaseFileSizeWithinLimit(Connection c, String blockchainName, long deltaBytes, long nowMs) throws SQLException {
return stateDao.tryIncreaseFileSizeWithinLimit(c, blockchainName, deltaBytes, nowMs);
}
}

21
shine-server-db/src/main/java/shine/db/dao/SolanaUsersDAO.java
View File

@ -42,19 +42,13 @@ public final class SolanaUsersDAO {
/** Вставка с внешним соединением. Соединение НЕ закрывает. */
public void insert(Connection c, SolanaUserEntry user) throws SQLException {
String sql = """
INSERT INTO solana_users (login, bchName, loginKey, deviceKey, bchLimit)
VALUES (?, ?, ?, ?, ?)
INSERT INTO solana_users (login, deviceKey)
VALUES (?, ?)
""";
try (PreparedStatement ps = c.prepareStatement(sql)) {
ps.setString(1, user.getLogin());
ps.setString(2, user.getBchName());
ps.setString(3, user.getLoginKey());
ps.setString(4, user.getDeviceKey());
if (user.getBchLimit() != null) ps.setInt(5, user.getBchLimit());
else ps.setNull(5, Types.INTEGER);
ps.setString(2, user.getDeviceKey());
ps.executeUpdate();
}
}
@ -97,7 +91,7 @@ public final class SolanaUsersDAO {
/** Получить по login (case-insensitive) с внешним соединением. Соединение НЕ закрывает. */
public SolanaUserEntry getByLogin(Connection c, String login) throws SQLException {
String sql = """
SELECT login, bchName, loginKey, deviceKey, bchLimit
SELECT login, deviceKey
FROM solana_users
WHERE LOWER(login) = LOWER(?)
""";
@ -121,7 +115,7 @@ public final class SolanaUsersDAO {
/** Поиск по префиксу с внешним соединением. Соединение НЕ закрывает. */
public List<SolanaUserEntry> searchByLoginPrefix(Connection c, String prefix) throws SQLException {
String sql = """
SELECT login, bchName, loginKey, deviceKey, bchLimit
SELECT login, deviceKey
FROM solana_users
WHERE LOWER(login) LIKE ?
ORDER BY login
@ -152,10 +146,7 @@ public final class SolanaUsersDAO {
private SolanaUserEntry mapRow(ResultSet rs) throws SQLException {
return new SolanaUserEntry(
rs.getString("login"),
rs.getString("bchName"),
rs.getString("loginKey"),
rs.getString("deviceKey"),
rs.getObject("bchLimit") != null ? rs.getInt("bchLimit") : null
rs.getString("deviceKey")
);
}
}

102
shine-server-db/src/main/java/shine/db/dao/UserCreateDAO.java Normal file
View File

@ -0,0 +1,102 @@
package shine.db.dao;
import shine.db.SqliteDbController;
import shine.db.entities.BlockchainStateEntry;
import shine.db.entities.SolanaUserEntry;
import java.sql.*;
/**
* UserCreateDAO — атомарное добавление пользователя:
* - solana_users (login, deviceKey)
* - blockchain_state (blockchainName, login, blockchainKey, size_limit, ... last_global_number=-1 ...)
*
* ВАЖНО:
* - только INSERT
* - если login или blockchainName заняты — возвращаем false (пользователь уже есть/занято)
*/
public final class UserCreateDAO {
private static volatile UserCreateDAO instance;
private final SqliteDbController db = SqliteDbController.getInstance();
private final SolanaUsersDAO usersDao = SolanaUsersDAO.getInstance();
private final BlockchainStateDAO stateDao = BlockchainStateDAO.getInstance();
private UserCreateDAO() {}
public static UserCreateDAO getInstance() {
if (instance == null) {
synchronized (UserCreateDAO.class) {
if (instance == null) instance = new UserCreateDAO();
}
}
return instance;
}
/**
* @return true если добавили; false если занято (login уже есть или blockchainName уже существует).
*/
public boolean insertUserWithBlockchain(
String login,
String deviceKey,
String blockchainName,
String blockchainKey,
long sizeLimit,
long nowMs
) throws SQLException {
try (Connection c = db.getConnection()) {
boolean oldAuto = c.getAutoCommit();
c.setAutoCommit(false);
// BEGIN IMMEDIATE — чтобы сразу взять write-lock и не ловить гонки
try (Statement st = c.createStatement()) {
st.execute("BEGIN IMMEDIATE");
}
try {
// 1) user
SolanaUserEntry u = new SolanaUserEntry(login, deviceKey);
usersDao.insert(c, u); // если login занят -> constraint
// 2) blockchain_state
BlockchainStateEntry st = new BlockchainStateEntry();
st.setBlockchainName(blockchainName);
st.setLogin(login);
st.setBlockchainKey(blockchainKey);
st.setSizeLimit(sizeLimit);
st.setFileSizeBytes(0L);
// старт: глобальных блоков ещё нет
st.setLastGlobalNumber(-1);
st.setLastGlobalHash("");
for (int line = 0; line < 8; line++) {
st.setLastLineNumber(line, 0);
st.setLastLineHash(line, "");
}
st.setUpdatedAtMs(nowMs);
stateDao.upsert(c, st); // если blockchainName занят -> constraint (PK)
c.commit();
return true;
} catch (SQLException e) {
c.rollback();
// SQLITE_CONSTRAINT -> "уже существует"
// Мы не делаем UPDATE, только insert.
String msg = e.getMessage() == null ? "" : e.getMessage().toLowerCase();
if (msg.contains("constraint")) {
return false;
}
throw e;
} finally {
c.setAutoCommit(oldAuto);
}
}
}
}

26
shine-server-db/src/main/java/shine/db/entities/BlockchainStateEntry.java
View File

@ -1,6 +1,7 @@
package shine.db.entities;
import java.util.Arrays;
import java.util.Base64;
/**
* Агрегатная сущность текущего состояния блокчейна.
@ -11,7 +12,9 @@ public final class BlockchainStateEntry {
private String blockchainName;
private String login;
private String publicKeyBase64;
/** Ключ блокчейна (pubkey), которым подписываются блоки. Base64(32 bytes). */
private String blockchainKey;
/** Лимит (теперь long). */
private long sizeLimit;
@ -36,7 +39,7 @@ public final class BlockchainStateEntry {
public BlockchainStateEntry(String blockchainName,
String login,
String publicKeyBase64,
String blockchainKey,
long sizeLimit,
long fileSizeBytes,
int lastGlobalNumber,
@ -46,7 +49,7 @@ public final class BlockchainStateEntry {
long updatedAtMs) {
this.blockchainName = blockchainName;
this.login = login;
this.publicKeyBase64 = publicKeyBase64;
this.blockchainKey = blockchainKey;
this.sizeLimit = sizeLimit;
this.fileSizeBytes = fileSizeBytes;
this.lastGlobalNumber = lastGlobalNumber;
@ -72,8 +75,21 @@ public final class BlockchainStateEntry {
public String getLogin() { return login; }
public void setLogin(String login) { this.login = login; }
public String getPublicKeyBase64() { return publicKeyBase64; }
public void setPublicKeyBase64(String publicKeyBase64) { this.publicKeyBase64 = publicKeyBase64; }
public String getBlockchainKey() { return blockchainKey; }
public void setBlockchainKey(String blockchainKey) { this.blockchainKey = blockchainKey; }
/** blockchainKey в байтах (32) или null, если битый. */
public byte[] getBlockchainKeyBytes() {
if (blockchainKey == null) return null;
String s = blockchainKey.trim();
if (s.isEmpty()) return null;
try {
byte[] b = Base64.getDecoder().decode(s);
return (b != null && b.length == 32) ? b : null;
} catch (IllegalArgumentException e) {
return null;
}
}
public long getSizeLimit() { return sizeLimit; }
public void setSizeLimit(long sizeLimit) { this.sizeLimit = sizeLimit; }

32
shine-server-db/src/main/java/shine/db/entities/SolanaUserEntry.java
View File

@ -15,52 +15,32 @@ import java.util.Base64;
public class SolanaUserEntry {
private String login; // TEXT PK
private String bchName; // TEXT NOT NULL
private String loginKey; // TEXT
private String deviceKey; // TEXT
private Integer bchLimit; // INTEGER nullable
private String deviceKey; // TEXT NOT NULL (Base64(32 bytes))
public SolanaUserEntry() {}
public SolanaUserEntry(String login,
String bchName,
String loginKey,
String deviceKey,
Integer bchLimit) {
public SolanaUserEntry(String login, String deviceKey) {
this.login = login;
this.bchName = bchName;
this.loginKey = loginKey;
this.deviceKey = deviceKey;
this.bchLimit = bchLimit;
}
public String getLogin() { return login; }
public void setLogin(String login) { this.login = login; }
public String getBchName() { return bchName; }
public void setBchName(String bchName) { this.bchName = bchName; }
/** Публичный ключ логина (основной ключ пользователя). */
public String getLoginKey() { return loginKey; }
public void setLoginKey(String loginKey) { this.loginKey = loginKey; }
/** Публичный ключ устройства (device key). */
public String getDeviceKey() { return deviceKey; }
public void setDeviceKey(String deviceKey) { this.deviceKey = deviceKey; }
public Integer getBchLimit() { return bchLimit; }
public void setBchLimit(Integer bchLimit) { this.bchLimit = bchLimit; }
/**
* Публичный ключ логина в байтах (32 байта) или null, если ключ битый/пустой.
* Device key в байтах (32 байта) или null, если ключ битый/пустой.
*
* Поддержка форматов:
* - Base64 (предпочтительно)
* - HEX (ровно 64 hex-символа, без пробелов)
*/
public byte[] getLoginKeyByte() {
if (loginKey == null) return null;
String s = loginKey.trim();
public byte[] getDeviceKeyByte() {
if (deviceKey == null) return null;
String s = deviceKey.trim();
if (s.isEmpty()) return null;
// 1) пробуем Base64

13
shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/blockchain/BlockchainWriter.java
View File

@ -72,6 +72,11 @@ public final class BlockchainWriter {
String newHashHex
) throws SQLException {
// ✅ ВАЖНО: state теперь ОБЯЗАТЕЛЕН, genesis НЕ создаёт запись, а обновляет существующую
if (stOrNull == null) {
throw new SQLException("blockchain_state not found for blockchainName=" + blockchainName + " (state обязателен)");
}
verifyMainFileSizeMatchesStateOrAlert(login, blockchainName, block, stOrNull);
// =====================================================================
@ -82,14 +87,14 @@ public final class BlockchainWriter {
// =====================================================================
// ШАГ 2. Считаем новый fileSizeBytes
// =====================================================================
final long oldFileSize = (stOrNull == null) ? 0L : stOrNull.getFileSizeBytes();
final long oldFileSize = stOrNull.getFileSizeBytes();
final long newFileSize = safeAdd(oldFileSize, newBlockFullBytes.length);
// =====================================================================
// ШАГ 3. Создаём новый tmp-файл: tmp = (old file bytes) + (new block bytes)
// =====================================================================
final byte[] tmpBytes;
if (stOrNull == null || oldFileSize == 0) {
if (oldFileSize == 0) {
tmpBytes = newBlockFullBytes;
} else {
byte[] oldBytes;
@ -246,10 +251,10 @@ public final class BlockchainWriter {
long newFileSizeBytes
) throws SQLException {
// ✅ state обязателен
BlockchainStateEntry st = stOrNull;
if (st == null) {
st = new BlockchainStateEntry();
st.setBlockchainName(blockchainName);
throw new SQLException("blockchain_state not found for blockchainName=" + blockchainName);
}
// глобальная цепочка всегда растёт по recordNumber

208
shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/blockchain/Net_AddBlock_Handler.java
View File

@ -13,9 +13,7 @@ import server.logic.ws_protocol.JSON.handlers.JsonMessageHandler;
import server.logic.ws_protocol.WireCodes;
import shine.db.dao.BlockchainStateDAO;
import shine.db.dao.BlocksDAO;
import shine.db.dao.SolanaUsersDAO;
import shine.db.entities.BlockchainStateEntry;
import shine.db.entities.SolanaUserEntry;
import utils.blockchain.BlockchainNameUtil;
import java.util.Base64;
@ -42,7 +40,6 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler {
private final BlocksDAO blocksDAO = BlocksDAO.getInstance();
private final BlockchainStateDAO stateDAO = BlockchainStateDAO.getInstance();
private final SolanaUsersDAO solanaUsersDAO = SolanaUsersDAO.getInstance();
private final BlockchainWriter dbWriter = new BlockchainWriter(blocksDAO, stateDAO);
@ -104,66 +101,10 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler {
return new AddBlockResult(WireCodes.Status.BAD_REQUEST, "bad_blockchain_name", 0, "");
}
final byte[] blockBytes;
try {
blockBytes = decodeBase64(blockBytesB64);
} catch (Exception e) {
log.warn("AddBlock: некорректный base64 блока (login={}, blockchainName={}, globalNumber={})",
login, blockchainName, globalNumber, e);
return new AddBlockResult(WireCodes.Status.BAD_REQUEST, "bad_block_base64", 0, "");
}
final BchBlockEntry block;
try {
block = new BchBlockEntry(blockBytes);
} catch (Exception e) {
// важно: BchBlockEntry теперь сам валит блок, если body в неправильной линии
log.warn("AddBlock: не удалось распарсить BchBlockEntry (login={}, blockchainName={}, globalNumber={}, bytesLen={})",
login, blockchainName, globalNumber, blockBytes.length, e);
return new AddBlockResult(WireCodes.Status.BAD_REQUEST, "bad_block_format", 0, "");
}
// body.check()
try {
block.body.check();
} catch (Exception e) {
log.warn("AddBlock: body.check() не прошёл (login={}, blockchainName={}, globalNumber={}, bodyType={}, bodyVersion={})",
login, blockchainName, globalNumber, safeBodyType(block), safeBodyVersion(block), e);
return new AddBlockResult(WireCodes.Status.BAD_REQUEST, "bad_block_body", 0, "");
}
// recordNumber == globalNumber
if (block.recordNumber != globalNumber) {
log.warn("AddBlock: global_number_mismatch (login={}, blockchainName={}, заявлен={}, внутриБлока={})",
login, blockchainName, globalNumber, block.recordNumber);
return new AddBlockResult(WireCodes.Status.BAD_REQUEST, "global_number_mismatch", 0, "");
}
// user + pubkey
SolanaUserEntry u;
try {
u = solanaUsersDAO.getByLogin(login);
} catch (Exception e) {
log.error("AddBlock: ошибка БД при чтении пользователя (login={}, blockchainName={}, globalNumber={})",
login, blockchainName, globalNumber, e);
return new AddBlockResult(WireCodes.Status.INTERNAL_ERROR, "db_error", 0, "");
}
if (u == null) {
log.warn("AddBlock: user_not_found (login={}, blockchainName={}, globalNumber={})",
login, blockchainName, globalNumber);
return new AddBlockResult(WireCodes.Status.NOT_FOUND, "user_not_found", 0, "");
}
byte[] loginKey32 = u.getLoginKeyByte();
if (loginKey32 == null || loginKey32.length != 32) {
log.warn("AddBlock: bad_user_login_key (login={}, blockchainName={}, globalNumber={}, keyLen={})",
login, blockchainName, globalNumber, (loginKey32 == null ? -1 : loginKey32.length));
return new AddBlockResult(WireCodes.Status.BAD_REQUEST, "bad_user_login_key", 0, "");
}
// state
BlockchainStateEntry st;
// -------------------------------------------------------------------
// ✅ 1) state теперь ОБЯЗАТЕЛЕН (и ключ подписи берём из него)
// -------------------------------------------------------------------
final BlockchainStateEntry st;
try {
st = stateDAO.getByBlockchainName(blockchainName);
} catch (Exception e) {
@ -172,21 +113,21 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler {
return new AddBlockResult(WireCodes.Status.INTERNAL_ERROR, "db_error", 0, "");
}
final int serverLastNum;
final String serverLastHash;
if (st == null) {
// нет state => обязаны принимать genesis
if (globalNumber != 0) {
log.warn("AddBlock: blockchain_state_not_found, но globalNumber != 0 (login={}, blockchainName={}, globalNumber={})",
login, blockchainName, globalNumber);
return new AddBlockResult(WireCodes.Status.NOT_FOUND, "blockchain_state_not_found", 0, "");
}
serverLastNum = -1;
serverLastHash = "";
} else {
serverLastNum = st.getLastGlobalNumber();
serverLastHash = nn(st.getLastGlobalHash());
// теперь даже для genesis это ошибка: state должен быть создан заранее (с lastGlobalNumber=-1)
log.warn("AddBlock: blockchain_state_not_found (login={}, blockchainName={}, globalNumber={})",
login, blockchainName, globalNumber);
return new AddBlockResult(WireCodes.Status.NOT_FOUND, "blockchain_state_not_found", -1, "");
}
final int serverLastNum = st.getLastGlobalNumber();
final String serverLastHash = nn(st.getLastGlobalHash());
// ✅ для genesis ожидаем, что state уже в начальном состоянии (-1)
if (globalNumber == 0 && serverLastNum != -1) {
log.warn("AddBlock: genesis_but_state_not_initial (login={}, blockchainName={}, stateLastGlobalNumber={})",
login, blockchainName, serverLastNum);
return new AddBlockResult(WireCodes.Status.BAD_REQUEST, "genesis_but_state_not_initial", serverLastNum, serverLastHash);
}
// следующий global строго
@ -197,12 +138,93 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler {
return new AddBlockResult(WireCodes.Status.BAD_REQUEST, "bad_global_number", serverLastNum, serverLastHash);
}
// prevGlobalHash сравниваем со state.lastGlobalHash
// -------------------------------------------------------------------
// ✅ 2) Декодируем блок (раньше парсинга body)
// -------------------------------------------------------------------
final byte[] blockBytes;
try {
blockBytes = decodeBase64(blockBytesB64);
} catch (Exception e) {
log.warn("AddBlock: некорректный base64 блока (login={}, blockchainName={}, globalNumber={})",
login, blockchainName, globalNumber, e);
return new AddBlockResult(WireCodes.Status.BAD_REQUEST, "bad_block_base64", serverLastNum, serverLastHash);
}
// -------------------------------------------------------------------
// ✅ 3) Ранняя проверка лимита ДО любых записей (как ты попросил)
// -------------------------------------------------------------------
try {
long oldSize = st.getFileSizeBytes();
long limit = st.getSizeLimit(); // предполагается, что поле уже есть (size_limit)
long newSize = safeAdd(oldSize, blockBytes.length);
if (limit > 0 && newSize > limit) {
log.warn("AddBlock: limit_exceeded (login={}, blockchainName={}, globalNumber={}, oldSize={}, addLen={}, newSize={}, limit={})",
login, blockchainName, globalNumber, oldSize, blockBytes.length, newSize, limit);
return new AddBlockResult(413, "limit_exceeded", serverLastNum, serverLastHash);
}
} catch (Exception e) {
log.error("AddBlock: limit_check_failed (login={}, blockchainName={}, globalNumber={})",
login, blockchainName, globalNumber, e);
return new AddBlockResult(WireCodes.Status.INTERNAL_ERROR, "limit_check_failed", serverLastNum, serverLastHash);
}
// -------------------------------------------------------------------
// ✅ 4) Парсим блок
// -------------------------------------------------------------------
final BchBlockEntry block;
try {
block = new BchBlockEntry(blockBytes);
} catch (Exception e) {
// важно: BchBlockEntry теперь сам валит блок, если body в неправильной линии
log.warn("AddBlock: не удалось распарсить BchBlockEntry (login={}, blockchainName={}, globalNumber={}, bytesLen={})",
login, blockchainName, globalNumber, blockBytes.length, e);
return new AddBlockResult(WireCodes.Status.BAD_REQUEST, "bad_block_format", serverLastNum, serverLastHash);
}
// body.check()
try {
block.body.check();
} catch (Exception e) {
log.warn("AddBlock: body.check() не прошёл (login={}, blockchainName={}, globalNumber={}, bodyType={}, bodyVersion={})",
login, blockchainName, globalNumber, safeBodyType(block), safeBodyVersion(block), e);
return new AddBlockResult(WireCodes.Status.BAD_REQUEST, "bad_block_body", serverLastNum, serverLastHash);
}
// recordNumber == globalNumber
if (block.recordNumber != globalNumber) {
log.warn("AddBlock: global_number_mismatch (login={}, blockchainName={}, заявлен={}, внутриБлока={})",
login, blockchainName, globalNumber, block.recordNumber);
return new AddBlockResult(WireCodes.Status.BAD_REQUEST, "global_number_mismatch", serverLastNum, serverLastHash);
}
// -------------------------------------------------------------------
// ✅ 5) Ключ подписи берём из blockchain_state.blockchainKey (Base64(32))
// -------------------------------------------------------------------
final byte[] loginKey32;
try {
// предполагается, что st.getBlockchainKey() возвращает base64-строку, а getBlockchainKeyByte() -> 32 bytes
loginKey32 = st.getBlockchainKeyBytes();
} catch (Exception e) {
log.warn("AddBlock: bad_blockchain_key_in_state (login={}, blockchainName={}, globalNumber={})",
login, blockchainName, globalNumber, e);
return new AddBlockResult(WireCodes.Status.BAD_REQUEST, "bad_blockchain_key_in_state", serverLastNum, serverLastHash);
}
if (loginKey32 == null || loginKey32.length != 32) {
log.warn("AddBlock: bad_blockchain_key_len (login={}, blockchainName={}, globalNumber={}, keyLen={})",
login, blockchainName, globalNumber, (loginKey32 == null ? -1 : loginKey32.length));
return new AddBlockResult(WireCodes.Status.BAD_REQUEST, "bad_blockchain_key_len", serverLastNum, serverLastHash);
}
// -------------------------------------------------------------------
// ✅ 6) prevGlobalHash сравниваем со state.lastGlobalHash
// -------------------------------------------------------------------
final byte[] prevGlobalHash32;
final byte[] serverPrevGlobal32;
try {
prevGlobalHash32 = hexTo32(nn(prevGlobalHashHex));
serverPrevGlobal32 = (st == null) ? new byte[32] : hexTo32(nn(st.getLastGlobalHash()));
serverPrevGlobal32 = hexTo32(nn(st.getLastGlobalHash())); // если пусто -> 32 нуля
} catch (Exception e) {
log.warn("AddBlock: bad_prev_global_hash_format (login={}, blockchainName={}, globalNumber={}, prevGlobalHashHex='{}')",
login, blockchainName, globalNumber, nn(prevGlobalHashHex), e);
@ -211,7 +233,7 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler {
if (!bytesEq(prevGlobalHash32, serverPrevGlobal32)) {
log.warn("AddBlock: bad_prev_global_hash (login={}, blockchainName={}, globalNumber={}, clientPrev='{}', serverPrev='{}')",
login, blockchainName, globalNumber, nn(prevGlobalHashHex), nn(st != null ? st.getLastGlobalHash() : ""));
login, blockchainName, globalNumber, nn(prevGlobalHashHex), nn(st.getLastGlobalHash()));
return new AddBlockResult(WireCodes.Status.BAD_REQUEST, "bad_prev_global_hash", serverLastNum, serverLastHash);
}
@ -242,11 +264,6 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler {
return new AddBlockResult(WireCodes.Status.BAD_REQUEST, "bad_line_index", serverLastNum, serverLastHash);
}
if (st == null) {
// теоретически сюда не должны попасть (global>0 при st==null уже отфутболили)
return new AddBlockResult(WireCodes.Status.INTERNAL_ERROR, "internal_state_error", serverLastNum, serverLastHash);
}
int expectedLineNumber = st.getLastLineNumber(li) + 1;
if (ln != expectedLineNumber) {
log.warn("AddBlock: bad_line_number (login={}, blockchainName={}, globalNumber={}, lineIndex={}, пришёлLineNumber={}, ожидалиLineNumber={}, lastLineNumber={})",
@ -261,16 +278,8 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler {
final byte[] prevLineHash32;
final String prevLineHashHex;
try {
if (st == null) {
prevLineHash32 = new byte[32];
prevLineHashHex = "";
} else {
// ✅ ВАЖНОЕ ИСПРАВЛЕНИЕ:
// Если это первая запись в линии (lastLineNumber==0),
// то prevLineHash должен быть hash(genesis), а не пустота.
prevLineHashHex = computePrevLineHashHex(st, li);
prevLineHash32 = hexTo32(prevLineHashHex);
}
prevLineHashHex = computePrevLineHashHex(st, li);
prevLineHash32 = hexTo32(prevLineHashHex);
} catch (Exception e) {
log.warn("AddBlock: bad_prev_line_hash_in_state (login={}, blockchainName={}, globalNumber={}, lineIndex={})",
login, blockchainName, globalNumber, li, e);
@ -341,7 +350,6 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler {
String g = nn(st.getLastGlobalHash());
if (!g.isBlank()) return g;
// в крайнем случае вернём пустоту -> 32 нуля (лучше чем NPE), но это уже будет симптомом проблем state
return "";
}
@ -415,4 +423,12 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler {
private static String safeBodyVersion(BchBlockEntry b) {
try { return String.valueOf(b.body.version()); } catch (Exception e) { return "unknown"; }
}
private static long safeAdd(long x, long y) {
long r = x + y;
if (((x ^ r) & (y ^ r)) < 0) {
throw new IllegalArgumentException("overflow: " + x + " + " + y);
}
return r;
}
}

95
shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/tempToTest/Net_AddUser_Handler.java
View File

@ -10,20 +10,25 @@ import server.logic.ws_protocol.JSON.entyties.tempToTest.Net_AddUser_Response;
import server.logic.ws_protocol.JSON.handlers.JsonMessageHandler;
import server.logic.ws_protocol.JSON.utils.NetExceptionResponseFactory;
import server.logic.ws_protocol.WireCodes;
import shine.db.SqliteDbController;
import shine.db.dao.BlockchainStateDAO;
import shine.db.dao.SolanaUsersDAO;
import shine.db.entities.BlockchainStateEntry;
import shine.db.entities.SolanaUserEntry;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Base64;
public class Net_AddUser_Handler implements JsonMessageHandler {
private static final Logger log = LoggerFactory.getLogger(Net_AddUser_Handler.class);
/** TEST ONLY: лимит блокчейна по умолчанию. Потом заменишь на норм логику. */
/** TEST ONLY */
private static final int TEST_BCH_LIMIT = 1_000_000;
@Override
public Net_Response handle(Net_Request baseRequest, ConnectionContext ctx) throws Exception {
public Net_Response handle(Net_Request baseRequest, ConnectionContext ctx) {
Net_AddUser_Request req = (Net_AddUser_Request) baseRequest;
if (req.getLogin() == null || req.getLogin().isBlank()
@ -39,33 +44,72 @@ public class Net_AddUser_Handler implements JsonMessageHandler {
);
}
Integer limit = req.getBchLimit();
if (limit == null || limit <= 0) limit = TEST_BCH_LIMIT;
int limit = (req.getBchLimit() == null || req.getBchLimit() <= 0)
? TEST_BCH_LIMIT
: req.getBchLimit();
try {
SolanaUsersDAO dao = SolanaUsersDAO.getInstance();
// ✅ Новая логика: если пользователь уже есть — возвращаем понятную ошибку
SolanaUserEntry exists = dao.getByLogin(req.getLogin());
if (exists != null) {
log.info("⚠️ AddUser: user already exists, login={}", req.getLogin());
byte[] blockchainKey32 = Base64.getDecoder().decode(req.getLoginKey());
if (blockchainKey32.length != 32) {
return NetExceptionResponseFactory.error(
req,
409, // CONFLICT
"USER_ALREADY_EXISTS",
"Пользователь с таким login уже существует в системе"
WireCodes.Status.BAD_REQUEST,
"BAD_BLOCKCHAIN_KEY",
"loginKey должен быть Base64(32 bytes)"
);
}
SolanaUserEntry user = new SolanaUserEntry(
req.getLogin(),
req.getBlockchainName(),
req.getLoginKey(),
req.getDeviceKey(),
limit
);
SolanaUsersDAO usersDAO = SolanaUsersDAO.getInstance();
BlockchainStateDAO stateDAO = BlockchainStateDAO.getInstance();
dao.insert(user);
SqliteDbController db = SqliteDbController.getInstance();
try (Connection c = db.getConnection()) {
c.setAutoCommit(false);
// 1. Проверяем, что пользователя нет
if (usersDAO.getByLogin(req.getLogin()) != null) {
return NetExceptionResponseFactory.error(
req,
409,
"USER_ALREADY_EXISTS",
"Пользователь с таким login уже существует"
);
}
// 2. Проверяем, что blockchain_state ещё нет
if (stateDAO.getByBlockchainName(req.getBlockchainName()) != null) {
return NetExceptionResponseFactory.error(
req,
409,
"BLOCKCHAIN_ALREADY_EXISTS",
"blockchain_state уже существует"
);
}
// 3. Создаём пользователя
SolanaUserEntry user = new SolanaUserEntry(
req.getLogin(),
req.getDeviceKey()
);
usersDAO.insert(c, user);
// 4. Создаём INITIAL blockchain_state
BlockchainStateEntry st = new BlockchainStateEntry();
st.setBlockchainName(req.getBlockchainName());
st.setBlockchainKey(req.getLoginKey()); // Base64(32)
st.setLastGlobalNumber(-1);
st.setLastGlobalHash("");
st.setFileSizeBytes(0);
st.setSizeLimit(limit);
st.setUpdatedAtMs(System.currentTimeMillis());
stateDAO.upsert(c, st);
c.commit();
}
Net_AddUser_Response resp = new Net_AddUser_Response();
resp.setOp(req.getOp());
@ -77,13 +121,20 @@ public class Net_AddUser_Handler implements JsonMessageHandler {
return resp;
} catch (IllegalArgumentException e) {
return NetExceptionResponseFactory.error(
req,
WireCodes.Status.BAD_REQUEST,
"BAD_KEY_FORMAT",
e.getMessage()
);
} catch (SQLException e) {
log.error("❌ DB error AddUser", e);
return NetExceptionResponseFactory.error(
req,
WireCodes.Status.SERVER_DATA_ERROR,
"DB_ERROR",
"Ошибка доступа к базе данных"
"Ошибка БД"
);
} catch (Exception e) {
log.error("❌ Internal error AddUser", e);

4
src/test/java/test/it/IT_01_AddUser.java
View File

@ -25,7 +25,7 @@ public class IT_01_AddUser {
public static void main(String[] args) {
// чтобы тест можно было запускать вообще без JUnit
int failed = run();
System.exit(failed);
// System.exit(failed);
}
/** Запуск одного теста (standalone). Возвращает 0 если ок, 1 если упал. */
@ -33,7 +33,7 @@ public class IT_01_AddUser {
return TestLog.runOne("IT_01_AddUser", IT_01_AddUser::testBody);
}
@Test
// @Test
void addUser_shouldReturn200_orAlreadyExists() {
// JUnit-режим: пусть падает через assert/fail как обычно
testBody();