SHA256
Старт
This commit is contained in:
AidarKC
@@ -0,0 +1,10 @@
|
||||
|
||||
просто запустить
|
||||
user@p628065:~/docker/ws-server$ java -jar ws-server.jar
|
||||
|
||||
|
||||
запустить нормально что бы в фоне работал
|
||||
user@p628065:~/docker/ws-server$ nohup java -jar ws-server.jar > server.log 2>&1 &
|
||||
|
||||
перестартовать кадди
|
||||
user@p628065:~/docker/ws-server$ docker restart caddy
|
||||
@@ -0,0 +1,13 @@
|
||||
Для того что бы работало ДАО SHiNE.DAO
|
||||
|
||||
Зарегить в дао в солане.
|
||||
Что бы в нём работало голосование на
|
||||
Перевод средств.
|
||||
Выдача лимита раздававть бонусы.
|
||||
На апдейт смарт кантрактов
|
||||
И посути на запуск любой программы в сол.
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,67 @@
|
||||
Инвестиции считаем в USDT а вносим и выносим просто в соланах поо текущему курсу из оракула
|
||||
|
||||
НИКАНИХ замороженных NFT токенов валют и т.д.
|
||||
|
||||
Просто записи об очереди и вызов только через наш сайт!! //(И страницу дозаписи можно сделать фикированной в ARVEAVE)
|
||||
|
||||
Храним в одном пда реестре:
|
||||
сколько сколько сейчас в очереди записей,
|
||||
на какую сумму
|
||||
адрес последней записи.
|
||||
(Адрес записи-инвестиции это имя пользователя и номер записи)
|
||||
а так же сколько уже выплаченно
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
Создание новой записи о инвестициях.
|
||||
|
||||
На каждого Пользователя-инвестора заводим вначале новый ПДА
|
||||
, а если он уже есть то просто увеличиваем размер старово ПДА и делаем дозапись
|
||||
|
||||
** В записи у пользователя храним.
|
||||
Её номер (то есть сколько до неё),
|
||||
Сумму в очереди до неё,
|
||||
Флаг что выплаченно
|
||||
Адрес СЛЕДУЮЩИЙ транцакции
|
||||
|
||||
|
||||
** Есть акаун реестр где указано сколько уже есть записей, на какую сумму и какой номер крайнейй записи
|
||||
|
||||
** И есть акаунт реестр на выплаты, в нём указано
|
||||
сколько по счёту записей уже выплаченно
|
||||
и на какую сумму уже выплаченно
|
||||
сколько USDT надо накопить на для следующей выплаты
|
||||
адрес (акаунт и номер записи)
|
||||
|
||||
** И вторая очеред для самых близких
|
||||
Там всё тоже самое что и в первой только суммы выплаты больше и даты непонятны
|
||||
|
||||
Полуается
|
||||
** добавить запись
|
||||
Прочитал главный реестр,
|
||||
И пда с крайней записью.
|
||||
Попробывал прочитать пда в который надо писать новую запись
|
||||
И дальше либо создал его или увеличил его размер на 1 запись
|
||||
И записал в него данные
|
||||
А в преведущую крайнюю запись добавил адрес следующей записи
|
||||
Обновил данные в реестре
|
||||
|
||||
** Прочитать данные для пользователя
|
||||
Прочитал Все записи из его пда
|
||||
Прочитал Сколько выплаченно прочитал из реестра на выплату
|
||||
Прочитал Сколько сейчас уже есть денег и сколько надо до следующей выплаты
|
||||
Пересчитал данные и показал пользователю в виде актуальной таблицы
|
||||
|
||||
** Сама выплата
|
||||
всё можно легко понять по аналогии с тем что выше написанно
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,4 @@
|
||||
(При создании новых пользователей вообще не гоним о том что может быть конфликт если два чел в раз попытаются за регистрироваться
|
||||
т.к. даже при средней скорости 1 зарегистрированный чел в минуту будеит уже 43 200/мес,)
|
||||
|
||||
Поэтому делаем всю регистрацию одной транзакцией!! и не тупим пока об этом !!!
|
||||
@@ -0,0 +1,29 @@
|
||||
|
||||
|
||||
|
||||
Зарегистрироваться
|
||||
|
||||
|
||||
Внести инвестиции (получить запись на бонус в 1 очередь)
|
||||
|
||||
Выдать (Записать комуто) бонус 1 очереди
|
||||
Выдать (Записать комуто) бонус второй очереди
|
||||
|
||||
Попробывать сделать шаг выплаты по очереди
|
||||
|
||||
Функции чтения
|
||||
Получить данные о пользователе
|
||||
Получить данные о пользователе(по логину, тоетсь по логину узнали ИД потом по ИД данные о пользователе)
|
||||
Получить данные об очереди выплат пользователя
|
||||
|
||||
Данные о пользователе по ИД подписанны ЦП пользователя (прямо в блокчейне!!)
|
||||
|
||||
|
||||
|
||||
|
||||
На одного пользователя храниться 2-3 пда
|
||||
ПДА ссылка по имени пользователя на ИД ПОльзователя
|
||||
ПДА по ИД пользователя со всеми его данными
|
||||
(И просто дописывать данные о каждом новом Bch пользователя иего пда по userИД)
|
||||
|
||||
|
||||
@@ -0,0 +1,27 @@
|
||||
07.11.2025г.
|
||||
Принципы сияющих людей.
|
||||
То что в соц сети можно постаить галочку что я Сияющий или воздержаться
|
||||
|
||||
1. `Не Врать / Не обманывать`
|
||||
(Соответственно все данные и оценки и высказывания этого человека будут должны бытьверными)
|
||||
|
||||
2. `Развиваться`
|
||||
(Соответствено должны появляться записи о пройденных курсах)
|
||||
|
||||
3. `Верить в духовное (что есть что то большее чем только физическое тело)`
|
||||
(По этому человек соглашается (не спорит) что есть духовные практики, и проходит курсы и практики духовные)
|
||||
|
||||
4. `Социальная ответственность. Понимание того что мы часть единой цивилизации`
|
||||
то что человек поддерживает: экологические, социальные, светлые начинания и т.д.
|
||||
(Соответственно в соц сети. Отчёты о действиях, переводы, подтверждениедругими что ты делаешь)
|
||||
|
||||
5. `Отсноситься кдругим таккак ты хочешь что бы относились к тебе.`
|
||||
И то что люди тебя так ценят.
|
||||
(В соц сетиважно как оценивают тебя люди из твоего круга) (И можно написать как ты относишмся к людям и как хочешь что бы относились к тебе - это один пункт)
|
||||
|
||||
Друзья как ты. Ты как друзья.
|
||||
Друзей оценивают по тебе. Тебя оценивают по друзьям.
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,45 @@
|
||||
* ============================================================================
|
||||
* HeaderBody — тело записи типа 0 (заглавие блокчейна)
|
||||
* ============================================================================
|
||||
*
|
||||
* 🧩 Назначение:
|
||||
* Первый блок каждой пользовательской цепочки (.bch) — это "заголовок".
|
||||
* Он хранит базовую информацию о владельце, версии и публичном ключе.
|
||||
*
|
||||
* Этот блок всегда имеет:
|
||||
* • recordType = 0
|
||||
* • recordNumber = 0
|
||||
* • recordTypeVersion = 1
|
||||
*
|
||||
* ----------------------------------------------------------------------------
|
||||
* 🔹 Формат body (без общих 20 байт заголовка блока BchBlock)
|
||||
*
|
||||
* | Смещение | Размер | Поле | Формат | Описание |
|
||||
* |-----------|--------|--------------------|---------|-----------|
|
||||
* | 0x00 | 8 | tag | ASCII | Статическая сигнатура "SHiNE001" |
|
||||
*
|
||||
* | 0x10 | 1 | userLoginLength=N | uint8 | Длина логина пользователя |
|
||||
* | 0x11 | N | userLogin | UTF-8 | Логин пользователя |
|
||||
|
||||
* | 0x11+N | 4 | blockchainType | int BE | Зарезервировано (всегда 0) |
|
||||
|
||||
|
||||
* | 0x08 | 8 | blockchainId | long BE | Уникальный идентификатор цепочки |
|
||||
* | 0x11+N | 4 | blockchainType | int BE | Зарезервировано (всегда 0) |
|
||||
* | 0x15+N | 4 | blockchainNumber | int BE | Зарезервировано (всегда 0) |
|
||||
* | 0x19+N | 2 | versionUserBch | short BE| Версия формата (всегда 1) |
|
||||
* | 0x1B+N | 8 | prevUserBchId | long BE | Зарезервировано (всегда 0) |
|
||||
* | 0x23+N | 32 | publicKey32 | raw | Публичный ключ (Ed25519, 32 байта) |
|
||||
*
|
||||
* ----------------------------------------------------------------------------
|
||||
* 💡 Пример структуры в байтах:
|
||||
*
|
||||
* 0000: 53 48 69 4E 45 30 30 31 "SHiNE001"
|
||||
* 0008: 00 00 00 00 01 23 45 67 blockchainId
|
||||
* 0010: 05 userLoginLength = 5
|
||||
* 0011: 41 69 64 61 72 userLogin = "Aidar"
|
||||
* 0016: 00 00 00 00 blockchainType = 0
|
||||
* 001A: 00 00 00 00 blockchainNumber = 0
|
||||
* 001E: 00 01 versionUserBch = 1
|
||||
* 0020: 00 00 00 00 00 00 00 00 prevUserBchId = 0
|
||||
* 0028: [32 байта публичного ключа]
|
||||
@@ -0,0 +1,49 @@
|
||||
Solana говорит актуальные
|
||||
userLogin
|
||||
userId
|
||||
|
||||
Текущий номер блокчейна
|
||||
|
||||
И Список Доверенных (userId, дата добавления)
|
||||
.. Добавить доверенного
|
||||
.. Убавить доверенного
|
||||
|
||||
|
||||
------------------------
|
||||
И на каждый блокчен :
|
||||
UserBlcId
|
||||
UserBlcSig
|
||||
UserBlcLimit лимит МБ этого блокчейна
|
||||
|
||||
uerId
|
||||
Какой это по счёту блокчейн у пользователя
|
||||
Ид преведущего блокчейна
|
||||
|
||||
-----------------
|
||||
Можно в солане
|
||||
Добавить доверенного
|
||||
Удалить доверенного
|
||||
Сменить свою подпись (приложив строки с подписью доверенных)
|
||||
|
||||
И задержка на 30 дней довступления в силу
|
||||
(А со старта можно и без задержки главное библиотеку для доступа к сушностям в солане на js сразу генерировать вместе с растом :))
|
||||
|
||||
и ещё создать запись для смены ( и пох если зделал то сделал откатить нельзя можнотолько что бы все остальные не голосовали)
|
||||
--------------
|
||||
|
||||
|
||||
Можно делать технические записи (они совпадают с соланой)
|
||||
|
||||
В самом начале блок №0
|
||||
userLogin - userId
|
||||
|
||||
блок №1
|
||||
UserBlcId - UserBlcSig
|
||||
|
||||
|
||||
|
||||
Это чисто записи
|
||||
Добавить доверенного
|
||||
Убавить доверенного
|
||||
Добавить лимит
|
||||
|
||||
@@ -0,0 +1,27 @@
|
||||
Первый это ссылка (Пда по логину, у него двва ключа "login" и сам логин пользователя (1 байт длинна + логин до 30 символов))
|
||||
В логине можно a-z 0-9 и "_"
|
||||
|
||||
В нём записано
|
||||
Посути нуден только UserId
|
||||
А так можно
|
||||
+ вначале 8 байт константа типо ПДА
|
||||
+ Сам логин с заклавными буквами (не надо)
|
||||
+ Цп (не надо)
|
||||
|
||||
|
||||
Второй блокчен
|
||||
(ПДА по двум ключам?? Ид)
|
||||
|
||||
|
||||
+ вначале 8 байт константа типо ПДА
|
||||
+ 1 байт - N длинна логина
|
||||
+ N байт - сам логин (можно с большими буквами)
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,66 @@
|
||||
* ============================================================================
|
||||
* BchBlockEntry — универсальная запись блокчейна SHiNE (.bch)
|
||||
* ============================================================================
|
||||
*
|
||||
* 🧩 Формат файла .bch:
|
||||
* Каждый блок хранится последовательно, без промежутков.
|
||||
* Один блок = «заголовок» (RAW) + подпись (64) + хэш (32).
|
||||
*
|
||||
* FULL = RAW + signature(64) + hash(32)
|
||||
*
|
||||
* ---------------------------------------------------------------------------
|
||||
* 🔹 Структура RAW-части блока (без подписи и хэша)
|
||||
* ---------------------------------------------------------------------------
|
||||
* Размеры и порядок строго фиксированы (BigEndian).
|
||||
*
|
||||
* Порядок байтов (сверху вниз, смещения от начала RAW):
|
||||
*
|
||||
* ┌────────────────────────────┬────────┬───────────────────────────────┐
|
||||
* │ Поле │ Размер │ Описание │
|
||||
* ├────────────────────────────┼────────┼───────────────────────────────┤
|
||||
* │ recordSize │ 4 байта│ = M + 20 — общий размер RAW │
|
||||
* │ recordNumber │ 4 байта│ порядковый номер блока │
|
||||
* │ timestamp │ 8 байт │ UNIX time (секунды) │
|
||||
|
||||
Номер линии 2 байта линии пока просто пишутся но никак не используются
|
||||
номер преведущего блока в этой линии 4 байа
|
||||
|
||||
//Можно сказать что здесь уже тело пошло
|
||||
* │ recordType │ 2 байта│ тип тела (0=Header, 1=Text) │
|
||||
* │ recordTypeVersion │ 2 байта│ версия структуры данного типа │
|
||||
* │ body │ M байт │ бинарное тело записи │
|
||||
* └────────────────────────────┴────────┴───────────────────────────────┘
|
||||
*
|
||||
* ⇒ RAW_HEADER_SIZE = 4 + 4 + 8 + 2 + 2 = 20 байт.
|
||||
* ⇒ recordSize = RAW_HEADER_SIZE + body.length
|
||||
*
|
||||
* ---------------------------------------------------------------------------
|
||||
* 🔹 Структура FULL-блока
|
||||
* ---------------------------------------------------------------------------
|
||||
*
|
||||
* ┌────────────────────────────┬─────────┬──────────────────────────────┐
|
||||
* │ RAW │ M+20 │ тело блока без подписи │
|
||||
* │ signature64 │ 64 │ подпись Ed25519(preimage) │
|
||||
* │ hash32 │ 32 │ SHA-256(preimage) │
|
||||
* └────────────────────────────┴─────────┴──────────────────────────────┘
|
||||
*
|
||||
* ⇒ Общая длина FULL = recordSize + 96 байт.
|
||||
*
|
||||
* ---------------------------------------------------------------------------
|
||||
* 🔹 Канонический preimage для подписи/хэша
|
||||
* ---------------------------------------------------------------------------
|
||||
Новый вариант преимадже без блокченй ИД !!
|
||||
так как он может меняться
|
||||
|
||||
* preimage = Заглавие SHiNE
|
||||
* userLogin(UTF-8, без длины) +
|
||||
* userId(8B, BE) +
|
||||
* можно номер блока?
|
||||
* prevHash32(32B) +
|
||||
* rawBytes (M+20B)
|
||||
*
|
||||
* hash32 = SHA-256(preimage)
|
||||
* signature64= Ed25519.sign(preimage, privateKey)
|
||||
*
|
||||
* Проверка осуществляется через {@link utils.crypto.BchCryptoVerifier}.
|
||||
|
||||
@@ -0,0 +1,13 @@
|
||||
Технический блокчен
|
||||
|
||||
Блоки в солану
|
||||
|
||||
Личнык данные
|
||||
Связи
|
||||
|
||||
|
||||
Публичные сообщения
|
||||
|
||||
|
||||
|
||||
Личые письма
|
||||
@@ -0,0 +1,9 @@
|
||||
import shine.db.DatabaseInitializer;
|
||||
|
||||
public class CreateNewDatabase {
|
||||
|
||||
public static void main(String[] args) {
|
||||
// Просто прокидываем управление в DatabaseInitializer
|
||||
DatabaseInitializer.createNewDB(args);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,106 @@
|
||||
import java.net.URI;
|
||||
import java.net.http.HttpClient;
|
||||
import java.net.http.WebSocket;
|
||||
import java.net.http.WebSocket.Listener;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
import java.util.concurrent.CompletableFuture;
|
||||
import java.util.concurrent.CompletionStage;
|
||||
import java.util.concurrent.CountDownLatch;
|
||||
|
||||
public class TestJsonWsClient {
|
||||
|
||||
public static void main(String[] args) throws Exception {
|
||||
String uri = "ws://localhost:7070/ws";
|
||||
|
||||
|
||||
String jsonRequestSessionRefresh = """
|
||||
{
|
||||
"op": "SessionRefresh",
|
||||
"requestId": "test-1",
|
||||
"sessionId": 123,
|
||||
"sessionPwd": "test-password"
|
||||
}
|
||||
""";
|
||||
|
||||
String jsonRequestAddUser = """
|
||||
{
|
||||
"op": "AddUser",
|
||||
"requestId": "test-add-1",
|
||||
"login": "anya1111",
|
||||
"loginId": 100211,
|
||||
"bchId": 4222,
|
||||
"pubkey0": "PUB0",
|
||||
"pubkey1": "PUB1",
|
||||
"bchLimit": 1000000
|
||||
}
|
||||
""";
|
||||
|
||||
String jsonRequestAuthSessionNewStep1 = """
|
||||
{
|
||||
"op": "AuthSessionNewStep1",
|
||||
"requestId": "test-auth-1",
|
||||
"login": "anya1111"
|
||||
}
|
||||
""";
|
||||
|
||||
|
||||
// Тестовый JSON-пакет SessionRefresh
|
||||
String jsonRequest = jsonRequestAuthSessionNewStep1;
|
||||
|
||||
System.out.println("Подключаемся к " + uri);
|
||||
|
||||
CountDownLatch latch = new CountDownLatch(1);
|
||||
|
||||
HttpClient client = HttpClient.newHttpClient();
|
||||
|
||||
WebSocket webSocket = client.newWebSocketBuilder()
|
||||
.buildAsync(URI.create(uri), new Listener() {
|
||||
@Override
|
||||
public void onOpen(WebSocket webSocket) {
|
||||
System.out.println("✅ WebSocket подключен");
|
||||
|
||||
// Отправляем JSON сразу после подключения
|
||||
System.out.println("📤 Отправляем JSON-запрос:");
|
||||
System.out.println(jsonRequest);
|
||||
|
||||
webSocket.sendText(jsonRequest, true);
|
||||
Listener.super.onOpen(webSocket);
|
||||
}
|
||||
|
||||
@Override
|
||||
public CompletionStage<?> onText(WebSocket webSocket,
|
||||
CharSequence data,
|
||||
boolean last) {
|
||||
String message = data.toString();
|
||||
System.out.println("📥 Получен TEXT-ответ от сервера:");
|
||||
System.out.println(message);
|
||||
|
||||
// После получения первого ответа — закрываем соединение
|
||||
webSocket.sendClose(WebSocket.NORMAL_CLOSURE, "test done");
|
||||
latch.countDown();
|
||||
return Listener.super.onText(webSocket, data, last);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onError(WebSocket webSocket, Throwable error) {
|
||||
System.out.println("❌ Ошибка WebSocket-клиента: " + error.getMessage());
|
||||
error.printStackTrace(System.out);
|
||||
latch.countDown();
|
||||
}
|
||||
|
||||
|
||||
@Override
|
||||
public CompletionStage<?> onClose(WebSocket webSocket,
|
||||
int statusCode,
|
||||
String reason) {
|
||||
System.out.println("🔚 Соединение закрыто. Код=" + statusCode + ", причина=" + reason);
|
||||
latch.countDown();
|
||||
return Listener.super.onClose(webSocket, statusCode, reason);
|
||||
}
|
||||
}).join();
|
||||
|
||||
// Ждём, пока получим ответ/ошибку/закрытие
|
||||
latch.await();
|
||||
System.out.println("Тест завершён, выходим.");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,119 @@
|
||||
import java.net.URI;
|
||||
import java.net.http.HttpClient;
|
||||
import java.net.http.WebSocket;
|
||||
import java.net.http.WebSocket.Listener;
|
||||
import java.util.concurrent.CompletableFuture;
|
||||
import java.util.concurrent.CompletionStage;
|
||||
import java.util.concurrent.CountDownLatch;
|
||||
|
||||
public class TestJsonWsClient2 {
|
||||
|
||||
public static void main(String[] args) throws Exception {
|
||||
String uri = "ws://localhost:7070/ws";
|
||||
|
||||
String jsonRequestSessionRefresh = """
|
||||
{
|
||||
"op": "SessionRefresh",
|
||||
"requestId": "test-1",
|
||||
"sessionId": 123,
|
||||
"sessionPwd": "test-password"
|
||||
}
|
||||
""";
|
||||
|
||||
String jsonRequestAddUser = """
|
||||
{
|
||||
"op": "AddUser",
|
||||
"requestId": "test-add-1",
|
||||
"login": "anya1111",
|
||||
"loginId": 100211,
|
||||
"bchId": 4222,
|
||||
"pubkey0": "PUB0",
|
||||
"pubkey1": "PUB1",
|
||||
"bchLimit": 1000000
|
||||
}
|
||||
""";
|
||||
|
||||
String jsonRequestAuthSessionNewStep1 = """
|
||||
{
|
||||
"op": "AuthSessionNewStep1",
|
||||
"requestId": "test-auth-1",
|
||||
"login": "anya1111"
|
||||
}
|
||||
""";
|
||||
|
||||
// Что тестируем сейчас:
|
||||
String jsonRequest = jsonRequestAuthSessionNewStep1;
|
||||
// String jsonRequest = jsonRequestSessionRefresh;
|
||||
// String jsonRequest = jsonRequestAddUser;
|
||||
|
||||
System.out.println("Подключаемся к " + uri);
|
||||
|
||||
CountDownLatch latch = new CountDownLatch(1);
|
||||
|
||||
HttpClient client = HttpClient.newHttpClient();
|
||||
|
||||
WebSocket webSocket = client.newWebSocketBuilder()
|
||||
.buildAsync(URI.create(uri), new Listener() {
|
||||
|
||||
// 0 — ещё ничего не получили
|
||||
// 1 — получили 1-й ответ, отправили повторно
|
||||
// 2 — получили 2-й ответ, закрываемся
|
||||
private int responsesCount = 0;
|
||||
|
||||
@Override
|
||||
public void onOpen(WebSocket webSocket) {
|
||||
System.out.println("✅ WebSocket подключен");
|
||||
|
||||
System.out.println("📤 Отправляем JSON-запрос (1 раз):");
|
||||
System.out.println(jsonRequest);
|
||||
|
||||
webSocket.sendText(jsonRequest, true);
|
||||
Listener.super.onOpen(webSocket);
|
||||
}
|
||||
|
||||
@Override
|
||||
public CompletionStage<?> onText(WebSocket webSocket,
|
||||
CharSequence data,
|
||||
boolean last) {
|
||||
String message = data.toString();
|
||||
responsesCount++;
|
||||
|
||||
System.out.println("📥 Получен TEXT-ответ #" + responsesCount + " от сервера:");
|
||||
System.out.println(message);
|
||||
|
||||
if (responsesCount == 1) {
|
||||
// После первого ответа — отправляем тот же запрос ещё раз
|
||||
System.out.println("📤 Отправляем JSON-запрос второй раз:");
|
||||
System.out.println(jsonRequest);
|
||||
webSocket.sendText(jsonRequest, true);
|
||||
} else {
|
||||
// После второго ответа — закрываем соединение
|
||||
webSocket.sendClose(WebSocket.NORMAL_CLOSURE, "test done");
|
||||
latch.countDown();
|
||||
}
|
||||
|
||||
return Listener.super.onText(webSocket, data, last);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onError(WebSocket webSocket, Throwable error) {
|
||||
System.out.println("❌ Ошибка WebSocket-клиента: " + error.getMessage());
|
||||
error.printStackTrace(System.out);
|
||||
latch.countDown();
|
||||
}
|
||||
|
||||
@Override
|
||||
public CompletionStage<?> onClose(WebSocket webSocket,
|
||||
int statusCode,
|
||||
String reason) {
|
||||
System.out.println("🔚 Соединение закрыто. Код=" + statusCode + ", причина=" + reason);
|
||||
latch.countDown();
|
||||
return Listener.super.onClose(webSocket, statusCode, reason);
|
||||
}
|
||||
}).join();
|
||||
|
||||
// Ждём, пока получим ответ/ошибку/закрытие
|
||||
latch.await();
|
||||
System.out.println("Тест завершён, выходим.");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,356 @@
|
||||
import java.net.URI;
|
||||
import java.net.http.HttpClient;
|
||||
import java.net.http.WebSocket;
|
||||
import java.nio.ByteBuffer;
|
||||
import java.nio.ByteOrder;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
import java.time.Instant;
|
||||
import java.time.ZoneId;
|
||||
import java.time.format.DateTimeFormatter;
|
||||
import java.util.*;
|
||||
import java.util.concurrent.*;
|
||||
|
||||
public class WsTestClient {
|
||||
|
||||
// ==== Настройки клиента ====
|
||||
static final String WS_URL = "wss://shineup.me/ws";// "ws://localhost:8080/ws";
|
||||
|
||||
// ==== Тестовые параметры ====
|
||||
static final String FIXED_PRIVATE_KEY_STRING = "SHiNE_TEST_FIXED_PRIVATE_KEY_2025";
|
||||
static final long BLOCKCHAIN_ID = 351130785469109974L;//777_000_001L;
|
||||
static final int BLOCKCHAIN_TYPE = 0;
|
||||
static final int BLOCKCHAIN_NUM = 0;
|
||||
static final short VERSION_USER_BCH = 1;
|
||||
static final long PREV_USER_BCH_ID = 0L;
|
||||
static final String USER_LOGIN = "test_user";
|
||||
|
||||
// ==== Опкоды ====
|
||||
static final int OP_ADD_BLOCK = 1;
|
||||
static final int OP_GET_BLOCKCHAIN = 2;
|
||||
|
||||
// ==== Статусы ====
|
||||
static final int STATUS_OK = 200;
|
||||
static final int STATUS_BAD_REQUEST = 400;
|
||||
static final int STATUS_ALREADY_EXISTS = 409;
|
||||
static final int STATUS_NON_SEQUENTIAL = 412;
|
||||
static final int STATUS_UNVERIFIED = 422;
|
||||
static final int STATUS_INTERNAL = 500;
|
||||
|
||||
// ==== Типы блоков ====
|
||||
static final short TYPE_HEADER = 0;
|
||||
static final short TYPE_TEXT = 1;
|
||||
static final short RECORD_TYPE_VERSION = 1; // Новое поле
|
||||
|
||||
// ==== Константы формата ====
|
||||
static final int SIGNATURE_LEN = 64;
|
||||
static final int HASH_LEN = 32;
|
||||
static final int RAW_HEADER_SIZE = 4 + 4 + 8 + 2 + 2; // Теперь 20 байт
|
||||
|
||||
public static void main(String[] args) throws Exception {
|
||||
System.out.println("=== WsTestClient v1.1 ===");
|
||||
|
||||
byte[] priv32 = HashUtil.sha256(FIXED_PRIVATE_KEY_STRING.getBytes(StandardCharsets.UTF_8));
|
||||
byte[] pub32 = Ed25519Util.derivePublicKey(priv32);
|
||||
|
||||
WsBinaryCollector reader = new WsBinaryCollector();
|
||||
WebSocket ws = HttpClient.newHttpClient()
|
||||
.newWebSocketBuilder()
|
||||
.buildAsync(URI.create(WS_URL), reader)
|
||||
.join();
|
||||
System.out.println("✅ Connected to " + WS_URL);
|
||||
|
||||
// === 1. Создание заглавного блока ===
|
||||
byte[] headerBody = buildHeaderBody(USER_LOGIN, BLOCKCHAIN_ID, BLOCKCHAIN_TYPE, BLOCKCHAIN_NUM,
|
||||
VERSION_USER_BCH, PREV_USER_BCH_ID, pub32);
|
||||
|
||||
long ts = Instant.now().getEpochSecond();
|
||||
byte[] rawHeader = buildRawRecord(0, ts, TYPE_HEADER, RECORD_TYPE_VERSION, headerBody);
|
||||
byte[] fullHeader = signAndPack(rawHeader, USER_LOGIN, BLOCKCHAIN_ID, new byte[32], priv32, pub32);
|
||||
|
||||
byte[] addHeaderMsg = concat(beInt(OP_ADD_BLOCK), beLong(BLOCKCHAIN_ID), fullHeader);
|
||||
int st1 = sendAndReadStatus(ws, addHeaderMsg, reader);
|
||||
System.out.println("ADD HEADER → " + st1 + " (" + statusName(st1) + ")");
|
||||
|
||||
// === 2. Получаем всю цепочку ===
|
||||
ResponseWithPayload chainResp = sendAndReadPayload(ws, concat(beInt(OP_GET_BLOCKCHAIN), beLong(BLOCKCHAIN_ID)), reader);
|
||||
System.out.println("GET_BLOCKCHAIN → " + chainResp.status + " (" + statusName(chainResp.status) + ")");
|
||||
if (chainResp.status != STATUS_OK) return;
|
||||
|
||||
List<BlockParsed> blocks = parseAllBlocks(chainResp.payload);
|
||||
System.out.println("Chain contains " + blocks.size() + " blocks:");
|
||||
|
||||
for (BlockParsed bp : blocks) {
|
||||
printBlock(bp);
|
||||
}
|
||||
|
||||
// === 3. Добавление нового текстового блока ===
|
||||
Scanner sc = new Scanner(System.in, StandardCharsets.UTF_8);
|
||||
System.out.print("\nВведите текст для добавления в блокчейн (Enter — пропустить): ");
|
||||
String text = sc.nextLine().trim();
|
||||
if (!text.isEmpty()) {
|
||||
byte[] lastHash = blocks.isEmpty() ? new byte[32] : blocks.get(blocks.size() - 1).hash32;
|
||||
int nextNum = blocks.isEmpty() ? 0 : (blocks.get(blocks.size() - 1).recordNumber + 1);
|
||||
|
||||
byte[] textBody = text.getBytes(StandardCharsets.UTF_8);
|
||||
byte[] rawText = buildRawRecord(nextNum, Instant.now().getEpochSecond(), TYPE_TEXT, RECORD_TYPE_VERSION, textBody);
|
||||
byte[] fullText = signAndPack(rawText, USER_LOGIN, BLOCKCHAIN_ID, lastHash, priv32, pub32);
|
||||
|
||||
int st2 = sendAndReadStatus(ws, concat(beInt(OP_ADD_BLOCK), beLong(BLOCKCHAIN_ID), fullText), reader);
|
||||
System.out.println("ADD TEXT → " + st2 + " (" + statusName(st2) + ")");
|
||||
}
|
||||
|
||||
ws.sendClose(WebSocket.NORMAL_CLOSURE, "bye").join();
|
||||
System.out.println("=== Done ===");
|
||||
}
|
||||
|
||||
// ==============================================================
|
||||
// БЛОКИ
|
||||
// ==============================================================
|
||||
|
||||
static byte[] buildRawRecord(int recordNumber, long timestampSec,
|
||||
short recordType, short recordTypeVersion, byte[] body) {
|
||||
int recordSize = RAW_HEADER_SIZE + body.length;
|
||||
ByteBuffer buf = ByteBuffer.allocate(recordSize).order(ByteOrder.BIG_ENDIAN);
|
||||
buf.putInt(recordSize);
|
||||
buf.putInt(recordNumber);
|
||||
buf.putLong(timestampSec);
|
||||
buf.putShort(recordType);
|
||||
buf.putShort(recordTypeVersion);
|
||||
buf.put(body);
|
||||
return buf.array();
|
||||
}
|
||||
|
||||
static byte[] buildHeaderBody(String userLogin, long blockchainId, int blockchainType,
|
||||
int blockchainNumber, short versionUserBch,
|
||||
long prevUserBchId, byte[] publicKey32) {
|
||||
byte[] tag = "SHiNE001".getBytes(StandardCharsets.US_ASCII);
|
||||
byte[] loginUtf8 = userLogin.getBytes(StandardCharsets.UTF_8);
|
||||
if (loginUtf8.length > 255) throw new IllegalArgumentException("Логин слишком длинный");
|
||||
|
||||
int cap = 8 + 8 + 1 + loginUtf8.length + 4 + 4 + 2 + 8 + 32;
|
||||
ByteBuffer buf = ByteBuffer.allocate(cap).order(ByteOrder.BIG_ENDIAN);
|
||||
buf.put(tag);
|
||||
buf.putLong(blockchainId);
|
||||
buf.put((byte) loginUtf8.length);
|
||||
buf.put(loginUtf8);
|
||||
buf.putInt(blockchainType);
|
||||
buf.putInt(blockchainNumber);
|
||||
buf.putShort(versionUserBch);
|
||||
buf.putLong(prevUserBchId);
|
||||
buf.put(publicKey32);
|
||||
return buf.array();
|
||||
}
|
||||
|
||||
static byte[] signAndPack(byte[] rawBytes, String userLogin, long blockchainId,
|
||||
byte[] prevHash32, byte[] privateKey32, byte[] publicKey32) {
|
||||
byte[] preimage = buildPreimage(userLogin, blockchainId, prevHash32, rawBytes);
|
||||
byte[] hash32 = HashUtil.sha256(preimage);
|
||||
byte[] sig64 = Ed25519Util.sign(preimage, privateKey32);
|
||||
return concat(rawBytes, sig64, hash32);
|
||||
}
|
||||
|
||||
// ==============================================================
|
||||
// ПАРСИНГ
|
||||
// ==============================================================
|
||||
|
||||
static class BlockParsed {
|
||||
int recordSize;
|
||||
int recordNumber;
|
||||
long timestamp;
|
||||
short recordType;
|
||||
short recordTypeVersion;
|
||||
byte[] body;
|
||||
byte[] signature64;
|
||||
byte[] hash32;
|
||||
}
|
||||
|
||||
static List<BlockParsed> parseAllBlocks(byte[] file) {
|
||||
List<BlockParsed> out = new ArrayList<>();
|
||||
int p = 0;
|
||||
while (p + 4 <= file.length) {
|
||||
int recordSize = beInt(file, p);
|
||||
int total = recordSize + SIGNATURE_LEN + HASH_LEN;
|
||||
if (p + total > file.length) break;
|
||||
|
||||
ByteBuffer raw = ByteBuffer.wrap(file, p, recordSize).order(ByteOrder.BIG_ENDIAN);
|
||||
BlockParsed bp = new BlockParsed();
|
||||
bp.recordSize = raw.getInt();
|
||||
bp.recordNumber = raw.getInt();
|
||||
bp.timestamp = raw.getLong();
|
||||
bp.recordType = raw.getShort();
|
||||
bp.recordTypeVersion = raw.getShort();
|
||||
int bodyLen = bp.recordSize - RAW_HEADER_SIZE;
|
||||
bp.body = new byte[bodyLen];
|
||||
raw.get(bp.body);
|
||||
bp.signature64 = Arrays.copyOfRange(file, p + recordSize, p + recordSize + SIGNATURE_LEN);
|
||||
bp.hash32 = Arrays.copyOfRange(file, p + recordSize + SIGNATURE_LEN, p + recordSize + SIGNATURE_LEN + HASH_LEN);
|
||||
out.add(bp);
|
||||
p += total;
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
static void printBlock(BlockParsed b) {
|
||||
System.out.println("------------------------------------------------------------");
|
||||
String ts = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")
|
||||
.withZone(ZoneId.systemDefault())
|
||||
.format(Instant.ofEpochSecond(b.timestamp));
|
||||
System.out.printf("num=%d, type=%d, ver=%d, ts=%s, size=%d%n",
|
||||
b.recordNumber, b.recordType, b.recordTypeVersion, ts, b.recordSize);
|
||||
|
||||
if (b.recordType == TYPE_HEADER)
|
||||
printHeaderBody(b.body);
|
||||
else if (b.recordType == TYPE_TEXT)
|
||||
System.out.println("TEXT: " + new String(b.body, StandardCharsets.UTF_8));
|
||||
else
|
||||
System.out.println("UNKNOWN BODY (" + b.body.length + " bytes)");
|
||||
|
||||
System.out.println("hash=" + toHex(b.hash32));
|
||||
}
|
||||
|
||||
static void printHeaderBody(byte[] body) {
|
||||
ByteBuffer buf = ByteBuffer.wrap(body).order(ByteOrder.BIG_ENDIAN);
|
||||
byte[] tag = new byte[8]; buf.get(tag);
|
||||
long id = buf.getLong();
|
||||
int n = Byte.toUnsignedInt(buf.get());
|
||||
byte[] login = new byte[n]; buf.get(login);
|
||||
int type = buf.getInt();
|
||||
int num = buf.getInt();
|
||||
buf.getShort(); buf.getLong(); // version + prev
|
||||
byte[] pub = new byte[32]; buf.get(pub);
|
||||
|
||||
System.out.println("HEADER: login=" + new String(login, StandardCharsets.UTF_8) +
|
||||
", id=" + id + ", type=" + type + ", num=" + num);
|
||||
System.out.println("(pubkey first 4 bytes: " + toHex(Arrays.copyOf(pub, 4)) + "...)");
|
||||
}
|
||||
|
||||
// ==============================================================
|
||||
// Вебсокет и вспомогательные классы
|
||||
// ==============================================================
|
||||
|
||||
static int sendAndReadStatus(WebSocket ws, byte[] payload, WsBinaryCollector reader) {
|
||||
ws.sendBinary(ByteBuffer.wrap(payload), true).join();
|
||||
byte[] resp = reader.collect(ws);
|
||||
if (resp == null || resp.length < 4) throw new IllegalStateException("empty response");
|
||||
return beInt(resp, 0);
|
||||
}
|
||||
|
||||
static class ResponseWithPayload {
|
||||
int status;
|
||||
byte[] payload;
|
||||
}
|
||||
|
||||
static ResponseWithPayload sendAndReadPayload(WebSocket ws, byte[] payload, WsBinaryCollector reader) {
|
||||
ws.sendBinary(ByteBuffer.wrap(payload), true).join();
|
||||
byte[] resp = reader.collect(ws);
|
||||
ResponseWithPayload out = new ResponseWithPayload();
|
||||
out.status = beInt(resp, 0);
|
||||
if (out.status == STATUS_OK) {
|
||||
int len = beInt(resp, 4);
|
||||
out.payload = Arrays.copyOfRange(resp, 8, 8 + len);
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
static class WsBinaryCollector implements WebSocket.Listener {
|
||||
private volatile CompletableFuture<byte[]> future = new CompletableFuture<>();
|
||||
private ByteBuffer acc = ByteBuffer.allocate(0);
|
||||
|
||||
public synchronized byte[] collect(WebSocket ws) {
|
||||
acc = ByteBuffer.allocate(0);
|
||||
future = new CompletableFuture<>();
|
||||
ws.request(1);
|
||||
return future.join();
|
||||
}
|
||||
|
||||
@Override public void onOpen(WebSocket ws) { ws.request(1); }
|
||||
@Override public CompletionStage<?> onBinary(WebSocket ws, ByteBuffer data, boolean last) {
|
||||
ByteBuffer newBuf = ByteBuffer.allocate(acc.remaining() + data.remaining());
|
||||
newBuf.put(acc); newBuf.put(data); newBuf.flip();
|
||||
acc = newBuf;
|
||||
if (last) {
|
||||
byte[] all = new byte[acc.remaining()];
|
||||
acc.get(all);
|
||||
future.complete(all);
|
||||
}
|
||||
ws.request(1);
|
||||
return CompletableFuture.completedFuture(null);
|
||||
}
|
||||
@Override public CompletionStage<?> onText(WebSocket ws, CharSequence data, boolean last) {
|
||||
if (last) future.complete(data.toString().getBytes(StandardCharsets.UTF_8));
|
||||
ws.request(1);
|
||||
return CompletableFuture.completedFuture(null);
|
||||
}
|
||||
@Override public void onError(WebSocket ws, Throwable error) { future.completeExceptionally(error); }
|
||||
}
|
||||
|
||||
// ==============================================================
|
||||
// Крипто и утилиты
|
||||
// ==============================================================
|
||||
|
||||
static byte[] buildPreimage(String userLogin, long blockchainId, byte[] prevHash32, byte[] rawBytes) {
|
||||
byte[] loginUtf8 = userLogin.getBytes(StandardCharsets.UTF_8);
|
||||
ByteBuffer buf = ByteBuffer.allocate(loginUtf8.length + 8 + 32 + rawBytes.length).order(ByteOrder.BIG_ENDIAN);
|
||||
buf.put(loginUtf8);
|
||||
buf.putLong(blockchainId);
|
||||
buf.put(prevHash32);
|
||||
buf.put(rawBytes);
|
||||
return buf.array();
|
||||
}
|
||||
|
||||
static final class HashUtil {
|
||||
static byte[] sha256(byte[] data) {
|
||||
org.bouncycastle.crypto.digests.SHA256Digest d = new org.bouncycastle.crypto.digests.SHA256Digest();
|
||||
d.update(data, 0, data.length);
|
||||
byte[] out = new byte[32];
|
||||
d.doFinal(out, 0);
|
||||
return out;
|
||||
}
|
||||
}
|
||||
|
||||
static final class Ed25519Util {
|
||||
static byte[] derivePublicKey(byte[] privateKey32) {
|
||||
var priv = new org.bouncycastle.crypto.params.Ed25519PrivateKeyParameters(privateKey32, 0);
|
||||
return priv.generatePublicKey().getEncoded();
|
||||
}
|
||||
static byte[] sign(byte[] data, byte[] privateKey32) {
|
||||
var priv = new org.bouncycastle.crypto.params.Ed25519PrivateKeyParameters(privateKey32, 0);
|
||||
var signer = new org.bouncycastle.crypto.signers.Ed25519Signer();
|
||||
signer.init(true, priv);
|
||||
signer.update(data, 0, data.length);
|
||||
return signer.generateSignature();
|
||||
}
|
||||
}
|
||||
|
||||
// ==== Утилиты ====
|
||||
static byte[] concat(byte[]... parts) {
|
||||
int n = Arrays.stream(parts).mapToInt(a -> a.length).sum();
|
||||
byte[] out = new byte[n];
|
||||
int off = 0;
|
||||
for (byte[] p : parts) { System.arraycopy(p, 0, out, off, p.length); off += p.length; }
|
||||
return out;
|
||||
}
|
||||
|
||||
static byte[] beInt(int v) { return ByteBuffer.allocate(4).order(ByteOrder.BIG_ENDIAN).putInt(v).array(); }
|
||||
static byte[] beLong(long v) { return ByteBuffer.allocate(8).order(ByteOrder.BIG_ENDIAN).putLong(v).array(); }
|
||||
static int beInt(byte[] a, int off) { return ByteBuffer.wrap(a, off, 4).order(ByteOrder.BIG_ENDIAN).getInt(); }
|
||||
|
||||
static String toHex(byte[] b) {
|
||||
StringBuilder sb = new StringBuilder(b.length * 2);
|
||||
for (byte x : b) sb.append(String.format("%02x", x));
|
||||
return sb.toString();
|
||||
}
|
||||
|
||||
static String statusName(int code) {
|
||||
return switch (code) {
|
||||
case STATUS_OK -> "OK";
|
||||
case STATUS_BAD_REQUEST -> "BAD_REQUEST";
|
||||
case STATUS_ALREADY_EXISTS -> "ALREADY_EXISTS";
|
||||
case STATUS_NON_SEQUENTIAL -> "NON_SEQUENTIAL";
|
||||
case STATUS_UNVERIFIED -> "UNVERIFIED";
|
||||
case STATUS_INTERNAL -> "INTERNAL_ERROR";
|
||||
default -> "UNKNOWN";
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,66 @@
|
||||
package server.logic;
|
||||
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
import server.logic.ws_protocol.binary.handlers.*;
|
||||
import server.logic.ws_protocol.WireCodes;
|
||||
|
||||
import java.nio.ByteBuffer;
|
||||
import java.nio.ByteOrder;
|
||||
import java.util.Map;
|
||||
|
||||
/**
|
||||
* Обработчик входящих сообщение на сервер.
|
||||
* По коду сообщения (первые 4 байта сообщения) находи нужный хэндлер и передаёт в него сообщение
|
||||
* Получает и возвращает ответ от хэндлера
|
||||
*/
|
||||
public final class InboundMessageProcessor {
|
||||
private static final Logger log = LoggerFactory.getLogger(InboundMessageProcessor.class);
|
||||
|
||||
private static final Map<Integer, MessageHandler> HANDLERS = Map.of(
|
||||
WireCodes.Op.PING, new PingHandler(),
|
||||
WireCodes.Op.ADD_BLOCK, new AddBlockHandler(),
|
||||
WireCodes.Op.GET_BLOCKCHAIN,new GetBlockchainHandler(),
|
||||
WireCodes.Op.SEARCH_USERS, new SearchUsersHandler(),
|
||||
WireCodes.Op.GET_LAST_BLOCK_INFO,new GetLastBlockInfoHandler()
|
||||
|
||||
);
|
||||
|
||||
private InboundMessageProcessor() {}
|
||||
|
||||
public static byte[] process(byte[] msg) {
|
||||
if (msg == null || msg.length < 4)
|
||||
return intTo4Bytes(WireCodes.Status.BAD_REQUEST);
|
||||
|
||||
int op = first4ToInt(msg);
|
||||
MessageHandler h = HANDLERS.get(op);
|
||||
if (h == null) {
|
||||
log.warn("Неизвестная операция: {}", op);
|
||||
return intTo4Bytes(WireCodes.Status.BAD_REQUEST);
|
||||
}
|
||||
|
||||
try {
|
||||
return h.handle(msg);
|
||||
} catch (Exception e) {
|
||||
log.error("Ошибка при обработке операции {}", op, e);
|
||||
return intTo4Bytes(WireCodes.Status.INTERNAL_ERROR);
|
||||
}
|
||||
}
|
||||
|
||||
private static int first4ToInt(byte[] msg) {
|
||||
return ByteBuffer.wrap(msg, 0, 4)
|
||||
.order(ByteOrder.BIG_ENDIAN)
|
||||
.getInt();
|
||||
}
|
||||
|
||||
public static byte[] intTo4Bytes(int code) {
|
||||
return ByteBuffer.allocate(4)
|
||||
.order(ByteOrder.BIG_ENDIAN)
|
||||
.putInt(code)
|
||||
.array();
|
||||
}
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
@@ -0,0 +1,250 @@
|
||||
package server.logic.ws_protocol.binary.handlers;
|
||||
|
||||
import blockchain.BchBlockEntry;
|
||||
import blockchain.body.BodyRecord;
|
||||
import blockchain.BodyRecordParser;
|
||||
import blockchain.body.HeaderBody;
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
import server.logic.ws_protocol.WireCodes;
|
||||
import utils.blockchain.BchInfoEntry;
|
||||
import utils.blockchain.BchInfoManager;
|
||||
import utils.crypto.BchCryptoVerifier;
|
||||
import utils.files.FileStoreUtil;
|
||||
|
||||
import java.nio.ByteBuffer;
|
||||
import java.nio.ByteOrder;
|
||||
import java.util.Arrays;
|
||||
|
||||
/**
|
||||
* AddBlockHandler — обработчик команды "добавить блок" (ADD_BLOCK)
|
||||
* ---------------------------------------------------------------
|
||||
* Принимает бинарное сообщение от клиента и добавляет новый блок в цепочку.
|
||||
*
|
||||
* Формат входного сообщения (msg):
|
||||
* [0..3] — 4 байта: код операции (WireCodes.ADD_BLOCK)
|
||||
* [4..11] — 8 байт: blockchainId (уникальный идентификатор цепочки)
|
||||
* [12..] — байты полного блока .bch:
|
||||
* ├── 4 байта recordSize = M + 18
|
||||
* ├── 4 байта recordNumber
|
||||
* ├── 8 байт timestamp
|
||||
* ├── 2 байта recordType
|
||||
* ├── 2 байта recordVersion
|
||||
* ├── M байт body (содержимое блока)
|
||||
* ├── 64 байта signature (Ed25519)
|
||||
* └── 32 байта hash (SHA-256)
|
||||
*
|
||||
* ---------------------------------------------------------------
|
||||
* Алгоритм работы:
|
||||
*
|
||||
* 1️⃣ Распаковать BchBlockEntry из msg (т.е. выделить тело блока и подписи).
|
||||
* 2️⃣ Найти описание цепочки (BchInfoEntry) по blockchainId.
|
||||
*
|
||||
* ─ Если описания нет (цепочка ещё не существует):
|
||||
* • принимаем только блок типа 0 (HeaderBody) и номера 0;
|
||||
* • парсим его, создаём новый BchInfoEntry на основе данных заголовка;
|
||||
* • проверяем подпись и хэш;
|
||||
* • проверяем корректность тела блока (check);
|
||||
* • сохраняем блок и создаём новый blockchain-файл;
|
||||
* • добавляем цепочку в менеджер BchInfoManager.
|
||||
* (💡 временное решение: создание цепочки допустимо только через HeaderBody)
|
||||
*
|
||||
* ─ Если цепочка уже существует:
|
||||
* • проверяем, что номер блока равен (lastBlockNumber + 1);
|
||||
* • проверяем подпись и хэш;
|
||||
* • проверяем тело блока (check);
|
||||
* • добавляем блок в файл цепочки;
|
||||
* • обновляем состояние BchInfoEntry (номер, хэш, размер).
|
||||
*
|
||||
* 3️⃣ Если все проверки пройдены — возвращаем статус OK.
|
||||
*
|
||||
* Таким образом, единственное различие между первым блоком и последующими —
|
||||
* момент инициализации описания цепочки (BchInfoEntry).
|
||||
* Всё остальное (валидация, подпись, добавление, обновление) выполняется одинаково.
|
||||
*/
|
||||
public class AddBlockHandler implements MessageHandler {
|
||||
|
||||
private static final Logger log = LoggerFactory.getLogger(AddBlockHandler.class);
|
||||
|
||||
@Override
|
||||
public byte[] handle(byte[] msg) {
|
||||
try {
|
||||
// =====================================================================
|
||||
// 1️⃣ Проверка минимальной длины пакета
|
||||
// =====================================================================
|
||||
int minFull = BchBlockEntry.RAW_HEADER_SIZE + BchBlockEntry.SIGNATURE_LEN + BchBlockEntry.HASH_LEN;
|
||||
// (RAW_HEADER_SIZE = 18 байт, подпись = 64, хэш = 32)
|
||||
if (msg.length < 4 + 8 + minFull)
|
||||
return code(WireCodes.Status.BAD_REQUEST);
|
||||
|
||||
// =====================================================================
|
||||
// 2️⃣ Извлекаем blockchainId (8 байт начиная с позиции 4)
|
||||
// =====================================================================
|
||||
long blockchainId = ByteBuffer.wrap(msg, 4, 8)
|
||||
.order(ByteOrder.BIG_ENDIAN)
|
||||
.getLong();
|
||||
|
||||
// Всё, что дальше, — это бинарное содержимое блока .bch
|
||||
int offset = 12; // первые 12 байт = код + blockchainId
|
||||
|
||||
// =====================================================================
|
||||
// 3️⃣ Парсим блок (RAW + подпись + хэш)
|
||||
// =====================================================================
|
||||
byte[] fullBlock = Arrays.copyOfRange(msg, offset, msg.length);
|
||||
BchBlockEntry block = new BchBlockEntry(fullBlock); // сам распакует RAW-часть и подписи
|
||||
|
||||
// =====================================================================
|
||||
// 4️⃣ Получаем текущее описание цепочки (BchInfoEntry)
|
||||
// =====================================================================
|
||||
BchInfoManager info = BchInfoManager.getInstance();
|
||||
BchInfoEntry chain = info.getBchInfo(blockchainId);
|
||||
|
||||
byte[] prevHash32;
|
||||
int expectedNum;
|
||||
String userLogin;
|
||||
byte[] publicKey32;
|
||||
|
||||
// =====================================================================
|
||||
// 🧩 СЦЕНАРИЙ 1: цепочка отсутствует — создаём новую
|
||||
// =====================================================================
|
||||
if (chain == null) {
|
||||
// Допускаем только блок-заголовок (type=0, num=0)
|
||||
if (block.recordType != BchBlockEntry.TYPE_HEADER || block.recordNumber != 0) {
|
||||
log.warn("Попытка создать новую цепочку без корректного заголовка (type={}, num={})",
|
||||
block.recordType, block.recordNumber);
|
||||
return code(WireCodes.Status.BAD_REQUEST);
|
||||
}
|
||||
|
||||
// Парсим тело блока → HeaderBody
|
||||
BodyRecord body = BodyRecordParser.parse(block.recordType, block.recordTypeVersion, block.body).check();
|
||||
if (!(body instanceof HeaderBody))
|
||||
return code(WireCodes.Status.BAD_REQUEST);
|
||||
|
||||
HeaderBody hb = (HeaderBody) body;
|
||||
|
||||
// Проверяем, что blockchainId совпадает
|
||||
if (hb.blockchainId != blockchainId) {
|
||||
log.warn("Несовпадение blockchainId в заголовке (ожидалось {}, получено {})",
|
||||
blockchainId, hb.blockchainId);
|
||||
return code(WireCodes.Status.BAD_REQUEST);
|
||||
}
|
||||
|
||||
// Проверяем подпись и хэш первого блока (предыдущий хэш = 0)
|
||||
prevHash32 = new byte[32];
|
||||
boolean verified = BchCryptoVerifier.verifyAll(
|
||||
hb.userLogin,
|
||||
blockchainId,
|
||||
prevHash32,
|
||||
block.rawBytes,
|
||||
block.getSignature64(),
|
||||
block.getHash32(),
|
||||
hb.publicKey32
|
||||
);
|
||||
if (!verified) {
|
||||
log.warn("❌ Подпись не прошла проверку при создании цепочки blockchainId={}", blockchainId);
|
||||
return code(WireCodes.Status.UNVERIFIED);
|
||||
}
|
||||
|
||||
// ✅ Всё хорошо: создаём новую цепочку
|
||||
info.addBlockchain(blockchainId, hb.userLogin, hb.publicKey32, Integer.MAX_VALUE);
|
||||
info.updateBlockchainState(blockchainId, block.recordNumber, bytesToHex(block.getHash32()), fullBlock.length);
|
||||
|
||||
FileStoreUtil.getInstance().addDataToBlockchain(blockchainId, fullBlock);
|
||||
|
||||
log.info("✅ Создана новая цепочка blockchainId={}, user={}, blockNum={}",
|
||||
blockchainId, hb.userLogin, block.recordNumber);
|
||||
|
||||
return code(WireCodes.Status.OK);
|
||||
}
|
||||
|
||||
// =====================================================================
|
||||
// 🧩 СЦЕНАРИЙ 2: цепочка существует — добавляем новый блок
|
||||
// =====================================================================
|
||||
expectedNum = chain.lastBlockNumber + 1;
|
||||
|
||||
// Проверка последовательности (и отправка lastBlockNumber)
|
||||
if (block.recordNumber < expectedNum) {
|
||||
log.info("🔁 Блок {} уже существует, последний = {}", block.recordNumber, chain.lastBlockNumber);
|
||||
ByteBuffer out = ByteBuffer.allocate(8).order(ByteOrder.BIG_ENDIAN);
|
||||
out.putInt(WireCodes.Status.BLOCK_ALREADY_EXISTS);
|
||||
out.putInt(chain.lastBlockNumber);
|
||||
return out.array();
|
||||
}
|
||||
if (block.recordNumber > expectedNum) {
|
||||
log.warn("⚠️ Нарушена последовательность: получен {}, ожидался {}", block.recordNumber, expectedNum);
|
||||
ByteBuffer out = ByteBuffer.allocate(8).order(ByteOrder.BIG_ENDIAN);
|
||||
out.putInt(WireCodes.Status.OUT_OF_SEQUENCE);
|
||||
out.putInt(chain.lastBlockNumber);
|
||||
return out.array();
|
||||
}
|
||||
|
||||
userLogin = chain.userLogin;
|
||||
publicKey32 = chain.getPublicKey32();
|
||||
|
||||
// Хэш предыдущего блока (или 32 нуля, если это первый)
|
||||
prevHash32 = (chain.lastBlockHash == null || chain.lastBlockHash.isEmpty())
|
||||
? new byte[32]
|
||||
: hexToBytes(chain.lastBlockHash);
|
||||
|
||||
// Проверяем подпись и хэш
|
||||
boolean verified = BchCryptoVerifier.verifyAll(
|
||||
userLogin,
|
||||
blockchainId,
|
||||
prevHash32,
|
||||
block.rawBytes,
|
||||
block.getSignature64(),
|
||||
block.getHash32(),
|
||||
publicKey32
|
||||
);
|
||||
if (!verified) {
|
||||
log.warn("❌ Подпись не прошла проверку: chainId={}, blockNum={}", blockchainId, block.recordNumber);
|
||||
return code(WireCodes.Status.UNVERIFIED);
|
||||
}
|
||||
|
||||
// Проверяем тело блока (например, корректный UTF-8 или структура)
|
||||
BodyRecord body = BodyRecordParser.parse(block.recordType, block.recordTypeVersion, block.body).check();
|
||||
|
||||
// ✅ Добавляем блок в файл цепочки
|
||||
FileStoreUtil.getInstance().addDataToBlockchain(blockchainId, fullBlock);
|
||||
|
||||
// Обновляем состояние цепочки (номер, хэш, размер)
|
||||
int newSize = chain.blockchainSize + fullBlock.length;
|
||||
info.updateBlockchainState(blockchainId, block.recordNumber, bytesToHex(block.getHash32()), newSize);
|
||||
|
||||
log.info("✅ Блок добавлен: chain={}, num={}, type={}, bytes={}",
|
||||
blockchainId, block.recordNumber, block.recordType, fullBlock.length);
|
||||
|
||||
return code(WireCodes.Status.OK);
|
||||
|
||||
} catch (Exception e) {
|
||||
log.error("❌ ADD_BLOCK: внутренняя ошибка при обработке", e);
|
||||
return code(WireCodes.Status.INTERNAL_ERROR);
|
||||
}
|
||||
}
|
||||
|
||||
// =====================================================================
|
||||
// Утилиты
|
||||
// =====================================================================
|
||||
|
||||
/** Преобразовать статус (int) в 4 байта BigEndian. */
|
||||
private static byte[] code(int status) {
|
||||
return ByteBuffer.allocate(4).order(ByteOrder.BIG_ENDIAN).putInt(status).array();
|
||||
}
|
||||
|
||||
/** Конвертация HEX → bytes (для хэшей). */
|
||||
private static byte[] hexToBytes(String hex) {
|
||||
int len = hex.length();
|
||||
byte[] out = new byte[len / 2];
|
||||
for (int i = 0; i < len; i += 2)
|
||||
out[i / 2] = (byte) Integer.parseInt(hex.substring(i, i + 2), 16);
|
||||
return out;
|
||||
}
|
||||
|
||||
/** Конвертация bytes → HEX (для сохранения в BchInfo). */
|
||||
private static String bytesToHex(byte[] b) {
|
||||
StringBuilder sb = new StringBuilder(b.length * 2);
|
||||
for (byte x : b) sb.append(String.format("%02x", x));
|
||||
return sb.toString();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,53 @@
|
||||
package server.logic.ws_protocol.binary.handlers;
|
||||
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
import server.logic.ws_protocol.WireCodes;
|
||||
import utils.files.FileStoreUtil;
|
||||
|
||||
import java.nio.ByteBuffer;
|
||||
import java.nio.ByteOrder;
|
||||
|
||||
/**
|
||||
* Возврат полного содержимого блокчейна (GET_BLOCKCHAIN).
|
||||
*/
|
||||
public class GetBlockchainHandler implements MessageHandler {
|
||||
private static final Logger log = LoggerFactory.getLogger(GetBlockchainHandler.class);
|
||||
|
||||
@Override
|
||||
public byte[] handle(byte[] msg) {
|
||||
try {
|
||||
if (msg.length < 12)
|
||||
return intTo4Bytes(WireCodes.Status.BAD_REQUEST);
|
||||
|
||||
long id = ByteBuffer.wrap(msg, 4, 8)
|
||||
.order(ByteOrder.BIG_ENDIAN)
|
||||
.getLong();
|
||||
|
||||
FileStoreUtil fs = FileStoreUtil.getInstance();
|
||||
byte[] data = fs.readAllDataFromBlockchain(id);
|
||||
|
||||
return packOk(data);
|
||||
|
||||
} catch (IllegalStateException e) {
|
||||
log.warn("GET_BLOCKCHAIN: файл не найден ({})", e.getMessage());
|
||||
return intTo4Bytes(WireCodes.Status.CHAIN_NOT_FOUND);
|
||||
} catch (Exception e) {
|
||||
log.error("GET_BLOCKCHAIN: ошибка", e);
|
||||
return intTo4Bytes(WireCodes.Status.INTERNAL_ERROR);
|
||||
}
|
||||
}
|
||||
|
||||
private static byte[] packOk(byte[] data) {
|
||||
if (data == null) data = new byte[0];
|
||||
ByteBuffer out = ByteBuffer.allocate(8 + data.length).order(ByteOrder.BIG_ENDIAN);
|
||||
out.putInt(WireCodes.Status.OK);
|
||||
out.putInt(data.length);
|
||||
out.put(data);
|
||||
return out.array();
|
||||
}
|
||||
|
||||
private static byte[] intTo4Bytes(int code) {
|
||||
return ByteBuffer.allocate(4).order(ByteOrder.BIG_ENDIAN).putInt(code).array();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,66 @@
|
||||
package server.logic.ws_protocol.binary.handlers;
|
||||
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
import server.logic.ws_protocol.WireCodes;
|
||||
import utils.blockchain.BchInfoEntry;
|
||||
import utils.blockchain.BchInfoManager;
|
||||
|
||||
import java.nio.ByteBuffer;
|
||||
import java.nio.ByteOrder;
|
||||
import java.util.Arrays;
|
||||
|
||||
/**
|
||||
* Возврат информации о последнем блоке цепочки (GET_LAST_BLOCK_INFO).
|
||||
*/
|
||||
public class GetLastBlockInfoHandler implements MessageHandler {
|
||||
private static final Logger log = LoggerFactory.getLogger(GetLastBlockInfoHandler.class);
|
||||
|
||||
@Override
|
||||
public byte[] handle(byte[] msg) {
|
||||
try {
|
||||
if (msg.length < 12)
|
||||
return intTo4Bytes(WireCodes.Status.BAD_REQUEST);
|
||||
|
||||
long blockchainId = ByteBuffer.wrap(msg, 4, 8)
|
||||
.order(ByteOrder.BIG_ENDIAN)
|
||||
.getLong();
|
||||
|
||||
BchInfoManager mgr = BchInfoManager.getInstance();
|
||||
BchInfoEntry entry = mgr.getBchInfo(blockchainId);
|
||||
if (entry == null)
|
||||
return intTo4Bytes(WireCodes.Status.CHAIN_NOT_FOUND);
|
||||
|
||||
int lastNum = entry.lastBlockNumber;
|
||||
byte[] hash = hexToBytes(entry.lastBlockHash);
|
||||
|
||||
ByteBuffer out = ByteBuffer.allocate(4 + 4 + 32).order(ByteOrder.BIG_ENDIAN);
|
||||
out.putInt(WireCodes.Status.OK);
|
||||
out.putInt(lastNum);
|
||||
out.put(hash);
|
||||
return out.array();
|
||||
|
||||
} catch (Exception e) {
|
||||
log.error("GET_LAST_BLOCK_INFO: ошибка", e);
|
||||
return intTo4Bytes(WireCodes.Status.INTERNAL_ERROR);
|
||||
}
|
||||
}
|
||||
|
||||
private static byte[] intTo4Bytes(int code) {
|
||||
return ByteBuffer.allocate(4).order(ByteOrder.BIG_ENDIAN).putInt(code).array();
|
||||
}
|
||||
|
||||
private static byte[] hexToBytes(String hex) {
|
||||
if (hex == null || hex.isEmpty()) return new byte[32];
|
||||
int len = hex.length();
|
||||
byte[] out = new byte[len / 2];
|
||||
for (int i = 0; i < len; i += 2)
|
||||
out[i / 2] = (byte) Integer.parseInt(hex.substring(i, i + 2), 16);
|
||||
if (out.length < 32) { // добиваем нулями
|
||||
byte[] full = new byte[32];
|
||||
System.arraycopy(out, 0, full, 32 - out.length, out.length);
|
||||
return full;
|
||||
}
|
||||
return Arrays.copyOf(out, 32);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,11 @@
|
||||
package server.logic.ws_protocol.binary.handlers;
|
||||
|
||||
/**
|
||||
* Общий интерфейс для всех обработчиков входящих сообщений.
|
||||
*/
|
||||
public interface MessageHandler {
|
||||
/**
|
||||
* Обработать входящее сообщение и вернуть бинарный ответ.
|
||||
*/
|
||||
byte[] handle(byte[] msg);
|
||||
}
|
||||
@@ -0,0 +1,16 @@
|
||||
package server.logic.ws_protocol.binary.handlers;
|
||||
|
||||
import server.logic.ws_protocol.WireCodes;
|
||||
|
||||
/**
|
||||
* Обработчик команды PING.
|
||||
* Возвращает просто статус PONG.
|
||||
*/
|
||||
public class PingHandler implements MessageHandler {
|
||||
@Override
|
||||
public byte[] handle(byte[] msg) {
|
||||
return new byte[]{
|
||||
0, 0, 0, (byte) WireCodes.Status.PONG // проще и быстрее, можно и через ByteBuffer
|
||||
};
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,59 @@
|
||||
package server.logic.ws_protocol.binary.handlers;
|
||||
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
import server.logic.ws_protocol.WireCodes;
|
||||
import utils.search.UserSearchService;
|
||||
|
||||
import java.nio.ByteBuffer;
|
||||
import java.nio.ByteOrder;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Поиск пользователей по логину (SEARCH_USERS).
|
||||
*/
|
||||
public class SearchUsersHandler implements MessageHandler {
|
||||
private static final Logger log = LoggerFactory.getLogger(SearchUsersHandler.class);
|
||||
|
||||
@Override
|
||||
public byte[] handle(byte[] msg) {
|
||||
try {
|
||||
if (msg.length < 8)
|
||||
return intTo4Bytes(WireCodes.Status.BAD_REQUEST);
|
||||
|
||||
int N = ByteBuffer.wrap(msg, 4, 4).order(ByteOrder.BIG_ENDIAN).getInt();
|
||||
if (N < 0 || msg.length < 8 + N)
|
||||
return intTo4Bytes(WireCodes.Status.BAD_REQUEST);
|
||||
|
||||
String query = new String(msg, 8, N, StandardCharsets.UTF_8);
|
||||
List<UserSearchService.Pair> found = UserSearchService.getInstance().searchFirst5(query);
|
||||
return pack(found);
|
||||
|
||||
} catch (Exception e) {
|
||||
log.error("SEARCH_USERS: ошибка", e);
|
||||
return intTo4Bytes(WireCodes.Status.INTERNAL_ERROR);
|
||||
}
|
||||
}
|
||||
|
||||
private static byte[] pack(List<UserSearchService.Pair> pairs) {
|
||||
if (pairs == null) pairs = List.of();
|
||||
int total = 8;
|
||||
var chunks = new java.util.ArrayList<byte[]>();
|
||||
for (var p : pairs) {
|
||||
byte[] packed = UserSearchService.packPair(p);
|
||||
chunks.add(packed);
|
||||
total += packed.length;
|
||||
}
|
||||
|
||||
ByteBuffer out = ByteBuffer.allocate(total).order(ByteOrder.BIG_ENDIAN);
|
||||
out.putInt(WireCodes.Status.OK);
|
||||
out.putInt(pairs.size());
|
||||
for (var c : chunks) out.put(c);
|
||||
return out.array();
|
||||
}
|
||||
|
||||
private static byte[] intTo4Bytes(int code) {
|
||||
return ByteBuffer.allocate(4).order(ByteOrder.BIG_ENDIAN).putInt(code).array();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,141 @@
|
||||
package server.ws;
|
||||
|
||||
import org.eclipse.jetty.websocket.api.Session;
|
||||
import org.eclipse.jetty.websocket.api.WriteCallback;
|
||||
import org.eclipse.jetty.websocket.api.annotations.*;
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
import server.logic.InboundMessageProcessor;
|
||||
import server.logic.ws_protocol.JSON.ConnectionContext;
|
||||
import server.logic.ws_protocol.JSON.JsonInboundProcessor;
|
||||
|
||||
import java.nio.ByteBuffer;
|
||||
import java.util.concurrent.CompletableFuture;
|
||||
|
||||
@WebSocket
|
||||
public class BlockchainWsEndpoint {
|
||||
private static final Logger log = LoggerFactory.getLogger(BlockchainWsEndpoint.class);
|
||||
|
||||
private Session session;
|
||||
|
||||
/** Контекст для текущего WebSocket-соединения. */
|
||||
private final ConnectionContext connectionContext = new ConnectionContext();
|
||||
|
||||
@OnWebSocketConnect
|
||||
public void onConnect(Session session) {
|
||||
this.session = session;
|
||||
log.info("WS connected: {}", session.getRemoteAddress());
|
||||
}
|
||||
|
||||
@OnWebSocketMessage
|
||||
public void onBinary(byte[] payload, int offset, int length) {
|
||||
byte[] msg = new byte[length];
|
||||
System.arraycopy(payload, offset, msg, 0, length);
|
||||
|
||||
// Асинхронно обрабатываем входящее бинарное сообщение
|
||||
CompletableFuture
|
||||
.supplyAsync(() -> InboundMessageProcessor.process(msg))
|
||||
.thenAccept(resp -> {
|
||||
if (resp != null && session != null && session.isOpen()) {
|
||||
session.getRemote().sendBytes(ByteBuffer.wrap(resp), new WriteCallback() {
|
||||
@Override
|
||||
public void writeFailed(Throwable x) {
|
||||
log.warn("Failed to send response", x);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void writeSuccess() {
|
||||
log.debug("Response sent successfully");
|
||||
}
|
||||
});
|
||||
}
|
||||
})
|
||||
.exceptionally(ex -> {
|
||||
log.error("Processing failed", ex);
|
||||
trySendCode(500);
|
||||
return null;
|
||||
});
|
||||
}
|
||||
|
||||
private void trySendCode(int code) {
|
||||
if (session != null && session.isOpen()) {
|
||||
byte[] resp = InboundMessageProcessor.intTo4Bytes(code);
|
||||
session.getRemote().sendBytes(ByteBuffer.wrap(resp), new WriteCallback() {
|
||||
@Override
|
||||
public void writeFailed(Throwable x) {
|
||||
log.warn("Failed to send error code", x);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void writeSuccess() {
|
||||
log.debug("Error code {} sent", code);
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
@OnWebSocketClose
|
||||
public void onClose(int statusCode, String reason) {
|
||||
log.info("WS closed: {} {}", statusCode, reason);
|
||||
// На всякий случай очищаем контекст
|
||||
connectionContext.reset();
|
||||
}
|
||||
|
||||
@OnWebSocketError
|
||||
public void onError(Throwable cause) {
|
||||
log.error("WS error", cause);
|
||||
}
|
||||
|
||||
// Обработка текстовых JSON-запросов
|
||||
@OnWebSocketMessage
|
||||
public void onText(String message) {
|
||||
log.info("📥 Получено TEXT-сообщение от клиента: {}", message);
|
||||
|
||||
CompletableFuture
|
||||
.supplyAsync(() -> JsonInboundProcessor.processJson(message, connectionContext))
|
||||
.thenAccept(respJson -> {
|
||||
if (respJson != null && session != null && session.isOpen()) {
|
||||
|
||||
log.info("📤 Отправляем ответ клиенту: {}", respJson);
|
||||
|
||||
session.getRemote().sendString(respJson, new WriteCallback() {
|
||||
@Override
|
||||
public void writeFailed(Throwable x) {
|
||||
log.warn("⚠️ Не удалось отправить JSON-ответ клиенту: {}", x.toString());
|
||||
}
|
||||
|
||||
@Override
|
||||
public void writeSuccess() {
|
||||
log.debug("✔ JSON-ответ успешно отправлен");
|
||||
}
|
||||
});
|
||||
}
|
||||
})
|
||||
.exceptionally(ex -> {
|
||||
log.error("❌ Ошибка при обработке JSON-сообщения", ex);
|
||||
trySendJsonError();
|
||||
return null;
|
||||
});
|
||||
}
|
||||
|
||||
private void trySendJsonError() {
|
||||
if (session != null && session.isOpen()) {
|
||||
String resp = "{\"op\":null,\"requestId\":null,\"status\":500,"
|
||||
+ "\"payload\":{\"code\":\"INTERNAL_ERROR\",\"message\":\"Ошибка сервера\"}}";
|
||||
|
||||
log.info("📤 Отправляем клиенту ошибку JSON: {}", resp);
|
||||
|
||||
session.getRemote().sendString(resp, new WriteCallback() {
|
||||
@Override
|
||||
public void writeFailed(Throwable x) {
|
||||
log.warn("⚠️ Не удалось отправить JSON-ответ клиенту: {}", x.toString());
|
||||
}
|
||||
|
||||
@Override
|
||||
public void writeSuccess() {
|
||||
log.debug("✔ JSON-ошибка успешно отправлена");
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,85 @@
|
||||
# server.ws
|
||||
|
||||
Пакет `server.ws` отвечает за сетевой уровень: WebSocket-сервер и обработку соединений.
|
||||
|
||||
Он принимает бинарные сообщения от клиентов, передаёт их в логику сервера и отправляет бинарные ответы обратно.
|
||||
|
||||
---
|
||||
|
||||
## Классы
|
||||
|
||||
### 1. `BlockchainWsEndpoint`
|
||||
WebSocket-эндпоинт для одного соединения.
|
||||
|
||||
Роль:
|
||||
- держит сессию с конкретным клиентом,
|
||||
- принимает сообщения,
|
||||
- вызывает бизнес-логику,
|
||||
- отправляет ответ.
|
||||
|
||||
Публичные методы (Jetty WebSocket lifecycle):
|
||||
|
||||
- `onConnect(Session session)`
|
||||
Вызывается Jetty при подключении клиента.
|
||||
Сохраняет `session`, пишет лог.
|
||||
|
||||
- `onBinary(byte[] payload, int offset, int length)`
|
||||
Клиент прислал бинарные данные.
|
||||
Логика:
|
||||
1. Копируем полезные байты.
|
||||
2. Передаём их в `InboundMessageProcessor.process(...)`.
|
||||
3. Асинхронно отправляем ответ обратно через `session.getRemote().sendBytes(...)`.
|
||||
|
||||
Ответ сервера — это либо `[4]statusCode`, либо `[4]OK + ...payload...` (в зависимости от операции).
|
||||
|
||||
- `onClose(int statusCode, String reason)`
|
||||
Логируем закрытие сессии.
|
||||
|
||||
- `onError(Throwable cause)`
|
||||
Логируем ошибку.
|
||||
|
||||
Внутренние (служебные):
|
||||
- `trySendCode(int code)` — отправить просто код ошибки, если что-то пошло не так.
|
||||
|
||||
Замечание: сам `BlockchainWsEndpoint` не знает протокола. Он просто прокидывает байты в `InboundMessageProcessor`.
|
||||
|
||||
---
|
||||
|
||||
### 2. `WsServer`
|
||||
Отдельный класс-ланчер. Поднимает Jetty WebSocket сервер.
|
||||
|
||||
Роль:
|
||||
- стартует HTTP-сервер Jetty на порту `8080`,
|
||||
- вешает WebSocket endpoint `/ws`,
|
||||
- задаёт таймаут бездействия.
|
||||
|
||||
Публичный метод:
|
||||
- `public static void main(String[] args)`
|
||||
Запуск сервера. Делает:
|
||||
- `new Server(8080)`
|
||||
- создаёт `ServletContextHandler`
|
||||
- через `JettyWebSocketServletContainerInitializer.configure(...)` регистрирует маппинг `/ws` → `BlockchainWsEndpoint`
|
||||
- `server.start(); server.join();`
|
||||
|
||||
После запуска сервер слушает `ws://localhost:8080/ws`.
|
||||
|
||||
---
|
||||
|
||||
## Как это стыкуется с остальной системой
|
||||
|
||||
1. Клиент открывает WebSocket на `/ws`.
|
||||
2. Шлёт бинарный пакет: `[4 байта opCode][дальше payload]`.
|
||||
3. `BlockchainWsEndpoint.onBinary()` → `InboundMessageProcessor.process(...)`.
|
||||
4. `InboundMessageProcessor` разбирает команду:
|
||||
- добавить блок
|
||||
- выдать блокчейн
|
||||
- поиск пользователей
|
||||
- ping
|
||||
5. Ответ упаковывается в бинарный формат и отправляется обратно через `BlockchainWsEndpoint`.
|
||||
|
||||
---
|
||||
|
||||
## Кратко
|
||||
|
||||
- `WsServer` = сервер, который слушает порт и вешает `/ws`.
|
||||
- `BlockchainWsEndpoint` = обработчик одного WebSocket-подключения, мост между сетью и логикой.
|
||||
@@ -0,0 +1,48 @@
|
||||
package server.ws;
|
||||
|
||||
import org.eclipse.jetty.server.Server;
|
||||
import org.eclipse.jetty.servlet.ServletContextHandler;
|
||||
import org.eclipse.jetty.websocket.server.config.JettyWebSocketServletContainerInitializer;
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
import shine.db.dao.SolanaUsersDAO;
|
||||
import shine.db.entities.SolanaUser;
|
||||
import utils.config.AppConfig;
|
||||
|
||||
import java.time.Duration;
|
||||
|
||||
/**
|
||||
* WsServer — поднимает Jetty WS на /ws (порт 8080).
|
||||
*/
|
||||
public final class WsServer {
|
||||
private static final Logger log = LoggerFactory.getLogger(WsServer.class);
|
||||
|
||||
public static void main(String[] args) throws Exception {
|
||||
AppConfig config = AppConfig.getInstance();
|
||||
int port = 7070;
|
||||
try {
|
||||
port = Integer.parseInt(config.getParam("server.port"),7070);
|
||||
} catch (Exception e) {
|
||||
log.info("Установите параметр server.port в файле настроек");
|
||||
}
|
||||
|
||||
Server server = new Server(port);
|
||||
|
||||
ServletContextHandler context = new ServletContextHandler();
|
||||
context.setContextPath("/");
|
||||
server.setHandler(context);
|
||||
|
||||
// Инициализация контейнера WebSocket
|
||||
JettyWebSocketServletContainerInitializer.configure(context, (servletContext, wsContainer) -> {
|
||||
// Таймаут простоя соединения (Jetty 11 синтаксис)
|
||||
wsContainer.setIdleTimeout(Duration.ofMinutes(5));
|
||||
|
||||
// Маппинг эндпоинта
|
||||
wsContainer.addMapping("/ws", (req, resp) -> new BlockchainWsEndpoint());
|
||||
});
|
||||
|
||||
server.start();
|
||||
log.info("✅ WS сервер запущен на ws://localhost:{}/ws", port);
|
||||
server.join();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,5 @@
|
||||
server.1port=7070
|
||||
|
||||
|
||||
db.path=data/shine.sqlite
|
||||
|
||||
@@ -0,0 +1,33 @@
|
||||
<configuration>
|
||||
|
||||
<!-- ========== Настройки формата лога ========== -->
|
||||
<property name="LOG_DIR" value="logs" />
|
||||
<property name="LOG_FILE" value="${LOG_DIR}/app.log" />
|
||||
|
||||
<appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
|
||||
<file>${LOG_FILE}</file>
|
||||
|
||||
<!-- Ротация файлов: по дате -->
|
||||
<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
|
||||
<fileNamePattern>${LOG_DIR}/app.%d{yyyy-MM-dd}.log</fileNamePattern>
|
||||
<maxHistory>14</maxHistory>
|
||||
</rollingPolicy>
|
||||
|
||||
<encoder>
|
||||
<pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
|
||||
</encoder>
|
||||
</appender>
|
||||
|
||||
<appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
|
||||
<encoder>
|
||||
<pattern>%highlight(%-5level) %cyan(%logger{20}) - %msg%n</pattern>
|
||||
</encoder>
|
||||
</appender>
|
||||
|
||||
<!-- ========== Уровень логирования ========== -->
|
||||
<root level="info">
|
||||
<appender-ref ref="CONSOLE" />
|
||||
<appender-ref ref="FILE" />
|
||||
</root>
|
||||
|
||||
</configuration>
|
||||
Reference in New Issue
Block a user